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