You are given an `m x n` grid that simulates the spread of an infection over discrete days. Each cell holds one of four states: - `0` — uninfected (healthy and susceptible) - `1` — infected - `2` — immune (recovered; permanently safe and can never be infected again) - `3` — dead (permanent; never changes) Two integer parameters govern the dynamics: - `infectThreshold` (`K_inf`): an uninfected cell becomes infected on the next day if **at least `infectThreshold`** of its neighbors are infected on the current day. - `deathThreshold` (`K_death`): if a cell is infected and, at the moment it becomes infected, **at least `deathThreshold`** of its neighbors are also infected, the cell is marked for death; when its recovery time arrives it dies instead of recovering. Every infected cell stays infected for exactly **one full day** and then resolves on the following day: - If the cell was **not** marked for death, it becomes immune (`2`) on the next day. - If the cell **was** marked for death, it becomes dead (`3`) on the next day instead of recovering. Neighbors are the up to 8 cells horizontally, vertically, and diagonally adjacent (Moore neighborhood). Cells outside the grid are not neighbors. ### Day-transition rules (applied simultaneously to every cell) Compute the next day's grid from the current grid as follows. All cells transition at the same instant — base every decision on the **current** day's values, not on partially-updated values. For each cell: 1. **`0` (uninfected):** Let `c` be the number of its neighbors that are `1` (infected) on the current day. If `c >= infectThreshold`, the cell becomes `1` (infected) next day. Otherwise it stays `0`. At the instant a cell becomes infected, if `c >= deathThreshold` as well, the cell is permanently marked for death (this mark is remembered until the cell resolves). 2. **`1` (infected):** The cell has now completed its one infected day and resolves next day. If it was marked for death, it becomes `3` (dead); otherwise it becomes `2` (immune). 3. **`2` (immune):** Stays `2` forever. 4. **`3` (dead):** Stays `3` forever. A cell that is uninfected and infected on the same transition uses the same neighbor count `c` for both the infection check (`>= infectThreshold`) and the death-mark check (`>= deathThreshold`). The simulation runs until the grid reaches a steady state — a day on which applying the transition rules produces a grid identical to the current one (no cell changes). Return the grid in that final, stable state. ### Worked example `infectThreshold = 1`, `deathThreshold = 1`. Day 0: ``` 1 0 0 0 0 0 0 0 0 ``` Day 1 (cell `(0,0)` was infected for its one day, has no infected neighbors so it is not marked for death, and recovers to `2`; cells `(0,1)`, `(1,0)`, `(1,1)` each had `1` infected neighbor, met `infectThreshold = 1`, so they become infected — and since their infected-neighbor count `1` also meets `deathThreshold = 1`, they are all marked for death): ``` 2 1 0 1 1 0 0 0 0 ``` Day 2 (the three cells infected on Day 1 were all marked for death, so they become `3`; their uninfected neighbors with `>= 1` infected neighbor on Day 1 become infected and are likewise marked for death): ``` 2 3 1 3 3 1 1 1 1 ``` Day 3 — final stable state (the newly infected cells were marked for death and become `3`; no uninfected cells remain reachable, so the grid no longer changes): ``` 2 3 3 3 3 3 3 3 3 ``` Return the Day 3 grid. ### Input / Output - **Input:** a 2D integer array `grid` (`m x n`, each entry in `{0, 1, 2, 3}`), an integer `infectThreshold`, and an integer `deathThreshold`. - **Output:** the 2D integer array representing the grid once it has reached a stable state (a day whose transition leaves the grid unchanged). ### Constraints - `1 <= m, n <= 200` - `1 <= infectThreshold <= 8` - `1 <= deathThreshold <= 8` - Every cell of the input grid is one of `0`, `1`, `2`, `3`. - The simulation is guaranteed to converge to a stable state.