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