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