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