Cargo Order Allocation Across Departing Planes

A freight company assigns incoming shipping orders to a fixed fleet of cargo planes. You must implement the order-processing logic: decide whether each order can be accepted, and if so, allocate its cargo across planes and update the fleet's remaining capacity.

You are given planes, where planes[i] = [departure_i, capacity_i]: plane i departs at time departure_i and can carry at most capacity_i units of cargo. Each plane's departure time and capacity are fixed; its remaining capacity only decreases as cargo is assigned to it and never resets.

Orders arrive as a sequence and must be processed strictly in the given order. orders[j] = [time_j, items_j], where time_j is the time the order is placed and items_j is a non-empty list of positive integers — the sizes of the cargo pieces in the order. Let total_j be the sum of items_j.

Rules

1. Eligibility: cargo from order j may only be loaded onto planes that depart strictly after time_j (a plane with departure_i > time_j).
2. Splitting: cargo is divisible — an order's cargo may be split across multiple eligible planes in integer units. Individual piece boundaries do not restrict the split; only the order's total size total_j matters for allocation.
3. Acceptance: order j is accepted if and only if, at the moment it is processed, the sum of the remaining capacities of all eligible planes is at least total_j.
4. All-or-nothing: if an order is rejected, no plane's remaining capacity changes. A rejected order is never retried.
5. Allocation policy (deterministic): when an order is accepted, fill eligible planes in ascending order of departure time, breaking ties by ascending plane index. Assign to each such plane min(remaining cargo to place, plane's remaining capacity) units, skipping planes whose remaining capacity is 0, until the full total_j units are placed. Then commit the capacity updates.

Output

Return an array result with one element per order, in input order:

• If order j is rejected, result[j] is an empty array [].
• If order j is accepted, result[j] is an array of [i, amount] pairs — plane index and the number of units assigned to that plane — listed in the order the planes were filled, including only planes that received amount > 0.

Example

planes = [[5, 10], [10, 8], [3, 6]]
orders = [[2, [4, 5]], [4, [12]], [6, [9]], [0, [30]]]

• Order 0 (time 2, total 9): eligible planes (departure > 2) are 0, 1, 2. Fill by ascending departure: plane 2 (departs 3) takes 6, plane 0 (departs 5) takes 3. Result: [[2, 6], [0, 3]]. Remaining capacities: plane 0 → 7, plane 1 → 8, plane 2 → 0.
• Order 1 (time 4, total 12): eligible planes are 0 (7 left) and 1 (8 left); 7 + 8 = 15 ≥ 12, accepted. Plane 0 takes 7, plane 1 takes 5. Result: [[0, 7], [1, 5]]. Remaining: plane 0 → 0, plane 1 → 3.
• Order 2 (time 6, total 9): only plane 1 is eligible (departs 10) with 3 left; 3 < 9, rejected. Result: []. State unchanged.
• Order 3 (time 0, total 30): all planes eligible, remaining sum is 0 + 3 + 0 = 3 < 30, rejected. Result: [].

result = [[[2, 6], [0, 3]], [[0, 7], [1, 5]], [], []]

Constraints

• 1 <= planes.length <= 2 * 10^5
• 1 <= orders.length <= 2 * 10^5
• The total number of cargo pieces across all orders is at most 4 * 10^5.
• 0 <= departure_i, time_j <= 10^9
• 1 <= capacity_i <= 10^9; each cargo piece size is between 1 and 10^9.
• All capacity and cargo sums fit in a signed 64-bit integer.
• Orders must be processed in the given sequence; each order's acceptance decision uses the fleet state left by all previous orders.

A solution that re-scans and re-sorts the whole fleet for every order will be too slow for the largest inputs; aim for roughly O((n + m) log n) overall, where n is the number of planes and m is the number of orders.