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