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