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