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