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