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