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