You are given a 2D integer array units of size m × n, where units[i][j] represents the capacity of the jth unit in the ith device. Each device contains exactly n units.

The rating of a device is defined as the minimum capacity among all its units.

You may perform the following operation any number of times (including zero):

• Choose a device i that has not been used as a source before.
• Remove exactly one unit from device i and add it to any different device.
• Then mark device i as used, so it cannot be chosen again as a source.

Your task is to return the maximum possible sum of the ratings of all devices after performing any number of such operations.

A few important details to keep in mind:

• A device can receive units from multiple devices, regardless of whether those devices have already been used as a source.
• The rating of an empty device (a device with no units left) is 0.

In short, you want to strategically move units between devices—where each device can give away at most one unit and only once—so that the combined sum of all device ratings (each rating being its minimum unit capacity) is as large as possible.

The first thing to notice is what an operation actually does. When we remove a unit from a device, that device loses one of its units, and when we add a unit to another device, that device gains a unit. Since the rating is the minimum capacity among a device's units, adding a unit to a device can never raise its rating—it can only keep the rating the same or lower it (if the added unit is smaller than the current minimum). So receiving units is never helpful for increasing a device's own rating.

This leads to a key observation: the only way to benefit is to take a unit away from one device so that its minimum value increases. When we remove the smallest unit from a device, the new minimum becomes the second smallest value of that device. So removing the smallest unit boosts that device's rating from its smallest value to its second smallest value.

Now consider the special case where n = 1. Each device has only one unit, so its rating is just that single value. Removing the unit from a device would leave it empty with a rating of 0, which is never better. Therefore, we simply return the sum of all the single values.

For the general case with n ≥ 2, here is the trick. If we take the smallest unit from every device, each device's rating rises from its smallest value to its second smallest value—but those removed units have to go somewhere. We need at least one device to absorb all these small units. Whichever device becomes the destination will end up holding the global smallest unit mn, so its rating drops down to mn.

So the plan is:

• Every device contributes its second smallest value x[1] to the total (since each gave away its smallest unit).
• One device must serve as the "dumping ground." That device, instead of contributing its second smallest value mn2, ends up with rating mn (the global minimum across all units).
• This causes a loss of mn2 - mn for the chosen device.

To make the final answer as large as possible, we want to minimize this loss. The loss is smallest when we pick the device whose second smallest value mn2 is the smallest among all devices, because that makes mn2 - mn as small as possible.

Putting it together, the answer is the sum of every device's second smallest value, minus the smallest possible penalty mn2 - mn, where mn is the minimum over all units and mn2 is the minimum of all the second smallest values.

We use a greedy strategy to implement the idea above.

Step 1: Handle the special case n = 1.

First, we read n = len(units[0]), the number of units per device. If n == 1, each device has only one unit, and removing it would only hurt the rating. So we directly return the sum of every device's single value:

if n == 1:
    return sum(x[0] for x in units)

Step 2: Process each device for the general case.

We maintain three variables:

• ans: the running total, which accumulates the second smallest value of each device.
• mn: the global minimum across all units (the smallest unit that gets dumped).
• mn2: the minimum among all devices' second smallest values (used to find the cheapest "dumping ground").

We initialize mn = mn2 = inf and ans = 0.

For each device x:

• Sort its units in ascending order with x.sort(). After sorting, x[0] is the smallest value and x[1] is the second smallest.
• Add x[1] to ans, since after removing the smallest unit, each device's rating becomes its second smallest value.
• Update mn2 = min(mn2, x[1]) to track the smallest second-smallest value across devices.
• Update mn = min(mn, x[0]) to track the global smallest unit.

ans = 0
mn = mn2 = inf
for x in units:
    x.sort()
    ans += x[1]
    mn2 = min(mn2, x[1])
    mn = min(mn, x[0])

Step 3: Apply the penalty.

One device must absorb all the removed smallest units, and its rating drops from its second smallest value down to the global minimum mn. To minimize the loss, we choose the device with the smallest mn2. The penalty is therefore mn2 - mn, which we subtract from the total:

ans -= mn2 - mn
return ans

Complexity Analysis:

• Time complexity: O(m × n × log n), where m is the number of devices and n is the number of units per device. Sorting each device's units takes O(n log n), and we do this for all m devices.
• Space complexity: O(log n) (or O(n) depending on the sort implementation), since sorting is done in place and only a constant number of extra variables are used.