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