There are `k` workers who want to move `n` boxes from an old warehouse to a new one. You are given the two integers `n` and `k`, and a 2D integer array `time` of size `k x 4` where `time[i] = [leftToRighti, pickOldi, rightToLefti, putNewi]`.

The warehouses are separated by a river and connected by a bridge. The old warehouse is on the right bank of the river, and the new warehouse is on the left bank of the river. Initially, all `k` workers are waiting on the left side of the bridge. To move the boxes, the `ith` worker (**0-indexed**) can :

*   Cross the bridge from the left bank (new warehouse) to the right bank (old warehouse) in `leftToRighti` minutes.
*   Pick a box from the old warehouse and return to the bridge in `pickOldi` minutes. Different workers can pick up their boxes simultaneously.
*   Cross the bridge from the right bank (old warehouse) to the left bank (new warehouse) in `rightToLefti` minutes.
*   Put the box in the new warehouse and return to the bridge in `putNewi` minutes. Different workers can put their boxes simultaneously.

A worker `i` is **less efficient** than a worker `j` if either condition is met:

*   `leftToRighti + rightToLefti > leftToRightj + rightToLeftj`
*   `leftToRighti + rightToLefti == leftToRightj + rightToLeftj` and `i > j`

The following rules regulate the movement of the workers through the bridge :

*   If a worker `x` reaches the bridge while another worker `y` is crossing the bridge, `x` waits at their side of the bridge.
*   If the bridge is free, the worker waiting on the right side of the bridge gets to cross the bridge. If more than one worker is waiting on the right side, the one with **the lowest efficiency** crosses first.
*   If the bridge is free and no worker is waiting on the right side, and at least one box remains at the old warehouse, the worker on the left side of the river gets to cross the bridge. If more than one worker is waiting on the left side, the one with **the lowest efficiency** crosses first.

Return _the instance of time at which the last worker **reaches the left bank** of the river after all n boxes have been put in the new warehouse_.

**Example 1:**

**Input:** n = 1, k = 3, time = \[\[1,1,2,1\],\[1,1,3,1\],\[1,1,4,1\]\]
**Output:** 6
**Explanation:** 
From 0 to 1: worker 2 crosses the bridge from the left bank to the right bank.
From 1 to 2: worker 2 picks up a box from the old warehouse.
From 2 to 6: worker 2 crosses the bridge from the right bank to the left bank.
From 6 to 7: worker 2 puts a box at the new warehouse.
The whole process ends after 7 minutes. We return 6 because the problem asks for the instance of time at which the last worker reaches the left bank.

**Example 2:**

**Input:** n = 3, k = 2, time = \[\[1,9,1,8\],\[10,10,10,10\]\]
**Output:** 50
**Explanation:** 
From 0  to 10: worker 1 crosses the bridge from the left bank to the right bank.
From 10 to 20: worker 1 picks up a box from the old warehouse.
From 10 to 11: worker 0 crosses the bridge from the left bank to the right bank.
From 11 to 20: worker 0 picks up a box from the old warehouse.
From 20 to 30: worker 1 crosses the bridge from the right bank to the left bank.
From 30 to 40: worker 1 puts a box at the new warehouse.
From 30 to 31: worker 0 crosses the bridge from the right bank to the left bank.
From 31 to 39: worker 0 puts a box at the new warehouse.
From 39 to 40: worker 0 crosses the bridge from the left bank to the right bank.
From 40 to 49: worker 0 picks up a box from the old warehouse.
From 49 to 50: worker 0 crosses the bridge from the right bank to the left bank.
From 50 to 58: worker 0 puts a box at the new warehouse.
The whole process ends after 58 minutes. We return 50 because the problem asks for the instance of time at which the last worker reaches the left bank.

**Constraints:**

*   `1 <= n, k <= 104`
*   `time.length == k`
*   `time[i].length == 4`
*   `1 <= leftToRighti, pickOldi, rightToLefti, putNewi <= 1000`

오래된 창고에서 새 창고로 `n`개의 상자를 옮기고자 하는 `k`명의 작업자가 있습니다. 두 개의 정수 `n`과 `k`, 그리고 크기 `k x 4`의 2D 정수 배열 `time`이 주어지며, `time[i] = [leftToRighti, pickOldi, rightToLefti, putNewi]`가 주어집니다.

창고는 강으로 분리되어 있고 다리로 연결되어 있습니다. 오래된 창고는 강 오른쪽 강둑에 있고 새 창고는 강 왼쪽 강둑에 있습니다. 처음에는 모든 `k` 작업자가 다리 왼쪽에서 기다리고 있습니다. 상자를 이동하려면 `ith` 작업자(**0-색인**)가 :

