def rottingOranges(grid):
    if not grid:
        return -1

    rows = len(grid)
    cols = len(grid[0])
    minutes_passed = 0

    while True:
        oranges_to_rot_this_minute = []
        fresh_oranges_count = 0
        previous_grid_snapshot = [row[:] for row in grid]

        for row_index in range(rows):
            for col_index in range(cols):
                if previous_grid_snapshot[row_index][col_index] == 1:
                    fresh_oranges_count += 1
                    is_adjacent_to_rotten = False
                    # Check all four neighbors to see if any were rotten in the previous state.
                    for delta_row, delta_col in [(0, 1), (0, -1), (1, 0), (-1, 0)]:
                        neighbor_row = row_index + delta_row
                        neighbor_col = col_index + delta_col

                        if 0 <= neighbor_row < rows and 0 <= neighbor_col < cols and previous_grid_snapshot[neighbor_row][neighbor_col] == 2:
                            is_adjacent_to_rotten = True
                            break
                    
                    if is_adjacent_to_rotten:
                        oranges_to_rot_this_minute.append((row_index, col_index))
        
        # If no oranges rotted this minute, the process stops.
        if not oranges_to_rot_this_minute:
            # If there are still fresh oranges left, it's impossible for them all to rot.
            if fresh_oranges_count > 0:
                return -1
            else:
                return minutes_passed

        # Update the grid with all newly rotten oranges for the next minute's simulation.
        for row_index, col_index in oranges_to_rot_this_minute:
            grid[row_index][col_index] = 2

        minutes_passed += 1

from collections import deque

def oranges_rotting(grid):
    if not grid:
        return 0

    number_of_rows = len(grid)
    number_of_cols = len(grid[0])
    fresh_oranges_count = 0
    rotten_oranges_queue = deque()

    for row_index in range(number_of_rows):
        for col_index in range(number_of_cols):
            if grid[row_index][col_index] == 1:
                fresh_oranges_count += 1
            elif grid[row_index][col_index] == 2:
                rotten_oranges_queue.append((row_index, col_index))

    minutes_elapsed = 0
    directions = [(1, 0), (-1, 0), (0, 1), (0, -1)]

    # The queue size represents all oranges that become rotten in the current minute.
    while rotten_oranges_queue and fresh_oranges_count > 0:

        number_rotten_in_current_minute = len(rotten_oranges_queue)
        for _ in range(number_rotten_in_current_minute):
            rotten_row, rotten_col = rotten_oranges_queue.popleft()

            for row_direction, col_direction in directions:
                neighbor_row = rotten_row + row_direction
                neighbor_col = rotten_col + col_direction

                if 0 <= neighbor_row < number_of_rows and 0 <= neighbor_col < number_of_cols and grid[neighbor_row][neighbor_col] == 1:
                    grid[neighbor_row][neighbor_col] = 2
                    rotten_oranges_queue.append((neighbor_row, neighbor_col))
                    fresh_oranges_count -= 1
        
        # Increment time only after all oranges from the current minute have spread rot.
        minutes_elapsed += 1

    # If fresh oranges remain, they were unreachable, so the task is impossible.
    if fresh_oranges_count == 0:
        return minutes_elapsed
    else:
        return -1