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