There is an ATM machine that stores banknotes of `5` denominations: `20`, `50`, `100`, `200`, and `500` dollars. Initially the ATM is empty. The user can use the machine to deposit or withdraw any amount of money.

When withdrawing, the machine prioritizes using banknotes of **larger** values.

*   For example, if you want to withdraw `$300` and there are `2` `$50` banknotes, `1` `$100` banknote, and `1` `$200` banknote, then the machine will use the `$100` and `$200` banknotes.
*   However, if you try to withdraw `$600` and there are `3` `$200` banknotes and `1` `$500` banknote, then the withdraw request will be rejected because the machine will first try to use the `$500` banknote and then be unable to use banknotes to complete the remaining `$100`. Note that the machine is **not** allowed to use the `$200` banknotes instead of the `$500` banknote.

Implement the ATM class:

*   `ATM()` Initializes the ATM object.
*   `void deposit(int[] banknotesCount)` Deposits new banknotes in the order `$20`, `$50`, `$100`, `$200`, and `$500`.
*   `int[] withdraw(int amount)` Returns an array of length `5` of the number of banknotes that will be handed to the user in the order `$20`, `$50`, `$100`, `$200`, and `$500`, and update the number of banknotes in the ATM after withdrawing. Returns `[-1]` if it is not possible (do **not** withdraw any banknotes in this case).

**Example 1:**

**Input**
\[ "ATM ",  "deposit ",  "withdraw ",  "deposit ",  "withdraw ",  "withdraw "\]
\[\[\], \[\[0,0,1,2,1\]\], \[600\], \[\[0,1,0,1,1\]\], \[600\], \[550\]\]
**Output**
\[null, null, \[0,0,1,0,1\], null, \[-1\], \[0,1,0,0,1\]\]

**Explanation**
ATM atm = new ATM();
atm.deposit(\[0,0,1,2,1\]); // Deposits 1 $100 banknote, 2 $200 banknotes,
                          // and 1 $500 banknote.
atm.withdraw(600);        // Returns \[0,0,1,0,1\]. The machine uses 1 $100 banknote
                          // and 1 $500 banknote. The banknotes left over in the
                          // machine are \[0,0,0,2,0\].
atm.deposit(\[0,1,0,1,1\]); // Deposits 1 $50, $200, and $500 banknote.
                          // The banknotes in the machine are now \[0,1,0,3,1\].
atm.withdraw(600);        // Returns \[-1\]. The machine will try to use a $500 banknote
                          // and then be unable to complete the remaining $100,
                          // so the withdraw request will be rejected.
                          // Since the request is rejected, the number of banknotes
                          // in the machine is not modified.
atm.withdraw(550);        // Returns \[0,1,0,0,1\]. The machine uses 1 $50 banknote
                          // and 1 $500 banknote.

**Constraints:**

*   `banknotesCount.length == 5`
*   `0 <= banknotesCount[i] <= 109`
*   `1 <= amount <= 109`
*   At most `5000` calls **in total** will be made to `withdraw` and `deposit`.
*   At least **one** call will be made to each function `withdraw` and `deposit`.

5` 지폐를 보관할 수 있는 ATM 기계가 있습니다: 20`, `50`, `100`, `200`, `500` 달러입니다. 처음에는 ATM이 비어 있습니다. 사용자는 이 기계를 사용하여 원하는 금액을 입금하거나 인출할 수 있습니다.

인출할 때 기계는 **더 큰** 금액의 지폐를 우선적으로 사용합니다.

* 예를 들어 `$300`을 인출하려고 하는데 `$50` 지폐 2장, `$100` 지폐 1장, `$200` 지폐 1장이 있는 경우 기계는 `$100`과 `$200` 지폐를 사용합니다.
* 그러나 `$600`을 인출하려고 하는데 `3` `$200` 지폐와 `1` `$500` 지폐가 있는 경우, 기계가 먼저 `$500` 지폐를 사용하려고 시도한 후 나머지 `$100`을 채우기 위해 지폐를 사용할 수 없기 때문에 인출 요청은 거부됩니다. 현금인출기는 `$500` 지폐 대신 `$200` 지폐를 사용할 수 없다는 점에 유의하시기 바랍니다.

ATM 클래스를 구현합니다:

* `ATM()` ATM 객체를 초기화합니다.
* `void deposit(int[] banknotesCount)` `$20`, `$50`, `$100`, `$200`, `$500` 순서로 새 지폐를 입금합니다.
* `int[] withdraw(int amount)` 사용자에게 전달할 지폐 개수를 `$20`, `$50`, `$100`, `$200`, `$500` 순서로 길이 `5`의 배열을 반환하고 인출 후 ATM에 있는 지폐 개수를 업데이트합니다. 불가능할 경우 `[-1]`을 반환합니다(이 경우 지폐를 인출하지 마십시오).

**예제 1:**

**입력**
\["ATM","입금","출금","입금","출금","출금"\]
\[\[\], \[\[0,0,1,2,1\]\], \[600\], \[\[0,1,0,1,1\]\], \[600\], \[550\]\]
**출력**
\[널, 널, \[0,0,1,0,1\], 널, \[-1\], \[0,1,0,0,0,1\]\]

설명** **설명
ATM atm = 새로운 ATM();
atm.deposit(\[0,0,1,2,1\]); // $100 지폐 1장, $200 지폐 2장을 입금합니다,
                          // 500달러 지폐 1장을 입금합니다.
atm.withdraw(600); // \[0,0,1,0,1\]을 반환합니다. 기계는 $100 지폐 1장
                          // 100달러 지폐 1개와 500달러 지폐 1개를 사용합니다. 기계에 남은 지폐는
                          // 지폐는 \[0,0,0,2,0\]입니다.
atm.deposit(\[0,1,0,1,1\]); // $50, $200, $500 지폐 1장을 입금합니다.
                          // 이제 기계에 있는 지폐는 \[0,1,0,3,1\]입니다.
atm.withdraw(600); // \[-1\]을 반환합니다. 기계는 500달러 지폐를 사용하려고 시도하지만
                          // 나머지 100달러를 인출할 수 없습니다,
                          // 따라서 인출 요청이 거부됩니다.
                          // 요청이 거부되었으므로 기계에 있는 지폐의 수는
                          // 지폐의 수는 수정되지 않습니다.
atm.withdraw(550); // \[0,1,0,0,1\]을 반환합니다. 기계는 50달러 지폐 1장과
                          // 50달러 지폐 1개와 500달러 지폐 1개를 사용합니다.

**제약 조건:**

* `banknotesCount.length == 5`
* `0 <= banknotesCount[i] <= 109`
* `1 <= 금액 <= 109`
출금` 및 `입금`을 위해 최대 `5000` 호출 **총 **개**가 수행됩니다.
* 출금`과 `입금` 함수 각각에 최소 **하나씩** 호출이 이루어집니다.