* 왼쪽 강둑(새 창고)에서 오른쪽 강둑(옛 창고)으로 다리를 '왼쪽에서 오른쪽으로' 몇 분 안에 건너갑니다.
* 이전 창고에서 상자를 골라 `pickOldi` 분 안에 다리로 돌아옵니다. 다른 작업자가 동시에 상자를 픽업할 수 있습니다.
* 오른쪽 둑(구 창고)에서 왼쪽 둑(새 창고)으로 다리를 건너는 데 걸리는 시간은 '오른쪽에서 왼쪽으로' 분입니다.
* 새 창고에 상자를 넣고 `putNewi` 분 안에 다리로 돌아옵니다. 다른 작업자가 동시에 상자를 넣을 수 있습니다.

두 조건 중 하나만 충족되면 작업자 `i`는 작업자 `j`보다 효율이 떨어집니다:

* `좌측에서 우측으로i + 우측에서 좌측으로i > 좌측에서 우측으로j + 우측에서 좌측으로j`입니다.
* `leftToRighti + rightToLefti == leftToRightj + rightToLeftj` 및 `i > j`.

다음 규칙은 다리를 통과하는 작업자의 이동을 규제합니다:

* 다른 작업자 `y`가 다리를 건너는 동안 작업자 `x`가 다리에 도달하면 `x`는 다리 옆에서 대기합니다.
* 다리가 비어 있으면 다리 오른쪽에서 대기 중인 작업자가 다리를 건너게 됩니다. 오른쪽에 대기 중인 작업자가 두 명 이상일 경우, **효율성이 가장 낮은 작업자가 먼저 건너갑니다.
* 다리가 비어 있고 오른쪽에 대기 중인 작업자가 없고 이전 창고에 상자가 하나 이상 남아 있는 경우, 왼쪽에 있는 작업자가 다리를 건너게 됩니다. 왼쪽에 두 명 이상의 작업자가 대기 중인 경우 **효율성이 가장 낮은 작업자가 먼저 건너갑니다.

n개의 상자를 모두 새 창고에 넣은 후 마지막 작업자가 강 왼쪽 강둑에 도착하는 시간의 인스턴스를 반환합니다.

**예제 1:**

**입력:** n = 1, k = 3, time = \[\[1,1,2,1\],\[1,1,3,1\],\[1,1,4,1\]\]
**출력:** 6
**설명:**
0에서 1까지: 작업자 2가 왼쪽 강둑에서 오른쪽 강둑으로 다리를 건너갑니다.
1에서 2까지: 작업자 2는 오래된 창고에서 상자를 집어옵니다.
2에서 6까지: 작업자 2가 오른쪽 강둑에서 왼쪽 강둑으로 다리를 건너갑니다.
6에서 7까지: 작업자 2가 새 창고에 상자를 놓습니다.
전체 과정은 7분 후에 종료됩니다. 마지막 작업자가 왼쪽 둑에 도달하는 시간의 인스턴스를 묻는 문제이므로 6을 반환합니다.

**예제 2:**

**입력:** n = 3, k = 2, time = \[\[1,9,1,8\],\[10,10,10,10\]\]
**출력:** 50
**설명:**
0에서 10까지: 작업자 1이 왼쪽 강둑에서 오른쪽 강둑으로 다리를 건너갑니다.
10에서 20까지: 작업자 1은 오래된 창고에서 상자를 집어옵니다.
10에서 11까지: 작업자 0이 왼쪽 강둑에서 오른쪽 강둑으로 다리를 건너갑니다.
11에서 20까지: 작업자 0이 오래된 창고에서 상자를 가져옵니다.
20에서 30까지: 작업자 1이 오른쪽 강둑에서 왼쪽 강둑으로 다리를 건너갑니다.
30에서 40까지: 작업자 1이 새 창고에 상자를 놓습니다.
30에서 31까지: 작업자 0이 오른쪽 강둑에서 왼쪽 강둑으로 다리를 건너갑니다.
31에서 39까지: 작업자 0이 새 창고에 상자를 놓습니다.
39에서 40까지: 작업자 0이 왼쪽 강둑에서 오른쪽 강둑으로 다리를 건너갑니다.
40에서 49까지: 작업자 0이 이전 창고에서 상자를 가져옵니다.
49에서 50까지: 작업자 0이 오른쪽 강둑에서 왼쪽 강둑으로 다리를 건너갑니다.
50에서 58까지: 작업자 0이 새 창고에 상자를 놓습니다.
전체 프로세스는 58분 후에 종료됩니다. 문제가 마지막 작업자가 왼쪽 둑에 도달하는 시간의 인스턴스를 요구하기 때문에 50을 반환합니다.

**제약 조건:**

* `1 <= n, k <= 104`
* `time.length == k`
* `time[i].length == 4`

