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