# In-Memory Key-Value Database with Nested Transactions Implement an in-memory key-value store whose keys and values are strings, supporting basic reads and writes plus **nested transactions** (a transaction started inside another transaction). The database is driven by a list of commands and returns one line of output per command that produces a result. Your function receives `commands: List[List[str]]` (each command is a list of tokens) and returns `List[str]` (the outputs, in order). Implement these commands: - `["SET", key, value]` — associate `value` with `key`. Produces no output. - `["GET", key]` — return the current value of `key`, or the literal string `"NULL"` if the key is not set. - `["DELETE", key]` — remove `key`. Produces no output. Deleting a missing key is a no-op. - `["COUNT", value]` — return, as a string, how many keys currently map to `value`. - `["BEGIN"]` — open a new transaction. Transactions may be nested arbitrarily deep; a `BEGIN` inside an open transaction starts a child transaction. Produces no output. - `["COMMIT"]` — permanently apply **all** changes made since the outermost `BEGIN`, closing every open transaction. If no transaction is open, return `"NO TRANSACTION"`. - `["ROLLBACK"]` — discard the changes made in the **innermost** currently-open transaction and close only that transaction. If no transaction is open, return `"NO TRANSACTION"`. ## Semantics - Reads (`GET`, `COUNT`) always reflect the state visible inside the current (innermost) transaction, layered over its parents and the committed base state. - A `SET`/`DELETE` inside a transaction is visible to reads within that transaction and its descendants, but must not affect the committed state until `COMMIT`. - `ROLLBACK` undoes only the innermost transaction's writes; the enclosing transaction (or base state) is restored to what it was before that innermost `BEGIN`. - `COMMIT` flattens every open transaction's writes into the committed base state at once. ## Constraints - `1 <= len(commands) <= 10^5`. - Keys and values are non-empty strings of length up to 100 with no spaces. - `COUNT` should run efficiently (do not scan all keys on every call if it can be avoided). ## Example Input: ``` [ ["SET", "a", "10"], ["GET", "a"], ["BEGIN"], ["SET", "a", "20"], ["BEGIN"], ["DELETE", "a"], ["GET", "a"], ["ROLLBACK"], ["GET", "a"], ["COMMIT"], ["GET", "a"] ] ``` Output: ``` ["10", "NULL", "20", "20"] ``` Explanation: `GET a` is `10`, then after the nested `DELETE` it is `NULL`; the inner `ROLLBACK` restores `a=20`; `COMMIT` makes `a=20` permanent, and the final `GET a` returns `20`.