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