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