{
  "b527c5c6": {
    "solve": "def solve_b527c5c6(grid):\n    \"\"\"Two rectangles of 3s, each has one 2. The 2 on the edge indicates direction\n    to extend. Extension width = 2*rect_dim_along_edge - 1, centered on the 2.\"\"\"\n    rows = len(grid)\n    cols = len(grid[0])\n    out = [row[:] for row in grid]\n\n    visited = [[False]*cols for _ in range(rows)]\n\n    def flood_fill(r, c):\n        stack = [(r, c)]\n        cells = []\n        while stack:\n            cr, cc = stack.pop()\n            if cr < 0 or cr >= rows or cc < 0 or cc >= cols:\n                continue\n            if visited[cr][cc] or grid[cr][cc] == 0:\n                continue\n            visited[cr][cc] = True\n            cells.append((cr, cc))\n            for dr, dc in [(-1,0),(1,0),(0,-1),(0,1)]:\n                stack.append((cr+dr, cc+dc))\n        return cells\n\n    rectangles = []\n    for r in range(rows):\n        for c in range(cols):\n            if grid[r][c] != 0 and not visited[r][c]:\n                cells = flood_fill(r, c)\n                if cells:\n                    rectangles.append(cells)\n\n    for rect_cells in rectangles:\n        two_pos = None\n        for r, c in rect_cells:\n            if grid[r][c] == 2:\n                two_pos = (r, c)\n                break\n        if two_pos is None:\n            continue\n\n        min_r = min(r for r, c in rect_cells)\n        max_r = max(r for r, c in rect_cells)\n        min_c = min(c for r, c in rect_cells)\n        max_c = max(c for r, c in rect_cells)\n\n        tr, tc = two_pos\n        rect_h = max_r - min_r + 1\n        rect_w = max_c - min_c + 1\n\n        if tr == min_r:  # top edge -> extend upward\n            # Extension direction is vertical (up), edge is horizontal (top)\n            # Perpendicular spread = 2 * rect_h - 1, centered on tc\n            spread = rect_h - 1\n            for r in range(min_r - 1, -1, -1):\n                for c in range(tc - spread, tc + spread + 1):\n                    if 0 <= c < cols:\n                        if c == tc:\n                            out[r][c] = 2\n                        else:\n                            out[r][c] = 3\n        elif tr == max_r:  # bottom edge -> extend downward\n            spread = rect_h - 1\n            for r in range(max_r + 1, rows):\n                for c in range(tc - spread, tc + spread + 1):\n                    if 0 <= c < cols:\n                        if c == tc:\n                            out[r][c] = 2\n                        else:\n                            out[r][c] = 3\n        elif tc == min_c:  # left edge -> extend leftward\n            spread = rect_w - 1\n            for c in range(min_c - 1, -1, -1):\n                for r in range(tr - spread, tr + spread + 1):\n                    if 0 <= r < rows:\n                        if r == tr:\n                            out[r][c] = 2\n                        else:\n                            out[r][c] = 3\n        elif tc == max_c:  # right edge -> extend rightward\n            spread = rect_w - 1\n            for c in range(max_c + 1, cols):\n                for r in range(tr - spread, tr + spread + 1):\n                    if 0 <= r < rows:\n                        if r == tr:\n                            out[r][c] = 2\n                        else:\n                            out[r][c] = 3\n\n    return out\n",
    "test_output": [
      [
        [
          0,
          0,
          0,
          0,
          3,
          3,
          3,
          0,
          3,
          3,
          3,
          3,
          3,
          2,
          3,
          3,
          3,
          3,
          3,
          0
        ],
        [
          0,
          0,
          0,
          0,
          3,
          3,
          3,
          0,
          3,
          3,
          3,
          3,
          3,
          2,
          3,
          3,
          3,
          3,
          3,
          0
        ],
        [
          0,
          0,
          0,
          0,
          3,
          3,
          3,
          0,
          3,
          3,
          3,
          3,
          3,
          2,
          3,
          3,
          3,
          3,
          3,
          0
        ],
        [
          3,
          3,
          3,
          3,
          3,
          3,
          3,
          0,
          3,
          3,
          3,
          3,
          3,
          2,
          3,
          3,
          3,
          3,
          3,
          0
        ],
        [
          3,
          3,
          3,
          3,
          3,
          3,
          3,
          0,
          3,
          3,
          3,
          3,
          3,
          2,
          3,
          3,
          3,
          3,
          3,
          0
        ],
        [
          2,
          2,
          2,
          2,
          2,
          3,
          3,
          0,
          3,
          3,
          3,
          3,
          3,
          2,
          3,
          3,
          3,
          3,
          3,
          0
        ],
        [
          3,
          3,
          3,
          3,
          3,
          3,
          3,
          0,
          3,
          3,
          3,
          3,
          3,
          2,
          3,
          3,
          3,
          3,
          3,
          0
        ],
        [
          3,
          3,
          3,
          3,
          3,
          3,
          3,
          0,
          3,
          3,
          3,
          3,
          3,
          2,
          3,
          3,
          3,
          3,
          3,
          0
        ],
        [
          0,
          0,
          0,
          0,
          3,
          3,
          3,
          0,
          3,
          3,
          3,
          3,
          3,
          2,
          3,
          3,
          3,
          3,
          3,
          0
        ],
        [
          0,
          0,
          0,
          0,
          3,
          3,
          3,
          0,
          3,
          3,
          3,
          3,
          3,
          2,
          3,
          3,
          3,
          3,
          3,
          0
        ],
        [
          0,
          0,
          0,
          0,
          3,
          3,
          3,
          0,
          3,
          3,
          3,
          3,
          3,
          2,
          3,
          3,
          3,
          3,
          3,
          0
        ],
        [
          0,
          0,
          0,
          0,
          0,
          0,
          0,
          0,
          3,
          3,
          3,
          3,
          3,
          2,
          3,
          3,
          3,
          3,
          3,
          0
        ],
        [
          0,
          0,
          0,
          0,
          0,
          0,
          0,
          0,
          3,
          3,
          3,
          3,
          3,
          2,
          3,
          3,
          3,
          3,
          3,
          0
        ],
        [
          0,
          0,
          0,
          0,
          0,
          0,
          0,
          0,
          3,
          3,
          3,
          3,
          3,
          2,
          3,
          3,
          3,
          3,
          3,
          0
        ],
        [
          0,
          0,
          0,
          0,
          0,
          0,
          0,
          3,
          3,
          3,
          3,
          3,
          3,
          2,
          3,
          3,
          3,
          3,
          3,
          3
        ],
        [
          0,
          0,
          0,
          0,
          0,
          0,
          0,
          3,
          3,
          3,
          3,
          3,
          3,
          3,
          3,
          3,
          3,
          3,
          3,
          3
        ],
        [
          0,
          0,
          0,
          0,
          0,
          0,
          0,
          3,
          3,
          3,
          3,
          3,
          3,
          3,
          3,
          3,
          3,
          3,
          3,
          3
        ],
        [
          0,
          0,
          0,
          0,
          0,
          0,
          0,
          3,
          3,
          3,
          3,
          3,
          3,
          3,
          3,
          3,
          3,
          3,
          3,
          3
        ],
        [
          0,
          0,
          0,
          0,
          0,
          0,
          0,
          3,
          3,
          3,
          3,
          3,
          3,
          3,
          3,
          3,
          3,
          3,
          3,
          3
        ],
        [
          0,
          0,
          0,
          0,
          0,
          0,
          0,
          3,
          3,
          3,
          3,
          3,
          3,
          3,
          3,
          3,
          3,
          3,
          3,
          3
        ]
      ]
    ]
  },
  "b548a754": {
    "solve": "def solve_b548a754(grid):\n    \"\"\"Rectangle with border color and inner color. An 8 dot indicates direction.\n    Stretch the rectangle toward the 8, keeping border/inner pattern.\"\"\"\n    rows = len(grid)\n    cols = len(grid[0])\n    out = [row[:] for row in grid]\n\n    eight_r, eight_c = None, None\n    for r in range(rows):\n        for c in range(cols):\n            if grid[r][c] == 8:\n                eight_r, eight_c = r, c\n                break\n\n    rect_cells = []\n    for r in range(rows):\n        for c in range(cols):\n            if grid[r][c] != 0 and grid[r][c] != 8:\n                rect_cells.append((r, c))\n\n    min_r = min(r for r, c in rect_cells)\n    max_r = max(r for r, c in rect_cells)\n    min_c = min(c for r, c in rect_cells)\n    max_c = max(c for r, c in rect_cells)\n\n    border_color = grid[min_r][min_c]\n    inner_color = None\n    for r in range(min_r+1, max_r):\n        for c in range(min_c+1, max_c):\n            if grid[r][c] != border_color:\n                inner_color = grid[r][c]\n                break\n        if inner_color:\n            break\n\n    out[eight_r][eight_c] = 0\n\n    # Determine new bounding box\n    new_min_r, new_max_r = min_r, max_r\n    new_min_c, new_max_c = min_c, max_c\n\n    if eight_r < min_r:\n        new_min_r = eight_r\n    elif eight_r > max_r:\n        new_max_r = eight_r\n    elif eight_c < min_c:\n        new_min_c = eight_c\n    elif eight_c > max_c:\n        new_max_c = eight_c\n\n    for r in range(new_min_r, new_max_r + 1):\n        for c in range(new_min_c, new_max_c + 1):\n            if r == new_min_r or r == new_max_r or c == new_min_c or c == new_max_c:\n                out[r][c] = border_color\n            else:\n                out[r][c] = inner_color\n\n    return out\n",
    "test_output": [
      [
        [
          0,
          0,
          0,
          0,
          0,
          0,
          0,
          0,
          0,
          0,
          0,
          0,
          0
        ],
        [
          0,
          0,
          0,
          6,
          6,
          6,
          6,
          6,
          0,
          0,
          0,
          0,
          0
        ],
        [
          0,
          0,
          0,
          6,
          4,
          4,
          4,
          6,
          0,
          0,
          0,
          0,
          0
        ],
        [
          0,
          0,
          0,
          6,
          4,
          4,
          4,
          6,
          0,
          0,
          0,
          0,
          0
        ],
        [
          0,
          0,
          0,
          6,
          4,
          4,
          4,
          6,
          0,
          0,
          0,
          0,
          0
        ],
        [
          0,
          0,
          0,
          6,
          4,
          4,
          4,
          6,
          0,
          0,
          0,
          0,
          0
        ],
        [
          0,
          0,
          0,
          6,
          4,
          4,
          4,
          6,
          0,
          0,
          0,
          0,
          0
        ],
        [
          0,
          0,
          0,
          6,
          4,
          4,
          4,
          6,
          0,
          0,
          0,
          0,
          0
        ],
        [
          0,
          0,
          0,
          6,
          4,
          4,
          4,
          6,
          0,
          0,
          0,
          0,
          0
        ],
        [
          0,
          0,
          0,
          6,
          4,
          4,
          4,
          6,
          0,
          0,
          0,
          0,
          0
        ],
        [
          0,
          0,
          0,
          6,
          4,
          4,
          4,
          6,
          0,
          0,
          0,
          0,
          0
        ],
        [
          0,
          0,
          0,
          6,
          4,
          4,
          4,
          6,
          0,
          0,
          0,
          0,
          0
        ],
        [
          0,
          0,
          0,
          6,
          6,
          6,
          6,
          6,
          0,
          0,
          0,
          0,
          0
        ]
      ]
    ]
  },
  "b60334d2": {
    "solve": "def solve_b60334d2(grid):\n    \"\"\"Each 5 gets a plus pattern: diagonals get 5, orthogonals get 1, center becomes 0.\"\"\"\n    rows = len(grid)\n    cols = len(grid[0])\n    out = [[0]*cols for _ in range(rows)]\n\n    for r in range(rows):\n        for c in range(cols):\n            if grid[r][c] == 5:\n                for dr in [-1, 0, 1]:\n                    for dc in [-1, 0, 1]:\n                        nr, nc = r + dr, c + dc\n                        if 0 <= nr < rows and 0 <= nc < cols:\n                            if dr == 0 and dc == 0:\n                                pass\n                            elif dr == 0 or dc == 0:\n                                out[nr][nc] = 1\n                            else:\n                                out[nr][nc] = 5\n\n    return out\n",
    "test_output": [
      [
        [
          5,
          1,
          5,
          0,
          0,
          0,
          0,
          0,
          0
        ],
        [
          1,
          0,
          1,
          0,
          0,
          0,
          0,
          0,
          0
        ],
        [
          5,
          1,
          5,
          5,
          1,
          5,
          0,
          0,
          0
        ],
        [
          0,
          0,
          0,
          1,
          0,
          1,
          0,
          0,
          0
        ],
        [
          0,
          0,
          0,
          5,
          1,
          5,
          5,
          1,
          5
        ],
        [
          0,
          0,
          0,
          0,
          0,
          0,
          1,
          0,
          1
        ],
        [
          0,
          5,
          1,
          5,
          0,
          0,
          5,
          1,
          5
        ],
        [
          0,
          1,
          0,
          1,
          0,
          0,
          0,
          0,
          0
        ],
        [
          0,
          5,
          1,
          5,
          0,
          0,
          0,
          0,
          0
        ]
      ]
    ]
  },
  "b6afb2da": {
    "solve": "def solve_b6afb2da(grid):\n    \"\"\"Each rectangle of 5s: corners->1, border non-corners->4, interior->2.\"\"\"\n    rows = len(grid)\n    cols = len(grid[0])\n    out = [row[:] for row in grid]\n\n    visited = [[False]*cols for _ in range(rows)]\n\n    def flood_fill(r, c):\n        stack = [(r, c)]\n        cells = []\n        while stack:\n            cr, cc = stack.pop()\n            if cr < 0 or cr >= rows or cc < 0 or cc >= cols:\n                continue\n            if visited[cr][cc] or grid[cr][cc] != 5:\n                continue\n            visited[cr][cc] = True\n            cells.append((cr, cc))\n            for dr, dc in [(-1,0),(1,0),(0,-1),(0,1)]:\n                stack.append((cr+dr, cc+dc))\n        return cells\n\n    for r in range(rows):\n        for c in range(cols):\n            if grid[r][c] == 5 and not visited[r][c]:\n                cells = flood_fill(r, c)\n                min_r2 = min(r for r, c in cells)\n                max_r2 = max(r for r, c in cells)\n                min_c2 = min(c for r, c in cells)\n                max_c2 = max(c for r, c in cells)\n\n                for cr, cc in cells:\n                    is_top = (cr == min_r2)\n                    is_bot = (cr == max_r2)\n                    is_left = (cc == min_c2)\n                    is_right = (cc == max_c2)\n\n                    is_corner = (is_top or is_bot) and (is_left or is_right)\n                    is_border = is_top or is_bot or is_left or is_right\n\n                    if is_corner:\n                        out[cr][cc] = 1\n                    elif is_border:\n                        out[cr][cc] = 4\n                    else:\n                        out[cr][cc] = 2\n\n    return out\n",
    "test_output": [
      [
        [
          0,
          1,
          4,
          4,
          1,
          0,
          0,
          0,
          0,
          0
        ],
        [
          0,
          4,
          2,
          2,
          4,
          0,
          0,
          0,
          0,
          0
        ],
        [
          0,
          4,
          2,
          2,
          4,
          0,
          0,
          0,
          0,
          0
        ],
        [
          0,
          4,
          2,
          2,
          4,
          0,
          0,
          0,
          0,
          0
        ],
        [
          0,
          4,
          2,
          2,
          4,
          0,
          0,
          0,
          0,
          0
        ],
        [
          0,
          1,
          4,
          4,
          1,
          0,
          0,
          0,
          0,
          0
        ],
        [
          0,
          0,
          0,
          0,
          0,
          0,
          0,
          0,
          0,
          0
        ],
        [
          0,
          0,
          0,
          0,
          1,
          4,
          4,
          4,
          4,
          1
        ],
        [
          0,
          0,
          0,
          0,
          4,
          2,
          2,
          2,
          2,
          4
        ],
        [
          0,
          0,
          0,
          0,
          1,
          4,
          4,
          4,
          4,
          1
        ]
      ]
    ]
  },
  "b7249182": {
    "solve": "def solve_b7249182(grid):\n    \"\"\"Two dots on same row or column. They extend toward each other,\n    meeting with bracket shapes. Arm width perpendicular is always 2.\"\"\"\n    rows = len(grid)\n    cols = len(grid[0])\n    out = [row[:] for row in grid]\n\n    dots = []\n    for r in range(rows):\n        for c in range(cols):\n            if grid[r][c] != 0:\n                dots.append((r, c, grid[r][c]))\n\n    r1, c1, color1 = dots[0]\n    r2, c2, color2 = dots[1]\n\n    if c1 == c2:\n        # Same column - vertical arrangement\n        if r1 > r2:\n            r1, c1, color1, r2, c2, color2 = r2, c2, color2, r1, c1, color1\n\n        dist = r2 - r1\n        half = dist // 2\n        half_w = 2\n\n        # Color1 vertical line from r1 down\n        bar1_r = r1 + half - 1\n        for r in range(r1 + 1, bar1_r):\n            out[r][c1] = color1\n        # Horizontal bar for color1\n        for c in range(c1 - half_w, c1 + half_w + 1):\n            if 0 <= c < cols:\n                out[bar1_r][c] = color1\n        # Side row for color1\n        side1_r = bar1_r + 1\n        if 0 <= c1 - half_w < cols:\n            out[side1_r][c1 - half_w] = color1\n        if 0 <= c1 + half_w < cols:\n            out[side1_r][c1 + half_w] = color1\n\n        # Color2 vertical line from r2 up\n        bar2_r = r2 - half + 1\n        for r in range(r2 - 1, bar2_r, -1):\n            out[r][c2] = color2\n        # Horizontal bar for color2\n        for c in range(c2 - half_w, c2 + half_w + 1):\n            if 0 <= c < cols:\n                out[bar2_r][c] = color2\n        # Side row for color2\n        side2_r = bar2_r - 1\n        if 0 <= c2 - half_w < cols:\n            out[side2_r][c2 - half_w] = color2\n        if 0 <= c2 + half_w < cols:\n            out[side2_r][c2 + half_w] = color2\n\n    else:  # Same row\n        if c1 > c2:\n            r1, c1, color1, r2, c2, color2 = r2, c2, color2, r1, c1, color1\n\n        dist = c2 - c1\n        half = dist // 2\n        half_w = 2\n\n        # Color1 horizontal line from c1 right\n        bar1_c = c1 + half - 1\n        for c in range(c1 + 1, bar1_c):\n            out[r1][c] = color1\n        # Vertical bar for color1\n        for r in range(r1 - half_w, r1 + half_w + 1):\n            if 0 <= r < rows:\n                out[r][bar1_c] = color1\n        # Side col for color1\n        side1_c = bar1_c + 1\n        if 0 <= r1 - half_w < rows:\n            out[r1 - half_w][side1_c] = color1\n        if 0 <= r1 + half_w < rows:\n            out[r1 + half_w][side1_c] = color1\n\n        # Color2 horizontal line from c2 left\n        bar2_c = c2 - half + 1\n        for c in range(c2 - 1, bar2_c, -1):\n            out[r2][c] = color2\n        # Vertical bar for color2\n        for r in range(r2 - half_w, r2 + half_w + 1):\n            if 0 <= r < rows:\n                out[r][bar2_c] = color2\n        # Side col for color2\n        side2_c = bar2_c - 1\n        if 0 <= r2 - half_w < rows:\n            out[r2 - half_w][side2_c] = color2\n        if 0 <= r2 + half_w < rows:\n            out[r2 + half_w][side2_c] = color2\n\n    return out\n",
    "test_output": [
      [
        [
          0,
          0,
          0,
          0,
          0,
          0,
          0,
          0,
          0
        ],
        [
          0,
          0,
          0,
          7,
          0,
          0,
          0,
          0,
          0
        ],
        [
          0,
          0,
          0,
          7,
          0,
          0,
          0,
          0,
          0
        ],
        [
          0,
          0,
          0,
          7,
          0,
          0,
          0,
          0,
          0
        ],
        [
          0,
          0,
          0,
          7,
          0,
          0,
          0,
          0,
          0
        ],
        [
          0,
          0,
          0,
          7,
          0,
          0,
          0,
          0,
          0
        ],
        [
          0,
          0,
          0,
          7,
          0,
          0,
          0,
          0,
          0
        ],
        [
          0,
          7,
          7,
          7,
          7,
          7,
          0,
          0,
          0
        ],
        [
          0,
          7,
          0,
          0,
          0,
          7,
          0,
          0,
          0
        ],
        [
          0,
          6,
          0,
          0,
          0,
          6,
          0,
          0,
          0
        ],
        [
          0,
          6,
          6,
          6,
          6,
          6,
          0,
          0,
          0
        ],
        [
          0,
          0,
          0,
          6,
          0,
          0,
          0,
          0,
          0
        ],
        [
          0,
          0,
          0,
          6,
          0,
          0,
          0,
          0,
          0
        ],
        [
          0,
          0,
          0,
          6,
          0,
          0,
          0,
          0,
          0
        ],
        [
          0,
          0,
          0,
          6,
          0,
          0,
          0,
          0,
          0
        ],
        [
          0,
          0,
          0,
          6,
          0,
          0,
          0,
          0,
          0
        ],
        [
          0,
          0,
          0,
          6,
          0,
          0,
          0,
          0,
          0
        ],
        [
          0,
          0,
          0,
          0,
          0,
          0,
          0,
          0,
          0
        ],
        [
          0,
          0,
          0,
          0,
          0,
          0,
          0,
          0,
          0
        ]
      ]
    ]
  },
  "b8cdaf2b": {
    "solve": "def solve_b8cdaf2b(grid):\n    \"\"\"Bottom rows form a base pattern. The center color extends diagonally upward\n    from the inner edges of the second-to-last row.\"\"\"\n    rows = len(grid)\n    cols = len(grid[0])\n    out = [row[:] for row in grid]\n\n    bottom = grid[rows-1]\n    second = grid[rows-2]\n\n    center_c = cols // 2\n    center_color = bottom[center_c]\n\n    inner_cells = [(c, second[c]) for c in range(cols) if second[c] != 0]\n    inner_left = min(c for c, _ in inner_cells)\n    inner_right = max(c for c, _ in inner_cells)\n\n    outer_left = min(c for c in range(cols) if bottom[c] != 0)\n    outer_right = max(c for c in range(cols) if bottom[c] != 0)\n\n    gap_left = inner_left - outer_left\n    gap_right = outer_right - inner_right\n\n    for step in range(1, gap_left + 1):\n        r = rows - 2 - step\n        c = inner_left - step\n        if 0 <= r < rows and 0 <= c < cols:\n            out[r][c] = center_color\n\n    for step in range(1, gap_right + 1):\n        r = rows - 2 - step\n        c = inner_right + step\n        if 0 <= r < rows and 0 <= c < cols:\n            out[r][c] = center_color\n\n    return out\n",
    "test_output": [
      [
        [
          0,
          0,
          0,
          0,
          0,
          0,
          0,
          0,
          0
        ],
        [
          0,
          0,
          0,
          0,
          0,
          0,
          0,
          0,
          0
        ],
        [
          0,
          0,
          0,
          0,
          0,
          0,
          0,
          0,
          0
        ],
        [
          0,
          0,
          0,
          0,
          0,
          0,
          0,
          0,
          0
        ],
        [
          2,
          0,
          0,
          0,
          0,
          0,
          0,
          0,
          2
        ],
        [
          0,
          2,
          0,
          0,
          0,
          0,
          0,
          2,
          0
        ],
        [
          0,
          0,
          2,
          0,
          0,
          0,
          2,
          0,
          0
        ],
        [
          0,
          0,
          0,
          8,
          8,
          8,
          0,
          0,
          0
        ],
        [
          8,
          8,
          8,
          2,
          2,
          2,
          8,
          8,
          8
        ]
      ]
    ]
  },
  "b91ae062": {
    "solve": "def solve_b91ae062(grid):\n    \"\"\"3x3 input scaled up by factor = number of distinct non-zero colors.\"\"\"\n    rows = len(grid)\n    cols = len(grid[0])\n\n    distinct_colors = len(set(grid[r][c] for r in range(rows) for c in range(cols) if grid[r][c] != 0))\n    scale = distinct_colors\n\n    out_rows = rows * scale\n    out_cols = cols * scale\n    out = [[0]*out_cols for _ in range(out_rows)]\n\n    for r in range(rows):\n        for c in range(cols):\n            val = grid[r][c]\n            for dr in range(scale):\n                for dc in range(scale):\n                    out[r*scale+dr][c*scale+dc] = val\n\n    return out\n",
    "test_output": [
      [
        [
          0,
          0,
          0,
          0,
          1,
          1,
          1,
          1,
          0,
          0,
          0,
          0
        ],
        [
          0,
          0,
          0,
          0,
          1,
          1,
          1,
          1,
          0,
          0,
          0,
          0
        ],
        [
          0,
          0,
          0,
          0,
          1,
          1,
          1,
          1,
          0,
          0,
          0,
          0
        ],
        [
          0,
          0,
          0,
          0,
          1,
          1,
          1,
          1,
          0,
          0,
          0,
          0
        ],
        [
          0,
          0,
          0,
          0,
          8,
          8,
          8,
          8,
          7,
          7,
          7,
          7
        ],
        [
          0,
          0,
          0,
          0,
          8,
          8,
          8,
          8,
          7,
          7,
          7,
          7
        ],
        [
          0,
          0,
          0,
          0,
          8,
          8,
          8,
          8,
          7,
          7,
          7,
          7
        ],
        [
          0,
          0,
          0,
          0,
          8,
          8,
          8,
          8,
          7,
          7,
          7,
          7
        ],
        [
          9,
          9,
          9,
          9,
          9,
          9,
          9,
          9,
          0,
          0,
          0,
          0
        ],
        [
          9,
          9,
          9,
          9,
          9,
          9,
          9,
          9,
          0,
          0,
          0,
          0
        ],
        [
          9,
          9,
          9,
          9,
          9,
          9,
          9,
          9,
          0,
          0,
          0,
          0
        ],
        [
          9,
          9,
          9,
          9,
          9,
          9,
          9,
          9,
          0,
          0,
          0,
          0
        ]
      ]
    ]
  },
  "b94a9452": {
    "solve": "def solve_b94a9452(grid):\n    \"\"\"Rectangle with border and inner colors. Extract and swap them.\"\"\"\n    rows = len(grid)\n    cols = len(grid[0])\n\n    rect_cells = []\n    for r in range(rows):\n        for c in range(cols):\n            if grid[r][c] != 0:\n                rect_cells.append((r, c))\n\n    min_r = min(r for r, c in rect_cells)\n    max_r = max(r for r, c in rect_cells)\n    min_c = min(c for r, c in rect_cells)\n    max_c = max(c for r, c in rect_cells)\n\n    h = max_r - min_r + 1\n    w = max_c - min_c + 1\n\n    rect = []\n    for r in range(min_r, max_r + 1):\n        row = []\n        for c in range(min_c, max_c + 1):\n            row.append(grid[r][c])\n        rect.append(row)\n\n    border_color = rect[0][0]\n    inner_color = None\n    for r in range(h):\n        for c in range(w):\n            if rect[r][c] != border_color:\n                inner_color = rect[r][c]\n                break\n        if inner_color:\n            break\n\n    out = []\n    for r in range(h):\n        row = []\n        for c in range(w):\n            if rect[r][c] == border_color:\n                row.append(inner_color)\n            else:\n                row.append(border_color)\n        out.append(row)\n\n    return out\n",
    "test_output": [
      [
        [
          8,
          8,
          8,
          8,
          8,
          8
        ],
        [
          8,
          8,
          8,
          8,
          8,
          8
        ],
        [
          8,
          8,
          3,
          3,
          8,
          8
        ],
        [
          8,
          8,
          3,
          3,
          8,
          8
        ],
        [
          8,
          8,
          8,
          8,
          8,
          8
        ],
        [
          8,
          8,
          8,
          8,
          8,
          8
        ]
      ]
    ]
  },
  "b9b7f026": {
    "solve": "def solve_b9b7f026(grid):\n    \"\"\"Multiple filled rectangles. One has holes (0s inside). Output its color.\"\"\"\n    rows = len(grid)\n    cols = len(grid[0])\n\n    visited = [[False]*cols for _ in range(rows)]\n\n    def flood_fill(r, c, color):\n        stack = [(r, c)]\n        cells = []\n        while stack:\n            cr, cc = stack.pop()\n            if cr < 0 or cr >= rows or cc < 0 or cc >= cols:\n                continue\n            if visited[cr][cc] or grid[cr][cc] != color:\n                continue\n            visited[cr][cc] = True\n            cells.append((cr, cc))\n            for dr, dc in [(-1,0),(1,0),(0,-1),(0,1)]:\n                stack.append((cr+dr, cc+dc))\n        return cells\n\n    for r in range(rows):\n        for c in range(cols):\n            if grid[r][c] != 0 and not visited[r][c]:\n                color = grid[r][c]\n                cells = flood_fill(r, c, color)\n\n                min_r2 = min(cr for cr, cc in cells)\n                max_r2 = max(cr for cr, cc in cells)\n                min_c2 = min(cc for cr, cc in cells)\n                max_c2 = max(cc for cr, cc in cells)\n\n                expected_area = (max_r2 - min_r2 + 1) * (max_c2 - min_c2 + 1)\n                actual_area = len(cells)\n\n                if actual_area < expected_area:\n                    return [[color]]\n\n    return [[0]]\n",
    "test_output": [
      [
        [
          7
        ]
      ]
    ]
  },
  "ba26e723": {
    "solve": "def solve_ba26e723(grid):\n    \"\"\"3-row pattern. Replace 4 with 6 at columns that are multiples of 3.\"\"\"\n    rows = len(grid)\n    cols = len(grid[0])\n    out = [row[:] for row in grid]\n\n    for r in range(rows):\n        for c in range(cols):\n            if out[r][c] == 4 and c % 3 == 0:\n                out[r][c] = 6\n\n    return out\n",
    "test_output": [
      [
        [
          0,
          4,
          0,
          6,
          0,
          4,
          0,
          4,
          0,
          6,
          0,
          4,
          0,
          4,
          0,
          6,
          0
        ],
        [
          6,
          4,
          4,
          6,
          4,
          4,
          6,
          4,
          4,
          6,
          4,
          4,
          6,
          4,
          4,
          6,
          4
        ],
        [
          6,
          0,
          4,
          0,
          4,
          0,
          6,
          0,
          4,
          0,
          4,
          0,
          6,
          0,
          4,
          0,
          4
        ]
      ]
    ]
  }
}