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