train_patterns.json

[
    {
        "id": "007bbfb7",
        "pattern": "To generate the output grid from the input grid, follow these steps:\n\n1. **Identify Filled Cells**: Locate all cells in the input grid that are filled with a specific color.\n\n2. **Determine Scaling Factors**: Note the height (H) and width (W) of the input grid.\n\n3. **Create Output Grid**: Initialize a new grid with dimensions H\u00b2 rows by W\u00b2 columns, filled with the background color.\n\n4. **Replicate Patterns**: For each filled cell at position (i, j) in the input grid, copy the pattern of all filled cells relative to (i, j) and place these copies in the output grid by shifting their positions by (i \u00d7 H, j \u00d7 W).\n\n5. **Fill Output Grid**: Set the corresponding shifted cells in the output grid to the same fill color.\n\nAs a result, the output grid contains multiple scaled copies of the input pattern, arranged based on the positions of the filled cells in the original grid."
    },
    {
        "id": "00d62c1b",
        "pattern": "In the input grid, identify all regions filled with the background color that are completely surrounded by foreground blocks and do not touch the grid's edges. Change the color of each of these enclosed background regions to color\u202f4 to produce the output grid."
    },
    {
        "id": "017c7c7b",
        "pattern": "To transform the input grid into the output grid, follow these steps:\n\n1. **Select a Region:** Choose a rectangular area with random height and width within the grid.\n\n2. **Form an Object:** Within this selected region, randomly pick a specific number of cells to create an object.\n\n3. **Duplicate Vertically:** Repeat this object multiple times down the grid, spacing each copy by the height of the chosen region.\n\n4. **Fill with Color:** Assign the color value `2` to all the duplicated objects.\n\n5. **Customize the Top Object:** In the top portion of the grid, replace the color `2` of the first object with a randomly selected color from a predefined set that excludes colors `0` and `2`."
    },
    {
        "id": "025d127b",
        "pattern": "For each distinct shape in the input grid, create a corresponding shape in the output grid by shifting its top and left edges one cell to the right and adjusting the right and bottom edges accordingly to maintain the overall structure."
    },
    {
        "id": "045e512c",
        "pattern": "1. Start with an input grid containing a single object positioned at a specific location.\n2. Select one or more directions (e.g., up, down, left, right, or diagonals).\n3. For each selected direction:\n   a. In the input grid, color certain cells along the border in that direction with a unique color.\n   b. In the output grid, create multiple copies of the original object, each shifted incrementally in that direction, and color each copy with the corresponding unique color.\n4. Repeat this for all chosen directions.\nThe output grid will thus contain multiple shifted and uniquely colored copies of the original object arranged in the selected directions."
    },
    {
        "id": "0520fde7",
        "pattern": "To create the output grid from the input grid, identify all cells that are filled with both of two distinct colors in the input grid. For each such overlapping cell, set its color to 2 in the output grid. All other cells in the output grid should be set to the background color."
    },
    {
        "id": "05269061",
        "pattern": "To transform the input grid into the output grid, perform the following steps:\n\n1. **Choose Line Type**:\n   - Decide whether to use diagonal lines running from the left to the right upwards or horizontal lines across specific rows.\n\n2. **Assign Colors**:\n   - Select a set of colors from a predefined palette.\n   - Assign each chosen line a specific color from this set.\n\n3. **Draw Lines in Output Grid**:\n   - For each line position based on the selected type (diagonal or horizontal):\n     - Draw the entire line across the grid using its assigned color, thereby creating the complete output grid.\n\n4. **Populate Input Grid**:\n   - From the set of all lines drawn in the output grid, include only a specific subset of these lines in the input grid. The selection of which lines to keep is based on their positions and assigned colors.\n\n5. **Optional Vertical Mirroring**:\n   - With a 50% probability, apply a vertical mirror transformation to both the input and output grids to create a symmetrical pattern.\n\nBy following these steps, the input grid serves as a partial representation, and the output grid is the complete version with all designated colored lines."
    },
    {
        "id": "05f2a901",
        "pattern": "To transform the input grid into the output grid, follow these steps:\n\n1. **Identify Key Elements**:\n   - Locate the **foreground-colored object** within the input grid.\n   - Locate the **square region** filled with a different color.\n\n2. **Reposition the Object**:\n   - **Shift the foreground-colored object upwards** repeatedly until it becomes adjacent to the square region.\n   - **Move the object down by one cell** to finalize its position next to the square.\n\n3. **Apply Random Transformations**:\n   - **Apply one or two random transformations** to the entire grid. These transformations can include:\n     - **Mirroring** (horizontal, vertical, diagonal, or counter-diagonal).\n     - **Rotating** the grid by 90\u00b0, 180\u00b0, or 270\u00b0.\n\nThe resulting output grid will have the foreground-colored object repositioned adjacent to the square region, with any applied transformations reflected consistently in both the input and output grids."
    },
    {
        "id": "06df4c85",
        "pattern": "1. **Initialize the Grid:**\n   - Create a grid filled with a default background color.\n   - Place smaller patches of a line color at regular, evenly spaced intervals across the grid, forming a grid-like pattern.\n\n2. **Select Colors for Modification:**\n   - Choose a specific number of additional colors from the available color palette to be used for creating new patterns.\n\n3. **Modify the Grid with Selected Colors:**\n   - For each selected color:\n     a. **Choose a Starting Patch:**\n        - Randomly select one of the existing line-colored patches in the grid.\n     b. **Extend Arms from the Patch:**\n        - From the selected patch, extend 1 to 4 arms in random directions (such as up, down, left, or right).\n        - Each arm extends outward by a random number of cells, maintaining the spacing defined during initialization.\n     c. **Color the Arms:**\n        - Recolor the cells along each extended arm with the selected color.\n     d. **Recolor the Original Patch:**\n        - Change the color of the original selected patch from the line color to the selected color.\n\n4. **Finalize the Output:**\n   - After processing all selected colors and extending their respective arms, the resulting grid represents the output pattern with the newly added colored arms emanating from originally spaced patches."
    },
    {
        "id": "08ed6ac7",
        "pattern": "All vertical bars in the input grid are recolored in the output grid based on their heights. Specifically, each bar is assigned a color from 1 to 4 according to its height rank:\n- The shortest bars are colored with 1.\n- The next shortest bars are colored with 2.\n- Middle-height bars are colored with 3.\n- The tallest bars are colored with 4.\nBars that share the same height receive the same color. The background color remains unchanged."
    },
    {
        "id": "09629e4f",
        "pattern": "To generate the output grid from the input grid, follow these steps:\n\n1. **Identify Colors**:\n   - Select a background color from the available colors.\n   - Choose a distinct bar color different from the background.\n\n2. **Initialize Output Grid**:\n   - Create a new grid of the same dimensions as the input grid, setting all cells to the background color.\n\n3. **Preserve Bar Color**:\n   - In the output grid, copy all cells from the input grid that are colored with the bar color, placing them in their original positions.\n\n4. **Scale and Place Colored Cells**:\n   - For each selected colored cell (excluding those with the background or bar color) in the input grid:\n     - Calculate a new position by multiplying the cell's row index by (height\u202f+\u202f1) and the column index by (width\u202f+\u202f1), where height and width are the dimensions of the input grid.\n     - Place a cell of the same color at this new calculated position in the output grid.\n\nThis process effectively preserves the structure and bar from the input grid while scaling and repositioning specific colored cells to create the output grid."
    },
    {
        "id": "0962bcdd",
        "pattern": "For each central cell in the input grid that is colored with a specific color and has its four directly adjacent neighbors (up, down, left, right) colored with another specific color:\n\n1. **Define a 5\u00d75 Square Area:**\n   - Center the square on the central cell identified in the input grid.\n\n2. **Draw Diagonal Lines (X) within the Square:**\n   - Draw two diagonal lines from corner to corner of the 5\u00d75 square.\n   - Color these diagonal lines with the first specific color (matching the central cell's color from the input).\n\n3. **Draw Horizontal and Vertical Lines (+) within the Square:**\n   - Draw one horizontal line across the middle row of the square.\n   - Draw one vertical line down the middle column of the square.\n   - Color these horizontal and vertical lines with the second specific color (matching the neighbors' color from the input).\n\n4. **Maintain Background:**\n   - All cells outside the defined 5\u00d75 square area remain colored with the background color.\n\nRepeat this process for each such central cell and its neighbors in the input grid to generate the corresponding patterns in the output grid."
    },
    {
        "id": "0a938d79",
        "pattern": "1. Locate the two uniquely colored cells in the input grid and record their column positions.\n2. Calculate the spacing interval by doubling the horizontal distance between these two columns.\n3. In the output grid, draw vertical lines using each respective color, starting from their original columns and repeating every calculated interval across the entire grid.\n4. Rotate the entire output grid by either 180 degrees or 270 degrees."
    },
    {
        "id": "0b148d64",
        "pattern": "1. **Divide the Input Grid**: Split the input grid into four distinct rectangular regions based on randomly selected horizontal and vertical boundaries.\n\n2. **Select a Target Region**: Randomly choose one of the four regions to be the target region.\n\n3. **Fill the Target Region**:\n   - Assign a specific color to randomly selected cells within the target region.\n   - Draw lines connecting the corners of the target region to form a pattern.\n\n4. **Fill the Remaining Regions**:\n   - Assign a different color to randomly selected cells within each of the three non-target regions.\n   - Draw lines connecting the corners of each non-target region to form similar patterns.\n\n5. **Extract the Output Grid**: Isolate and output the subgrid corresponding to the target region, which now contains the uniquely colored and patterned cells."
    },
    {
        "id": "0ca9ddb6",
        "pattern": "To transform the input grid into the output grid:\n1. Keep all cells with color\u202f6 and color\u202f8 unchanged.\n2. For every cell with color\u202f2, change the colors of its diagonally adjacent cells to\u202f4 in the output grid.\n3. For every cell with color\u202f1, change the colors of its directly adjacent cells to\u202f7 in the output grid.\n4. All other cells retain their original background color."
    },
    {
        "id": "0d3d703e",
        "pattern": "For each cell in the input grid, if its color is one of 1, 2, 3, 4, 5, 6, 8, or 9, replace it with the corresponding color as follows:\n- 1 becomes 5\n- 2 becomes 6\n- 3 becomes 4\n- 4 becomes 3\n- 5 becomes 1\n- 6 becomes 2\n- 8 becomes 9\n- 9 becomes 8"
    },
    {
        "id": "0dfd9992",
        "pattern": "1. Rotate the input grid by 0\u00b0, 90\u00b0, 180\u00b0, or 270\u00b0.\n2. Divide the rotated grid into equal-sized tiles.\n3. For each tile:\n    a. If the tile is in an odd-numbered row, flip it horizontally.\n    b. If the tile is in an odd-numbered column, flip it vertically.\n    c. Apply these flips to a predefined pattern and place the transformed pattern in the tile\u2019s position.\n4. Identify all rectangular regions filled with a specific noise color within the grid.\n5. Remove each identified noise rectangle by restoring those areas to the original background color."
    },
    {
        "id": "0e206a2e",
        "pattern": "To create the output grid from the input grid, follow these steps:\n\n1. **Identify Objects**: Locate each distinct object in the input grid that is marked with specific marker colors.\n\n2. **Transform Objects**:\n   - For each identified object, randomly choose one of the following transformations:\n     - **Rotation**: Rotate the object by 90\u00b0, 180\u00b0, or 270\u00b0 clockwise.\n     - **Mirroring**: Flip the object horizontally, vertically, or along a diagonal axis.\n\n3. **Positioning**:\n   - Select a new location on the grid where the transformed object can fit without overlapping any existing objects.\n   - Ensure that the selected position allows the entire transformed object to be placed within the grid boundaries.\n\n4. **Place Transformed Objects**: Insert each transformed object into the output grid at its newly chosen location.\n\n5. **Finalize Grid**:\n   - Set all remaining cells in the output grid that are not occupied by transformed objects to the background color.\n\nThis process ensures that the output grid comprises transformed and repositioned versions of the original objects from the input grid, maintaining a clear and consistent background."
    },
    {
        "id": "10fcaaa3",
        "pattern": "1. **Tile the Input Grid**: Create a new grid by placing four copies of the input grid in a 2\u00d72 arrangement, effectively doubling the grid's width and height.\n\n2. **Identify Diagonal Neighbors**: In the tiled grid, find all cells that are diagonally adjacent to any colored cell from the original input grids and currently have the background color.\n\n3. **Fill with Color 8**: Change the color of all identified diagonal background cells to color 8."
    },
    {
        "id": "11852cab",
        "pattern": "For each non-overlapping 5x5 square region in the input grid, assign four concentric rings starting from the center outward. In the input grid, some of these rings may be partially colored with specific colors. To generate the output grid, complete each region by filling in all remaining cells of every concentric ring with their assigned colors, ensuring that each 5x5 region has fully colored concentric rings without any gaps."
    },
    {
        "id": "1190e5a7",
        "pattern": "To transform the input grid into the output grid, follow these steps:\n\n1. **Count Horizontal Lines**: Determine the number of distinct horizontal colored lines present in the input grid.\n2. **Count Vertical Lines**: Determine the number of distinct vertical colored lines present in the input grid.\n3. **Create Output Grid**: \n   - Set the height of the output grid to be the number of horizontal lines plus one.\n   - Set the width of the output grid to be the number of vertical lines plus one.\n4. **Fill with Background Color**: Fill every cell of the newly created output grid with the background color."
    },
    {
        "id": "137eaa0f",
        "pattern": "1. Examine the input grid and identify all distinct colored objects, ignoring the background color.\n2. For each identified object, note its specific color and the arrangement of its cells.\n3. Create a new, smaller grid initialized with a single background color.\n4. Place each identified object into the new grid, maintaining their original colors and relative cell positions without overlapping.\n5. Ensure that all objects are arranged tightly within the new grid, filling only their designated cells.\n6. The newly arranged smaller grid, containing all the distinct colored objects in their preserved configurations, becomes the output grid."
    },
    {
        "id": "150deff5",
        "pattern": "To generate the output grid from the input grid, follow these steps:\n\n1. **Initialize the Output Grid**: Start with an output grid where every cell is set to the background color.\n\n2. **Identify Filled Regions**: In the input grid, locate each distinct region filled with the foreground color.\n\n3. **Replace 2x2 Squares**:\n    - If a filled region forms a 2x2 square, fill the corresponding 2x2 area in the output grid with color **8**.\n\n4. **Replace 3-Cell Lines**:\n    - If a filled region forms a horizontal or vertical line consisting of three adjacent cells, fill the corresponding three-cell line in the output grid with color **2**.\n\n5. **Ensure Separation**:\n    - Make sure that each replaced shape (whether a 2x2 square or a 3-cell line) does not overlap with others and is appropriately spaced apart to prevent interference.\n\n6. **Maintain Background**:\n    - All cells in the output grid that are not part of the replaced shapes remain set to the background color.\n\nBy systematically replacing specific filled patterns in the input grid with designated colors and ensuring proper spacing, the output grid reflects these transformations accurately."
    },
    {
        "id": "178fcbfb",
        "pattern": "1. **Initialize** the output grid with the same dimensions as the input grid, filling all cells with the background color.\n\n2. **For each cell** in the input grid that is colored with **color 2**:\n   - **Set every cell** in the same **column** of the output grid to **color 2**.\n\n3. **For each cell** in the input grid that is colored with **color 1**:\n   - **Set every cell** in the same **row** of the output grid to **color 1**.\n\n4. **For each cell** in the input grid that is colored with **color 3**:\n   - **Set every cell** in the same **row** of the output grid to **color 3**."
    },
    {
        "id": "1a07d186",
        "pattern": "Start with the input grid containing several vertical colored lines on a uniform background. For each row that has a colored dot matching one of the line colors, add an extra cell of that same color immediately adjacent to the corresponding vertical line in that row, either to the left or to the right. All other cells in the grid remain unchanged."
    },
    {
        "id": "1b2d62fb",
        "pattern": "1. **Divide the Input Grid**: Split the input grid vertically into three sections:\n   - **Left Section**: Occupies the left portion of the grid.\n   - **Center Bar**: A single-column section in the middle filled with a specific color.\n   - **Right Section**: Occupies the right portion of the grid.\n\n2. **Color the Sections**:\n   - **Left Section**: Randomly color certain cells with **Color A**, leaving the remaining cells as background (color 0).\n   - **Right Section**: Randomly color certain cells with **Color B**, leaving the remaining cells as background (color 0).\n   - **Center Bar**: Fill the entire center column with the **Bar Color**.\n\n3. **Generate the Output Grid**:\n   - Create a new grid of the same height and the same width as one of the side sections.\n   - For each corresponding pair of cells from the left and right sections of the input grid:\n     - **If both cells are background (color 0)**:\n       - Set the corresponding cell in the output grid to **Color 8**.\n     - **Otherwise**:\n       - Set the corresponding cell in the output grid to background (color 0).\n\n4. **Optional Mirroring**:\n   - With a 50% chance, mirror both the input and output grids diagonally."
    },
    {
        "id": "1b60fb0c",
        "pattern": "1. Select a square area within the input grid at a random location.\n2. Divide this square into four equal quadrants.\n3. In three of these quadrants, place rotated and slightly shifted copies of a specific pattern, each filled with the same color.\n4. Leave the fourth quadrant empty in the input grid.\n5. To create the output grid, fill the previously empty fourth quadrant with color 2, completing the full set of four rotated and shifted pattern copies within the square area."
    },
    {
        "id": "1bfc4729",
        "pattern": "To transform the input grid into the output grid, follow these steps precisely:\n\n1. **Identify Colored Cells**:\n   - Locate the two distinct colored cells in the input grid. Let\u2019s call their colors **Color A** and **Color B**.\n\n2. **Fill Entire Rows**:\n   - Fill the entire row containing the first colored cell with **Color A**.\n   - Fill the entire row containing the second colored cell with **Color B**.\n\n3. **Fill Top and Bottom Borders**:\n   - Fill the entire **top row** of the grid with **Color A**.\n   - Fill the entire **bottom row** of the grid with **Color B**.\n\n4. **Fill Left and Right Borders**:\n   - From the **top to the middle** of the grid, fill both the **leftmost** and **rightmost columns** with **Color A**.\n   - From the **middle to the bottom** of the grid, fill both the **leftmost** and **rightmost columns** with **Color B**.\n\nBy applying these steps, the input grid is transformed into the output grid with distinct colored borders and filled rows based on the positions of the initially colored cells."
    },
    {
        "id": "1c786137",
        "pattern": "1. **Identify the Rectangle Boundary**: Locate the rectangular outline in the input grid, which is drawn using a specific target color distinct from the noise colors.\n2. **Determine the Interior Area**: Find the area enclosed within the boundaries of this rectangle, excluding the border itself.\n3. **Crop to the Interior**: Extract the subgrid that represents this interior area.\n4. **Generate the Output Grid**: The cropped interior area becomes the output grid."
    },
    {
        "id": "1caeab9d",
        "pattern": "1. **Identify the Object**: Select a connected group of cells (the object) within the input grid.\n\n2. **Choose a Target Position**: Determine a specific row (`loci`) and column (`locj`) where the object will be placed in the output grid.\n\n3. **Place the Primary Object**: Position the selected object at the target row (`loci`) and column (`locj`) in both the input and output grids, using a randomly chosen background color.\n\n4. **Add Colored Copies in Input Grid**:\n   - For a randomly selected number of times (`numo`), do the following:\n     - Choose a different color from the available colors.\n     - Place a copy of the object at a random row (within the grid's height) but at the same column (`locj`) in the **input grid** using the chosen color.\n\n5. **Align Copies in Output Grid**:\n   - For each colored copy added to the input grid, place a corresponding copy at the target row (`loci`) and column (`locj`) in the **output grid** using the same color.\n\n6. **Finalize the Grids**:\n   - The **input grid** will contain multiple colored copies of the object spread vertically at the same column.\n   - The **output grid** will have all these colored copies aligned at the specific target row and column."
    },
    {
        "id": "1cf80156",
        "pattern": "1. **Identify the Foreground Region**: Locate the connected group of cells in the input grid that are colored with the foreground color (a color different from the background).\n\n2. **Determine the Bounding Rectangle**: Find the smallest rectangle that completely contains the entire foreground region. This rectangle is defined by the topmost, bottommost, leftmost, and rightmost cells of the foreground group.\n\n3. **Create a New Grid**: Initialize a new grid with the same height and width as the bounding rectangle determined in the previous step.\n\n4. **Set the Background Color**: Fill all cells of the new grid with the original background color.\n\n5. **Populate the Foreground Region**: Transfer the foreground cells from the identified region in the input grid to their corresponding positions within the new grid, preserving their original shape and arrangement."
    },
    {
        "id": "1e0a9b12",
        "pattern": "To transform the input grid into the output grid, perform the following steps for each column:\n\n1. **Identify Colored Cells**: Locate all cells in the column that are not the background color.\n2. **Sort Colors**: Arrange the identified colored cells in ascending order based on their color values, positioning the lower color values towards the top of the column.\n3. **Maintain Background**: Fill the remaining cells in the column with the background color to ensure it remains the most prevalent color in the grid.\n\nThis process ensures that within each column, colored cells are neatly sorted from top to bottom by their color values, while the background color dominates the grid."
    },
    {
        "id": "1e32b0e9",
        "pattern": "To transform the input grid into the output grid, follow these precise steps:\n\n1. **Maintain Grid Structure**: \n   - Keep the grid divided into equally sized tiles separated by lines colored with the line color (`linc`).\n\n2. **Identify and Outline Shapes**:\n   - **Main Shape**:\n     - Locate the primary connected shape filled with the fill color (`fgc`) within one of the tiles.\n     - Draw an outline around this main shape using the line color (`linc`).\n   - **Additional Shapes**:\n     - In the remaining tiles, optionally identify partial copies or subsets of the main shape.\n     - For each partial shape found:\n       - Draw an outline around the subset using the line color (`linc`).\n       - Retain the fill color (`fgc`) within these outlined subsets.\n\n3. **Preserve Fill Colors**:\n   - Ensure that the original fill color (`fgc`) remains inside each outlined region, both for the main shape and any partial shapes in other tiles.\n\nThe **output grid** will thus:\n- Retain the original grid layout with separators colored `linc`.\n- Feature the main shape and any partial shapes outlined with `linc`.\n- Preserve the fill color `fgc` within each outlined shape.\n\nThis pattern effectively enhances each filled shape in the input grid by adding a clear outline, improving their definition while maintaining their original coloration."
    },
    {
        "id": "1f0c79e5",
        "pattern": "1. **Identify 2\u00d72 Blocks**: Locate every 2\u00d72 square in the input grid that is filled entirely with the object color.\n\n2. **Mark Specific Cells**: Within each identified 2\u00d72 block, select one to three cells and color them differently from the object color.\n\n3. **Determine Directions**: For each differently colored cell within a 2\u00d72 block, assign a specific direction based on its position in the block (e.g., top-left, top-right, bottom-left, bottom-right).\n\n4. **Draw Lines**: From each marked cell, draw a straight, continuous line in its assigned direction across the entire grid.\n\n5. **Generate Output Grid**: In the output grid, color all cells along each drawn line with the object color, while keeping all other cells as the original background color."
    },
    {
        "id": "1f642eb9",
        "pattern": "1. Start with a grid that has a colored square positioned away from the grid\u2019s edges, leaving at least two cells of margin on all sides.\n2. Select a random number of cells along the top, bottom, left, and right borders of the entire grid.\n3. For each selected border cell:\n   a. Choose a new color different from the background and the square\u2019s color.\n   b. Apply this color to the selected border cell on the grid.\n   c. Apply the same color to a corresponding cell on the border of the inner square.\n4. The output grid will be identical to the input grid except for these newly colored cells on both the grid\u2019s outer borders and the square\u2019s borders."
    },
    {
        "id": "1f85a75f",
        "pattern": "To transform the input grid into the output grid, follow these steps:\n\n1. **Identify a Connected Object**: Find a connected group of cells within the input grid. The size of this object is randomly chosen within specified limits.\n\n2. **Normalize the Object\u2019s Position**: Shift the identified object so that its upper-left corner aligns with the top-left corner of a new grid, effectively repositioning it to start at the origin.\n\n3. **Create the Output Grid**: \n   - Initialize a new grid sized to exactly fit the bounding box of the normalized object.\n   - Fill the entire background of this grid with a uniform background color.\n   - Paint the cells corresponding to the normalized object with its original color.\n\nThe output grid will thus contain only the normalized object on a plain background, removing any noise or additional elements present in the input grid."
    },
    {
        "id": "1f876c06",
        "pattern": "Connect pairs of colored endpoints in the input grid with continuous diagonal lines in one of four diagonal directions. Each line is assigned a unique color, and all cells along the line are filled with this color in the output grid. Only the endpoints are colored in the input grid, while the output grid displays the complete diagonal lines."
    },
    {
        "id": "1fad071e",
        "pattern": "To transform the input grid into the output grid, follow these precise steps:\n\n1. **Initialize the Output Container**: Start with an empty list that will eventually contain up to five elements.\n\n2. **Identify 2x2 Color '1' Blocks**:\n   - Scan the input grid to locate all non-overlapping 2x2 squares where every cell is filled with the color '1'.\n   - Ensure that these 2x2 blocks do not overlap with each other.\n\n3. **Count the Identified Blocks**:\n   - Let `bcount` represent the number of such 2x2 color '1' blocks found in the grid.\n   - `bcount` can range from 0 to 5.\n\n4. **Populate the Output List**:\n   - Add `bcount` number of '1's to the output list.\n   - Fill the remaining positions in the list (to reach a total of five elements) with the background color (`bgc`).\n\n5. **Finalize the Output Grid**:\n   - Encapsulate the list of five elements within a tuple to form the output grid.\n\n**Example**:\n- If `bcount` is 2 and the background color is `0`, the output will be `(1, 1, 0, 0, 0)`.\n- If `bcount` is 5, the output will be `(1, 1, 1, 1, 1)`."
    },
    {
        "id": "2013d3e2",
        "pattern": "1. **Identify the Area of Interest:** Locate all cells in the input grid that are not the background color. Determine the smallest rectangular region that completely encompasses these cells.\n\n2. **Extract the Top Half:** From the identified rectangular region, select the upper half of the grid. If the height is odd, include the middle row in the top half.\n\n3. **Extract the Left Half:** From the top half obtained in the previous step, select the left half of the grid. If the width is odd, include the middle column in the left half.\n\n4. **Resulting Output:** The grid obtained after extracting the top half and then the left half is the output grid."
    },
    {
        "id": "2204b7a8",
        "pattern": "1. **Set Borders:**\n   - Fill the **leftmost column** of the input grid with **Color C\u2081**.\n   - Fill the **rightmost column** of the input grid with **Color C\u2082**.\n\n2. **Divide and Fill:**\n   - **Left Half:** For every cell in the **left half** of the grid (excluding the leftmost column), set its color to **Color C\u2081**.\n   - **Right Half:** For every cell in the **right half** of the grid (excluding the rightmost column), set its color to **Color C\u2082**.\n\n3. **Optional Mirroring:**\n   - With a 50% chance, **mirror** the entire grid along its **main diagonal**.\n\nThis process transforms the input grid by assigning colors based on each cell\u2019s horizontal position, ensuring consistent coloring on the borders and within each half of the grid. The optional mirroring adds a diagonal reflection to the pattern."
    },
    {
        "id": "22168020",
        "pattern": "To transform the input grid into the output grid, follow these precise steps:\n\n1. **Identify the Background Color:**\n   - Determine the background color present in the input grid.\n\n2. **Initialize the Output Grid:**\n   - Create the output grid with the same dimensions as the input grid, filling all cells with the identified background color.\n\n3. **Determine the Number of Patterns to Add:**\n   - Choose a random number of patterns (`num`) to add based on the grid's height and width, ensuring it does not exceed a maximum limit.\n\n4. **Add Each Pattern:**\n   For each of the `num` patterns, perform the following sub-steps:\n\n   a. **Select a Size Parameter:**\n      - Choose a random integer `d` between 2 and 5.\n\n   b. **Choose a Starting Location:**\n      - Randomly select a cell `(i, j)` within the grid as the starting point.\n\n   c. **Draw Two Connected Lines:**\n      - **Diagonal Line:** Connect the starting cell `(i, j)` to the cell `(i + d - 1, j + d - 1)`, creating a diagonal line extending down and to the right by `d - 1` cells.\n      - **Horizontal Line:** Connect the cell `(i, j + 2*d - 1)` to the cell `(i + d - 1, j + d)`, creating a horizontal line extending to the right by `2*d` cells.\n\n   d. **Add Additional Cells:**\n      - Include two specific cells at positions `(i + d, j + d - 1)` and `(i + d, j + d)` to complete the pattern.\n\n   e. **Form the Connected Pattern:**\n      - Combine the cells from the diagonal line, horizontal line, and the two additional cells to form a single connected shape.\n\n   f. **Apply a Transformation:**\n      - Randomly apply one of the following transformations to the entire pattern:\n        - **Identity:** No change.\n        - **Diagonal Mirror:** Reflect the pattern along its diagonal.\n        - **Counter-Diagonal Mirror:** Reflect the pattern along its counter-diagonal.\n        - **Horizontal Mirror:** Reflect the pattern horizontally.\n        - **Vertical Mirror:** Reflect the pattern vertically.\n\n   g. **Assign a Unique Color:**\n      - Select a color from the remaining available colors, ensuring it is different from the background color and previously used pattern colors.\n\n   h. **Fill the Pattern in the Output Grid:**\n      - Color the cells of the transformed pattern in the output grid with the selected unique color.\n      - Ensure that the chosen pattern does not overlap with any existing colored regions in the output grid. If an overlap occurs, skip adding this pattern and proceed to the next.\n\n5. **Finalize the Output Grid:**\n   - Repeat step 4 until all desired patterns are added or until a maximum number of attempts is reached to prevent infinite loops.\n   - The resulting output grid will have multiple non-overlapping, uniquely colored transformed patterns on the background."
    },
    {
        "id": "22233c11",
        "pattern": "For each distinct object in the input grid, add two cells colored with the number\u202f8 at opposite corners of the object in the output grid. The output grid retains all original objects from the input and includes these additional\u202f8-colored corner cells for each object."
    },
    {
        "id": "2281f1f4",
        "pattern": "To transform the input grid into the output grid, follow these steps:\n\n1. **Identify Active Columns on the Top Row:**\n   - Locate all cells in the top row that are colored differently from the background color. These cells mark specific columns.\n\n2. **Identify Active Rows on the Rightmost Column:**\n   - Locate all cells in the rightmost column that are colored differently from the background color. These cells mark specific rows.\n\n3. **Mark Intersections:**\n   - For each active column identified in step 1 and each active row identified in step 2, find the cell where the column from the top row intersects with the row from the rightmost column.\n   - Change the color of each of these intersecting cells to the color `2`.\n\n4. **Maintain All Other Cells:**\n   - Keep all other cells in the grid unchanged from the input grid.\n\n5. **Apply Rotation (Optional):**\n   - Optionally, rotate the entire grid by 0\u00b0, 90\u00b0, 180\u00b0, or 270\u00b0 to obtain the final output grid."
    },
    {
        "id": "228f6490",
        "pattern": "To transform the input grid into the output grid, follow these precise steps:\n\n1. **Initialize Background**: Start with the input grid where all cells are filled with a single background color.\n\n2. **Add Rectangular Boundaries**:\n   - Randomly select several non-overlapping rectangular areas within the grid.\n   - For each selected rectangle, color its outer boundary (the perimeter cells) with a distinct color different from the background.\n\n3. **Fill Interior Cells**:\n   - Within each rectangular boundary, choose a connected group of interior cells.\n   - Assign a new color to these interior cells, ensuring it is different from both the background and the boundary colors.\n\n4. **Repeat Placement**:\n   - Continue adding such rectangular boundaries and filling their interiors with different colors until a predetermined number of regions have been created or no more suitable areas are available.\n\n5. **Generate Output Grid**: The final output grid will display the background color with multiple colored rectangular regions, each having distinct boundary and interior colors as defined above."
    },
    {
        "id": "22eb0ac0",
        "pattern": "To transform the input grid into the output grid, perform the following steps:\n\n1. **Identify Horizontal Bars**:\n   - Select certain rows in the input grid.\n   - Fill each selected row entirely with a single color.\n\n2. **Color the Edges of Other Rows**:\n   - For every row that is not selected as a horizontal bar, color only the leftmost and rightmost cells with two distinct colors.\n\n3. **Optional Diagonal Mirroring**:\n   - With a 50% probability, mirror the entire grid along its main diagonal (i.e., swap rows and columns).\n\nThe output grid will either be identical to the input grid or its diagonally mirrored version based on the optional mirroring step."
    },
    {
        "id": "234bbc79",
        "pattern": "To generate the output grid from the input grid, follow these steps:\n\n1. **Reflect the Input Grid Along the Main Diagonal:** Flip the input grid so that the rows become columns and the columns become rows.\n\n2. **Remove the Last Row:** Delete the last row from the reflected grid.\n\n3. **Reflect the Truncated Grid Again Along the Main Diagonal:** Flip the truncated grid once more along the main diagonal to restore the original orientation of rows and columns.\n\n4. **Resulting Output Grid:** The grid obtained after these transformations is the output grid."
    },
    {
        "id": "23581191",
        "pattern": "To transform the input grid into the output grid, follow these steps:\n\n1. **Identify Special Cells**: Locate all cells in the input grid that are colored with color A and color B.\n\n2. **Fill Rows and Columns for Color A**:\n   - For each cell colored with color A, fill the entire row containing that cell with color A.\n   - Similarly, fill the entire column containing that cell with color A.\n\n3. **Fill Rows and Columns for Color B**:\n   - For each cell colored with color B, fill the entire row containing that cell with color B.\n   - Similarly, fill the entire column containing that cell with color B.\n\n4. **Handle Overlapping Areas**:\n   - If a cell is affected by both the color A and color B filling operations (i.e., it lies on a row or column of both color A and color B cells), change its color to color 2.\n\n5. **Restore Original Colored Cells**:\n   - Ensure that the original cells colored with color A and color B retain their original colors, overriding any changes made in previous steps.\n\nBy following these steps, the output grid will have rows and columns filled based on the positions of color A and color B cells in the input grid, with overlapping regions distinctly colored as color 2."
    },
    {
        "id": "239be575",
        "pattern": "To obtain the output grid from the input grid, follow these steps:\n\n1. **Identify the Two Squares**: Locate the two distinct square shapes within the input grid.\n\n2. **Find Marked Cells**: Identify all groups of cells that are colored with the designated mark color (`markcol`).\n\n3. **Check for Connection**:\n   - Determine if any group of marked cells is adjacent to both of the identified squares.\n   - Adjacency means that the marked group touches both squares directly.\n\n4. **Set the Output**:\n   - **If a Connecting Group Exists**: Create an output grid consisting of a single cell colored with the mark color (`markcol`).\n   - **If No Connecting Group Exists**: Create an output grid consisting of a single cell with the background color (0).\n\nThis pattern effectively checks for a connection between two squares via marked cells and represents the presence or absence of such a connection in a minimal output grid."
    },
    {
        "id": "23b5c85d",
        "pattern": "To generate the output grid from the input grid, follow these steps:\n\n1. **Identify Rectangles**: Locate all non-background rectangles within the input grid. Each rectangle is defined by its unique color, height, and width.\n\n2. **Select the Smallest Rectangle**: Among the identified rectangles, determine the one with the smallest area (where area is calculated as height multiplied by width).\n\n3. **Extract Rectangle Properties**: Note the color, height, and width of this smallest rectangle.\n\n4. **Create Output Grid**: Generate a new grid that has the same height and width as the selected smallest rectangle.\n\n5. **Fill Output Grid**: Fill every cell of this new grid with the color of the smallest rectangle identified from the input grid.\n\nThe resulting output grid will be a uniformly colored grid that matches the size of the smallest rectangle found in the input grid."
    },
    {
        "id": "253bf280",
        "pattern": "To transform the input grid into the output grid, follow these steps:\n\n1. **Identify Rows with Multiple Foreground Cells**:\n   - For each row in the input grid, check if it contains more than one cell with the foreground color.\n   \n2. **Draw Horizontal Lines**:\n   - In each identified row, draw a horizontal line of color `3` connecting the first and last foreground-colored cells in that row.\n\n3. **Identify Columns with Multiple Foreground Cells**:\n   - For each column in the input grid, check if it contains more than one cell with the foreground color.\n   \n4. **Draw Vertical Lines**:\n   - In each identified column, draw a vertical line of color `3` connecting the first and last foreground-colored cells in that column.\n\n5. **Produce the Output Grid**:\n   - The output grid is the original input grid augmented with all the horizontal and vertical lines of color `3` drawn in the previous steps.\n\nThis pattern ensures that any row or column with multiple foreground-colored cells is visually connected by a line of color `3` between the extremities of those cells."
    },
    {
        "id": "25d487eb",
        "pattern": "For each distinct object in the input grid, identify a specific point within the object and draw a straight vertical line of the same color from that point directly down to the bottom edge of the grid. The output grid contains all original objects from the input grid, each extended by their respective vertical lines."
    },
    {
        "id": "25d8a9c8",
        "pattern": "For each row in the input grid:\n\n- If every cell in the row is the same, set all cells in the corresponding output row to\u202f5.\n- Otherwise, set all cells in the corresponding output row to\u202f0."
    },
    {
        "id": "25ff71a9",
        "pattern": "Shift the connected foreground shape in the input grid one cell downward to create the output grid."
    },
    {
        "id": "264363fd",
        "pattern": "To transform the input grid into the output grid, follow these precise steps:\n\n1. **Select a Central Point:**\n   - Choose a specific location within the grid to serve as the center of the pattern.\n\n2. **Color the Central Cell:**\n   - Assign a distinct color (`cpcol`) to the central cell at the selected location.\n\n3. **Create Directional Spikes:**\n   - Randomly choose between 1 to 4 directions from the four cardinal points: up, down, left, and right.\n   - For each selected direction, extend a line (\"spike\") from the central cell by coloring specific adjacent cells with another color (`linc`).\n\n4. **Color Remaining Neighbors:**\n   - Assign a third color (`nbhcol`) to all immediate neighboring cells around the central point that are not part of the extended spikes.\n\n5. **Place Additional Patterns (Optional):**\n   - Repeat the above steps multiple times, placing additional central patterns at different random locations within the grid to add complexity.\n\n6. **Finalize the Output Grid:**\n   - The output grid will display the original input grid with all the newly added central patterns and their corresponding spikes and colored neighbors.\n\nThis pattern results in one or more central points in the grid, each highlighted with a unique color, extended lines in random directions, and surrounding cells colored differently to create a visually distinct structure."
    },
    {
        "id": "272f95fa",
        "pattern": "To transform the input grid into the output grid, follow these precise steps:\n\n1. **Identify Background Regions**:\n   - Locate all background areas in the input grid that are not positioned at the grid's corners.\n\n2. **Select Specific Background Regions**:\n   - **Central Region**: Find the background region that does not border the edges of the grid and recolor it pink.\n   - **Leftmost Region**: Identify the leftmost background region and recolor it yellow.\n   - **Rightmost Region**: Identify the rightmost background region and recolor it green.\n   - **Uppermost Region**: Identify the topmost background region and recolor it red.\n   - **Lowermost Region**: Identify the bottommost background region and recolor it blue.\n\n3. **Apply Recoloring**:\n   - Update the input grid by changing the colors of these selected background regions as specified.\n\nThe final output grid will be the original input grid with these specific background regions recolored to pink, yellow, green, red, and blue based on their spatial positions."
    },
    {
        "id": "27a28665",
        "pattern": "To transform the input grid into the output grid, follow these precise steps:\n\n1. **Identify the Object Pattern:**\n   - Locate the single object present in the input grid.\n   - Determine its specific shape by matching its arrangement of cells to one of the predefined patterns.\n\n2. **Determine the Corresponding Label Color:**\n   - Each identified pattern is associated with a unique label color.\n   - Retrieve the label color that corresponds to the matched pattern.\n\n3. **Generate the Output Grid:**\n   - Create a new grid consisting of a single cell.\n   - Fill this single cell with the determined label color.\n\n**Summary:**  \nExtract the shape of the object in the input grid, identify its corresponding label color based on predefined patterns, and produce an output grid that is a single cell filled with that label color."
    },
    {
        "id": "28bf18c6",
        "pattern": "To obtain the output grid from the input grid, identify the single foreground shape in the input grid and create an output grid by placing two identical copies of that shape side-by-side horizontally on the same background color."
    },
    {
        "id": "28e73c20",
        "pattern": "To transform the input grid into the output grid, follow these steps:\n\n1. **Start at the Top-Right Corner:** Begin at the cell located in the first row and last column of the input grid.\n\n2. **Draw a Spiral Clockwise:**\n   - **Initial Direction:** Move downward.\n   - **Alternating Directions:** After each segment, turn 90 degrees to the right (clockwise).\n   - **Decreasing Length:** With each new segment, reduce the length by one cell compared to the previous segment.\n   \n3. **Color the Spiral Path:**\n   - **Assign Color 3:** Color every cell along the spiral path with the color value 3.\n   \n4. **Continue Until Completion:** Repeat the alternating directions and decreasing lengths, continuing the spiral inward until no more segments can be drawn within the grid boundaries.\n\nThe result is the original input grid overlaid with a clockwise spiral of color 3 starting from the top-right corner."
    },
    {
        "id": "29623171",
        "pattern": "Divide the input grid into multiple non-overlapping small rectangular regions. In the output grid, completely fill one randomly selected region with a specific color. For all other regions, if every cell in a region was filled with that specific color in the input grid, keep the entire region filled with that color in the output; otherwise, set the entire region to the background color."
    },
    {
        "id": "29c11459",
        "pattern": "For each selected row in the input grid that has a colored cell in the first column and a colored cell in the last column:\n1. In the output grid, extend the color from the first column horizontally to the middle of the row.\n2. Extend the color from the last column horizontally to the middle of the row.\n3. Set the central cell of the row to color 5.\n4. Optionally, mirror the entire grid diagonally."
    },
    {
        "id": "29ec7d0e",
        "pattern": "1. Locate all cells in the input grid that are colored with the noise color.\n2. Change the color of these noisy cells to the background color.\n3. Ensure that all original colored patches and the background remain unchanged."
    },
    {
        "id": "2bcee788",
        "pattern": "To generate the output grid from the input grid, follow these steps:\n\n1. **Concatenate with Mirrored Version**: Horizontally join the input grid with a vertically mirrored version of itself, resulting in a larger grid.\n\n2. **Apply Geometric Transformations**: Apply one or two random geometric transformations to the concatenated grid. These transformations can include operations such as rotation (by 90\u00b0, 180\u00b0, or 270\u00b0), horizontal mirroring, vertical mirroring, diagonal mirroring, or a combination of these.\n\n3. **Replace Background Color**: In the transformed grid, change all cells that have the original background color to the color represented by the integer `3`.\n\nThe resulting grid after these steps is the output grid."
    },
    {
        "id": "2bee17df",
        "pattern": "To transform the input grid into the output grid, follow these steps:\n\n1. **Trim the Borders**: Remove the outermost rows and columns from the input grid.\n\n2. **Identify Frontiers**: \n   - Find all rows within the trimmed grid where every cell is the same color.\n   - Find all columns within the trimmed grid where every cell is the same color.\n   \n3. **Collect Frontier Cells**: Combine all the cells from the identified uniform rows and columns.\n\n4. **Shift Frontier Cells**: Move each collected frontier cell one position down and one position to the right.\n\n5. **Update the Original Grid**: In the original input grid, change the color of each shifted cell to color `3`.\n\nThe resulting grid after these steps is the output grid."
    },
    {
        "id": "2c608aff",
        "pattern": "Given an input grid filled with a background color:\n1. Select a rectangular area within the grid at a random position and with a random size, then fill this rectangle with a specific color.\n2. Randomly choose several cells outside the rectangle and color them with a different color.\n3. For each of these differently colored cells:\n    - If the cell is in the same row as the rectangle, draw a horizontal line from the cell to the corresponding edge of the rectangle.\n    - If the cell is in the same column as the rectangle, draw a vertical line from the cell to the corresponding edge of the rectangle.\n4. Ensure the original rectangular area remains filled with the specific color."
    },
    {
        "id": "2dc579da",
        "pattern": "To transform the input grid into the output grid, follow these steps:\n\n1. **Identify Lines**:\n   - Locate a horizontal line and a vertical line within the input grid. Both lines are the same color and have specified thicknesses.\n   - These lines intersect at a certain point, dividing the grid into four quadrants.\n\n2. **Locate the Rectangle (Dot)**:\n   - Find a rectangular region (referred to as a \"dot\") situated in the top-left quadrant formed by the intersection of the horizontal and vertical lines. This rectangle has specific dimensions and is colored differently from the lines.\n\n3. **Crop the Grid**:\n   - Extract a subgrid from the input grid that starts at the top-left corner and extends up to the intersection point of the horizontal and vertical lines.\n   - The dimensions of this cropped area correspond to the position where the lines intersect.\n\n4. **Apply Rotation**:\n   - Rotate both the original input grid and the cropped output grid by the same angle (either 0\u00b0, 90\u00b0, 180\u00b0, or 270\u00b0). This ensures that the spatial relationship between the lines and the rectangle remains consistent in both grids.\n\nThe output grid is the rotated cropped subgrid, maintaining the relative positions and colors of the lines and rectangle from the input grid."
    },
    {
        "id": "2dd70a9a",
        "pattern": "To transform the input grid into the output grid, perform the following steps precisely:\n\n1. **Identify Key Points:**\n   - Locate two distinct starting points and two distinct ending points within the input grid. These points are marked with specific colors.\n\n2. **Choose Connection Method:**\n   - Randomly select one of two connection methods to link the starting points to the ending points.\n\n   **a. Vertical-Then-Horizontal Connection:**\n      - Draw vertical lines upward from each starting point to reach a common branch point.\n      - From this branch point, draw horizontal lines outward to each corresponding ending point.\n\n   **b. Horizontal-Then-Vertical Connection:**\n      - Draw horizontal lines outward from each starting point to reach a common branch point.\n      - From this branch point, draw vertical lines downward to each corresponding ending point.\n\n3. **Mark Branch Points:**\n   - At each branch point where the lines intersect or diverge, fill these locations with a designated foreground color to highlight the connection junctions.\n\n4. **Add Connecting Lines:**\n   - Ensure that the lines connecting the starting points to the branch points and from the branch points to the ending points are consistently colored to distinguish them from the background.\n\n5. **Introduce Noise:**\n   - Randomly select a subset of background cells and fill them with the foreground color. This adds noise to both the input and output grids, making the pattern less uniform and more natural.\n\n6. **Apply Random Transformations:**\n   - Uniformly apply one or two random transformations to both the input and output grids. These transformations may include rotations (90\u00b0, 180\u00b0, 270\u00b0) or mirrorings (horizontal, vertical, diagonal). This ensures that the overall pattern orientation can vary while maintaining its structural integrity.\n\nBy following these steps, the output grid will display the starting points connected to the ending points through a branched pathway, complemented by random noise and potential rotational or mirror transformations."
    },
    {
        "id": "2dee498d",
        "pattern": "To obtain the output grid from the input grid, divide the input grid into three equal vertical sections and select one of these sections as the output grid."
    },
    {
        "id": "31aa019c",
        "pattern": "1. Identify the single cell in the input grid that has a unique color (a color that appears only once).\n2. Create a new grid of the same dimensions, filling every cell with the original background color.\n3. Set the identified unique cell in the new grid to its original unique color.\n4. Change all cells surrounding the unique cell (including diagonally adjacent cells) in the new grid to color 2."
    },
    {
        "id": "321b1fc6",
        "pattern": "To transform the input grid into the output grid, follow these steps:\n\n1. **Remove the Original Shape:** Eliminate the single colored shape present in the input grid.\n\n2. **Create Multiple Copies:** Generate several replicas of this shape. Each replica should be colored using one of multiple selected colors, ensuring that the colors differ from the background color.\n\n3. **Place Copies Randomly:** Position these colored copies at random locations on the grid. Ensure that the copies do not overlap with each other and are not adjacent to one another.\n\n4. **Finalize the Output:** The resulting grid will contain multiple non-overlapping, non-adjacent copies of the original shape, each with varying colors, against the original background."
    },
    {
        "id": "32597951",
        "pattern": "Within a specific rectangular area of the input grid, change every cell that is colored with the noise color to color\u202f3. All other cells outside this rectangle and cells within the rectangle that are not noise-colored remain unchanged."
    },
    {
        "id": "3345333e",
        "pattern": "1. **Identify the Main Shape**: Locate a vertically symmetric shape within the input grid that is filled with a specific color.\n\n2. **Locate the Inner Rectangle**: Within this symmetric shape, find a rectangular area that is filled with a different color.\n\n3. **Remove the Inner Rectangle**: Change all the cells in the rectangular area from their current color to the background color, effectively removing the rectangle from the main shape.\n\n4. **Maintain Symmetry**: Ensure that the overall symmetric structure of the main shape remains unchanged after removing the rectangle."
    },
    {
        "id": "3428a4f5",
        "pattern": "To transform the input grid into the output grid, follow these precise steps:\n\n1. **Identify Regions**: Locate the two distinct colored areas on either side of a central vertical bar in the input grid.\n2. **Determine Exclusive Cells**: For each cell in the grid, check if it is colored in only one of the two identified regions (either the left or the right, but not both).\n3. **Apply Coloring**: \n    - If a cell is colored in exactly one of the two regions, set that cell's color to **3** in the output grid.\n    - If a cell does not meet this condition, set its color to the background color **0**.\n4. **Optional Mirroring**: With a 50% probability, mirror the entire grid along the diagonal both before creating the output and after.\n\nThis process ensures that the output grid highlights the cells that are uniquely present in one of the two regions from the input, using color 3, while all other cells revert to the background color."
    },
    {
        "id": "3618c87e",
        "pattern": "For each vertical line extending from the top horizontal line in the input grid, move the dot from the bottom end of the line to the top end of the same line."
    },
    {
        "id": "3631a71a",
        "pattern": "1. **Initialize the Grid:**\n   - Create an input grid filled with a background color.\n   \n2. **Select Cells to Paint:**\n   - Identify and select cells where the row index is greater than or equal to the column index.\n\n3. **Paint Selected Cells:**\n   - Paint these selected cells with randomly chosen colors from a predefined set of colors.\n\n4. **Apply Diagonal Mirroring:**\n   - Mirror the painted pattern diagonally to create symmetry.\n\n5. **Concatenate Horizontally:**\n   - Place the original and diagonally mirrored grids side by side horizontally.\n\n6. **Apply Horizontal Mirroring and Concatenate Vertically:**\n   - Mirror the horizontally concatenated grid horizontally again.\n   - Stack the original and mirrored horizontal concatenations vertically to ensure symmetry in both dimensions.\n\n7. **Trim the Grid:**\n   - Remove a fixed number of rows and columns from the edges of the concatenated grid to finalize the output.\n\n8. **Output the Final Grid:**\n   - The transformed grid, now symmetric both horizontally and vertically with trimmed edges, becomes the output grid."
    },
    {
        "id": "363442ee",
        "pattern": "To generate the output grid from the input grid, follow these steps:\n\n1. **Identify Dots**: Locate several dots of a specific color positioned at regular intervals within the input grid.\n\n2. **Replace Dots with Patterns**: For each identified dot, insert a copy of the upper left corner pattern of the input grid, placing it exactly where the dot is located.\n\n3. **Maintain Other Elements**: Keep all other parts of the input grid unchanged, including the background and any existing vertical bars.\n\n4. **Apply Transformations**: Optionally, apply one or two random transformations such as rotations or mirroring to the entire grid to finalize the output."
    },
    {
        "id": "36d67576",
        "pattern": "1. **Identify the Primary Object:** Start with the input grid, which contains a single connected object composed of multiple cells. This object includes one specially marked cell.\n\n2. **Apply Symmetry Transformations:** Create copies of the primary object by randomly applying combinations of mirroring transformations, such as horizontal, vertical, diagonal, or counterdiagonal flips.\n\n3. **Assign Colors to Copies:** For each transformed copy, assign distinct colors to different parts of the object to differentiate between the main segments and additional components.\n\n4. **Position Copies on the Grid:** Place each transformed and colored copy at random locations on the grid. Ensure that these placements do not overlap with each other or with the original object and maintain a minimum distance to prevent adjacency.\n\n5. **Assemble the Output Grid:** Combine the original object with all the transformed and positioned copies to form the final output grid, which showcases multiple symmetrically transformed versions of the primary object in various colors and positions."
    },
    {
        "id": "36fdfd69",
        "pattern": "To transform the input grid into the output grid, for each distinct object in the input:\n1. Draw a rectangular border around the object's bounding box using color 4.\n2. Fill the cells of the object itself with a unique object-specific color.\nThe output grid will have all objects outlined with a color 4 border and each object filled with its designated color."
    },
    {
        "id": "3906de3d",
        "pattern": "To transform the input grid into the output grid, follow these steps:\n\n1. **Draw a Colored Rectangle**: Fill a rectangular area within the input grid with a specific box color.\n\n2. **Add Background Vertical Lines**: In each column of this rectangle, draw a vertical line using the background color. Each line starts from a randomly chosen cutoff row within the rectangle and extends downward to the bottom edge of the rectangle.\n\n3. **Select Specific Columns**: Randomly choose a subset of these columns.\n\n4. **Draw Colored Lines in Selected Columns**: In each selected column, replace the background-colored vertical line with a new line of a different color. This new line starts from the original cutoff row and extends upward by a randomly determined height.\n\n5. **Apply Rotation**: Rotate the entire grid by a random angle chosen from 0\u00b0, 90\u00b0, 180\u00b0, or 270\u00b0."
    },
    {
        "id": "39a8645d",
        "pattern": "To obtain the output grid from the input grid, follow these steps:\n\n1. **Identify the Main Object**: Locate the primary object within the input grid.\n\n2. **Normalize the Object Position**: Shift the main object so that its upper-left corner is at the origin (top-left corner) of a new grid.\n\n3. **Create the Output Grid**: \n   - Initialize a new grid with the same dimensions as the normalized main object.\n   - Fill this new grid entirely with the background color.\n\n4. **Color the Main Object**: \n   - In the new grid, color the cells corresponding to the main object with its designated color.\n\nThe resulting output grid will contain only the main object, properly positioned and colored, against a uniform background."
    },
    {
        "id": "39e1d7f9",
        "pattern": "To transform the input grid into the output grid, follow these steps:\n\n1. **Select Scaling Factors**: Randomly choose scaling factors for both height and width.\n\n2. **Create a Larger Canvas**: Initialize a new, larger grid based on the selected scaling factors, filling it with a background color.\n\n3. **Replicate the Input Pattern**:\n    - For each cell in the input grid, copy its color to corresponding positions in the output grid.\n    - Position each copied cell in the output grid according to the scaling factors, maintaining the original relative arrangement.\n    \n4. **Insert Spacing**: Ensure there are spaces between each replicated pattern in the output grid based on the scaling factors, preventing overlap.\n\n5. **Finalize the Output Grid**: The resulting grid will display multiple scaled and evenly spaced copies of the input pattern arranged systematically across the larger canvas."
    },
    {
        "id": "3aa6fb7a",
        "pattern": "For each connected foreground-colored shape in the input grid, identify one of its four corner cells based on its orientation and set that cell to\u202f1 in the output grid. All other cells remain unchanged."
    },
    {
        "id": "3ac3eb23",
        "pattern": "To transform the input grid into the output grid, follow these steps:\n\n1. **Identify Colored Cells**:\n   - Locate each cell in the top row of the input grid that has a color different from the background.\n\n2. **Create Vertical Lines**:\n   - For each identified colored cell at column *j* in the input grid, draw a vertical line of the same color in the output grid. \n   - Fill every even-numbered row (starting from row 0) in column *j* with this color.\n\n3. **Add Horizontal Adjacent Cells**:\n   - In the output grid, for each vertical line created in step 2:\n     - At every odd-numbered row, fill the cells immediately to the left (*j-1*) and right (*j+1*) of column *j* with the same color.\n\n4. **Apply Rotation**:\n   - Rotate the entire output grid by 0\u00b0, 90\u00b0, 180\u00b0, or 270\u00b0 uniformly.\n\nThis pattern ensures that each colored cell in the input grid is expanded into a structured pattern of vertical and adjacent horizontal lines in the output grid, with an overall rotation applied."
    },
    {
        "id": "3af2c5a8",
        "pattern": "1. **Create a Vertical Mirror:** Take the input grid and produce its vertical mirror (flip it left-to-right).\n2. **Concatenate Horizontally:** Place the original input grid to the left of its vertical mirror, forming a single row.\n3. **Create a Horizontal Mirror:** Take the horizontally concatenated grid from step 2 and produce its horizontal mirror (flip it top-to-bottom).\n4. **Concatenate Vertically:** Stack the original horizontally concatenated grid on top of its horizontal mirror.\n   \nThe final output grid is a symmetric 2x2 arrangement composed of the original input grid and its vertical and horizontal mirrors."
    },
    {
        "id": "3bd67248",
        "pattern": "To transform the input grid into the output grid, follow these steps:\n\n1. **Add a Horizontal Line:**\n   - Draw a horizontal line colored with color\u00a04 along the bottom row of the grid, starting from the second column and extending to the last column.\n\n2. **Add a Diagonal Line:**\n   - From the cell immediately above and to the right of the leftmost cell in the bottom row, draw a diagonal line colored with color\u00a02 that extends upwards to the right across the grid.\n\n3. **Rotate the Grid:**\n   - Rotate the entire grid by 0\u00b0, 90\u00b0, 180\u00b0, or 270\u00b0, chosen uniformly at random.\n\n4. **Scale the Grid:**\n   - Uniformly enlarge the grid by an integer scaling factor between\u00a01 and a maximum value determined by dividing\u00a030 by the grid's largest dimension (height or width).\n\nThese steps modify the input grid by adding specified lines, applying a random rotation, and scaling the grid to produce the output grid."
    },
    {
        "id": "3bdb4ada",
        "pattern": "To transform the input grid into the output grid, perform the following steps:\n\n1. **Initialize** the grid with a background color.\n2. **Place a specified number of rectangles** randomly on the grid. For each rectangle:\n   - **Choose orientation**:\n     - **Horizontal**: Make the rectangle 3 rows tall with an odd number of columns.\n     - **Vertical**: Make the rectangle 3 columns wide with an odd number of rows.\n   - **Select a position** where the rectangle fits without overlapping existing rectangles.\n   - **Fill the entire area** of the rectangle with a unique color.\n   - **Create a dashed line** by setting every other cell in the central row (for horizontal rectangles) or central column (for vertical rectangles) back to the background color.\n3. **Ensure no overlap** by only placing rectangles in areas that remain unoccupied.\n\nThis process results in the output grid containing multiple colored rectangles each featuring a dashed line through their center."
    },
    {
        "id": "3befdf3e",
        "pattern": "1. **Identify Rectangular Regions:** Locate each distinct rectangular block within the input grid.\n\n2. **Swap Colors:**\n   - **Inner Area:** Replace the color of the inner cells of each rectangle with the original border color.\n   - **Border:** Replace the color of the border cells of each rectangle with the original inner color.\n\n3. **Fill Aligned Cells:**\n   - Within each rectangle, locate any cells that are in the same row or column as the border.\n   - Fill these aligned cells with the original border color.\n\n**Summary:**  \nFor every rectangular region in the input grid, invert its colors by swapping the inner area with the border color and vice versa. Additionally, within each rectangle, ensure that cells aligned horizontally or vertically with the border are filled with the border color in the output grid."
    },
    {
        "id": "3c9b0459",
        "pattern": "Rotate the input grid by 180 degrees to create the output grid."
    },
    {
        "id": "3de23699",
        "pattern": "Identify a rectangular region within the input grid. Assign one color to the four corners of this rectangle and assign a second color to a random selection of cells along the rectangle's border. Then, swap these two colors throughout the entire input grid, extract the rectangular region, and remove its outer border to produce the output grid."
    },
    {
        "id": "3e980e27",
        "pattern": "To transform the input grid into the output grid, follow these steps:\n\n1. **Identify Objects**: Locate the distinct colored objects in the input grid.\n2. **Mirror Objects Vertically**: Create a vertical mirror image of each identified object.\n3. **Place Mirrored Objects**: Position the mirrored objects at random locations on the grid, ensuring they do not overlap with existing objects.\n4. **Add Additional Copies**: Randomly add more copies of both the original and mirrored objects to the grid, placing each copy in a new, non-overlapping location.\n5. **Optional Recoloring**: With a certain probability, change the color of some of the added objects to match one of the original colors.\n6. **Finalize Output**: The output grid will consist of the original objects along with their vertically mirrored and additional copies, all arranged without overlapping."
    },
    {
        "id": "3eda0437",
        "pattern": "Identify the largest rectangular areas in the input grid where all cells are background (value\u202f0). In the output grid, replace each of these largest background rectangles with the color\u202f6."
    },
    {
        "id": "3f7978a0",
        "pattern": "1. **Initialize the Grid**: Fill the entire grid with a uniform background color.\n2. **Add Noise**: Randomly place noise cells of a specific color at various positions within the grid.\n3. **Draw Vertical Lines**: Create two vertical lines of a different color to form the left and right boundaries of a rectangle.\n4. **Mark Corners**: Highlight the four corners of the rectangle by changing their colors to the noise color.\n5. **Extract Subgrid**: Identify and extract the smallest rectangular area that encompasses all four marked corners.\n6. **Optional Mirroring**: With a 50% chance, flip both the original grid and the extracted subgrid along the diagonal."
    },
    {
        "id": "40853293",
        "pattern": "To transform the input grid into the output grid, follow these precise steps:\n\n1. **Identify Horizontal Lines:**\n   - In the input grid, locate all pairs of colored cells that lie on the same row. Each pair represents the endpoints of a horizontal line.\n   \n2. **Draw Horizontal Lines:**\n   - For each identified pair of horizontal endpoints, color every cell between them on that row with the same color as the endpoints, forming a complete horizontal line in the output grid.\n\n3. **Identify Vertical Lines:**\n   - In the input grid, locate all pairs of colored cells that lie on the same column. Each pair represents the endpoints of a vertical line.\n   \n4. **Draw Vertical Lines:**\n   - For each identified pair of vertical endpoints, color every cell between them on that column with the same color as the endpoints, forming a complete vertical line in the output grid.\n\n5. **Preserve Background:**\n   - All cells not part of any drawn horizontal or vertical line remain in the background color, ensuring that only the specified lines are colored.\n\nBy executing these steps, the output grid will display fully drawn horizontal and vertical lines corresponding to the colored endpoint pairs in the input grid, with all other cells maintaining the background color."
    },
    {
        "id": "4093f84a",
        "pattern": "1. **Identify Vertical Bars**: Locate all vertical bars in the input grid that span from row `loci1` to row `loci2` across their respective columns.\n\n2. **Add Upward Extensions**: For each selected column in the input grid, if there are dots above the top of the vertical bar (`loci1`), extend the vertical bar upward in the output grid by drawing a straight line from the top of the bar to the position of each corresponding dot.\n\n3. **Add Downward Extensions**: Similarly, for dots below the bottom of the vertical bar (`loci2`), extend the vertical bar downward in the output grid by drawing straight lines from the bottom of the bar to each corresponding dot's position.\n\n4. **Optional Mirroring**: Optionally, mirror the entire grid along the diagonal to create a symmetric pattern in the output grid."
    },
    {
        "id": "41e4d17e",
        "pattern": "To transform the input grid into the output grid, follow these steps:\n\n1. **Identify Filled Regions**: Locate all filled boxes in the input grid and determine the center position of each box.\n\n2. **Copy Filled Boxes**: Retain all filled boxes from the input grid unchanged in the output grid.\n\n3. **Draw Center Lines**:\n   - For each identified center position:\n     - Draw a horizontal line that spans the entire row of the center.\n     - Draw a vertical line that spans the entire column of the center.\n   \n4. **Apply Coloring**: On the output grid, color all cells on these horizontal and vertical lines with color `6` **only** if those cells were the background color in the input grid.\n\nThis process results in an output grid that includes the original filled boxes and additional horizontal and vertical lines intersecting at the centers of each box, with the lines colored distinctly where the background was present."
    },
    {
        "id": "4258a5f9",
        "pattern": "To transform the input grid into the output grid:\n\n1. Identify all cells that have the foreground color.\n2. For each of these foreground cells, locate all neighboring cells that are directly or diagonally adjacent.\n3. In the output grid, set each of these neighboring cells to the color 1.\n4. Keep the foreground cells unchanged.\n5. All other cells retain their original background color."
    },
    {
        "id": "4290ef0e",
        "pattern": "1. **Identify All Colored Objects**: Detect and extract all non-background colored shapes from the input grid.\n\n2. **Normalize Objects**: Shift each extracted object so that its upper-left corner aligns with the origin (top-left corner) of the grid.\n\n3. **Sort Objects by Width**: Arrange the normalized objects in order of their widths, from narrowest to widest.\n\n4. **Place Objects Symmetrically**:\n   - Sequentially place each sorted object onto a new output grid, ensuring that they do not overlap.\n   - For each object, select a suitable location within the output grid where it fits without overlapping existing objects.\n\n5. **Apply Horizontal and Vertical Mirroring**:\n   - Mirror the entire arrangement of placed objects horizontally.\n   - Then, mirror the mirrored arrangement vertically to create a fully symmetric pattern.\n\n6. **Optional Center Fill**: With a 50% probability, fill the central cell of the output grid with a randomly chosen color different from the background and existing object colors.\n\n7. **Finalize Output Grid**: The resulting grid now displays all the objects arranged symmetrically, optionally enhanced with a central colored cell."
    },
    {
        "id": "42a50994",
        "pattern": "For each cell in the input grid, if it is colored and is adjacent (including diagonally) to at least one other colored cell, retain its color in the output grid. Otherwise, change the cell to the background color. Only cells that are part of groups of two or more connected colored cells remain colored; all isolated colored cells become background."
    },
    {
        "id": "4347f46a",
        "pattern": "Transform the input grid by replacing each filled rectangular area with its corresponding border. Specifically, for every distinct colored filled rectangle in the input grid, draw only the outline of that rectangle in the same color on the output grid, leaving the interior cells as the background color."
    },
    {
        "id": "444801d8",
        "pattern": "To transform the input grid into the output grid, follow these steps:\n\n1. **Initialize the Output Grid**: Start with an empty grid that has the same dimensions as the input grid, filled with the background color.\n\n2. **Determine Object Parameters**:\n   - Decide the number of objects to modify, ensuring it does not exceed a calculated limit based on the grid size.\n   - Select a unique color for each object from the available color palette.\n\n3. **Modify Each Object**:\n   - **Recolor Specific Regions**: Within each object, change the color of a defined rectangular area and a single dot.\n   - **Optional Mirroring and Shifting**:\n     - With a 50% probability, horizontally mirror the modified object.\n     - Shift the mirrored object upwards by a fixed amount.\n\n4. **Place the Modified Object**:\n   - Choose a random valid location on the output grid where the modified object can fit without overlapping existing objects.\n   - Insert the modified (and possibly mirrored and shifted) object into the output grid at the chosen location.\n\n5. **Repeat Until Complete**: Continue modifying and placing objects until the desired number of objects has been successfully added to the output grid or the maximum number of attempts is reached.\n\n6. **Finalize the Output Grid**: Ensure all modifications are applied, and the output grid maintains the background color where no objects are placed.\n\nThis process systematically recolors, optionally mirrors, and shifts objects from the input grid to produce the output grid with the described transformations."
    },
    {
        "id": "445eab21",
        "pattern": "To transform the input grid to the output grid, follow these steps:\n\n1. **Identify All Colored Rectangles:** Examine the input grid and locate all rectangular regions that are filled with a single color, excluding the background color.\n\n2. **Determine the Largest Rectangle:** Among all the identified colored rectangles, find the one with the greatest area (i.e., the largest number of cells).\n\n3. **Create the Output Grid:** Generate a new 2x2 grid where every cell is filled with the color of the largest rectangle identified in the input grid."
    },
    {
        "id": "447fd412",
        "pattern": "1. **Retain the Original Object:** Keep the main object in its existing position and fully colored state from the input grid unchanged.\n\n2. **Identify Partial Copies:** Locate all scaled (enlarged) copies of the main object that appear partially colored in the input grid.\n\n3. **Complete the Coloring:** For each identified partial copy, fill in the uncolored or indicator-colored cells with the main color to fully reconstruct the object.\n\n4. **Ensure Proper Placement:** Position each fully colored scaled copy in the grid without overlapping improperly with other objects.\n\n5. **Generate the Output Grid:** The output grid will display the original main object along with all its scaled copies, each fully colored and properly placed."
    },
    {
        "id": "44d8ac46",
        "pattern": "To transform the input grid into the output grid, follow these precise steps:\n\n1. **Initialize the Grid:**\n   - Start with an input grid entirely filled with a background color.\n\n2. **Add Colored Rectangles:**\n   - Randomly place a number of non-overlapping rectangles on the grid. \n   - Each rectangle has a height and width between 5 and 7 cells.\n   - Fill each rectangle with a randomly chosen color from a predefined set, excluding the background color.\n\n3. **Create Inner Regions:**\n   - For each placed rectangle, carve out a smaller inner region within it:\n     - **Option A:** If ensuring a square, select a smaller square area inside the rectangle and set this region back to the background color in the input grid, making the rectangle appear hollow.\n     - **Option B:** If not ensuring a square, create an irregular inner pattern by selecting specific cells within the rectangle and setting them back to the background color.\n\n4. **Generate the Output Grid:**\n   - Replicate the colored rectangles from the input grid to the output grid.\n   - For each carved-out inner region:\n     - **If the inner region is a perfect square:** Fill this region with a specific secondary color (e.g., color 2) in the output grid.\n     - **If the inner region is not a perfect square:** Leave this region as the background color in the output grid.\n\n5. **Finalize:**\n   - Repeat the above steps until the desired number of rectangles has been added or no more space is available.\n   - The output grid will now display the same colored rectangles as the input grid, but with their inner regions either filled with a secondary color (if they are perfect squares) or left hollow.\n\nThis pattern results in the output grid containing colored rectangles that may have filled-in square centers or remain hollow, depending on the specific conditions applied during the transformation."
    },
    {
        "id": "44f52bb0",
        "pattern": "To transform the input grid into the output grid, follow these steps:\n\n1. **Check Symmetry**: Examine the input grid to determine if it is symmetric along the horizontal axis.\n2. **Generate Output**:\n   - **If the input grid is horizontally symmetric**, produce an output grid that consists of a single cell colored with color **1**.\n   - **If the input grid is not horizontally symmetric**, produce an output grid that consists of a single cell colored with color **7**."
    },
    {
        "id": "4522001f",
        "pattern": "Randomly place one or more small squares with a central dot onto the input grid at non-overlapping and non-adjacent positions. For each such square in the input, insert a corresponding larger square filled with a specific color into the output grid at the same relative location. Finally, rotate both the input and output grids by a randomly chosen multiple of 90 degrees (0\u00b0, 90\u00b0, 180\u00b0, or 270\u00b0)."
    },
    {
        "id": "4612dd53",
        "pattern": "1. Draw a rectangular box within the grid using a specific color.\n2. Inside this box, draw either a horizontal or vertical line connecting two opposite sides, using the same color.\n3. Randomly select some non-corner cells along the box's border and some cells along the connecting line.\n4. In the input grid, change the color of these selected border and line cells back to the background color.\n5. In the output grid, change the color of the same selected cells to a new distinct color.\n6. Additionally, with a certain probability, remove the entire connecting line by setting its color to the background color in both the input and output grids."
    },
    {
        "id": "46442a0e",
        "pattern": "To transform the input grid into the output grid, follow these steps:\n\n1. **Create Rotated Copies**:\n   - Take the original input grid.\n   - Create three additional copies of this grid:\n     - Rotate one copy 90 degrees clockwise.\n     - Rotate another copy 180 degrees.\n     - Rotate the last copy 270 degrees clockwise.\n\n2. **Arrange in a 2x2 Formation**:\n   - **Top-Left Quadrant**: Place the original input grid.\n   - **Top-Right Quadrant**: Place the grid rotated 90 degrees clockwise.\n   - **Bottom-Left Quadrant**: Place the grid rotated 270 degrees clockwise.\n   - **Bottom-Right Quadrant**: Place the grid rotated 180 degrees.\n\nThe final output grid will be a larger grid composed of these four quadrants arranged as follows:\n\n```\n| Original | 90\u00b0 Rotated |\n|----------|-------------|\n| 270\u00b0 Rotated | 180\u00b0 Rotated |\n```\n\nThis arrangement ensures that each quadrant is a rotated version of the original input grid, seamlessly combined to form the output grid."
    },
    {
        "id": "469497ad",
        "pattern": "1. Create a grid filled entirely with a background color.\n2. Place a smaller rectangle of a different color within this grid at a random position, ensuring it does not touch the grid's edges.\n3. From the edges of the colored rectangle, draw multiple horizontal and vertical lines outward using distinct colors.\n4. Rotate the entire grid by 0\u00b0, 90\u00b0, 180\u00b0, or 270\u00b0, selected at random.\n5. Enlarge the grid by repeating each cell a specific number of times based on the number of colors used.\n6. From each corner of the enlarged colored rectangle, draw diagonal lines across the grid.\n7. Where these diagonal lines overlap with the background, change those cells to a designated secondary color.\n8. Apply the same random rotation to both the input and output grids to maintain their orientation relative to each other."
    },
    {
        "id": "46f33fce",
        "pattern": "To generate the output grid from the input grid, first move each colored cell one position to the right and one position down. Then, double the coordinates of these shifted cells. Finally, enlarge the entire grid by a factor of four to produce the output grid."
    },
    {
        "id": "47c1f68c",
        "pattern": "To transform the input grid into the output grid, follow these steps:\n\n1. **Identify the Main Object:** Locate the distinct object within the input grid, which is colored differently from the background and intersecting lines.\n\n2. **Create Mirrored Copies:** Generate three additional copies of this object by mirroring it horizontally, vertically, and both horizontally and vertically.\n\n3. **Arrange Symmetrically:** Combine the original object with its three mirrored copies, arranging them symmetrically to form a balanced pattern in all four quadrants of the grid.\n\n4. **Change Object Color:** Replace the color of all four object copies with a designated line color to unify their appearance.\n\n5. **Apply Random Symmetry:** Optionally, apply a random symmetrical reflection (horizontal, vertical, or both) to the entire output grid to enhance the symmetric effect.\n\nThe result is an output grid that features the original object replicated and symmetrically arranged in all directions, unified by a consistent line color."
    },
    {
        "id": "484b58aa",
        "pattern": "1. **Identify the Repeating Object:** Locate all instances of a specific object pattern that are systematically repeated and shifted across the entire grid.\n2. **Remove Noise Patches:** Detect and eliminate any additional colored patches or noise that do not match the identified repeating object pattern.\n3. **Maintain Consistent Arrangement:** Ensure that the remaining object patterns are consistently and uniformly arranged in their shifted positions across the grid.\n4. **Apply Rotation:** Rotate the cleaned and uniformly arranged grid by 0\u00b0, 90\u00b0, 180\u00b0, or 270\u00b0 to achieve the final output orientation."
    },
    {
        "id": "48d8fb45",
        "pattern": "To transform the input grid into the output grid, follow these steps:\n\n1. **Identify Objects**: Start with an input grid that has a uniform background color and multiple distinct colored objects scattered across it.\n\n2. **Select an Object**: Randomly choose one of the colored objects from the input grid.\n\n3. **Recolor the Object**: Change the color of the selected object to a different color that is not used as the background color.\n\n4. **Normalize Position**: Shift the recolored object so that its upper-left corner aligns with the top-left corner of a new, empty grid, ensuring the object is positioned as far to the origin as possible.\n\n5. **Generate Output**: The output grid will consist solely of this newly recolored and repositioned object on a uniform background, effectively isolating it from the original input grid."
    },
    {
        "id": "4938f0c2",
        "pattern": "To transform the input grid into the output grid, follow these steps:\n\n1. **Create Mirrors**:\n   - Generate a vertically mirrored copy of the input grid.\n   - Generate a horizontally mirrored copy of the input grid.\n   - Generate a copy that is both vertically and horizontally mirrored.\n\n2. **Arrange Grids with Separators**:\n   - Place the original grid and its vertical mirror side by side, separated by a single-column background-colored bar.\n   - Below this, place the horizontally mirrored grid and the double-mirrored grid side by side, also separated by a single-column background-colored bar.\n\n3. **Insert Central Connector**:\n   - Add a horizontal background-colored bar between the top and bottom arrangements.\n   - Place a single-colored cell at the center of this horizontal bar to serve as a connection point.\n\n4. **Combine into a Larger Grid**:\n   - Stack the top arrangement, the central connector, and the bottom arrangement vertically to form a complete larger grid.\n\n5. **Random Rotation**:\n   - Rotate the entire combined grid by either 0\u00b0, 90\u00b0, 180\u00b0, or 270\u00b0, chosen at random.\n\n6. **Remove Central Row and Column**:\n   - Identify the row and column where the central colored cell is located.\n   - Remove this specific row and column from the rotated grid.\n\nThe resulting grid after these steps is the output grid derived from the input grid."
    },
    {
        "id": "496994bd",
        "pattern": "1. **Initialize the Canvas**: Create a grid (`canvas`) with a randomly chosen height between 3 and 30 and a width between 3 and 14. Fill the entire grid with a randomly selected background color.\n\n2. **Select Colors**: From a predefined set of colors (1 to 9), remove the background color. Randomly select between 1 and 8 colors from the remaining colors to be used for coloring cells.\n\n3. **Place Initial Colored Cells**:\n    - **Top Half**: Randomly choose a color from the selected colors and place a colored cell in the upper half of the grid (rows less than half the height).\n    - **Bottom Half**: Randomly choose a color from the selected colors and place another colored cell in the lower half of the grid (rows greater than half the height).\n\n4. **Expand the Colored Object**:\n    - Determine a total number of colored cells (`nc`) randomly chosen between 2 and one less than the total number of cells in the grid.\n    - Iteratively add `nc - 2` additional colored cells to the grid. Each new cell must be adjacent (horizontally or vertically) to at least one already colored cell and is assigned a randomly selected color from the chosen colors.\n\n5. **Paint the Grid**: Apply the colored object onto the canvas, updating the grid to reflect the colored cells.\n\n6. **Create the Output Grid**:\n    - **Decide Concatenation**: Randomly decide whether to horizontally concatenate the painted grid (`gix`) with the original canvas or with an additional single-column canvas filled with the background color.\n    - **Apply Mirroring**: Based on a random flag (`flag`), either:\n        - Concatenate horizontally with the original canvas.\n        - Concatenate horizontally with a vertically mirrored version of the painted grid.\n    - Additionally, randomly decide to mirror both the input (`gi`) and output (`go`) grids either vertically, horizontally, both, or not at all.\n\n7. **Finalize**:\n    - The **input grid** (`gi`) is the result of the horizontal concatenation and any applied mirroring.\n    - The **output grid** (`go`) is the horizontally concatenated version, potentially mirrored vertically based on the initial flag, and may also undergo additional mirroring.\n\n**Summary**: Given an input grid, the output grid is constructed by creating a colored object within a background-filled canvas, optionally mirroring and concatenating it horizontally. Random decisions determine the specific colors used, the placement and expansion of colored cells, and whether and how to mirror parts of the grid to form the final output."
    },
    {
        "id": "49d1d64f",
        "pattern": "To transform the input grid into the output grid:\n\n1. **Enlarge the Grid**: Create a new grid that is two rows taller and two columns wider than the input grid.\n2. **Center the Input**: Place the entire input grid in the center of this new, larger grid, leaving a one-cell-wide border around it.\n3. **Shift Top Edge Up**: Move all cells from the top row of the original input grid one cell upward in the output grid.\n4. **Shift Bottom Edge Down**: Move all cells from the bottom row of the original input grid one cell downward.\n5. **Shift Left Edge Left**: Move all cells from the leftmost column of the original input grid one cell to the left.\n6. **Shift Right Edge Right**: Move all cells from the rightmost column of the original input grid one cell to the right.\n\nThe resulting grid, with the input grid centered and its edges shifted outward, is the final output grid."
    },
    {
        "id": "4be741c5",
        "pattern": "1. **Identify the Original Colors:** Determine the distinct colors that make up the vertical stripes in the input grid, in the order they appear from left to right.\n\n2. **Create a Single Row:** Arrange these identified colors sequentially into a single horizontal row.\n\n3. **Apply Mirroring (if applicable):** If the input grid was mirrored along its diagonal, mirror the single row of colors in the same manner to form the output grid."
    },
    {
        "id": "4c4377d9",
        "pattern": "To create the output grid, place a vertically flipped copy of the input grid directly above the original input grid."
    },
    {
        "id": "4c5c2cf0",
        "pattern": "1. **Identify the Small Pattern**: Locate a specific small region within the input grid positioned at a designated location.\n\n2. **Create Mirrored Copies**:\n   - Generate a vertically mirrored version of the small pattern.\n   - Generate a horizontally mirrored version of the small pattern.\n   - Generate a version mirrored both vertically and horizontally.\n\n3. **Arrange Patterns with Separators**:\n   - Place the original small pattern and its vertically mirrored copy side by side, separated by a vertical line filled with the background color.\n   - Place the horizontally mirrored copy and the doubly mirrored copy side by side in a similar manner.\n\n4. **Add a Central Cell**: Insert a single cell of a specific color at the center where the horizontal and vertical separators intersect.\n\n5. **Combine into a Composite Pattern**: Assemble all the arranged patterns and the central cell into a larger, symmetrical composite pattern.\n\n6. **Position on a Larger Canvas**: Place this composite pattern onto a larger grid or canvas at the same location where the original small pattern was found in the input grid.\n\n7. **Apply Rotation**: Rotate the entire grid by a random angle of 0\u00b0, 90\u00b0, 180\u00b0, or 270\u00b0 to finalize the output grid.\n\nBy following these steps, the output grid is a symmetrically expanded and rotated version of the input grid's small pattern, enhanced with mirrored copies and background separators."
    },
    {
        "id": "50846271",
        "pattern": "To transform the input grid into the output grid, follow these steps:\n\n1. **Identify the Cross Pattern**: Locate the cross-shaped pattern within the input grid. This cross consists of intersecting horizontal and vertical lines centered at a specific position.\n\n2. **Add Noise to the Grid**: The input grid includes random noise cells scattered throughout the background. These noise cells are in a distinct noise color.\n\n3. **Select Noise Regions Around the Cross**: Identify several noise regions that are directly adjacent to or connected with the cross pattern. The number of regions selected is determined randomly within a specified range.\n\n4. **Replace Selected Noise with '8's**: For each of the selected noise regions around the cross, change their color from the original noise color to the color '8'.\n\n5. **Produce the Output Grid**: The output grid will be identical to the input grid except that the selected noise regions around the cross are now colored '8's, while all other elements\u2014including the background and the cross pattern\u2014remain unchanged."
    },
    {
        "id": "508bd3b6",
        "pattern": "To transform the input grid into the output grid, follow these steps:\n\n1. **Identify the Horizontal Bar**: Locate the horizontal colored bar that spans the entire width of the grid at a specific position.\n\n2. **Locate the V-Shaped Line**: Find the V-shaped diagonal line that intersects the horizontal bar. In the input grid, only a portion of this V-shaped line is drawn.\n\n3. **Complete the V-Shaped Line**:\n   - **Fill the Remaining Segments**: Fill in the unfilled parts of the V-shaped line with a second, distinct color to complete the full V-shape.\n\n4. **Apply Optional Transformations**:\n   - **Rotate or Mirror**: Optionally, rotate the entire grid by 90\u00b0, 180\u00b0, or 270\u00b0, or apply horizontal or vertical mirroring to the completed grid.\n\nBy following these steps, the output grid will display a fully formed V-shaped diagonal line intersecting the horizontal bar, with optional rotations or mirrorings applied."
    },
    {
        "id": "50cb2852",
        "pattern": "For each colored rectangular region in the input grid, replace it in the output grid with the same colored border outlining the rectangle and fill the interior of the rectangle with color\u202f8."
    },
    {
        "id": "5117e062",
        "pattern": "Select a single connected group of cells from the input grid. Change the color of one cell within this group to a new color and recolor all other cells in the group to a different color. Place this modified group of cells onto a blank background to produce the output grid."
    },
    {
        "id": "5168d44c",
        "pattern": "To transform the input grid into the output grid, follow these steps:\n\n1. **Identify the Central Dot**: Locate the main dot within the input grid.\n\n2. **Draw a Bounding Box**: Surround this central dot with a rectangular border of specified thickness.\n\n3. **Determine the Direction**: Identify the direction in which multiple copies of the dot are arranged\u2014either downward, to the right, or diagonally both down and right.\n\n4. **Calculate the Offset**: Based on the size of the bounding box and the border, compute the distance and direction to shift the bounding box.\n\n5. **Shift the Bounding Box**: Move the rectangular border in the determined direction by the calculated offset.\n\n6. **Overlay the Shifted Box**: Add the shifted bounding box to the original grid, resulting in the output grid containing both the original and the shifted bounding boxes."
    },
    {
        "id": "539a4f51",
        "pattern": "To generate the output grid from the input grid, first duplicate the arrangement of colored vertical and horizontal lines from the input grid onto a grid that is twice as large in both height and width, repeating the sequence of colors as needed. Then, apply the same random rotation (by 0\u00b0, 90\u00b0, 180\u00b0, or 270\u00b0) to both the input and output grids."
    },
    {
        "id": "53b68214",
        "pattern": "To generate the output grid from the input grid, follow these steps:\n\n1. **Choose a Background Color:** Select a single color to fill the entire output canvas.\n\n2. **Determine Object Colors:** Select a subset of colors different from the background color to be used for the object.\n\n3. **Shift the Input Object Horizontally:** Move the input object left or right by a random number of columns within the canvas.\n\n4. **Place Multiple Copies Vertically:** Paint several copies of the shifted input object stacked vertically on the canvas. Each copy is placed below the previous one, with a random vertical offset and an additional random horizontal shift to create variation.\n\n5. **Optionally Mirror Vertically:** Flip the entire canvas upside down to create a mirrored version of the pattern.\n\nThe input grid contains a single horizontally shifted object, and the output grid displays multiple vertically stacked and optionally mirrored copies of this object on a uniformly colored background."
    },
    {
        "id": "543a7ed5",
        "pattern": "For each colored rectangular area in the input grid, the output grid displays the same rectangle surrounded by a one-cell-wide border colored with 3. Additionally, if the rectangle's height and width exceed five cells, an inner smaller area within the rectangle is filled with color 4."
    },
    {
        "id": "54d82841",
        "pattern": "Randomly rotate the input grid by 0\u00b0, 90\u00b0, 180\u00b0, or 270\u00b0. Then, for each column that contains a colored shape, color the bottom cell of that column with color 4. The resulting grid after these modifications is the output grid."
    },
    {
        "id": "54d9e175",
        "pattern": "For each distinct rectangular region (tile) in the input grid that contains exactly one colored cell, identify the color of that single cell. Then, in the output grid, fill the entire corresponding tile with a new color that is five numerical units higher than the identified color of the single cell."
    },
    {
        "id": "5521c0d9",
        "pattern": "Each colored rectangular region in the input grid is moved upward by a number of rows equal to its own height, producing the output grid. All background cells remain unchanged."
    },
    {
        "id": "5582e5ca",
        "pattern": "Identify the color that appears most frequently in the input grid and fill every cell of the output grid with this predominant color."
    },
    {
        "id": "5614dbcf",
        "pattern": "1. **Divide the Input Grid**: Split the input grid into non-overlapping 3\u00d73 blocks.\n\n2. **Process Each Block Individually**:\n   - **Occupied Blocks**:\n     - If a block contains a majority of cells filled with the same color (excluding color 5), determine this color as the block's representative color.\n     - Assign this representative color to the corresponding single cell in the output grid.\n   - **Unoccupied Blocks**:\n     - If a block does not have a majority of any single color (other than color 5), consider it unoccupied.\n     - Assign the value 0 to the corresponding cell in the output grid.\n\n3. **Construct the Output Grid**: After processing all 3\u00d73 blocks, the output grid will consist of cells colored based on the majority colors of their respective blocks or set to 0 if unoccupied."
    },
    {
        "id": "56dc2b01",
        "pattern": "1. **Initialize the Grid**: Start with a grid of specified height and width, filled entirely with a background color.\n\n2. **Draw a Vertical Line**: Insert a vertical line of a specific color at a randomly chosen column within the grid.\n\n3. **Place the Object**: Position an object of a different color at a randomly selected location within the grid.\n\n4. **Create the Output Grid**:\n    - **Retain Background and Original Line**: Keep the background color and the initially drawn vertical line unchanged.\n    - **Shift the Object**: Move the object horizontally so that it is positioned immediately to the right of the original vertical line.\n    - **Add a Second Vertical Line**: Draw an additional vertical line of another specific color at a column that is a set distance to the right of the shifted object.\n\n5. **Apply Transformations**: Optionally, apply one or two random transformations (such as rotation or mirroring) uniformly to both the input and output grids to introduce variation."
    },
    {
        "id": "56ff96f3",
        "pattern": "To generate the output grid from the input grid, perform the following steps:\n\n1. **Identify Rectangle Corners**: In the input grid, locate pairs of cells that share the same color. Each pair represents two opposite corners of a rectangle.\n\n2. **Determine Rectangle Boundaries**: For each identified pair of colored corner cells, define the rectangular area that spans from one corner to the other. This area includes all cells within the smallest bounding box that contains both corners.\n\n3. **Fill the Rectangle**: In the output grid, fill every cell within each determined rectangular area with the color associated with the corresponding corner pair from the input grid.\n\n4. **Ensure Non-Overlap**: Make sure that the rectangles do not overlap. Each rectangle's area should be distinct and not interfere with others to maintain clear boundaries.\n\n5. **Finalize the Output**: Repeat the above steps for all identified rectangle corner pairs in the input grid. The output grid will then display fully colored rectangles based on the corner indications from the input."
    },
    {
        "id": "57aa92db",
        "pattern": "1. **Initialize the Output Grid**: Start with a grid of specified height and width, filling all cells with a background color.\n\n2. **Create a Base Object**:\n   - Select a random connected group of at least three cells within a small region.\n   - Designate one cell within this group as the fixed point.\n   - Assign a unique color to the fixed cell and a different color to the remaining cells of the object.\n\n3. **Place the Base Object**: Position the colored base object at a random location on the grid, ensuring it fits within the grid boundaries.\n\n4. **Add Additional Objects**:\n   - Determine the number of additional objects to add based on grid size and the base object's size.\n   - For each additional object:\n     - **Scale the Base Object**: Enlarge the base object by a random scaling factor between 1 and 4.\n     - **Recolor**: Assign a new unique color to the fixed cell of the scaled object, and a distinct color to its other cells.\n     - **Position**: Place the scaled and recolored object at a random location on the grid, ensuring it does not overlap with existing objects and remains separated by at least one cell from them.\n\n5. **Finalize the Output Grid**: After placing all additional objects, the grid now contains the original base object and several scaled, recolored copies positioned at various locations."
    },
    {
        "id": "5ad4f10b",
        "pattern": "To derive the output grid from the input grid, follow these steps:\n\n1. **Identify the Main Object**: Locate all cells in the input grid that are colored with the designated object color (`objc`).\n\n2. **Remove Noise**: Eliminate any noise cells present in the input grid that do not match the object color, retaining only the main object.\n\n3. **Normalize the Object Position**: Shift the main object so that its upper-left corner aligns with the origin (top-left corner) of the grid.\n\n4. **Scale Down the Object**: Reduce the size of the normalized object uniformly by the scaling factor that was originally used to enlarge it in the input grid.\n\n5. **Generate the Output Grid**: The resulting scaled-down and normalized object forms the output grid."
    },
    {
        "id": "5bd6f4ac",
        "pattern": "To obtain the output grid from the input grid, follow these steps:\n1. **Rotate** the input grid 90 degrees counter-clockwise.\n2. **Extract** the top-left 3\u00d73 section from the rotated grid.\n3. **Rotate** this 3\u00d73 section 90 degrees clockwise.\nThe resulting 3\u00d73 grid is the output grid."
    },
    {
        "id": "5c0a986e",
        "pattern": "For each 2\u00d72 square in the input grid colored with color\u202f1 or color\u202f2, extend the square by adding a diagonal line of the same color. Specifically, if the square is colored with color\u202f1, draw a diagonal line upward to the left from the square, and if it is colored with color\u202f2, draw a diagonal line downward to the right from the square. The output grid consists of the original squares along with their respective diagonal extensions."
    },
    {
        "id": "5c2c9af4",
        "pattern": "Given an input grid where three specific cells are colored\u2014namely, the top-left corner, the bottom-right corner, and the center of a rectangular area\u2014produce the output grid by filling every cell within the rectangle defined by these corners with the same color."
    },
    {
        "id": "5daaa586",
        "pattern": "To transform the input grid into the output grid, follow these precise steps:\n\n1. **Identify the Rectangle Borders:**\n   - Locate two horizontal lines and two vertical lines within the input grid. Each line is colored uniquely, forming the borders of a rectangle.\n\n2. **Crop the Grid:**\n   - Extract the rectangular area enclosed by these four border lines from the input grid, creating a smaller, focused grid.\n\n3. **Replace Noise Pixels:**\n   - Within the cropped grid, identify all pixels of a specific color (referred to as the noise color).\n   - For each of these noise-colored pixels, draw a vertical line extending upwards from its position, effectively replacing the original noise pixel with this new line.\n\n4. **Apply Rotation:**\n   - Rotate the resulting grid by a random multiple of 90 degrees (i.e., 0\u00b0, 90\u00b0, 180\u00b0, or 270\u00b0) to finalize the output grid.\n\nThis sequence ensures that the output grid is a rotated, processed version of the cropped input, where specified noise pixels have been systematically transformed into vertical lines."
    },
    {
        "id": "60b61512",
        "pattern": "For each distinct colored region in the input grid, draw an outline around it using color\u202f7. The output grid retains the original colors of all regions and adds a boundary of color\u202f7 surrounding each colored area."
    },
    {
        "id": "6150a2bd",
        "pattern": "Rotate the input grid by 180 degrees to produce the output grid."
    },
    {
        "id": "623ea044",
        "pattern": "For each colored cell in the input grid, draw four diagonal lines of the same color extending from that cell in the up-right, down-left, up-left, and down-right directions all the way to the edges of the grid. The output grid includes the original colored cells and these extended diagonal lines."
    },
    {
        "id": "62c24649",
        "pattern": "1. **Create a Vertical Mirror:** Generate a vertically flipped copy of the input grid.\n2. **Concatenate Horizontally:** Place the vertically mirrored grid to the right of the original input grid, forming the top half of the output.\n3. **Create Horizontal Mirrors:** Generate horizontally flipped copies of both the original input grid and its vertically mirrored version.\n4. **Concatenate Horizontally Again:** Place these horizontally mirrored grids side by side, forming the bottom half of the output.\n5. **Stack Vertically:** Stack the top half (original and vertical mirror) above the bottom half (horizontal mirrors) to produce the final output grid.\n\nIn summary, the pattern involves mirroring the input grid both vertically and horizontally, concatenating these mirrors with the original grid horizontally, and then stacking the resulting top and bottom halves vertically to form a symmetrical output grid."
    },
    {
        "id": "63613498",
        "pattern": "To transform the input grid into the output grid, follow these steps:\n\n1. **Preserve the Background and Separator:**\n   - Maintain the existing background color of the entire grid.\n   - Retain the separator lines that are already present in the input grid.\n\n2. **Add New Objects:**\n   - Randomly place a number of small, connected colored objects onto the background. The number of objects should be within a specified range based on the grid's size.\n   - Ensure that each new object does not overlap with the existing separator lines or with other objects already placed on the grid.\n   - Assign each new object a color selected randomly from a predefined set of colors distinct from the background and separator colors.\n\n3. **Apply Rotation:**\n   - Rotate the entire grid by a random multiple of 90 degrees (i.e., 0\u00b0, 90\u00b0, 180\u00b0, or 270\u00b0) to vary the orientation of the patterns.\n\nThe resulting grid after these steps will be the output grid, which includes the original background and separator along with the newly added colored objects, all potentially rotated."
    },
    {
        "id": "6430c8c4",
        "pattern": "1. **Identify Regions and Separator**:\n   - Divide the input grid vertically into three sections.\n   - In the left section, randomly select and color a subset of cells with a specific color (Color A).\n   - Insert a thin vertical separator line in the middle section with a different specific color (Color L).\n   - In the right section, randomly select and color a subset of cells with another specific color (Color B).\n\n2. **Generate Output Grid**:\n   - Create a new grid filled entirely with a background color (Background Color).\n   - Change the color of all cells **not** part of the left and right colored regions (i.e., all cells except those colored with Color A or Color B) to a new specific color (Color 3).\n   - Ensure that the cells in the left and right regions retain the background color.\n\n3. **Optional Mirroring**:\n   - With a 50% probability, horizontally mirror both the input and output grids."
    },
    {
        "id": "6455b5f5",
        "pattern": "1. Identify all distinct connected objects in the input grid.\n2. Determine which object(s) are the smallest and which are the largest based on their size.\n3. Change the color of the smallest object(s) to color 8.\n4. Change the color of the largest object(s) to color 1.\n5. Leave all other objects and the background color unchanged."
    },
    {
        "id": "662c240a",
        "pattern": "To generate the output grid from the input grid, follow these steps:\n\n1. **Divide the Input Grid**: \n   - The input grid is composed of multiple smaller grids of size *d \u00d7 d*, arranged either horizontally or vertically.\n\n2. **Select a Single Subgrid**: \n   - Choose one of these *d \u00d7 d* subgrids from the input.\n\n3. **Ensure Diagonal Symmetry**: \n   - Make the selected subgrid symmetric across its main diagonal by copying the color of each cell in the upper triangle (where column index \u2265 row index) to its corresponding mirrored cell in the lower triangle.\n\n4. **Modify Off-Diagonal Cells**:\n   - Randomly select a number of off-diagonal cells within the subgrid.\n   - For each selected cell:\n     - **Option A**: Set its color to match its mirrored counterpart, maintaining symmetry.\n     - **Option B**: Assign it a different color chosen from a predefined set of colors, introducing asymmetry.\n\n5. **Produce the Output Grid**:\n   - The resulting modified *d \u00d7 d* subgrid becomes the output grid."
    },
    {
        "id": "67385a82",
        "pattern": "Identify all cells in the input grid that are colored with a specific color (chosen from 1, 2, 3, 4, 5, 6, 7, or 9). For each such colored cell, check if it is part of a group of two or more adjacent cells of the same color. If it is, change its color to 8 in the output grid. Cells that are either background (color 0) or single isolated colored cells remain unchanged."
    },
    {
        "id": "673ef223",
        "pattern": "To transform the input grid into the output grid, follow these precise steps:\n\n1. **Identify the Vertical Bars:**\n   - Recognize the two vertical bars located on the leftmost and rightmost columns of the input grid.\n\n2. **Select Rows for Modification:**\n   - Randomly choose a number of rows within the upper half of the grid. The number of selected rows is determined by a random integer between 1 and half the height of the grid.\n\n3. **Place Dots in Selected Rows:**\n   - For each selected row:\n     a. **Choose a Column Position:**\n        - Select a random column position that is not on the extreme left or right edges (i.e., between the second and second-to-last columns).\n     b. **Add a Dot in the Input Grid:**\n        - In the input grid's left vertical bar, place a dot at the chosen column position using a designated dot color.\n   \n4. **Modify the Output Grid:**\n   - For each dot placed in the input grid:\n     a. **Change Dot Color:**\n        - In the output grid's corresponding position, change the color of the dot to a distinct color (e.g., color index 4).\n     b. **Fill Horizontal Connection:**\n        - Fill all cells horizontally from the second column up to one column before the dot's position with the dot color, creating a continuous horizontal line leading to the dot.\n     c. **Mirror Horizontal Line in Right Bar:**\n        - In the right vertical bar of the output grid, draw a horizontal line across the entire row (excluding the last column) using the dot color, effectively mirroring the modification made in the left bar.\n   \n5. **Ensure Grid Height Consistency:**\n   - If the combined rows of the modified top and bottom sections are fewer than the desired grid height, randomly insert additional rows filled with the background color into both the input and output grids until the grid reaches the specified height.\n\n6. **Apply Random Transformations:**\n   - Apply one or two random geometric transformations to both the input and output grids to vary their orientation. The possible transformations include:\n     - **Rotation:** Rotate the grid by 90\u00b0, 180\u00b0, or 270\u00b0 clockwise.\n     - **Mirroring:** Reflect the grid horizontally, vertically, diagonally, or counter-diagonally.\n\nBy following these steps, the output grid is a transformed version of the input grid with specific modifications in selected rows, including colored dots and connecting horizontal lines, all potentially altered through geometric transformations to ensure variability."
    },
    {
        "id": "6773b310",
        "pattern": "To transform the input grid to the output grid, follow these steps:\n\n1. **Divide the Input Grid**: Segment the input grid into a series of equally sized, non-overlapping rectangular blocks.\n\n2. **Select Blocks to Highlight**: Randomly choose a subset of these blocks based on a predefined number or probability.\n\n3. **Mark Selected Blocks in Output**: In the output grid, represent each selected block by marking its corresponding position with a specific color or indicator.\n\n4. **Finalize the Output Grid**: The output grid will display markers only at the positions corresponding to the selected blocks from the input grid, while all other positions remain in the background color.\n\nThis process results in an output grid that highlights specific areas of the input grid based on the randomly selected blocks."
    },
    {
        "id": "67a3c6ac",
        "pattern": "Mirror the input grid horizontally by reversing each row, producing the output grid as a left-right reflection of the input."
    },
    {
        "id": "67a423a3",
        "pattern": "1. **Select a Background Color:** Choose a color (other than color 4) to fill the entire grid as the background.\n\n2. **Draw Horizontal Lines:** Draw a series of horizontal lines across the grid at specific row positions using a selected color distinct from the background.\n\n3. **Draw Vertical Lines:** Draw a series of vertical lines across the grid at specific column positions using another selected color different from both the background and the horizontal lines.\n\n4. **Identify Intersection Area:** Determine the rectangular region where the horizontal and vertical lines intersect.\n\n5. **Draw a Border Around the Intersection:** Outline the perimeter of the identified rectangular intersection area by coloring its border cells with color 4.\n\n6. **Optional Mirroring:** With a 50% chance, mirror the entire grid along its main diagonal to create a symmetrical pattern."
    },
    {
        "id": "67e8384a",
        "pattern": "1. **Start with the input grid.**\n\n2. **Create a vertically mirrored version of the input grid** (flip it left to right).\n\n3. **Place the vertically mirrored grid to the right of the original grid**, forming the top half of the output.\n\n4. **Create a horizontally mirrored version of the original grid** (flip it top to bottom).\n\n5. **Place the horizontally mirrored grid below the original grid**, forming the bottom left quadrant of the output.\n\n6. **Create a grid that is both horizontally and vertically mirrored** (flip it left to right and then top to bottom).\n\n7. **Place this doubly mirrored grid to the right of the horizontally mirrored grid**, completing the bottom half of the output.\n\n8. **The final output grid consists of four sections**:\n   - Top-left: Original input grid.\n   - Top-right: Vertically mirrored input grid.\n   - Bottom-left: Horizontally mirrored input grid.\n   - Bottom-right: Both horizontally and vertically mirrored input grid.\n\nThis arrangement results in the output grid being symmetric along both the horizontal and vertical axes."
    },
    {
        "id": "681b3aeb",
        "pattern": "1. Identify two distinct connected regions in the input grid, each filled with a different color.\n2. Determine new, non-overlapping positions within the output grid where each of these regions can fit without exceeding the grid boundaries.\n3. Move the first region to its new position in the output grid, maintaining its original shape and color.\n4. Move the second region to its designated new position in the output grid, ensuring its shape and color remain unchanged.\n5. Ensure that both regions are placed completely within the output grid and do not overlap each other."
    },
    {
        "id": "6855a6e4",
        "pattern": "To transform the input grid into the output grid, follow these precise steps:\n\n1. **Select a Rectangular Area**: Choose a randomly sized rectangle within the input grid and fill it with a specific box color.\n\n2. **Draw Horizontal Lines**: Inside this rectangle, draw one or more horizontal lines to divide the area.\n\n3. **Place Objects**: On one side of each horizontal line, randomly color a set of cells with an object color.\n\n4. **Mirror the Objects Horizontally**: For each group of object-colored cells, create a horizontally mirrored copy across the vertical center axis of the rectangle.\n\n5. **Finalize the Output Grid**: The output grid is identical to the input grid except that the objects within the selected rectangle are mirrored horizontally."
    },
    {
        "id": "68b16354",
        "pattern": "Vertically flip the input grid by mirroring it over a horizontal axis to produce the output grid."
    },
    {
        "id": "694f12f3",
        "pattern": "To transform the input grid into the output grid, follow these precise steps:\n\n1. **Initialize the Grid**:\n   - Start with a grid of size *height* \u00d7 *width*, filled entirely with a background color.\n\n2. **Draw Two Rectangles**:\n   - **Big Rectangle**:\n     - Choose a random position near the top of the grid.\n     - Draw a large axis-aligned rectangle with randomly selected height and width within specified ranges.\n     - Fill the border of this big rectangle with a specific square color.\n   - **Small Rectangle**:\n     - Choose a random position lower in the grid, ensuring it does not overlap with the big rectangle.\n     - Draw a smaller axis-aligned rectangle with height and width less than the big rectangle's area.\n     - Fill the border of this small rectangle with the same square color used for the big rectangle.\n\n3. **Fill Interiors with Distinct Colors**:\n   - **Big Rectangle Interior**:\n     - Fill the area inside the big rectangle's border with color `2`.\n   - **Small Rectangle Interior**:\n     - Fill the area inside the small rectangle's border with color `1`.\n\n4. **Apply a Uniform Rotation**:\n   - Randomly select a rotation angle from 0\u00b0, 90\u00b0, 180\u00b0, or 270\u00b0.\n   - Rotate both the input grid and the modified grid by the chosen angle.\n\n5. **Generate the Output Grid**:\n   - The rotated grid, now containing two rectangles with their interiors filled with distinct colors, becomes the output grid.\n\nThis pattern ensures that the output grid consists of the original background, two colored rectangles with distinct interior fillings, all uniformly rotated by a multiple of 90 degrees."
    },
    {
        "id": "6a1e5592",
        "pattern": "To transform the input grid into the output grid, follow these steps:\n\n1. **Identify the Horizontal Bar**:\n   - Locate the top horizontal bar in the input grid, which is filled with a specific color.\n\n2. **Determine Object Placement Parameters**:\n   - Decide on the number of objects to place on the bar.\n   - For each object, randomly choose its height and width within predefined limits.\n\n3. **Create and Normalize Objects**:\n   - Generate each object as a connected group of cells based on the chosen dimensions.\n   - Adjust the object's position so that its upper-left corner aligns with the origin.\n\n4. **Place Objects on the Input Grid**:\n   - Select a valid horizontal position on the bar where the object can fit without overlapping existing objects or exceeding the bar's boundaries.\n   - Color the cells of the input grid corresponding to the object's location with a designated object color.\n\n5. **Mark Object Locations in the Output Grid**:\n   - In the output grid, mark each placed object's location by setting the corresponding cells to a specific marker value (e.g., 1).\n\n6. **Apply Rotation**:\n   - Rotate both the input and output grids by a randomly chosen angle of 0\u00b0, 90\u00b0, 180\u00b0, or 270\u00b0 to introduce variability.\n\nBy following these steps, the output grid will reflect the placement of objects on the input grid's horizontal bar, with their locations clearly marked and the entire grid optionally rotated."
    },
    {
        "id": "6aa20dc0",
        "pattern": "To create the output grid from the input grid, first identify a specific object within the input grid. Then, generate several copies of this object, each time randomly mirroring it either horizontally or diagonally and scaling its size by a factor between 1 and 4. Place each transformed copy at a random location in the grid, ensuring that none of the copies overlap with each other or with the original object. The output grid consists of the original input grid combined with all these additional transformed copies."
    },
    {
        "id": "6b9890af",
        "pattern": "1. **Select an Object**: Identify a specific object within the input grid.\n\n2. **Scale the Object**: Increase the size of the selected object uniformly by a chosen scaling factor.\n\n3. **Create a Square Area**: Generate a square region that is slightly larger than the scaled object.\n\n4. **Fill the Square**: Fill the entire square area with a designated color.\n\n5. **Position the Scaled Object**: Place the scaled object inside the filled square, offsetting it by one cell both horizontally and vertically.\n\n6. **Apply Rotation**: Rotate the entire grid by 0\u00b0, 90\u00b0, 180\u00b0, or 270\u00b0."
    },
    {
        "id": "6c434453",
        "pattern": "To transform the input grid into the output grid, follow these precise steps:\n\n1. **Identify Objects**: Locate all distinct objects within the input grid. An object is a contiguous group of cells sharing the same color.\n\n2. **Process Each Object Individually**:\n   \n   a. **Check Object Shape**:\n      - **Rectangular Boxes**: If an object is a perfect rectangle with both its height and width exactly 3 or exactly 5 cells.\n      - **Other Shapes**: Any object that does not meet the above rectangular criteria.\n   \n   b. **Transform Based on Shape**:\n      - **For Rectangular Boxes**:\n        - Replace the entire rectangular area of the object with a cross shape.\n        - The cross consists of two lines:\n          - A **vertical line** that spans the full height of the rectangle and is centered horizontally.\n          - A **horizontal line** that spans the full width of the rectangle and is centered vertically.\n        - Color all cells in the cross shape with the color value **2**.\n      \n      - **For Other Shapes**:\n        - Retain the object as it is, preserving both its shape and original color.\n\n3. **Finalize the Output Grid**:\n   - The output grid will have:\n     - Cross-shaped replacements (colored with 2) in places where rectangular boxes of size 3x3 or 5x5 were found in the input.\n     - All other objects unchanged from the input.\n     - The background remains consistent with the original input grid.\n\nThis process ensures that only specific rectangular objects are transformed into cross shapes, while all other elements of the grid remain unaffected."
    },
    {
        "id": "6cdd2623",
        "pattern": "Identify all rows and columns in the input grid where both endpoints are colored with a specific line color. For each such row, fill every cell in that row with the line color, creating a continuous horizontal line across the grid. Similarly, for each identified column, fill every cell in that column with the line color, creating a continuous vertical line. The output grid will thus display complete horizontal and vertical lines connecting the previously marked endpoints."
    },
    {
        "id": "6cf79266",
        "pattern": "In the input grid, locate every 3\u00d73 block where all nine cells are set to 0. For each of these blocks, change all nine cells to 1 in the output grid. All other cells in the grid remain the same."
    },
    {
        "id": "6d0160f0",
        "pattern": "To transform the input grid into the output grid, follow these steps:\n\n1. **Divide the Grid:** Split the input grid into equally sized cells separated by horizontal and vertical lines.\n\n2. **Select a Target Cell:** Choose a specific cell within the grid and assign it a distinct color different from the line color.\n\n3. **Shift the Target Cell:** Move the colored target cell to a new position by horizontally and vertically shifting it based on the grid's dimensions.\n\n4. **Assign New Colors to Other Cells:** Select a number of other cells and assign each a new color chosen from a predefined set, ensuring none of these colors match the line color.\n\n5. **Update the Grid:** Apply the shifted target cell and the newly colored cells to the grid while keeping the original grid lines intact.\n\nThe resulting output grid will have the target cell relocated to a new position with its new color, other selected cells updated with different colors, and the original grid structure maintained."
    },
    {
        "id": "6d0aefbc",
        "pattern": "Mirror the input grid horizontally (flip it left to right) and place this mirrored version immediately to the right of the original grid, combining them side by side to create the output grid."
    },
    {
        "id": "6d58a25d",
        "pattern": "To transform the input grid into the output grid, follow these steps:\n\n1. **Identify Special Cells**:\n   - Locate all cells in the input grid that are colored with a specific color (let's call this color C2).\n   - For each of these C2-colored cells, draw an imaginary vertical line extending upwards from the cell.\n\n2. **Check for Intersection with a Shape**:\n   - If the imaginary vertical line from a C2-colored cell intersects a predefined shape within the grid, proceed to the next step for that column.\n\n3. **Fill the Column Below the Shape**:\n   - In each column where an intersection is found, fill all cells from just below the bottom of the predefined shape down to the bottom edge of the grid with the specific color C2.\n\n4. **Apply Rotation**:\n   - Finally, rotate the entire grid by a random multiple of 90 degrees (i.e., 0\u00b0, 90\u00b0, 180\u00b0, or 270\u00b0).\n\nThis process results in the output grid containing the original background and shape, along with vertical lines of color C2 extending from the shape to the bottom in specific columns determined by the initial placement of C2-colored cells."
    },
    {
        "id": "6d75e8bb",
        "pattern": "1. Identify the smallest rectangle that completely contains the foreground shape in the input grid.\n2. Fill every cell within this rectangle with color\u202f2.\n3. Restore the original foreground shape by setting its cells back to the foreground color within the rectangle.\n4. Leave all other cells in the grid unchanged."
    },
    {
        "id": "6e02f1e3",
        "pattern": "1. **Determine the Number of Distinct Colors in the Input Grid:**\n   - **One Color:**\n     - Create an output grid of the same dimensions filled entirely with `0`.\n     - Draw a vertical line of `5`s in the first (leftmost) column of the grid.\n   \n   - **Two Colors:**\n     - Create an output grid of the same dimensions filled entirely with `0`.\n     - Draw a diagonal line of `5`s from the top-left corner `(0, 0)` to the bottom-right corner `(d-1, d-1)`.\n\n   - **Three Colors:**\n     - Create an output grid of the same dimensions filled entirely with `0`.\n     - Draw a diagonal line of `5`s from the bottom-left corner `(d-1, 0)` to the top-right corner `(0, d-1)`."
    },
    {
        "id": "6e19193c",
        "pattern": "For each 2\u00d72 block in the input grid that is missing one corner, the output grid completes the block by filling in the missing cell and then extends the block by adding a continuous line of cells from that filled corner in a specific diagonal direction."
    },
    {
        "id": "6e82a1ae",
        "pattern": "To transform the input grid into the output grid, follow these steps:\n\n1. **Identify Objects**: Detect each distinct object within the input grid based on their shape and connectivity.\n2. **Categorize Objects**: Assign each identified object to one of three predefined shape categories:\n   - **Category 1**: Objects matching the first predefined shape.\n   - **Category 2**: Objects matching the second predefined shape.\n   - **Category 3**: Objects matching the third predefined shape.\n3. **Assign Colors**: Recolor each object in the grid according to its category:\n   - **Category 1** objects are colored with color `1`.\n   - **Category 2** objects are colored with color `2`.\n   - **Category 3** objects are colored with color `3`.\n4. **Generate Output Grid**: Produce the output grid by applying the assigned colors to their respective objects, ensuring that each object retains its original position and structure but now has its designated color.\n\nThis process ensures that each object in the input grid is distinctly colored in the output grid based on its category."
    },
    {
        "id": "6ecd11f4",
        "pattern": "1. **Select a Connected Shape**: Identify a contiguous region within the input grid.\n\n2. **Assign Random Colors**: For each cell in the selected shape, assign a color randomly chosen from a specific subset of colors, ensuring multiple colors are used.\n\n3. **Normalize Position**: Shift the colored shape so that its upper-left corner aligns with the top-left corner of a new output grid.\n\n4. **Output the Result**: Produce the output grid displaying only the colored, normalized shape on a uniform background."
    },
    {
        "id": "6f8cd79b",
        "pattern": "To transform the input grid into the output grid, identify all the cells on the border (the first and last rows and the first and last columns) and set their color to 8. All other cells remain unchanged."
    },
    {
        "id": "6fa7a44f",
        "pattern": "1. **Flip the Input Grid Vertically:** Create a vertically mirrored copy of the input grid by flipping it upside down.\n2. **Stack the Grids:** Place the original input grid directly above the vertically flipped copy.\n3. **Form the Output Grid:** The combined result, with the original grid on top and its mirrored version below, becomes the output grid."
    },
    {
        "id": "72322fa7",
        "pattern": "To produce the output grid from the input grid, follow these steps:\n\n1. **Identify Objects**: Locate each distinct connected group of cells in the input grid. Each group (object) is composed of cells and is assigned two specific colors.\n\n2. **Select Objects to Modify**: Choose a number of these objects based on the grid size and object dimensions.\n\n3. **Determine New Positions**: For each selected object, find a new location within the grid where the entire object can fit without overlapping existing cells or extending beyond the grid boundaries.\n\n4. **Adjust Dimensions (Optional)**: Optionally swap the object's height and width to change its orientation.\n\n5. **Recolor Parts of the Object**: Divide the object into two parts and recolor each part with one of the object's two original colors.\n\n6. **Place Modified Objects**: Insert the recolored object into the chosen new location on the grid.\n\nBy repeating these steps for the selected objects, the input grid is transformed into the output grid with objects repositioned and partially recolored."
    },
    {
        "id": "72ca375d",
        "pattern": "To transform the input grid into the output grid, follow these steps:\n\n1. **Identify the Target Object**: Locate all instances of a specific vertically mirrored object that are colored differently from the background within the input grid.\n\n2. **Select an Instance**: Choose one of these identified objects from the input grid.\n\n3. **Normalize the Position**: Move the selected object so that it is positioned at the top-left corner of the output grid.\n\n4. **Apply Vertical Mirroring**: Ensure that the selected object maintains its vertical mirror symmetry.\n\n5. **Create the Output Grid**: Generate a new grid filled with the background color and place the normalized, vertically mirrored object onto this grid.\n\nThe resulting output grid will contain a single, vertically mirrored instance of the object against a uniform background."
    },
    {
        "id": "73251a56",
        "pattern": "To transform the input grid into the output grid, follow these precise steps:\n\n1. **Identify the Main Diagonal**: Locate the diagonal line that runs from the top-left corner to the bottom-right corner of the grid.\n\n2. **Preserve the Diagonal Line**: Ensure that this main diagonal is filled with a specific designated color, maintaining its continuity and integrity.\n\n3. **Remove Rectangular Noise Patches**: Detect and eliminate all rectangular areas in the grid that are filled with a designated noise color. These patches should be removed without disrupting the main diagonal line.\n\n4. **Maintain Diagonal Symmetry**: After removing the noise patches, ensure that the grid remains symmetrically balanced along the main diagonal. This may involve mirroring elements to preserve symmetry.\n\n5. **Finalize the Output Grid**: The grid, now free of noise patches and maintaining a clear, uninterrupted main diagonal, is the desired output grid."
    },
    {
        "id": "7447852a",
        "pattern": "Identify all distinct connected regions of the background color in the input grid, ordered from left to right. Then, in the output grid, change the color of every third background region to color\u202f4 while leaving all other regions unchanged."
    },
    {
        "id": "7468f01a",
        "pattern": "1. **Identify the Object:** Locate the distinct shape in the input grid that is a vertically mirrored version of the desired output shape.\n2. **Determine the Shift:** Find the position where this mirrored shape has been shifted within the input grid.\n3. **Reverse the Shift:** Move the mirrored shape back to its original position by applying the inverse of the detected shift.\n4. **Unmirror the Shape:** Flip the reversed shape vertically to obtain the original orientation of the output shape.\n5. **Create the Output Grid:** Initialize a new grid with the specified background color.\n6. **Fill the Output Shape:** Fill the area corresponding to the unmirrored shape in the output grid with the designated output color."
    },
    {
        "id": "746b3537",
        "pattern": "To transform the input grid to the output grid, follow these steps:\n\n1. **Identify Horizontal Stripes:** In the input grid, each row is a single color repeated across its entire width, forming horizontal stripes of uniform color.\n\n2. **Remove Duplicate Stripes:** Eliminate any duplicate rows so that each color stripe appears only once in the grid.\n\n3. **Convert Stripes to Columns:** For each unique horizontal stripe remaining, create a single vertical column in the output grid with the corresponding color.\n\n4. **Optional Diagonal Mirroring:** With a 50% probability, mirror both the input and output grids along their diagonal axis."
    },
    {
        "id": "74dd1130",
        "pattern": "To generate the output grid from the input grid, perform a reflection across the main diagonal. Specifically, for each cell located at row _i_ and column _j_ in the input grid, place its value at row _j_ and column _i_ in the output grid."
    },
    {
        "id": "75b8110e",
        "pattern": "1. **Divide the input grid** into four equal quadrants arranged in a 2x2 layout: top-left, top-right, bottom-left, and bottom-right.\n\n2. **Assign colors**:\n   - Each quadrant has a uniform background color.\n   - Within each quadrant, a distinct color (c1, c2, c3, c4) is applied to a random subset of its cells.\n\n3. **Modify the top-left quadrant** to create the output grid:\n   - Replace certain colored cells in the top-left quadrant by sequentially applying the fourth color (c4), then the third color (c3), and finally the second color (c2).\n\n4. **Leave the other three quadrants unchanged**:\n   - The top-right, bottom-left, and bottom-right quadrants retain their original background and distinct colors.\n\nThe transformation results in the output grid where the top-left quadrant has some of its original colored cells replaced by new colors from the other quadrants, while the remaining quadrants remain the same as in the input grid."
    },
    {
        "id": "760b3cac",
        "pattern": "To transform the input grid into the output grid, follow these steps:\n\n1. **Place a Central Object:** Position a predefined central object near the bottom center of the input grid.\n2. **Add a Top Object:** Locate an additional object near the top center of the grid.\n3. **Create a Mirrored Copy:** Generate a horizontally mirrored version of the top object.\n4. **Shift the Mirrored Object:** Move the mirrored object horizontally to either the left or right side of the grid.\n5. **Combine Objects:** Add the shifted, mirrored object to the grid alongside the central object.\n6. **Apply Rotation:** Rotate the entire grid by a randomly chosen multiple of 90 degrees (0\u00b0, 90\u00b0, 180\u00b0, or 270\u00b0).\n\nThe resulting grid after these steps is the output grid."
    },
    {
        "id": "776ffc46",
        "pattern": "To transform the input grid into the output grid, follow these steps:\n\n1. **Draw a Colored Rectangle**: Select a random location on the grid and draw a rectangular box filled with a specific color.\n\n2. **Place a Connected Shape Inside the Rectangle**: Within the colored rectangle, create a small, connected shape using a different color.\n\n3. **Add Multiple Copies of the Shape Elsewhere**: Identify suitable positions outside the rectangle and place several non-overlapping copies of the previously created shape. Each copy should be filled with another specified color.\n\nThis process results in the output grid containing the original colored rectangle with the central shape and multiple colored copies of that shape scattered around the grid."
    },
    {
        "id": "77fdfe62",
        "pattern": "1. **Remove the Border**: Eliminate the surrounding border lines from the input grid.\n2. **Transfer Corner Colors**: Copy the colors from each of the four corners of the input grid to the corresponding corners of the output grid.\n3. **Extract Regions**: Identify and extract the four distinct colored regions located within each quadrant of the input grid.\n4. **Shift Regions**: Move each extracted region to align with its respective quadrant in the output grid.\n5. **Place Regions in Output**: Position the shifted regions into the output grid, ensuring each occupies the correct quadrant."
    },
    {
        "id": "780d0b14",
        "pattern": "To transform the input grid into the output grid, follow these steps:\n\n1. **Remove Background Rows:**\n   - Identify and eliminate all rows that are completely filled with the background color.\n\n2. **Remove Background Columns:**\n   - Identify and eliminate all columns that are completely filled with the background color.\n\n3. **Collapse Repeated Rows:**\n   - For any group of consecutive identical rows remaining in the grid, retain only one representative row from each group.\n\n4. **Collapse Repeated Columns:**\n   - For any group of consecutive identical columns remaining in the grid, retain only one representative column from each group.\n\n5. **Result:**\n   - The grid obtained after performing the above removals and collapses is the desired output grid."
    },
    {
        "id": "7837ac64",
        "pattern": "1. **Divide the Input Grid**: Split the input grid into equally sized rectangular blocks.\n\n2. **Identify Colored Blocks**: For each block, examine its four corner cells to determine its color:\n   - If the corners of a block contain a specific color (other than the background color), consider the entire block as that color.\n   - If all corners match the background color, the block remains as the background.\n\n3. **Map to Output Grid**: Create the output grid where each cell corresponds to a block from the input grid:\n   - Assign the identified color from each block to the corresponding cell in the output grid.\n   - Preserve the background color for cells corresponding to background blocks.\n\n4. **Finalize the Output**: Ensure that the output grid accurately reflects the arrangement and colors of the colored blocks from the input grid, maintaining consistency in background areas."
    },
    {
        "id": "794b24be",
        "pattern": "1. **Identify the Background Color:** Determine the background color used in the input grid.\n\n2. **Count Specific Cells:** Count the number of cells in the input grid that are colored with color **1**. Let this count be **n** (where **1 \u2264 n \u2264 4**).\n\n3. **Create a New Grid:** Generate a new **3\u00d73** grid and fill all its cells with the identified background color.\n\n4. **Place Color 2 Cells:** In the new grid, set the first **n** cells to color **2** following this specific order:\n   - **First cell:** Top-left corner (position (0,0))\n   - **Second cell:** Top-center (position (0,1))\n   - **Third cell:** Top-right corner (position (0,2))\n   - **Fourth cell:** Center (position (1,1))\n\n   For example:\n   - If **n = 1**, color the top-left corner.\n   - If **n = 2**, color the top-left and top-center cells.\n   - If **n = 3**, color the top-left, top-center, and top-right cells.\n   - If **n = 4**, color the above three cells and the center cell.\n\n5. **Finalize the Output Grid:** The resulting **3\u00d73** grid with the specified colored cells is the output grid."
    },
    {
        "id": "7b6016b9",
        "pattern": "To transform the input grid into the output grid, follow these steps:\n\n1. **Identify Enclosed Background Regions**:\n   - Locate all areas in the grid that are filled with the background color and are completely surrounded by other colors. These regions must not touch any edge of the grid.\n\n2. **Modify Enclosed Regions and Their Neighbors**:\n   - For each identified enclosed background region:\n     - Change the color of every cell within this region to a new designated color (e.g., color 2).\n     - Fill all cells that are directly adjacent to this region with the foreground color.\n\n3. **Update Remaining Background Cells**:\n   - Change the color of all remaining background-colored cells in the grid to another specified color (e.g., color 3).\n\nBy following these steps, the output grid will have the enclosed background regions recolored and their neighboring cells filled, while the rest of the background is updated to a new color."
    },
    {
        "id": "7b7f7511",
        "pattern": "To obtain the output grid from the input grid, follow these steps:\n\n1. **Determine the Duplication Orientation:**\n   - **Vertical Duplication:** If the input grid is composed of two identical sections stacked one above the other.\n   - **Horizontal Duplication:** If the input grid is composed of two identical sections placed side by side.\n\n2. **Process Based on Orientation:**\n   - **If Vertically Duplicated:**\n     a. **Split the Input Grid:** Divide the input grid into the top half and the bottom half.\n     b. **Apply Diagonal Mirroring:** Diagonally mirror the bottom half.\n     c. **Extract the Output Grid:** The mirrored bottom half becomes the output grid.\n     \n   - **If Horizontally Duplicated:**\n     a. **Split the Input Grid:** Divide the input grid into the left half and the right half.\n     b. **Extract the Output Grid:** Select either the left or the right half as the output grid.\n\n3. **Final Output:**\n   - The resulting grid from the above steps is the output grid corresponding to the original single pattern before duplication and mirroring."
    },
    {
        "id": "7c008303",
        "pattern": "To transform the input grid into the output grid, follow these steps:\n1. **Divide the central pattern** of the input grid into four equal quadrants: top-left, top-right, bottom-left, and bottom-right.\n2. **In each quadrant**, replace every cell that has the main fill color with a unique one of four specified new colors.\n3. **Reassemble the four modified quadrants** back into a single grid.\n4. **Rotate the entire grid** by a random multiple of 90 degrees (0\u00b0, 90\u00b0, 180\u00b0, or 270\u00b0)."
    },
    {
        "id": "7ddcd7ec",
        "pattern": "To transform the input grid into the output grid, follow these steps:\n\n1. **Identify Four Corner Cells**: Select four cells positioned diagonally around a central random location within the grid (top-left, top-right, bottom-left, and bottom-right relative to this central point).\n\n2. **Assign Colors**: Assign each of these four corner cells a unique color different from the background color.\n\n3. **Randomly Select Corners for Extension**: Randomly choose a subset of these four colored corner cells (any number from zero up to all four).\n\n4. **Extend Lines from Selected Corners**: For each selected corner cell, draw a straight line in a specific diagonal direction (up-left, up-right, down-left, or down-right) from that cell. Color every cell along each line with the same color as the originating corner cell, extending the line until it reaches the edge of the grid.\n\n5. **Generate the Output Grid**: The output grid will include the original four colored corner cells along with the newly drawn colored lines extending from the selected corners.\n\nThis pattern results in the output grid having colored lines radiating diagonally from certain corner cells based on the random selection, while the rest of the grid remains unchanged with the background color."
    },
    {
        "id": "7df24a62",
        "pattern": "To transform the input grid to the output grid, follow these steps:\n\n1. **Identify the Main Object**: Locate the primary object within the input grid.\n\n2. **Generate Transformations**: Create multiple versions of this object by applying various transformations, including rotations and reflections (such as flipping horizontally, vertically, or diagonally).\n\n3. **Place Transformed Copies**: For each transformed version of the object, randomly select a new location within the grid. Ensure that each copied object is placed in a position that does not overlap with other objects or extend beyond the grid boundaries.\n\n4. **Add Background Noise**: Introduce random noise to the remaining areas of the grid, avoiding the regions occupied by any of the objects.\n\nThe output grid will display several transformed copies of the original object, each positioned differently and complemented by random background noise."
    },
    {
        "id": "7e0986d6",
        "pattern": "To transform the input grid into the output grid, follow these steps:\n\n1. **Identify Noise Pixels**: Locate all cells in the input grid that have colors different from the background color and the colors of the main colored squares.\n\n2. **Remove Noise**: Change the color of each identified noise pixel back to the background color.\n\n3. **Preserve Main Structures**: Ensure that all the original colored squares remain intact and correctly positioned on the background, without any alterations.\n\nThe resulting grid will retain only the background and the original colored squares, with all noise pixels removed."
    },
    {
        "id": "7f4411dc",
        "pattern": "1. **Identify Rectangular Regions:** Locate all contiguous rectangular areas in the input grid that are filled with the foreground color.\n\n2. **Retain Rectangles:** Keep these identified rectangular regions unchanged in the grid.\n\n3. **Remove Noise:** Change any foreground-colored cells that do not belong to the identified rectangles back to the background color.\n\n4. **Produce Output Grid:** The resulting grid will contain only the original rectangular foreground patterns without any additional noise pixels."
    },
    {
        "id": "7fe24cdd",
        "pattern": "1. **Rotate the Input Grid:**\n   - Rotate the input grid 90 degrees clockwise to create Grid A.\n   - Rotate the input grid 180 degrees to create Grid B.\n   - Rotate the input grid 270 degrees clockwise to create Grid C.\n\n2. **Concatenate Horizontally:**\n   - Place the original input grid to the left of Grid A, forming the top half of the output grid.\n   - Place Grid C to the left of Grid B, forming the bottom half of the output grid.\n\n3. **Combine Vertically:**\n   - Stack the top half and the bottom half vertically to form the final output grid.\n\n**Summary:**  \nTransform the input grid into four versions by rotating it 90\u00b0, 180\u00b0, and 270\u00b0 clockwise. Then, arrange these four grids in a 2\u00d72 layout where the original grid is in the top-left, the 90\u00b0 rotated grid is in the top-right, the 270\u00b0 rotated grid is in the bottom-left, and the 180\u00b0 rotated grid is in the bottom-right to create the output grid."
    },
    {
        "id": "80af3007",
        "pattern": "To transform the input grid into the output grid, repeatedly copy the arrangement of colored cells from the input grid both horizontally and vertically. Place these copies side by side and stacked to tile the entire output grid, maintaining the same background color throughout."
    },
    {
        "id": "810b9b61",
        "pattern": "For each distinct rectangular shape in the input grid:\n\n1. **Identify the Rectangle**: Locate each separate rectangular area filled with a single color.\n\n2. **Check Dimensions**:\n   - If the rectangle has both its height and width greater than two cells,\n   \n3. **Recolor if Applicable**:\n   - Change the color of all cells in this rectangle to color **3** in the output grid.\n   \n4. **Retain Original Color Otherwise**:\n   - If the rectangle does not meet the size criteria, keep its original color unchanged in the output grid.\n\n5. **Maintain Background**:\n   - All background cells (with the initial background color) remain unchanged in the output grid.\n\nIn summary, the pattern transforms the input grid by recoloring each sufficiently large perfect rectangle to color 3 while leaving smaller or irregularly shaped rectangles and the background unchanged."
    },
    {
        "id": "82819916",
        "pattern": "1. Select a background color and two distinct colors.\n2. Choose a specific row in the grid.\n3. Divide the columns of that row into two non-overlapping groups.\n4. Fill the first group of columns in the chosen row with the first distinct color and the second group with the second distinct color.\n5. Optionally, select additional rows and similarly fill their columns with new pairs of distinct colors.\n6. Cover a rectangular area of the grid with the background color, effectively masking part of the colored rows.\n7. Rotate the entire grid by 0\u00b0, 90\u00b0, 180\u00b0, or 270\u00b0 to produce the output grid."
    },
    {
        "id": "83302e8f",
        "pattern": "1. Start with the input grid containing evenly spaced horizontal and vertical lines in a specific color.\n2. Randomly remove certain cells from these lines to create breaks.\n3. Identify all rectangular areas bounded by the remaining lines that have a defined height and width.\n4. Fill each identified rectangular area with color\u202f3.\n5. Change all other background cells to color\u202f4."
    },
    {
        "id": "834ec97d",
        "pattern": "1. **Shift the Cell Downward:** Move the single colored cell in the input grid down by one row.\n\n2. **Draw Vertical Lines:**\n   - Starting from the top of the grid, draw vertical lines using a different color.\n   - These lines should be placed at every two columns to the left and right of the original column of the moved cell.\n\nThis transformation results in the output grid having the original cell moved down and multiple vertical lines extending from the top to specific columns symmetrically positioned around the cell's new location."
    },
    {
        "id": "8403a5d5",
        "pattern": "Starting from the input grid with a single colored cell in the bottom row:\n\n1. **Identify the Column**: Locate the column where the single foreground cell is positioned in the bottom row of the input grid.\n\n2. **Draw Vertical Lines**: In the output grid, create vertical lines using the foreground color in the identified column and every second column to the right of it.\n\n3. **Add Top Markers**: Beginning one column to the right of the identified column, and then every fourth column thereafter, color the top cell of each of these columns with the color value 5.\n\n4. **Add Bottom Markers**: Starting three columns to the right of the identified column, and then every fourth column thereafter, color the bottom cell of each of these columns with the color value 5.\n\nAll other cells in the output grid should remain the background color."
    },
    {
        "id": "846bdb03",
        "pattern": "1. **Identify a Rectangular Region:** Locate a rectangle within the input grid that features two distinct vertical lines\u2014one on the left edge and one on the right edge\u2014each colored differently.\n\n2. **Check Corner Dots:** Ensure that all four corners of this identified rectangle are marked with dots of a specific color.\n\n3. **Extract the Rectangle:** Once the correct region is found, extract this rectangular section from the input grid.\n\n4. **Apply Rotation (if necessary):** If the rectangle has been rotated, adjust its orientation by rotating it back to its original alignment (0\u00b0, 90\u00b0, 180\u00b0, or 270\u00b0).\n\n5. **Output the Extracted Grid:** The final extracted and correctly oriented rectangle represents the output grid."
    },
    {
        "id": "855e0971",
        "pattern": "To transform the input grid into the output grid, follow these steps:\n\n1. **Identify Highlighted Columns**: In the input grid, examine each vertical bar and determine which columns contain at least one highlighted cell (marked with a specific highlight color).\n\n2. **Fill Entire Columns**: For every column identified as containing a highlighted cell in the input grid, fill the entire column in the output grid with the highlight color.\n\n3. **Retain Unchanged Columns**: All other columns that do not contain any highlighted cells in the input grid remain unchanged in the output grid.\n\nThis results in the output grid where only the columns that had highlighted cells in the input are fully colored with the highlight color, while the rest of the grid maintains its original coloring."
    },
    {
        "id": "85c4e7cd",
        "pattern": "To transform the input grid into the output grid, follow these steps:\n\n1. **Identify Concentric Borders**: Starting from the outer edge of the input grid, identify each concentric square border moving inward. Each border is one layer thick.\n\n2. **Collect Colors**: Record the color of each identified border in the order from the outermost to the innermost.\n\n3. **Reverse Color Order**: Reverse the sequence of the collected colors.\n\n4. **Apply Reversed Colors**: Assign the reversed colors to the corresponding borders in the output grid. Specifically:\n   - The outermost border of the output grid receives the color of the innermost border from the input grid.\n   - The next outer border receives the color of the second innermost border from the input grid.\n   - Continue this pattern until all borders are colored.\n\n5. **Maintain Border Positions and Shapes**: Ensure that each colored border retains its original position and shape from the input grid.\n\nThis process effectively reverses the color order of the concentric borders while preserving their structural arrangement."
    },
    {
        "id": "868de0fa",
        "pattern": "Given an input grid filled with a background color and several non-overlapping colored rectangular regions:\n\n1. **Identify Each Colored Rectangle**: Locate each distinct rectangular area in the input grid that is filled with a color different from the background.\n\n2. **Determine the Height Parity**:\n   - **Odd Height**: If the height of the rectangle (number of rows) is an odd number, proceed to the next step.\n   - **Even Height**: If the height is an even number, proceed to the next step.\n\n3. **Fill the Interior**:\n   - **Odd Height**: Fill the interior (all cells excluding the border) of the identified rectangle in the output grid with color **7**.\n   - **Even Height**: Fill the interior of the identified rectangle in the output grid with color **2**.\n\n4. **Preserve the Borders**: Retain the original border color of each rectangle from the input grid in the corresponding area of the output grid.\n\n5. **Maintain Background**: All areas outside the colored rectangles remain filled with the original background color in the output grid.\n\n**Summary**: Transform each colored rectangle by filling its interior with color 7 if its height is odd or color 2 if its height is even, while keeping the borders colored as in the input. The background color stays the same."
    },
    {
        "id": "8731374e",
        "pattern": "For each cell in the input grid that is colored with the foreground color, draw a horizontal line across the entire row and a vertical line down the entire column of that cell using the foreground color. The output grid is the input grid enhanced with these horizontal and vertical lines intersecting every foreground-colored cell."
    },
    {
        "id": "88a10436",
        "pattern": "To generate the output grid from the input grid, follow these steps:\n\n1. **Identify the Central Object:** Start with the input grid that contains a single central object positioned on a background.\n\n2. **Mark Additional Locations:** In the input grid, certain central cells are marked with a distinct foreground color to indicate where additional copies of the object should be placed.\n\n3. **Duplicate the Object:** For each marked central cell in the input grid:\n   - **Positioning:** Place a complete copy of the original central object so that its center aligns with the marked cell's position.\n   - **Color Adjustment:** In each duplicated object, change the color of its central cell to the foreground color while keeping the rest of the object's colors the same as the original.\n\n4. **Ensure Non-Overlap:** Position each duplicated object in a way that it does not overlap with other objects on the grid.\n\nThe result is an output grid that contains the original central object along with multiple non-overlapping copies of the same object, each centered on previously marked cells and with their central cells highlighted in the foreground color."
    },
    {
        "id": "88a62173",
        "pattern": "1. Divide the input grid into four distinct corner regions.\n2. Compare the color patterns of each corner region.\n3. Identify the one corner region that has a different color pattern from the other three identical regions.\n4. Extract and output this unique corner region as the output grid."
    },
    {
        "id": "890034e9",
        "pattern": "To transform the input grid into the output grid, perform the following steps:\n\n1. **Identify Patterns:** Locate all rectangular regions within the input grid that match a specific height and width.\n\n2. **Clear Interiors:** For each identified rectangular region, set every cell inside the rectangle to black (color `0`).\n\n3. **Draw Borders:** Around each cleared rectangle, draw a border using a designated marker color.\n\nThis process results in the output grid where the specified rectangular patterns are highlighted by their colored borders, and their interiors are uniformly blacked out."
    },
    {
        "id": "8a004b2b",
        "pattern": "1. **Initialize the Grid**: Start with an input grid filled entirely with a background color.\n\n2. **Create an Object**: Place a contiguous object of a specific color within the grid. The object's size and shape are randomly determined within defined limits.\n\n3. **Highlight Two Cells**: Select two distinct cells within this object and change their colors to two different designated colors.\n\n4. **Shift the Object**: Move the entire object slightly to a new position within the grid to create space.\n\n5. **Define a Square Region**: Select a square area in the grid and color its four corners with a specific corner color.\n\n6. **Extract and Scale a Subregion**: Take a portion of the shifted object, enlarge it by scaling both its height and width, and place this scaled subregion within the previously defined square area.\n\n7. **Apply Transformations**: Optionally, randomly rotate or mirror the entire grid to introduce variation.\n\n8. **Generate Output Grid**: The resulting grid, after performing all the above steps, is produced as the output grid."
    },
    {
        "id": "8be77c9e",
        "pattern": "To transform the input grid into the output grid, first create a horizontally mirrored copy of the input grid. Then, stack the original input grid above this mirrored copy vertically."
    },
    {
        "id": "8d5021e8",
        "pattern": "To transform the input grid into the output grid, follow these steps:\n\n1. **Create a Horizontal Mirror:** Generate a horizontally mirrored version of the input grid.\n\n2. **Combine Side by Side:** Place this mirrored grid to the left of the original input grid, forming a wider combined grid.\n\n3. **Create a Vertical Mirror:** Flip the combined grid upside down to create a vertically mirrored version.\n\n4. **Stack Vertically:** Place the vertically mirrored combined grid above and below the original combined grid.\n\nThe final output grid is a larger grid that is symmetrical both horizontally and vertically, composed of the original input grid and its mirrored copies arranged in a balanced pattern."
    },
    {
        "id": "8d510a79",
        "pattern": "To transform the input grid into the output grid, follow these precise steps:\n\n1. **Create a Horizontal Bar:**\n   - Draw a horizontal line (bar) of a specific color at a randomly chosen row within the grid.\n\n2. **Select Columns for Decorations:**\n   - Randomly choose a number of columns at the top edge and a number of columns at the bottom edge of the grid for adding decorations.\n\n3. **Add and Connect Top Decorations:**\n   - For each selected top column:\n     - Place a colored cell (either color 1 or color 2) above the horizontal bar at the chosen column.\n     - If the cell is colored **1**, draw a vertical line connecting this cell directly to the very top edge of the grid.\n     - If the cell is colored **2**, draw a vertical line connecting this cell to the horizontal bar.\n\n4. **Add and Connect Bottom Decorations:**\n   - For each selected bottom column:\n     - Place a colored cell (either color 1 or color 2) below the horizontal bar at the chosen column.\n     - If the cell is colored **1**, draw a vertical line connecting this cell directly to the very bottom edge of the grid.\n     - If the cell is colored **2**, draw a vertical line connecting this cell to the horizontal bar.\n\n5. **Optional Mirroring:**\n   - With a 50% probability, mirror the entire grid along its main diagonal, reflecting all elements accordingly.\n\nThese steps ensure that decorations are appropriately placed and connected either to the grid's edges or to the central horizontal bar, creating a structured and patterned transformation from the input to the output grid."
    },
    {
        "id": "8e1813be",
        "pattern": "To transform the input grid into the output grid, follow these steps:\n\n1. **Remove Background Margins:** Eliminate all rows that consist solely of the background color, effectively removing any horizontal padding around the main content.\n\n2. **Delete the Embedded Square:** Locate and remove the square shape embedded within the grid, ensuring that only the horizontal color bars remain.\n\n3. **Standardize Bar Widths:** For each horizontal colored bar, adjust its width to a fixed number of columns by uniformly repeating the bar's color across the specified width.\n\n4. **Optional Diagonal Mirroring:** With a 50% chance, mirror the entire grid along its diagonal axis to produce a reflected version of the pattern.\n\nBy executing these steps, the output grid will consist solely of evenly spaced horizontal color bars with standardized widths, free from any additional background margins or embedded squares."
    },
    {
        "id": "8e5a5113",
        "pattern": "Split the input grid into several equal sections separated by uniform colored bars. In the input grid, all sections except one display a specific pattern, while one section is filled with the background color (appearing blank). To create the output grid, fill the previously blank section with the same pattern used in the other sections, resulting in all sections uniformly displaying the pattern. Additionally, the entire grid may be rotated by 90 or 180 degrees."
    },
    {
        "id": "8eb1be9a",
        "pattern": "To generate the output grid from the input grid:\n\n1. **Identify the Object**: Locate the distinct object within the input grid.\n\n2. **Duplicate Vertically**: Create multiple copies of this object.\n\n3. **Position Copies Above and Below**: \n    - Place one copy directly above the original object, shifted upward by the object's height.\n    - Place another copy directly below the original object, shifted downward by the object's height.\n\n4. **Repeat Shifting**:\n    - Continue duplicating the object and shifting each new copy upward and downward by additional multiples of the object's height.\n    - Ensure that copies are spaced evenly without overlapping, extending as far as the grid allows in both vertical directions.\n\n5. **Combine All Copies**: Merge all the shifted copies with the original object on a new grid, maintaining the background color where no objects are present.\n\nThe resulting output grid will display the original object repeated vertically at regular intervals above and below its initial position, effectively creating a vertically aligned pattern of the object throughout the grid."
    },
    {
        "id": "8efcae92",
        "pattern": "From the input grid containing multiple non-overlapping squares of a specific color on a background, select one square. In the output grid, reproduce this selected square with the same size and position, but randomly change a subset of its cells to a different specified color, leaving the rest of the grid unchanged."
    },
    {
        "id": "8f2ea7aa",
        "pattern": "To transform the input grid into the output grid, follow these steps:\n\n1. **Identify the Pattern:**\n   - The input grid contains a single small pattern of size _d \u00d7 d_ placed at a specific location within a larger grid filled with a background color.\n\n2. **Locate Colored Cells:**\n   - Within this small _d \u00d7 d_ pattern, identify all the cells that are colored (i.e., not the background color).\n\n3. **Replicate the Pattern:**\n   - For each colored cell located at position _(i, j)_ in the small pattern:\n     - Create a copy of the entire _d \u00d7 d_ pattern.\n     - Shift this copy by _(i \u00d7 d, j \u00d7 d)_ units horizontally and vertically within the larger grid.\n\n4. **Compose the Output Grid:**\n   - Place all the shifted copies of the _d \u00d7 d_ pattern onto the larger grid, maintaining the original background color in all other areas.\n   - The output grid will thus consist of multiple copies of the small pattern, each positioned according to the locations of the colored cells in the input pattern.\n\nThis process results in the input pattern being replicated across the output grid at positions determined by the originally colored cells, creating a structured and repeatable arrangement based on the initial configuration."
    },
    {
        "id": "90c28cc7",
        "pattern": "To transform the input grid into the output grid, follow these steps:\n\n1. **Diagonal Reflection**: Reflect the input grid across its main diagonal (swap rows with columns).\n2. **Remove Duplicate Rows**: Eliminate any rows that are identical to earlier rows in the mirrored grid.\n3. **Second Diagonal Reflection**: Reflect the resulting grid again across its main diagonal.\n4. **Remove Duplicate Rows Again**: Eliminate any duplicate rows that appear after the second reflection.\n5. **Output Grid**: The final grid after these steps is the output grid."
    },
    {
        "id": "90f3ed37",
        "pattern": "To transform the input grid into the output grid, follow these steps:\n\n1. **Identify Side Patterns**: Locate and extract distinct patterns from the left and right sides of the input grid.\n\n2. **Optional Middle Pattern**: Optionally, create a central pattern with a variable width between the left and right side patterns.\n\n3. **Repeat Patterns Horizontally**: \n    - Tile the extracted left and right side patterns repeatedly across the entire width of the grid.\n    - Apply random horizontal shifts to these patterns to vary their placement and ensure they do not overlap excessively.\n    - If a middle pattern is used, insert it appropriately between the repeated side patterns.\n\n4. **Overlay and Color Modification**:\n    - Overlay the shifted and repeated patterns onto the input grid.\n    - Modify the colors of specific cells based on the placement of these patterns, setting them to a designated foreground color while preserving the background color elsewhere.\n\n5. **Finalize Output Grid**: The resulting grid, after overlaying and color modifications, becomes the output grid.\n\nThis process ensures that the output grid is a horizontally extended version of the input grid, with side patterns consistently repeated and optionally separated by a middle pattern, all while maintaining a coherent color scheme."
    },
    {
        "id": "913fb3ed",
        "pattern": "For each cell in the input grid that is colored with 2,\u202f3, or\u202f8, retain its color in the output grid and set all its adjacent neighbors to a specific new color based on the original color:\n- If the cell is colored\u202f2, set its neighbors to\u202f1.\n- If the cell is colored\u202f3, set its neighbors to\u202f6.\n- If the cell is colored\u202f8, set its neighbors to\u202f4.\nAll other cells remain unchanged."
    },
    {
        "id": "91413438",
        "pattern": "To transform the input grid into the output grid, follow these steps:\n\n1. **Identify Filled Cells**: Determine all the cells in the input grid that are filled with a specific color (foreground color).\n\n2. **Create a Larger Canvas**: Initialize a new, larger grid whose dimensions are multiples of the input grid's height and width.\n\n3. **Replicate the Pattern**: \n    - Copy the pattern of filled cells from the input grid.\n    - Place multiple copies of this pattern onto the larger grid.\n    - Each copy is shifted horizontally and vertically by multiples of the input grid's height and width, respectively.\n\n4. **Arrange Copies in a Grid Layout**: Ensure that the replicated patterns are evenly spaced and arranged in a regular, grid-like fashion within the larger output grid.\n\nThe result is an output grid that consists of several repeated instances of the input grid's filled cell pattern, neatly tiled across the larger canvas."
    },
    {
        "id": "91714a58",
        "pattern": "To transform the input grid into the output grid, follow these steps:\n1. **Identify the Bounding Rectangle**: Locate the smallest rectangular area that entirely contains all cells colored with the target color.\n2. **Fill the Rectangle**: Set every cell within this identified rectangle to the target color.\n3. **Reset Outside Cells**: Change all cells outside the bounding rectangle to the background color."
    },
    {
        "id": "9172f3a0",
        "pattern": "To create the output grid from the input grid, enlarge the input grid by a factor of three in both height and width. This means that each cell in the input grid is expanded into a 3\u00d73 block of the same color in the output grid."
    },
    {
        "id": "928ad970",
        "pattern": "To transform the input grid into the output grid, follow these steps:\n\n1. **Identify Four Edge Dots**: Locate four specific cells (dots) positioned on each of the four edges (top, bottom, left, right) of an internal rectangular region within the input grid. Ensure that these dots are not placed at the corners of the rectangle.\n\n2. **Determine Bounding Coordinates**: Using the positions of the four edge dots, determine the smallest rectangle that encompasses all four dots. This involves identifying the topmost, bottommost, leftmost, and rightmost positions of the dots to define the rectangle's boundaries.\n\n3. **Draw the New Rectangle Outline**: Draw the outline of the newly determined bounding rectangle by connecting the four edge dots with lines of a designated line color. This replaces any existing patterns or shapes within that bounding area of the input grid.\n\n4. **Maintain Background and Dots**: Ensure that the background color of the grid remains unchanged and that the four edge dots retain their original colors in the output grid.\n\nThe result is an output grid where the original internal rectangular pattern is replaced by a new rectangle defined precisely by the positions of the four edge dots, maintaining clarity and consistency in the transformation."
    },
    {
        "id": "93b581b8",
        "pattern": "To transform the input grid into the output grid, follow these precise steps:\n\n1. **Initialize Grids:**\n   - Start with both the input and output grids filled entirely with a single background color.\n\n2. **Select Colors:**\n   - Choose a set of distinct colors (excluding the background color) to be used for creating patterns.\n\n3. **Place a 2\u00d72 Block in the Input Grid:**\n   - Identify a suitable location in the input grid where a 2\u00d72 block can fit without overlapping existing blocks.\n   - Assign four different selected colors to the four cells of this 2\u00d72 block.\n\n4. **Create Shifts for the Output Grid:**\n   - For each 2\u00d72 block placed in the input grid, generate four identical 2\u00d72 blocks in the output grid.\n   - Position each of these four blocks by shifting the original block two cells diagonally in each of the four diagonal directions:\n     - **Up-Left:** Shift the block two cells upwards and two cells to the left.\n     - **Up-Right:** Shift the block two cells upwards and two cells to the right.\n     - **Down-Left:** Shift the block two cells downwards and two cells to the left.\n     - **Down-Right:** Shift the block two cells downwards and two cells to the right.\n\n5. **Apply Corresponding Colors to Shifted Blocks:**\n   - Assign colors to each shifted 2\u00d72 block in the output grid as follows:\n     - The block shifted **Up-Left** uses the color from the bottom-right cell of the original input block.\n     - The block shifted **Up-Right** uses the color from the bottom-left cell of the original input block.\n     - The block shifted **Down-Left** uses the color from the top-right cell of the original input block.\n     - The block shifted **Down-Right** uses the color from the top-left cell of the original input block.\n\n6. **Ensure Valid Placement:**\n   - Verify that each shifted block in the output grid remains within the grid boundaries and does not overlap with other blocks.\n\n7. **Repeat Placement:**\n   - Continue placing additional 2\u00d72 blocks in the input grid and creating their corresponding shifted blocks in the output grid until the desired number of occurrences is reached or no more valid positions are available.\n\nThis pattern systematically propagates each 2\u00d72 colored block from the input grid to four new diagonally shifted positions in the output grid, maintaining a consistent and non-overlapping distribution of colors."
    },
    {
        "id": "941d9a10",
        "pattern": "1. **Identify Objects**: Analyze the input grid to detect all distinct objects based on their connected cells.\n\n2. **Determine Top-Left Object**: Among all identified objects, find the one that is positioned closest to the top-left corner of the grid (i.e., the object with the smallest row and column indices).\n\n3. **Determine Bottom-Right Object**: Find the object that is positioned closest to the bottom-right corner of the grid (i.e., the object with the largest row and column indices).\n\n4. **Determine Central Object**: Locate the object that is centrally positioned such that the number of objects to its left is equal to the number of objects to its right, and the number of objects above it is equal to the number of objects below it.\n\n5. **Color the Objects**:\n   - **Top-Left Object**: Color this object blue.\n   - **Bottom-Right Object**: Color this object green.\n   - **Central Object**: Color this object red.\n\n6. **Generate Output Grid**: Create the output grid by applying the above color assignments while keeping all other cells unchanged from the input grid."
    },
    {
        "id": "94f9d214",
        "pattern": "To generate the output grid from the input grid, follow these steps:\n\n1. **Split the Input Grid Horizontally**: Divide the input grid into two equal horizontal sections.\n\n2. **Identify Background Cells**: In both sections, determine which cells are not colored with their respective accent colors (i.e., these cells remain the background color).\n\n3. **Mark Common Background Cells**: In the output grid, set all cells that are background in both horizontal sections to color 2.\n\n4. **Preserve Other Cells**: All other cells in the output grid retain the original background color.\n\n5. **Optional Mirroring**: There is a 50% chance that both the input and output grids are mirrored diagonally. If this mirroring occurs, apply the diagonal mirror transformation to both grids."
    },
    {
        "id": "952a094c",
        "pattern": "Identify a filled rectangle on the grid. Within this rectangle, color one cell near each of its four internal corners with distinct colors. To produce the output grid, keep the rectangle unchanged and move each of these four colored cells to the corresponding positions immediately outside each corner of the rectangle."
    },
    {
        "id": "9565186b",
        "pattern": "Determine the most frequent color in the input grid. In the output grid, retain all cells of this dominant color and preserve a limited number of cells with other distinct colors as buffers. Replace every remaining non-buffer cell with the dominant color, ensuring that the output grid is mostly filled with the dominant color while keeping only a few cells with their original alternative colors."
    },
    {
        "id": "95990924",
        "pattern": "To transform the input grid into the output grid, follow these steps:\n\n1. **Identify and Place Boxes**: Locate multiple non-overlapping 4\u00d74 square regions within the input grid.\n\n2. **Fill Inner Cells**: For each identified 4\u00d74 square, fill the central 2\u00d72 cells with the foreground color.\n\n3. **Color the Corners**: In the output grid, for each 4\u00d74 square:\n   - Assign color\u202f1 to the top-left corner cell.\n   - Assign color\u202f2 to the top-right corner cell.\n   - Assign color\u202f3 to the bottom-left corner cell.\n   - Assign color\u202f4 to the bottom-right corner cell.\n\n4. **Maintain Background**: All other cells outside these 4\u00d74 squares retain their original background color.\n\nThe resulting output grid will have the same background as the input, with each 4\u00d74 square featuring a filled central area and uniquely colored corners."
    },
    {
        "id": "963e52fc",
        "pattern": "To transform the input grid into the output grid, follow these precise steps:\n\n1. **Initialize the Output Grid**: Start with a blank grid (`go`) of the same height as the input and double its width, filling it entirely with the background color.\n\n2. **Create the Core Pattern (`obj`)**:\n   - Select a set of columns (`p`) from the left side of the grid.\n   - Within these `p` columns, randomly place colored cells. The rows for these cells are chosen within a specific vertical range, and each cell is assigned a random color from a predefined set of colors excluding the background color.\n\n3. **Duplicate and Shift the Core Pattern**:\n   - Make a copy of the core pattern and shift it horizontally by `p` columns to the right. Combine this shifted pattern with the original to form `minobj`.\n\n4. **Add Partial Pattern (`addon`)**:\n   - From the original core pattern, select a subset of cells that are within the first few columns (`addonw`).\n   - Combine this subset with `minobj` to create `fullobj`.\n   - Apply a random left shift to `fullobj` by up to `leftshift` columns.\n\n5. **Tile the Pattern Across the Output Grid**:\n   - Paint the adjusted `fullobj` onto the initialized output grid.\n   - Repeat this painted pattern across the entire width of the output grid at intervals of twice the pattern width (`2p`), ensuring consistent spacing and alignment.\n\n6. **Generate the Input-Output Pair**:\n   - The final output grid (`go`) now contains multiple, periodically shifted copies of the core pattern.\n   - The input grid (`gi`) is defined as the left half of this output grid.\n\nThrough these steps, the output grid is constructed by systematically repeating and shifting the initial pattern from the input grid horizontally across the entire grid, maintaining a structured and periodic arrangement."
    },
    {
        "id": "97999447",
        "pattern": "For each selected row in the input grid, identify the column where a colored dot is placed. In the corresponding row of the output grid, starting from this column, color every other cell with the same color as the dot. Fill the cells in between these with color\u202f5. All other cells in the grid remain unchanged with the background color."
    },
    {
        "id": "97a05b5b",
        "pattern": "To transform the input grid into the output grid, follow these steps:\n\n1. **Identify the Square Region**: In the input grid, locate a square area and fill it entirely with a specific color.\n\n2. **Generate Objects**: Create a set of distinct objects, each consisting of connected cells, using colors different from the square's color and the background.\n\n3. **Apply Transformations**: For each object, randomly apply a combination of horizontal, vertical, or diagonal mirroring transformations to alter its shape.\n\n4. **Assign Colors**: Assign a unique new color to each transformed object from the remaining available colors.\n\n5. **Place Objects in Output Grid**: Insert all the transformed and recolored objects into a new grid of the same size as the square region, ensuring that they fit within the square without overlapping each other.\n\nThis process results in the output grid containing transformed and uniquely colored versions of the objects originally placed in the input grid's non-square areas, all neatly arranged within the colored square region."
    },
    {
        "id": "98cf29f8",
        "pattern": "To transform the input grid into the output grid, follow these steps:\n\n1. **Identify the Primary Rectangle**: Locate a rectangular object within the input grid.\n\n2. **Locate the Secondary Rectangle**: Find a second rectangular object that is connected to the primary rectangle by a vertical line.\n\n3. **Measure the Connecting Line**: Determine the length of the vertical line connecting the two rectangles.\n\n4. **Shift the Secondary Rectangle**: Move the second rectangle upward by a number of cells equal to the length of the connecting vertical line.\n\nThe resulting grid after these steps is the output grid."
    },
    {
        "id": "995c5fa3",
        "pattern": "To transform the input grid into the output grid, follow these steps:\n\n1. **Identify Each 4\u00d74 Block:**\n   - Locate every distinct 4\u00d74 block within the input grid, positioned horizontally with one empty column separating adjacent blocks.\n\n2. **Determine the Shape of Each Block:**\n   - **Fully Filled Block:** The entire 4\u00d74 area is filled with a single color.\n   - **Outlined Block:** Only the border cells of the 4\u00d74 area are filled, leaving the inner 2\u00d72 cells empty.\n   - **Partial Filled Block (Type 1):** The 4\u00d74 block is filled except for the cells at positions (1,0), (2,0), (1,3), and (2,3).\n   - **Partial Filled Block (Type 2):** The 4\u00d74 block is filled except for a shifted 2\u00d72 area offset by (2,1).\n\n3. **Assign Output Colors Based on Block Shape:**\n   - **Fully Filled Block:** Assign the output color **2**.\n   - **Outlined Block:** Assign the output color **8**.\n   - **Partial Filled Block (Type 1):** Assign the output color **3**.\n   - **Partial Filled Block (Type 2):** Assign the output color **4**.\n\n4. **Generate the Output Grid:**\n   - Create a sequence where each element corresponds to the assigned output color of each identified 4\u00d74 block in the order they appear from left to right in the input grid."
    },
    {
        "id": "99b1bc43",
        "pattern": "To transform the input grid into the output grid:\n1. Identify all cells that are colored in either one of two distinct regions but not both.\n2. Change the color of these identified cells to color\u202f3 in the output grid.\n3. Set all remaining cells in the output grid to the background color.\n4. Optionally, mirror the entire output grid along its diagonal."
    },
    {
        "id": "99fa7670",
        "pattern": "To transform the input grid into the output grid, perform the following steps for each colored cell in the input:\n\n1. **Draw a Horizontal Line**: Extend a horizontal line of the same color from the colored cell to the rightmost edge of the grid.\n\n2. **Draw a Vertical Line**: From the endpoint of the horizontal line, extend a vertical line of the same color downward to the bottom boundary of the designated segment.\n\nAll cells not part of these lines remain unchanged with the background color."
    },
    {
        "id": "9aec4887",
        "pattern": "1. **Identify Boundary Lines**: In the input grid, locate the four colored lines that form the borders of a rectangular (or similarly shaped) area.\n\n2. **Determine Closest Boundary for Each Cell**: For every cell inside the bordered area, calculate its Manhattan distance to each of the four boundary lines.\n\n3. **Assign Cell Colors Based on Proximity**:\n   - **Nearest Boundary**: Assign the cell the color of the boundary line to which it is closest.\n   - **Equidistant Boundaries**: If a cell is equally close to two or more boundary lines, assign it a predefined default pattern color.\n\n4. **Apply Random Rotation**: Rotate the entire grid by a randomly chosen angle of 0\u00b0, 90\u00b0, 180\u00b0, or 270\u00b0.\n\n5. **Generate Output Grid**: The resulting grid after these transformations serves as the output grid."
    },
    {
        "id": "9af7a82c",
        "pattern": "For each column in the input grid, count the number of cells filled with a specific color. Then, in the output grid, replace each column with a vertical, connected line of the same color that occupies exactly that number of cells, starting from the top of the grid."
    },
    {
        "id": "9d9215db",
        "pattern": "To transform the input grid into the output grid, follow these steps:\n\n1. **Mirror Vertically:** Create a vertical mirror image of all colored lines in the input grid and paint them onto the grid.\n2. **Mirror Horizontally:** Create a horizontal mirror image of all colored lines in the input grid and paint them onto the grid.\n3. **Combine Mirrors:** Merge the original lines with both their vertical and horizontal mirror images to form a symmetric pattern.\n4. **Rotate the Grid:** Rotate the entire grid by either 0\u00b0, 90\u00b0, 180\u00b0, or 270\u00b0 degrees selected at random."
    },
    {
        "id": "9dfd6313",
        "pattern": "1. **Select a Central Axis**: Choose one of four possible central lines in the input grid\u2014a vertical line in the middle column, a horizontal line in the middle row, a diagonal from the top-left to the bottom-right, or a diagonal from the bottom-left to the top-right.\n\n2. **Draw the Central Line**: Paint the selected central axis with a specific color, ensuring it spans the entire grid along the chosen direction.\n\n3. **Color One Side of the Axis**: On the side of the grid determined by the central axis, randomly select a number of pixels and color each selected pixel with randomly chosen colors from a predefined set, excluding the central line's color.\n\n4. **Mirror to Create Symmetry**: Reflect all the colored pixels from the chosen side across the central axis to the opposite side, ensuring the output grid is a symmetrical version of the input grid.\n\n5. **Optional Swap**: With a 50% probability, swap the original and mirrored grids, making the mirrored version either the input or the output based on random choice."
    },
    {
        "id": "9ecd008a",
        "pattern": "1. **Identify the Erased Regions:** Locate the two rectangular areas within the input grid where the cells have been set to the background color.\n\n2. **Determine Bounding Boxes:** For each identified erased area, determine the smallest rectangle that completely encloses all the erased cells.\n\n3. **Extract Original Content:** From each bounding box, retrieve the original cell values that were present before they were replaced with the background color.\n\n4. **Combine Extracted Areas:** Merge the extracted contents from both bounding boxes to form the output grid."
    },
    {
        "id": "9edfc990",
        "pattern": "Identify all contiguous regions of background color (0) in the input grid that are directly adjacent to any block colored with 1. Change the color of these adjacent background regions from 0 to 1 to produce the output grid."
    },
    {
        "id": "9f236235",
        "pattern": "To transform the input grid into the output grid, follow these steps:\n\n1. **Divide the Input Grid**: Split the input grid into a grid of equally sized rectangular tiles arranged in rows and columns.\n\n2. **Identify Tile Colors**:\n   - For each tile, check its color.\n   - If a tile is colored with a special color (different from the background color), note its position and color.\n   - Otherwise, consider the tile as having the background color.\n\n3. **Map to Output Grid**:\n   - Create a new, smaller grid where each cell corresponds to a tile from the input grid.\n   - For each noted special tile, set the corresponding cell in the output grid to the tile's special color.\n   - Set all other cells in the output grid to the background color.\n\n4. **Vertically Mirror the Output Grid**: Flip the entire output grid upside down, reversing the order of its rows.\n\nThis process results in an output grid that represents the arrangement and colors of the special tiles from the input grid, but mirrored vertically."
    },
    {
        "id": "a1570a43",
        "pattern": "Within a distinctively marked rectangular area defined by four corner cells of a specific color, there is a connected colored object composed of multiple cells. In the input grid, this object is randomly shifted to a new position inside the rectangle without overlapping the corner cells. To produce the output grid, reposition the connected object back to its original location within the same rectangular area, ensuring that the four corner cells remain unchanged."
    },
    {
        "id": "a2fd1cf0",
        "pattern": "To transform the input grid into the output grid, first locate the centers of the two distinct colored cells. Then, draw a horizontal line from the center of the first cell extending to the column of the second cell. From this intersection point, draw a vertical line down to the center of the second cell. Use a specific color for both connecting lines. The output grid retains the original colored cells and includes the newly drawn horizontal and vertical lines connecting them."
    },
    {
        "id": "a3325580",
        "pattern": "1. **Identify the Largest Objects**: Locate all distinct objects in the input grid and determine which ones have the maximum number of cells.\n\n2. **Order the Objects**: Arrange these largest objects from left to right based on their positions in the input grid.\n\n3. **Create the Output Grid**:\n   - Set the height of the output grid to match the number of cells in the largest objects.\n   - Set the width of the output grid to equal the number of these largest objects.\n   \n4. **Fill the Output Grid**: For each ordered largest object, fill an entire vertical column in the output grid with the object's color."
    },
    {
        "id": "a3df8b1e",
        "pattern": "1. Draw a zig-zagging line that starts at the bottom-left corner of the input grid and moves upward, reversing horizontal direction each time it reaches the left or right edge.\n2. Optionally rotate or mirror this zig-zagging line using one or two geometric transformations (such as rotation by 90 degrees or horizontal/vertical reflection).\n3. Depending on a randomly chosen number, add additional lines by reflecting the original line horizontally, vertically, or both.\n4. The output grid consists of the original zig-zagging line along with any mirrored or rotated copies added in the previous steps."
    },
    {
        "id": "a416b8f3",
        "pattern": "The output grid is created by placing two identical copies of the input grid side by side horizontally."
    },
    {
        "id": "a48eeaf7",
        "pattern": "1. Start with an empty grid filled with the background color.\n2. Draw a rectangle at a random position within the grid, using a specific square color.\n3. Randomly place a number of colored dots adjacent to each side of the rectangle in the input grid.\n4. In the output grid, move some of these dots to new random positions adjacent to the rectangle.\n5. Optionally, add colored dots to the four corners of the rectangle in the output grid and place corresponding random dots elsewhere in the input grid.\n6. Rotate both the input and output grids by the same random multiple of 90 degrees."
    },
    {
        "id": "a5313dff",
        "pattern": "To create the output grid from the input grid, follow these steps:\n1. **Identify Enclosed Background Areas:** Find all regions in the input grid that are filled with the background color and are completely surrounded by foreground elements, meaning these regions do not touch any edge of the grid.\n2. **Fill Enclosed Areas:** Change the color of each of these identified enclosed background regions to color '1'.\n3. **Leave Other Regions Unchanged:** All other parts of the grid, including background regions that are adjacent to the grid's borders and all foreground elements, remain as they are.\n\nIn summary, the output grid is the same as the input grid except that any background area fully enclosed by foreground elements is filled with color '1'."
    },
    {
        "id": "a5f85a15",
        "pattern": "For each diagonal line running from the top-left to the bottom-right in the input grid, the output grid retains the same lines but changes every second cell along each line to color 4. All other cells remain unchanged."
    },
    {
        "id": "a61ba2ce",
        "pattern": "To transform the input grid into the output grid, follow these steps:\n\n1. **Identify Four L-Shaped Lines**: Locate four distinct L-shaped lines in the input grid. Each line consists of a connected vertical and horizontal segment and is filled with a unique color.\n\n2. **Assign Each Line to a Corner**: Assign each of the four identified lines to one of the four corners of the output grid:\n   - Top-left corner\n   - Top-right corner\n   - Bottom-left corner\n   - Bottom-right corner\n\n3. **Reposition the Lines from Corners**: Move each assigned line so that it originates from its designated corner in the output grid. The vertical and horizontal segments of each line should extend from the corner outward to specific internal positions.\n\n4. **Maintain Unique Colors**: Ensure that each line retains its original unique color when moved to the corner position.\n\n5. **Set Background Color**: Fill all remaining cells in the output grid with the background color, ensuring that only the four repositioned lines are colored.\n\nBy following these precise steps, the input grid with four randomly placed L-shaped colored lines is transformed into an output grid with four L-shaped lines originating from each of the four corners, each maintaining its distinct color."
    },
    {
        "id": "a61f2674",
        "pattern": "1. **Identify Vertical Bars**: Detect all vertical bars in the input grid. A vertical bar is a continuous column of cells with the same non-background color.\n\n2. **Determine Heights**: Measure the height of each identified vertical bar.\n\n3. **Select Tallest and Shortest Bars**:\n   - **Tallest Bar**: Find the vertical bar with the maximum height.\n   - **Shortest Bar**: Find the vertical bar with the minimum height.\n\n4. **Create Output Grid**:\n   - **Background**: Initialize the output grid with the same background color as the input grid.\n   - **Highlight Tallest Bar**: Draw the tallest vertical bar in the output grid using color **1**.\n   - **Highlight Shortest Bar**: Draw the shortest vertical bar in the output grid using color **2**.\n\n5. **Apply Rotation**: Rotate the output grid by a randomly chosen multiple of 90 degrees (i.e., 0\u00b0, 90\u00b0, 180\u00b0, or 270\u00b0) to match the orientation of the input grid."
    },
    {
        "id": "a64e4611",
        "pattern": "1. **Select a Column Range:** Choose a consecutive range of columns within the input grid.\n\n2. **Draw Vertical Background Lines:** In each selected column, draw a vertical line using the background color starting from a randomly chosen row down to the bottom of the grid.\n\n3. **Add Parallel Vertical Lines:** For each vertical background line, draw a parallel vertical line offset by one row using a distinct color.\n\n4. **Draw Horizontal Background Lines:** From a randomly selected starting row, draw horizontal lines across the selected columns in one or both horizontal directions using the background color.\n\n5. **Add Parallel Horizontal Lines:** For each horizontal background line, draw a parallel horizontal line offset by one column using the distinct color."
    },
    {
        "id": "a65b410d",
        "pattern": "To transform the input grid into the output grid, follow these steps:\n\n1. **Identify the Central Position:** Locate a horizontal line in the input grid that starts from the left edge and extends to a specific point near the center of the grid.\n\n2. **Add a Lower Line:** In the output grid, draw a new horizontal line below the original line. This line should start from a position slightly below and to the left of the central point and extend leftwards all the way to the left edge. Color this line with color **1**.\n\n3. **Add an Upper Line:** Also in the output grid, draw another horizontal line above the original line. This line should start from a position slightly above and to the right of the central point and extend leftwards to the left edge. Color this line with color **3**.\n\n4. **Optional Rotation:** Rotate the entire grid by a randomly chosen multiple of 90 degrees (i.e., 0\u00b0, 90\u00b0, 180\u00b0, or 270\u00b0) to introduce variation.\n\nThis sequence results in the output grid having the original horizontal line from the input, supplemented by two additional horizontal lines colored differently above and below the original line, with the possibility of the entire pattern being rotated."
    },
    {
        "id": "a68b268e",
        "pattern": "To transform the input grid into the output grid, follow these steps:\n\n1. **Divide the Input Grid into Four Quadrants**:\n   - Split the input grid into four equal parts:\n     - Upper-Left (UL) quadrant.\n     - Upper-Right (UR) quadrant.\n     - Lower-Left (LL) quadrant.\n     - Lower-Right (LR) quadrant.\n\n2. **Shift Each Quadrant to the Center**:\n   - Move each quadrant towards the center of the grid:\n     - Shift the UL quadrant to align with the top-left position.\n     - Shift the UR quadrant to align with the top-right position.\n     - Shift the LL quadrant to align with the bottom-left position.\n     - Shift the LR quadrant to align with the bottom-right position.\n\n3. **Merge the Quadrants to Form the Output Grid**:\n   - Combine the shifted quadrants by overlaying their colored cells:\n     - For each cell position in the output grid, if multiple quadrants have a colored cell in that position, retain all colors.\n     - Fill the remaining cells with the background color.\n\n4. **Finalize the Output Grid**:\n   - The merged result from the previous step is the output grid, representing the combined pattern from all four quadrants of the input grid."
    },
    {
        "id": "a699fb00",
        "pattern": "For each selected row in the input grid, determine a horizontal segment by choosing start and end columns. In the output grid, fill every cell within this segment in that row with color\u202f2, and then overwrite every second cell in the segment with the foreground color from the input grid."
    },
    {
        "id": "a740d043",
        "pattern": "To transform the input grid to the output grid, follow these steps:\n1. **Remove Fully Background Rows:** Delete any row that is entirely filled with the background color.\n2. **Remove Fully Background Columns:** Delete any column that is entirely filled with the background color.\n3. **Recolor Background:** In the resulting grid, change all remaining cells that have the background color to black (0)."
    },
    {
        "id": "a78176bb",
        "pattern": "To transform the input grid into the output grid, follow these steps:\n\n1. **Identify Diagonal Lines**:\n   - Locate all diagonal lines that start from the bottom edge or the left edge of the grid and extend diagonally upwards to the right.\n\n2. **Remove Attached Triangles**:\n   - For each identified diagonal line, find and remove any small triangular shapes attached to it.\n\n3. **Extend the Diagonal Lines**:\n   - After removing the triangles, extend each diagonal line further in the same diagonal direction by adding new diagonal segments beyond the original end of the line.\n\n4. **Optional Mirroring**:\n   - Randomly decide whether to mirror the entire grid horizontally. If chosen, flip the grid along its vertical axis.\n\nBy systematically removing triangles from each diagonal line and extending the lines further in the same direction, while optionally mirroring the grid, the input grid is transformed into the desired output grid."
    },
    {
        "id": "a79310a0",
        "pattern": "To transform the input grid into the output grid, follow these steps:\n\n1. **Identify the Foreground Pattern**: Locate the connected group of cells that are colored with the foreground color in the input grid.\n\n2. **Shift the Pattern Downward**: Move the entire foreground pattern down by one cell within the grid.\n\n3. **Recolor the Shifted Pattern**: Change the color of the shifted pattern to color 2.\n\n4. **Maintain the Background**: Ensure that all other cells in the grid remain unchanged and retain the original background color.\n\nThis results in the output grid where the foreground pattern has been moved down by one cell and recolored, while the background remains consistent."
    },
    {
        "id": "a85d4709",
        "pattern": "For each row in the input grid, locate the single colored cell and determine whether it is in the left third, middle third, or right third of that row. Then, in the output grid, fill the entire corresponding row with a specific color based on the cell's position:\n- If the cell is in the left third, color the row with color\u202f2.\n- If the cell is in the middle third, color the row with color\u202f4.\n- If the cell is in the right third, color the row with color\u202f3.\nAll other cells remain filled with the background color."
    },
    {
        "id": "a87f7484",
        "pattern": "To transform the input grid into the output grid, follow these steps:\n\n1. **Select a Specific Color**: Choose one particular color present in the input grid to isolate.\n\n2. **Identify Cells with the Selected Color**: Locate all cells in the input grid that are filled with the chosen color.\n\n3. **Create the Output Grid**:\n   - **Retain the Selected Color**: In the output grid, set the identified cells to the selected color.\n   - **Set All Other Cells to Background**: Change every other cell in the output grid to the background color (typically black).\n\n4. **Apply Diagonal Mirroring (Optional)**: If the input grid was diagonally mirrored, apply the same diagonal mirroring to the output grid to maintain symmetry.\n\nThis process effectively extracts and preserves the pattern of the chosen color from the input grid while removing all other colors, resulting in an output grid that highlights only the selected color in its original locations."
    },
    {
        "id": "a8c38be5",
        "pattern": "1. **Restore Orientation**: If the input grid has been rotated or mirrored, first reverse these transformations to align the grid to its original orientation.\n2. **Remove Extra Borders**: Delete the additional rows and columns of background color that were inserted around the original grid to return to the original grid dimensions.\n3. **Reposition Objects**: Identify any objects that were moved or swapped and return them to their original positions based on their shapes.\n4. **Finalize the Output**: After undoing rotations/mirrors, removing extra borders, and repositioning objects, the grid will match the original output grid."
    },
    {
        "id": "a8d7556c",
        "pattern": "In the input grid, locate every 2\u00d72 block where all four cells are black. For each such block found, replace all four black cells with the color 2 in the output grid."
    },
    {
        "id": "a9f96cdd",
        "pattern": "For each foreground cell in the input grid:\n\n1. Identify the four diagonally adjacent positions relative to the foreground cell:\n   - Top-left (one row up and one column to the left)\n   - Top-right (one row up and one column to the right)\n   - Bottom-left (one row down and one column to the left)\n   - Bottom-right (one row down and one column to the right)\n\n2. In the output grid, set each of these diagonally adjacent positions to specific colors:\n   - Top-left position: color **3**\n   - Top-right position: color **6**\n   - Bottom-left position: color **8**\n   - Bottom-right position: color **7**\n\nAll other cells in the output grid remain with the background color."
    },
    {
        "id": "aabf363d",
        "pattern": "Given a grid where a single connected region is filled with one color and exactly one background cell is colored with a different color, the output grid is created by changing the entire connected region to that different color while keeping the rest of the grid unchanged."
    },
    {
        "id": "aba27056",
        "pattern": "1. **Identify the Filled Rectangle and Hole:**\n   - Locate the rectangular area in the input grid that is filled with a specific color.\n   - Within this rectangle, identify the horizontal gap (hole) where the background color appears.\n\n2. **Create the Output Grid:**\n   - **Outline the Rectangle:**\n     - Draw a border around the entire perimeter of the identified rectangle using a distinct color (color 4).\n   \n   - **Refill the Rectangle:**\n     - Fill the interior of the outlined rectangle with the original square color used in the input grid.\n   \n   - **Extend Lines from the Hole:**\n     - From each cell of the horizontal hole, draw vertical lines extending upwards. Color these lines with the distinct outline color.\n   \n   - **Draw Diagonal Lines from Hole Corners:**\n     - From the upper-left corner of the horizontal hole, draw a diagonal line extending upwards to the left.\n     - From the upper-right corner of the horizontal hole, draw a diagonal line extending upwards to the right.\n     - Color both diagonal lines with the distinct outline color.\n\n3. **Apply Rotation:**\n   - Rotate the entire output grid by a randomly chosen multiple of 90 degrees (either 0\u00b0, 90\u00b0, 180\u00b0, or 270\u00b0) to vary the orientation of the pattern."
    },
    {
        "id": "ac0a08a4",
        "pattern": "To transform the input grid into the output grid, replace each cell in the input grid with an N\u00d7N block of the same color, where N is a randomly selected integer based on the input grid\u2019s dimensions. This uniformly scales the entire grid by the factor N."
    },
    {
        "id": "ae3edfdc",
        "pattern": "To transform the input grid into the output grid, follow these steps:\n\n1. **Select Two Central Cells**: Choose two distinct non-border cells in the grid. Assign a unique color to each of these central cells.\n\n2. **Color Surrounding Cells**: For each central cell, randomly select a number of its adjacent (neighboring) cells within specified limits. Assign a third color to the cells surrounding the first central cell and a fourth color to those surrounding the second central cell.\n\n3. **Determine Movement Directions**: For each of the newly colored surrounding cells, determine a direction to move based on its position relative to its respective central cell.\n\n4. **Move Colored Cells**:\n    - For a randomly chosen number of steps within defined bounds, do the following:\n        - Move each colored surrounding cell one step in its determined direction.\n        - Update the grid by setting the new position of the moved cell to its assigned color.\n        - Change the cell's original position back to the background color.\n\nThis sequence of selecting central points, coloring their neighbors, determining movement directions, and iteratively moving the colored cells creates the transformation from the input grid to the output grid."
    },
    {
        "id": "ae4f1146",
        "pattern": "To obtain the output grid from the input grid, follow these steps:\n\n1. **Start with a large grid filled with a background color.**\n2. **Randomly place several small, non-overlapping foreground-colored objects onto this grid at various locations.**\n3. **Select one of these foreground objects and extract it as the output grid, maintaining its original color and shape.**"
    },
    {
        "id": "aedd82e4",
        "pattern": "To transform the input grid into the output grid, identify every individual cell that is the only one of its color in the grid and change its color to 1. All other cells remain unchanged."
    },
    {
        "id": "af902bf9",
        "pattern": "For each rectangle in the input grid, identify its four corner cells that are colored with the same specific color. In the output grid, retain these corner colors exactly as they are and fill every cell inside each identified rectangle with color\u202f2."
    },
    {
        "id": "b0c4d837",
        "pattern": "1. **Identify Filled Columns**: In the input grid, locate a specific rectangular area where a smaller rectangle inside it has several vertical lines filled with the background color.\n\n2. **Count Background Lines**: Count the number of these vertical lines within the smaller rectangle that are filled with the background color.\n\n3. **Create Output Grid**: \n   - Initialize a new 3\u00d73 grid.\n   - Fill the first *n* cells with the fill color, where *n* is the count from step 2.\n   - Fill the remaining cells with the background color.\n\n4. **Arrange Cells**:\n   - Place the first three filled cells in the top row from left to right.\n   - Place the next three filled cells in the middle row from right to left.\n   - Place the last three filled cells in the bottom row from left to right.\n\n5. **Finalize Output**: The resulting 3\u00d73 grid represents the output based on the number of background-filled vertical lines in the input grid."
    },
    {
        "id": "b190f7f5",
        "pattern": "1. **Create a Base Grid:** Start with a small grid of random height and width (between 2 and 5 cells each) filled with a chosen background color.\n\n2. **Select Source Cells:** Randomly choose a number of cells (at least one and less than the total number of cells) within this base grid and fill them with a single source color different from the background.\n\n3. **Assign Target Colors:** Randomly select a separate set of cells (at least two) in the base grid. Assign each of these cells a different target color from a distinct color palette, ensuring these colors are also different from the background and source colors.\n\n4. **Concatenate Grids:** Combine two copies of this base grid either side by side horizontally or stacked vertically to form the input grid.\n\n5. **Initialize Output Grid:** Create a larger grid with dimensions equal to the square of the base grid's height and width, filled with the same background color.\n\n6. **Replicate Patterns Based on Targets:** For each target-colored cell in the input grid:\n    - **Scale Position:** Determine the position by multiplying the target cell's row and column indices by the base grid's height and width, respectively.\n    - **Place Source Pattern:** Insert a copy of the source-colored cells from the base grid into the output grid at the scaled position.\n    - **Apply Target Color:** Color the placed pattern with the corresponding target color assigned to that target cell.\n\n7. **Finalize Output:** The resulting output grid consists of multiple scaled and colored copies of the source pattern, each positioned according to the locations and colors of the target cells in the input grid, all set against the original background color."
    },
    {
        "id": "b1948b0a",
        "pattern": "To transform the input grid to the output grid, follow these steps:\n\n1. **Identify Cells with Color 6:** Locate all cells in the input grid that are colored with the value **6**.\n\n2. **Change Color to 2:** For each identified cell, change its color from **6** to **2** in the output grid.\n\n3. **Preserve Other Cells:** All other cells that do not have the color **6** in the input grid remain unchanged in the output grid.\n\nIn summary, the pattern replaces every cell colored **6** in the input grid with color **2**, while keeping all other cell colors the same."
    },
    {
        "id": "b230c067",
        "pattern": "Locate two separate connected regions of the same color in the input grid. In the output grid, recolor one of these regions with color\u202f1 and the other region with color\u202f2, leaving all other cells unchanged."
    },
    {
        "id": "b27ca6d3",
        "pattern": "To create the output grid from the input grid, follow these steps:\n\n1. **Identify Bars**: Locate each vertical or mirrored vertical bar present in the input grid.\n\n2. **Modify Bar Areas**: For every identified bar, change all cells within the bar's bounding box that are set to the background color to color 3.\n\n3. **Preserve Other Elements**: Leave all other elements, such as cross-shaped dots, unchanged.\n\nThe resulting grid will have the same arrangement of dots and bars as the input, but the areas of the bars that were originally background-colored will now be colored with color 3."
    },
    {
        "id": "b2862040",
        "pattern": "To transform the input grid into the output grid, follow these steps:\n\n1. **Identify Border Objects**: Locate all distinct objects in the input grid that are directly adjacent to the edges of the grid (i.e., touching the top, bottom, left, or right borders).\n\n2. **Recolor Border Objects**: Change the color of each identified border-adjacent object to color **8**.\n\nThe output grid will be the same as the input grid but with all objects that were touching the grid's borders now colored **8**."
    },
    {
        "id": "b527c5c6",
        "pattern": "To transform the input grid into the output grid, follow these precise steps:\n\n1. **Identify Rectangular Regions:**\n   - Locate each distinct rectangular area in the input grid that is colored differently from the background.\n\n2. **Select a Starting Cell:**\n   - Within each identified rectangle, choose a specific cell that is not on the border of the rectangle.\n\n3. **Determine Line Direction:**\n   - Based on the rectangle's dimensions:\n     - If the rectangle is taller than it is wide, prepare to draw a vertical line.\n     - If the rectangle is wider than it is tall, prepare to draw a horizontal line.\n\n4. **Draw the Line:**\n   - From the selected starting cell, extend a straight line in the determined direction (either horizontally or vertically) across the interior of the rectangle.\n\n5. **Update the Output Grid:**\n   - In the output grid, replace the chosen starting cell with the drawn line, ensuring that the line maintains the original color of the rectangle.\n   - The rest of the rectangle remains unchanged, preserving its original colored borders and background.\n\nBy systematically replacing specific cells within each colored rectangle with lines extending in appropriate directions, the output grid reflects these structured modifications based on the input grid's initial configuration."
    },
    {
        "id": "b548a754",
        "pattern": "To transform the input grid into the output grid, first identify the partially drawn rectangular box. Extend this box to its full height and width, filling the entire extended area with the designated box color. Then, fill the inner border of the completed box with the specified inner color. Finally, remove the single dot that was present on one edge of the original partial box."
    },
    {
        "id": "b60334d2",
        "pattern": "For each cell in the input grid that is colored with the foreground color, the output grid sets the four diagonally adjacent cells to the same foreground color and colors the four directly adjacent (up, down, left, right) cells with color\u202f1. All other cells in the output grid retain the background color."
    },
    {
        "id": "b6afb2da",
        "pattern": "For each rectangular area in the input grid:\n\n1. **Fill the entire rectangle with color 2**.\n2. **Outline the border of the rectangle with color 4**.\n3. **Color the four corner cells of the rectangle with color 1**.\n\nAll cells outside these rectangles remain unchanged with the background color."
    },
    {
        "id": "b7249182",
        "pattern": "To transform the input grid into the output grid, follow these steps:\n\n1. **Identify Marked Cells**: Locate two specific cells in the input grid\u2014one colored with color A and the other with color B.\n\n2. **Draw Vertical Connection**: In the output grid, draw a vertical line using color A that connects the positions corresponding to the two marked input cells.\n\n3. **Extend Horizontal Lines**: At both the top and bottom ends of this vertical line, extend horizontal lines outward to the left and right using color A.\n\n4. **Mark Endpoints**: Replace the color A at both ends of these horizontal lines with color B, highlighting the endpoints.\n\n5. **Optional Mirroring**: Optionally, mirror the entire pattern along the diagonal to create a symmetric variation.\n\nThis results in an output grid where two colored endpoints (color B) are connected by vertical and horizontal lines of a different color (color A), forming a symmetric and clearly defined pattern."
    },
    {
        "id": "b775ac94",
        "pattern": "1. Start with an empty grid filled with a background color.\n2. Determine a random number of objects to place on the grid.\n3. For each object:\n    a. Create a small shape with random height and width between 2 and 5 cells.\n    b. Fill the shape with a unique color.\n    c. Generate three mirrored versions of this shape:\n        - Vertically mirrored.\n        - Horizontally mirrored.\n        - Both vertically and horizontally mirrored.\n    d. Assign each mirrored shape a distinct color different from the original.\n    e. Randomly decide which of the mirrored shapes to keep or replace with the background color.\n    f. Optionally rotate each kept shape by 0\u00b0, 90\u00b0, 180\u00b0, or 270\u00b0.\n    g. Place the transformed shapes onto the grid at random locations, ensuring they do not overlap or touch other objects.\n4. Repeat until all objects are placed or a maximum number of attempts is reached.\n5. The final grid is the output, showing all placed and transformed objects against the background."
    },
    {
        "id": "b782dc8a",
        "pattern": "To transform the input grid into the output grid, follow these steps:\n\n1. **Identify a Connected Path**:\n   - Locate a connected path within the input grid where all cells in the path share the same color.\n\n2. **Select a Random Cell**:\n   - Randomly choose one cell from the identified path and change its color to a distinct \"dot\" color.\n\n3. **Color Adjacent Cells**:\n   - Change the color of all cells directly adjacent (north, south, east, west) to the selected \"dot\" cell that are part of the path to another specific color (\"ncol\").\n\n4. **Divide the Path into Two Groups**:\n   - Split the remaining cells in the path into two groups based on their Manhattan distance from the \"dot\" cell:\n     - **Group 1**: Cells at even distances.\n     - **Group 2**: Cells at odd distances.\n\n5. **Apply Colors to the Groups**:\n   - In the output grid, color all cells in **Group 1** with the \"dot\" color.\n   - Color all cells in **Group 2** with the \"ncol\" color.\n\n6. **Rotate the Grid (Optional)**:\n   - Optionally, rotate the entire grid by 0\u00b0, 90\u00b0, 180\u00b0, or 270\u00b0 to achieve the final output orientation."
    },
    {
        "id": "b8825c91",
        "pattern": "1. **Start with a Symmetric Grid:** Begin with an input grid that is symmetric both horizontally and vertically.\n\n2. **Select Two Locations:** Choose two distinct positions within the grid.\n\n3. **Fill Surrounding Areas:**\n   - For each selected position:\n     - Determine a rectangular bounding box around the location.\n     - Fill this bounding box area with the color value **4**.\n\n4. **Maintain Symmetry with Rotation:**\n   - After filling each bounding box, rotate the entire grid by **180 degrees** to preserve the grid's overall symmetry.\n\n5. **Apply Additional Transformations:**\n   - Finally, apply **one or two** random transformations to the grid. These transformations can include:\n     - **Rotations** (e.g., 90\u00b0, 180\u00b0, or 270\u00b0 clockwise)\n     - **Mirroring** (horizontally or vertically)\n\n6. **Output the Transformed Grid:** The result after performing these steps is the output grid, which reflects the applied pattern transformations based on the input grid."
    },
    {
        "id": "b8cdaf2b",
        "pattern": "1. **Initialize the Grid**: Start with a grid of height\u202f*h* and width\u202f*w*, filled with the background color.\n\n2. **Draw the Top Horizontal Line**: Draw a horizontal line across the entire top row (from the leftmost to the rightmost column) using the line color.\n\n3. **Add a Shorter Bar**: Within this top horizontal line, draw a shorter horizontal bar starting at a random column position and spanning\u202f*w\u2082*\u202fcolumns using the dot color.\n\n4. **Shift the Shorter Bar Down**: Move the shorter bar down by one row, keeping it in the same column positions, and recolor it with the line color.\n\n5. **Draw Diagonal Lines**: From both ends of the shifted shorter bar, extend two diagonal lines downward:\n   - One diagonal line moves down and to the left.\n   - The other diagonal line moves down and to the right.\n   Both diagonals are drawn using the dot color.\n\n6. **Rotate the Grid**: Finally, rotate the entire grid by a randomly chosen multiple of 90 degrees (i.e., 0\u00b0, 90\u00b0, 180\u00b0, or 270\u00b0).\n\nThis sequence transforms the input grid by adding a central horizontal bar with downward diagonals emanating from it, then applies a rotation to vary its orientation."
    },
    {
        "id": "b91ae062",
        "pattern": "1. **Count Distinct Colors**: Determine the number of unique colors present in the input grid. Let this number be\u202f*N*.\n2. **Determine Scaling Factor**: Subtract one from\u202f*N*\u202fto obtain the scaling factor, i.e.,\u202f*Scale Factor* =\u202f*N*\u202f\u2212\u202f1.\n3. **Enlarge the Grid**: For each cell in the input grid, replicate it into a block of size\u202f(*Scale Factor* \u00d7 *Scale Factor*). This means each cell is expanded horizontally and vertically by the scaling factor.\n4. **Generate Output Grid**: The collection of all replicated blocks forms the output grid, which is therefore larger by the scaling factor in both dimensions compared to the input grid."
    },
    {
        "id": "b94a9452",
        "pattern": "To transform the input grid into the output grid, first remove any rows and columns that are entirely filled with a single color. Then, swap the colors of the outer and inner filled regions."
    },
    {
        "id": "b9b7f026",
        "pattern": "To transform the input grid into the output grid, follow these steps:\n\n1. **Identify the Background Color**: Determine the most common color in the input grid, which serves as the background color.\n\n2. **Find the First Non-Background Rectangle**:\n   - Locate the first rectangular region in the input grid that is filled with a color different from the background color.\n   - This rectangle will have a random height and width between 3 and 7 cells.\n   \n3. **Extract the Rectangle's Color**: Note the color used to fill this first non-background rectangle. This color will be referred to as `outcol`.\n\n4. **Generate the Output Grid**:\n   - Create a new grid consisting of a single cell.\n   - Fill this single cell with the color `outcol` identified from the first non-background rectangle.\n\nThe output grid will therefore be a 1x1 grid colored with the color of the first non-background rectangle found in the input grid."
    },
    {
        "id": "ba26e723",
        "pattern": "For each column in the input grid, copy all cell colors to the output grid unchanged, except for columns whose index is a multiple of three (0, 3, 6, etc.). In these multiples-of-three columns, set all cell colors to color\u202f6."
    },
    {
        "id": "ba97ae07",
        "pattern": "To transform the input grid into the output grid, follow these steps:\n\n1. **Draw Horizontal Lines**: Overlay several horizontal lines on the input grid using a specific color (Color A).\n\n2. **Draw Vertical Lines**: Overlay several vertical lines on top of the horizontal lines using a different color (Color B).\n\n3. **Handle Intersections**: At every cell where a horizontal line intersects with a vertical line, set the cell's color to Color A (the color of the horizontal line) instead of Color B.\n\nThe output grid will thus contain all the original horizontal and vertical lines, with their intersection points displaying the color of the horizontal lines."
    },
    {
        "id": "bb43febb",
        "pattern": "1. **Initialize the Output Grid**: Start with an output grid of the same size as the input grid, filled entirely with the background color.\n\n2. **Identify and Process Each Rectangle**:\n    - For each solid colored rectangle in the input grid:\n        a. **Fill the Rectangle Area**: In the output grid, fill the entire area of the rectangle with color `2`.\n        b. **Draw the Rectangle Border**: Then, outline the rectangle in the output grid using the rectangle's original color, restoring its border.\n\n3. **Maintain Remaining Cells**: All cells outside the rectangles remain as the background color in the output grid.\n\n**Summary**: Transform the input grid by replacing the interior of each solid colored rectangle with color `2` while keeping their borders in the original colors. The rest of the grid stays unchanged with the background color."
    },
    {
        "id": "bbc9ae5d",
        "pattern": "1. **Input Grid Structure**:\n    - The input grid has a single row.\n    - The first consecutive cells in this row are filled with one color (let's call it **Color A**).\n    - The remaining cells in the row are each filled with different colors (**Color B**, **Color C**, etc.).\n\n2. **Creating the Output Grid**:\n    - The output grid has multiple rows, specifically half the height of the input grid, and the same width.\n\n3. **Transforming Color A**:\n    - For each cell colored with **Color A** in the input row:\n        - Draw a diagonal line downward to the right.\n        - From each point along this diagonal line, extend a horizontal line to the left.\n        - Fill all cells along these horizontal lines with **Color A**.\n\n4. **Transforming the Other Colors**:\n    - For each of the remaining colored cells (**Color B**, **Color C**, etc.) in the input row:\n        - Draw a diagonal line downward to the right.\n        - Fill all cells along each of these diagonal lines with the respective color (e.g., **Color B** remains **Color B**).\n\nThis results in the output grid where:\n- **Color A** forms diagonal and horizontal patterns extending downward and to the left.\n- Each additional color forms its own diagonal pattern extending downward and to the right."
    },
    {
        "id": "bc1d5164",
        "pattern": "To generate the output grid from the input grid, follow these steps:\n\n1. **Divide the Input Grid:** Split the input grid into four distinct regions:\n   - **Top-Left Quadrant**\n   - **Top-Right Quadrant**\n   - **Bottom-Left Quadrant**\n   - **Bottom-Right Quadrant**\n\n2. **Identify Filled Cells:** In each of the four quadrants, locate all cells that are colored with the object color.\n\n3. **Merge Filled Cells:** Combine all the identified object-colored cells from the four quadrants into a single, unified set of cells.\n\n4. **Create the Output Grid:** \n   - Initialize a new grid of smaller dimensions.\n   - Set the background of this grid to the background color.\n   - Fill in the merged object-colored cells onto this grid at their respective positions.\n\nThe resulting output grid will display the combined pattern of the object-colored cells from all four quadrants of the input grid, set against the uniform background."
    },
    {
        "id": "bd4472b8",
        "pattern": "To transform the input grid into the output grid, follow these steps:\n\n1. **Initialize the Grid:**\n   - **Central Row:** Start with a single row filled with a sequence of randomly selected colors.\n   - **Bridge Row:** Add a second row filled entirely with a specific chosen color.\n   - **Lower Section:** Append multiple rows below the bridge row, all filled with the background color.\n\n2. **Create a Pattern Object:**\n   - **Mirror and Scale:** Take the central row, mirror it along the diagonal, and then scale it horizontally by the width of the central row to create a larger, patterned object.\n\n3. **Paint the Pattern onto the Grid:**\n   - **Positioning:** Starting from the third row, place the mirrored and scaled pattern object onto the grid.\n   - **Shifting:** Move the pattern downward by the width amount each time and paint it onto the grid.\n   - **Repeat:** Continue this shifting and painting process until the specified height of the grid is reached.\n\n4. **Apply Rotation:**\n   - **Random Rotation:** Rotate the entire grid (both input and output) by a randomly selected angle of 0\u00b0, 90\u00b0, 180\u00b0, or 270\u00b0.\n\nThe **output grid** is thus the **input grid** enhanced with multiple shifted, mirrored, and horizontally scaled copies of the central color pattern, all uniformly rotated by the same randomly chosen angle."
    },
    {
        "id": "bda2d7a6",
        "pattern": "To transform the input grid into the output grid, follow these steps:\n\n1. **Identify Concentric Rectangles**: Locate all the nested rectangular regions in the input grid, ordered from the outermost rectangle to the innermost one.\n\n2. **Shift Colors Circularly**: For each identified rectangle, change its color to match the color of the next inner rectangle in the sequence. Specifically:\n   - The outermost rectangle takes on the color of the second outermost rectangle.\n   - The second outermost rectangle takes on the color of the third outermost rectangle.\n   - This pattern continues inward, with the innermost rectangle adopting the color of the outermost rectangle.\n\n3. **Produce the Output Grid**: Apply the new color assignments to all the rectangles, resulting in the output grid where the colors of the concentric rectangles have been cyclically shifted."
    },
    {
        "id": "bdad9b1f",
        "pattern": "To obtain the output grid from the input grid:\n1. **Extend Horizontal Lines:** For each horizontal line in the input grid, extend it so that it spans the entire row from the left edge to the right edge.\n2. **Extend Vertical Lines:** For each vertical line in the input grid, extend it so that it spans the entire column from the top edge to the bottom edge.\n3. **Mark Intersections:** At every cell where a horizontal line and a vertical line intersect, change the cell's color to 4.\n4. **Rotate the Grid:** Rotate the entire grid by either 0\u00b0, 90\u00b0, 180\u00b0, or 270\u00b0, applying the same rotation consistently to both input and output grids."
    },
    {
        "id": "be94b721",
        "pattern": "1. **Background Setup**: Begin with an input grid entirely filled with a single background color.\n\n2. **Main Object Creation**: Identify and fill one prominent connected region within the grid with a distinct color different from the background. This region is connected via its top, bottom, left, and right neighbors.\n\n3. **Addition of Noise Objects**: Introduce several smaller connected regions (noise) elsewhere in the grid, each filled with different colors, ensuring they do not touch the main region.\n\n4. **Extraction and Normalization**:\n   - **Remove Noise**: Eliminate all the smaller colored regions, leaving only the main connected region and the background.\n   - **Shift to Corner**: Move the main connected region to the top-left corner of the grid without altering its shape or color.\n\n5. **Output Grid**: The final output grid consists of the background color with the main connected region positioned neatly in the top-left corner, free from any additional colored regions."
    },
    {
        "id": "beb8660c",
        "pattern": "To obtain the output grid from the input grid, follow these steps:\n\n1. **Vertically flip** (mirror) the input grid.\n2. **Rotate** the flipped grid by either 0\u00b0, 90\u00b0, 180\u00b0, or 270\u00b0."
    },
    {
        "id": "c0f76784",
        "pattern": "For each square frame in the input grid with a size between 3\u00d73 and 5\u00d75, keep the border cells unchanged and fill all the cells inside the border with a new color that is equal to the size of the square plus three."
    },
    {
        "id": "c1d99e64",
        "pattern": "1. Identify all horizontal and vertical lines in the input grid where every cell in the line has the same color.\n2. Change the color of every cell in each identified line to color\u202f2."
    },
    {
        "id": "c3e719e8",
        "pattern": "To generate the output grid from the input grid, follow these steps:\n\n1. **Identify Main Color Cells**: Locate all cells in the input grid that are colored with the main color (a specific color chosen from the available colors).\n\n2. **Determine Placement Positions**: For each cell identified in step 1 at position (i, j) in the input grid:\n   - Calculate the placement position in the output grid by multiplying the row index `i` by the input grid's height and the column index `j` by the input grid's width. This results in a new top-left position `(i * height, j * width)` for placing a copy of the input grid.\n\n3. **Copy and Place Grids**: \n   - Create a larger output grid sized to accommodate all copies based on the input grid's dimensions.\n   - At each calculated position from step 2, place a full copy of the input grid into the output grid.\n\n4. **Fill Background**: Fill all remaining cells in the output grid that are not covered by any copied input grids with the background color (typically color `0`).\n\nThis process results in the output grid being a tiled arrangement of the input grid copies, positioned wherever the main color was present in the original input grid."
    },
    {
        "id": "c3f564a4",
        "pattern": "To transform the input grid into the output grid, follow these steps:\n\n1. **Identify and Locate Rectangular Patches**: Detect all rectangular areas within the input grid that are filled with a specific fixed color.\n\n2. **Remove the Fixed-Color Rectangles**: Erase or clear each identified rectangular patch that contains the fixed color.\n\n3. **Retain the Main Pattern**: Ensure that only the original, unaltered pattern remains intact after the removal of the fixed-color rectangles.\n\nThe result is an output grid that displays the original pattern without any of the additional fixed-color rectangular disturbances."
    },
    {
        "id": "c444b776",
        "pattern": "1. Divide the input grid into a grid of equally sized small rectangular regions.\n2. Locate the single small region that contains some colored cells different from the background.\n3. Copy the pattern of the colored cells from this identified region.\n4. Apply this copied pattern to every small region in the grid.\n5. The output grid will have all small regions filled with the identical colored cell pattern."
    },
    {
        "id": "c59eb873",
        "pattern": "Each cell in the input grid is expanded into a 2\u00d72 block of the same color in the output grid, effectively doubling both the height and width of the grid."
    },
    {
        "id": "c8cbb738",
        "pattern": "1. **Initialize Grids**:\n   - Create an input grid (`gi`) filled entirely with a background color, having dimensions height `h` \u00d7 width `w`.\n   - Create an output grid (`go`) also filled with the same background color, but with smaller dimensions height `gh` \u00d7 width `gw`.\n\n2. **Define Color Selection**:\n   - Choose a background color (`bgc`) from a predefined set of colors.\n   - Select a list of `n` distinct colors (`ccols`) from the remaining available colors, excluding the background color.\n\n3. **Color the Output Grid**:\n   - Outline a rectangular border around the output grid `go`.\n   - Fill the four corner cells of this border with the first color from `ccols`.\n   - For each additional color in `ccols`, randomly select a subset of the border (excluding corners) ensuring that the selected cells span two opposite sides. Fill these selected border cells with the respective color.\n\n4. **Replicate Patterns in the Input Grid**:\n   - For each colored section in the output grid `go` (starting with the corners and then the additional border segments):\n     - Choose a random location within the input grid `gi` where the colored pattern can fit without exceeding the grid boundaries.\n     - Replicate the colored corner or border segment from `go` into the input grid `gi` at the chosen random location.\n\n5. **Finalize**:\n   - After all colors and their corresponding border segments have been placed, the input grid `gi` contains multiple instances of the colored border patterns randomly distributed within its larger area.\n   - The output grid `go` serves as a template, showcasing the fundamental rectangular border patterns with their assigned colors.\n\n**Summary**:\nThe transformation pattern takes a smaller, color-coded rectangular border from the output grid and places multiple random instances of this border within a larger input grid. Each colored section of the border in the output grid is replicated at random positions in the input grid, maintaining the relative arrangement and colors of the original border segments."
    },
    {
        "id": "c8f0f002",
        "pattern": "For each cell in the input grid, if the cell is colored with color\u202f7, change its color to\u202f5 in the output grid. All other cells remain unchanged."
    },
    {
        "id": "c909285e",
        "pattern": "Identify a rectangular area within the input grid that is filled entirely with a single color distinct from the background and other markings. Extract this rectangular region so that the output grid consists only of the contents of the identified rectangle."
    },
    {
        "id": "c9e6f938",
        "pattern": "To create the output grid, take the input grid and generate a horizontally flipped version of it. Then, place this mirrored grid directly to the right of the original input grid. The combination of the original grid and its horizontally flipped copy forms the output grid."
    },
    {
        "id": "c9f8e694",
        "pattern": "1. **Preserve the Leftmost Column:** Keep the leftmost column of the input grid unchanged.\n\n2. **Initialize the Main Area:** In the remaining area of the grid (excluding the leftmost column), fill it entirely with the background color (0).\n\n3. **Select a Square Color:** Choose a specific color (from colors 1 to 9) to be used for creating squares in the main area.\n\n4. **Place Random Squares:**\n   - Randomly determine the number of squares to place.\n   - For each square:\n     - Randomly select a top-left and bottom-right position within the main area to define the square's boundaries.\n     - Fill the defined square region with the chosen square color.\n\n5. **Overlay Scaled Left Column onto Squares:**\n   - For each placed square, horizontally scale the preserved leftmost column by duplicating its colors across the width of the square.\n   - Overlay this horizontally scaled column pattern onto the corresponding square region in the main area.\n\n6. **Combine Columns and Main Area:** Concatenate the preserved leftmost column with the modified main area to form the complete grid.\n\n7. **Apply Random Rotation:** Rotate the entire grid by a randomly selected multiple of 90 degrees (i.e., 0\u00b0, 90\u00b0, 180\u00b0, or 270\u00b0).\n\n8. **Output the Result:** The final grid after applying all the above transformations is the output grid."
    },
    {
        "id": "caa06a1f",
        "pattern": "To transform the input grid into the output grid, shift all colored objects one cell to the right horizontally while removing any additional horizontal and vertical lines present in the input."
    },
    {
        "id": "cbded52d",
        "pattern": "To transform the input grid into the output grid, follow these precise steps:\n\n1. **Identify the Grid Structure**:\n   - The input grid consists of multiple small blocks of a specific color (`bgc`) arranged in a regular, evenly spaced grid pattern on a different background color (`linc`).\n\n2. **Select Colors for Extensions**:\n   - Choose a subset of additional colors (`ccols`) from the available color palette, excluding the background and block colors.\n\n3. **Add Colored Extensions (Arms)**:\n   - For each selected color in `ccols`:\n     a. **Choose a Starting Block**:\n        - Randomly select one of the background blocks (`bgc`) from the input grid.\n     b. **Determine Number of Directions**:\n        - Randomly decide to extend 1 to 4 arms from the chosen block.\n     c. **Extend Arms in Random Directions**:\n        - For each arm:\n          i. **Select Direction**:\n             - Randomly choose a direction (up, down, left, or right).\n          ii. **Extend the Arm**:\n              - Extend the arm cell by cell in the chosen direction.\n              - Continue extending until reaching the edge of the grid or encountering another block.\n              - The length of each arm is randomly determined but ensures that each arm has at least one cell.\n          iii. **Color the Arm**:\n               - Paint each cell along the extended path with the selected color.\n     d. **Mark the Starting Block**:\n        - Color the originally selected background block with the current color to indicate the origin of the arms.\n\n4. **Finalize the Output Grid**:\n   - The output grid retains the original arrangement of colored blocks on the background.\n   - Additionally, it includes the newly added colored arms extending from some of the blocks in various directions.\n\nThis process results in an output grid that mirrors the input grid structure but features colorful extensions emanating from selected blocks, creating a more intricate and visually appealing pattern."
    },
    {
        "id": "cce03e0d",
        "pattern": "To generate the output grid from the input grid, follow these steps:\n\n1. **Identify Red Cells**: Locate all cells in the input grid that are colored red.\n\n2. **Copy and Position**: For each red cell found at row *i* and column *j* in the input grid:\n   - Create a duplicate of the entire input grid.\n   - Place this duplicate into the output grid such that its top-left corner is shifted downward by *i* times the input grid\u2019s height and rightward by *j* times the input grid\u2019s width.\n\n3. **Assemble Output**: Combine all the shifted copies within a larger grid. The final output grid will be sized to accommodate all these positioned copies, resulting in a patterned arrangement based on the original red cells' locations.\n\nThis process results in the output grid being a larger version composed of multiple copies of the input grid, each strategically placed according to the positions of the red cells in the original input."
    },
    {
        "id": "cdecee7f",
        "pattern": "Given an input grid filled entirely with a background color, perform the following steps to generate the output grid:\n\n1. **Select Columns:**\n   - Choose up to nine distinct columns from the input grid. Each selected column must contain exactly one cell that is colored differently from the background color.\n\n2. **Record Colors:**\n   - For each selected column, identify and record the color of the uniquely colored cell.\n\n3. **Pad Colors:**\n   - If fewer than nine colors have been recorded from the selected columns, append the background color to the list until there are exactly nine colors.\n\n4. **Arrange into Output Grid:**\n   - Organize the nine colors into a 3\u00d73 output grid as follows:\n     - **First Row:** Place the first three recorded colors in left-to-right order.\n     - **Second Row:** Place the next three recorded colors in right-to-left order.\n     - **Third Row:** Place the final three recorded colors in left-to-right order.\n\nThe resulting output grid will be a tuple of three tuples, each containing three colors arranged according to the steps above."
    },
    {
        "id": "ce22a75a",
        "pattern": "To transform the input grid into the output grid, follow these steps:\n\n1. **Identify Foreground Cells**: Locate all cells in the input grid that are colored with the foreground color.\n\n2. **Determine Neighbors**: For each identified foreground cell, find all its neighboring cells. Neighbors include cells that are horizontally, vertically, and diagonally adjacent.\n\n3. **Color Neighbors and Original Cells**: In the output grid, change the color of each neighboring cell and the original foreground cell to color\u202f1.\n\n4. **Retain Background**: Keep all other cells in the output grid unchanged, preserving their original background color."
    },
    {
        "id": "ce4f8723",
        "pattern": "To generate the output grid from the input grid, replace every cell that is colored either with cola or colb in the input grid with color 3. All other cells in the grid remain unchanged."
    },
    {
        "id": "ce602527",
        "pattern": "1. **Identify and Isolate the Upscaled Object**: Locate the object in the input grid that has been enlarged (scaled by a factor of two) and recolored differently from the other objects.\n\n2. **Remove the Upscaled Copy**: Eliminate the upscaled and recolored version of the identified object from the grid, leaving only the original objects.\n\n3. **Extract the Original Object**: Isolate the original version of the identified object from the remaining grid.\n\n4. **Recolor the Original Object**: Ensure the original object retains its initial color, restoring it if necessary.\n\n5. **Construct the Output Grid**: Create a new grid that contains only the original, correctly colored object against the original background, devoid of any upscaled or additional objects."
    },
    {
        "id": "ce9e57f2",
        "pattern": "For each vertical bar in the input grid, the upper half of the bar is recolored to color 8 in the output grid."
    },
    {
        "id": "cf98881b",
        "pattern": "To transform the input grid into the output grid, follow these precise steps:\n\n1. **Set Background**: Fill the entire grid with the background color.\n\n2. **Apply Color C**: Color all cells in the specified set **C** with color C.\n\n3. **Apply Color B**: Overwrite the cells in the specified set **B** with color B.\n\n4. **Apply Color A**: Finally, overwrite the cells in the specified set **A** with color A.\n\nThis results in the output grid where:\n- Cells in set **A** are colored with color A.\n- Cells in set **B** are colored with color B, unless they are also in set **A**.\n- Cells in set **C** are colored with color C, unless they are in set **A** or **B**.\n- All other cells remain the background color."
    },
    {
        "id": "d037b0a7",
        "pattern": "For each colored cell in the input grid, draw a vertical line from that cell down to the bottom of its column by filling all cells below it in the same column with the same color."
    },
    {
        "id": "d06dbe63",
        "pattern": "To transform the input grid into the output grid, follow these steps:\n\n1. **Identify Dots**: Locate each colored dot in the input grid.\n\n2. **Retain Dots**: Keep each identified dot unchanged in the output grid.\n\n3. **Add Surrounding Pattern**: For every retained dot, add additional cells around it in a symmetrical arrangement. This pattern consists of multiple cells positioned at specific offsets in all four cardinal directions (up, down, left, right) relative to the dot.\n\n4. **Coloring**: Color the newly added surrounding cells with a distinct color different from the background and the original dots.\n\n5. **Ensure Non-Overlap**: Place the surrounding patterns in such a way that they do not overlap with each other or extend beyond the grid boundaries.\n\nBy applying this consistent arrangement around each dot, the output grid displays the original dots enhanced with symmetric patterns around them."
    },
    {
        "id": "d07ae81c",
        "pattern": "1. **Divide the Grid into Rectangular Regions:** Start by partitioning the input grid into several large, non-overlapping rectangular areas.\n\n2. **Assign Two Distinct Colors:** Assign each of these rectangular regions one of two distinct colors.\n\n3. **Select Source Cells:** For each color group, randomly select multiple source cells within the regions, ensuring that no two source cells are adjacent to each other.\n\n4. **Draw Diagonal Lines from Sources:** From each selected source cell, extend diagonal lines in all four diagonal directions (northeast, northwest, southeast, southwest) across the grid.\n\n5. **Color the Diagonal Lines with New Colors:** Color the cells along these diagonal lines with two new distinct colors, different from the colors assigned to the rectangular regions.\n\n6. **Generate the Output Grid:** The final output grid will display the original colored rectangular regions overlaid with the newly drawn and colored diagonal lines."
    },
    {
        "id": "d0f5fe59",
        "pattern": "Count the number of distinct objects in the input grid. Then, create a square output grid with both height and width equal to this count. In the output grid, set all cells to the background color except for the cells along the diagonal from the top-left corner to the bottom-right corner, which are filled with the foreground color."
    },
    {
        "id": "d10ecb37",
        "pattern": "To obtain the output grid from the input grid, perform the following steps:\n\n1. **Locate the Top-Left Corner**: Identify the top-left corner of the input grid, which starts at row 0 and column 0.\n\n2. **Extract a 2x2 Subgrid**: From the top-left corner, select a subgrid that spans 2 rows and 2 columns.\n\n3. **Form the Output Grid**: The selected 2x2 subgrid becomes the output grid."
    },
    {
        "id": "d13f3404",
        "pattern": "To transform the input grid into the output grid, follow these steps:\n\n1. **Identify Starting Points**: Select a number of cells located along the top row and the leftmost column of the input grid.\n\n2. **Choose Target Cells**: For each selected starting cell, choose one cell along its diagonal extending down and to the right within the input grid.\n\n3. **Initialize Output Grid**: Create a new grid that is twice as tall and twice as wide as the input grid, filling all cells with a background color.\n\n4. **Draw Diagonal Lines**: In the output grid, for each chosen target cell from the input, draw a diagonal line extending down and to the right from the corresponding position in the larger grid. Use the same color as the target cell to fill all cells along each diagonal line.\n\n5. **Finalize Output**: Ensure all cells in the output grid that are not part of these diagonal lines remain set to the background color."
    },
    {
        "id": "d22278a0",
        "pattern": "Each colored corner in the input grid is expanded in the output grid by filling all cells that are closer to that corner than to any other colored corner with the corner's color. This creates distinct colored regions around each selected corner based on their proximity."
    },
    {
        "id": "d23f8c26",
        "pattern": "To create the output grid from the input grid, follow these steps:\n\n1. **Identify the Center Column:**\n   - Determine the middle column of the input grid.\n\n2. **Process Each Cell:**\n   - For every cell in the input grid:\n     - **If the cell is in the center column:**\n       - Retain its original color in the output grid.\n     - **Otherwise:**\n       - Set the cell's color in the output grid to the background color.\n\n3. **Finalize the Output Grid:**\n   - Ensure that all cells not in the center column are set to the background color, and only the cells in the center column reflect the colors from the input grid."
    },
    {
        "id": "d2abd087",
        "pattern": "For each distinct connected group of cells in the input grid, the output grid assigns the value\u202f2 if the group contains exactly six cells, and assigns the value\u202f1 otherwise. All background cells remain unchanged."
    },
    {
        "id": "d364b489",
        "pattern": "For each filled cell in the input grid:\n1. Keep the cell unchanged in the output grid.\n2. Fill the cell immediately to the left with color\u202f7.\n3. Fill the cell immediately to the right with color\u202f6.\n4. Fill the cell immediately below with color\u202f8.\n5. Fill the cell immediately above with color\u202f2.\nAll other cells remain as in the input grid."
    },
    {
        "id": "d406998b",
        "pattern": "To transform the input grid into the output grid, follow these steps:\n\n1. **Initialize the Output Grid**: Start with a grid of the same dimensions as the input grid, filled with the background color.\n\n2. **Process Each Column Individually**:\n   \n   a. **Select Dot Locations**: For each column in the input grid, randomly choose a number of cells to place dots. The number of dots selected for each column is between 1 and half the height of the grid (rounded down).\n   \n   b. **Identify Dot Positions**: Randomly select specific row positions within the column based on the number chosen in the previous step.\n   \n   c. **Fill Dots in the Input Grid**: In the input grid, color the selected cells in the current column with a designated dot color (`dotc`).\n   \n3. **Create the Output Grid with Alternating Dot Colors**:\n   \n   a. **Determine Column Parity**: For each column, check whether the column index relative to the grid's width is even or odd.\n   \n   b. **Color Dots Accordingly**:\n      - If the column is even (based on the parity check), retain the original dot color (`dotc`) in the output grid for the selected dot positions.\n      - If the column is odd, change the color of the dots in the output grid to color `3` for the same selected positions.\n\nThis process results in an output grid where dots alternate in color between the original dot color and color `3` across adjacent columns, while maintaining their positions as determined in the input grid."
    },
    {
        "id": "d43fd935",
        "pattern": "To transform the input grid into the output grid, follow these steps:\n\n1. **Identify the Central Rectangle:** Locate a central rectangular area within the input grid and fill it entirely with a specific color.\n\n2. **Add Colored Noise Cells:** Select several individual cells outside the central rectangle and assign each a different color from a predefined set of colors.\n\n3. **Draw Connecting Lines:**\n   - For each colored noise cell, determine its position relative to the central rectangle (above, below, to the left, or to the right).\n   - Draw a straight horizontal or vertical line from the noise cell directly towards the nearest edge of the central rectangle, ensuring the line is in the same color as the noise cell.\n\n4. **Finalize the Output Grid:** The output grid will display the central colored rectangle, the colored noise cells, and the straight lines connecting each noise cell to the central rectangle.\n\nThese precise and unambiguous steps ensure that each noise cell is visually connected to the central rectangle, maintaining consistency in colors and alignment."
    },
    {
        "id": "d4469b4b",
        "pattern": "To transform the input grid into the output grid, follow these steps:\n\n1. **Identify the Base Color:**\n   - Determine the primary color used to fill the entire input grid. This color will be either **1**, **2**, or **3**.\n\n2. **Select the Corresponding Output Pattern Based on the Base Color:**\n   \n   - **If the Base Color is 2:**\n     - **Top Row:** Fill all cells in the first row with color **5**.\n     - **Middle Row:** Fill only the center cell of the second row with color **5**; set the other cells to **0**.\n     - **Bottom Row:** Fill only the center cell of the third row with color **5**; set the other cells to **0**.\n     \n     **Resulting Output Grid:**\n     ```\n     5 5 5\n     0 5 0\n     0 5 0\n     ```\n\n   - **If the Base Color is 1:**\n     - **Corners:** Fill all four corner cells (top-left, top-right, bottom-left, bottom-right) with **0**.\n     - **Remaining Cells:** Fill all other cells with color **5**.\n     \n     **Resulting Output Grid:**\n     ```\n     0 5 0\n     5 5 5\n     0 5 0\n     ```\n\n   - **If the Base Color is 3:**\n     - **Bottom Row:** Fill all cells in the third row with color **5**.\n     - **Rightmost Column:** Fill all cells in the third column with color **5**.\n     - **Remaining Cells:** Set all other cells to **0**.\n     \n     **Resulting Output Grid:**\n     ```\n     0 0 5\n     0 0 5\n     5 5 5\n     ```\n\n3. **Apply the Selected Pattern:**\n   - Replace the input grid with the chosen 3x3 output pattern based on the identified base color.\n\nBy following these precise steps, the output grid is generated deterministically from the input grid based on its primary color."
    },
    {
        "id": "d4a91cb9",
        "pattern": "1. Locate the central positions of the cells colored with color 2 and color 8 in the input grid.\n2. Draw a horizontal line using color 4 from the center of the color 2 cell directly to align horizontally with the center of the color 8 cell.\n3. From the end of the horizontal line, draw a vertical line using color 4 down to the center of the color 8 cell.\n4. Ensure that the centers of the color 2 and color 8 cells remain unchanged."
    },
    {
        "id": "d4f3cd78",
        "pattern": "To transform the input grid into the output grid, follow these steps:\n\n1. **Identify the Box Outline:**\n   - Locate the rectangular box drawn with the foreground color within the input grid.\n   \n2. **Determine Hole Positions:**\n   - Find all positions along the box outline where the color is missing (these are the \"holes\").\n\n3. **Fill the Interior:**\n   - Fill the entire area inside the identified box with the color `8`.\n\n4. **Determine Directions for Holes:**\n   - For each hole in the box outline, determine the direction to extend a line based on its position relative to the box:\n     - **Top Side Holes:** Extend the line upwards.\n     - **Bottom Side Holes:** Extend the line downwards.\n     - **Left Side Holes:** Extend the line to the left.\n     - **Right Side Holes:** Extend the line to the right.\n     - **Corner Holes:** Extend the line diagonally outwards from the corner.\n\n5. **Draw Lines from Holes:**\n   - From each hole, draw a continuous line in the determined direction.\n   - Fill each cell along these lines with the color `8` until the edge of the grid is reached or another boundary condition is met.\n\nThe output grid will thus consist of:\n- A filled interior area of the box in color `8`.\n- Lines extending outward from each hole in directions based on their positions on the box outline, also in color `8`."
    },
    {
        "id": "d511f180",
        "pattern": "To transform the input grid to the output grid, follow these precise steps:\n\n1. **Identify Background Cells**: Determine which cells in the input grid are designated as background cells.\n\n2. **Swap Colors in Background**:\n   - For each background cell:\n     - If the cell is colored with **8**, change its color to **5** in the output grid.\n     - If the cell is colored with **5**, change its color to **8** in the output grid.\n\n3. **Retain Other Cells**: All non-background cells should remain unchanged in the output grid.\n\nIn summary, the pattern involves swapping the colors **8** and **5** specifically in the background cells while leaving all other cells untouched."
    },
    {
        "id": "d5d6de2d",
        "pattern": "To transform the input grid into the output grid, follow these steps:\n\n1. **Identify Colored Rectangles**: Locate all non-overlapping rectangular areas in the input grid that are filled with colors different from the background color.\n\n2. **Determine Rectangle Size**: For each identified rectangle, check if both its height and width are greater than two cells.\n\n3. **Color Inner Borders**: \n   - If a rectangle is larger than 2 rows in height and 2 columns in width, outline its inner perimeter by coloring those border cells with the color `3` in the output grid.\n   - If the rectangle does not meet the size criteria, leave the output grid unchanged for that area.\n\n4. **Maintain Background**: Ensure that all cells in the output grid not part of the inner borders of large rectangles retain the original background color.\n\nThis process results in an output grid where the background remains the same, and only the inner borders of sufficiently large colored rectangles from the input grid are highlighted with color `3`."
    },
    {
        "id": "d631b094",
        "pattern": "To transform the input grid into the output grid, follow these steps:\n\n1. **Count Filled Cells**: Determine the number of cells in the input grid that are colored with the foreground color (any color other than the background color, which is 0).\n\n2. **Create Output Grid**: Construct a new grid with a single row and a number of columns equal to the count of filled cells from the input grid.\n\n3. **Fill Output Grid**: Color each cell in the output grid with the same foreground color used in the input grid.\n\nIn summary, the output grid is a single horizontal row where each cell represents a filled cell from the input grid, all uniformly colored with the input's foreground color."
    },
    {
        "id": "d687bc17",
        "pattern": "To transform the input grid into the output grid, follow these steps:\n\n1. **Retain the Colored Borders**: Keep the four border lines of the input grid unchanged. Each border (top, left, right, bottom) is colored with a distinct color (c\u2081, c\u2082, c\u2083, c\u2084).\n\n2. **Identify and Relocate Dots**:\n   - **Top Border Dots (c\u2081)**: For every dot inside the grid colored with c\u2081, move it to the second row in its respective column.\n   - **Left Border Dots (c\u2082)**: For every dot inside the grid colored with c\u2082, move it to the second column in its respective row.\n   - **Right Border Dots (c\u2083)**: For every dot inside the grid colored with c\u2083, move it to the second-to-last column in its respective row.\n   - **Bottom Border Dots (c\u2084)**: For every dot inside the grid colored with c\u2084, move it to the second-to-last row in its respective column.\n\n3. **Remove Noise**: Eliminate any additional random colored cells (noise) present within the interior of the input grid, ensuring that only the relocated dots and the colored borders remain.\n\nThe output grid will thus maintain the original colored borders with all relevant dots repositioned adjacent to their corresponding borders, free from any internal noise."
    },
    {
        "id": "d6ad076f",
        "pattern": "To transform the input grid into the output grid, follow these steps:\n\n1. **Draw Two Rectangular Frames:**\n   - Create two rectangular outlines within the input grid using two distinct colors.\n   - The first rectangle spans from the top-left to a randomly chosen internal position.\n   - The second rectangle spans from a different internal position to the bottom-right.\n\n2. **Position the Frames:**\n   - Shift both rectangular frames to a random location within the grid, ensuring they fit within the grid boundaries.\n\n3. **Fill the Inner Area:**\n   - Inside the area bounded by the two frames, fill a smaller rectangular region with the color 8.\n\n4. **Optional Mirroring:**\n   - With a 50% chance, mirror the entire grid along the diagonal axis to create a symmetrical pattern.\n\nThis sequence results in the output grid having two distinct colored frames positioned randomly, with a filled inner region and possible diagonal symmetry."
    },
    {
        "id": "d89b689b",
        "pattern": "To transform the input grid into the output grid, follow these steps:\n\n1. **Identify the Central Block**: Locate a contiguous 2x2 area in the input grid that is filled entirely with a specific background color.\n\n2. **Select Surrounding Cells**: \n   - Divide the grid into four quadrants relative to the identified 2x2 block: top-left, top-right, bottom-left, and bottom-right.\n   - From each quadrant, select the nearest cell to the central block that is not filled with the background color.\n\n3. **Extract Colors**: Retrieve the colors from each of the four selected cells, one from each quadrant.\n\n4. **Fill the Central Block**: In the output grid, replace the original 2x2 background block with a new 2x2 block where each cell is filled with the corresponding color extracted from the selected cells in their respective quadrant positions.\n\n5. **Maintain Background**: Ensure that all other cells in the output grid remain filled with the original background color.\n\nThis process effectively moves four colored cells from their surrounding positions into the central 2x2 block, replacing the background color with these specific colors in their designated positions."
    },
    {
        "id": "d8c310e9",
        "pattern": "To create the output grid from the input grid, perform the following steps:\n\n1. **Replicate the Input Pattern Horizontally:** Copy the pattern present in the input grid and place multiple copies side by side across the output grid. Each copy is spaced apart by twice the width of the original pattern.\n\n2. **Overlay the Copies:** Overlay all the replicated copies onto the output grid, ensuring they are evenly distributed horizontally at the specified intervals.\n\n3. **Apply a Rotation:** Rotate the entire output grid by a random angle of 0\u00b0, 90\u00b0, 180\u00b0, or 270\u00b0.\n\nThis results in the output grid containing multiple, evenly spaced and rotated copies of the input pattern."
    },
    {
        "id": "d90796e8",
        "pattern": "In the input grid, find every cell colored with\u202f2 that is directly next to a cell colored with\u202f3 (horizontally or vertically). For each such pair, change the\u202f2-colored cell back to the background color and change the adjacent\u202f3-colored cell to color\u202f8 in the output grid."
    },
    {
        "id": "d9f24cd1",
        "pattern": "To transform the input grid into the output grid, follow these steps:\n\n1. **Draw Vertical Lines**: For each marked column in the input grid, draw a continuous vertical line from the bottom to the top of the grid in the output grid using the designated line color.\n\n2. **Handle Dots**: If a dot is present in a marked column:\n   - Interrupt the vertical line at the row where the dot is located.\n   - From the interruption point, extend the line diagonally to the adjacent column in the direction towards the top of the grid.\n\n3. **Apply Rotation**: Rotate the entire grid by 0\u00b0, 90\u00b0, 180\u00b0, or 270\u00b0 randomly to finalize the output grid.\n\nThis process ensures that all marked columns have vertical lines in the output grid, with lines branching diagonally at the positions of any dots present in the input grid."
    },
    {
        "id": "d9fac9be",
        "pattern": "To transform the input grid into the output grid, replace the entire input with a new grid consisting of a single cell. Set the color of this single cell to the noise color used in the input grid."
    },
    {
        "id": "dae9d2b5",
        "pattern": "To generate the output grid from the input grid, follow these steps:\n\n1. **Identify Colored Cells**: In the input grid, there are two distinct sections side by side. In the left section, certain cells are colored with a specific color (Color A), and in the right section, different cells are colored with another color (Color B). Ensure that at least one cell is colored in both sections.\n\n2. **Combine Colored Areas**: Determine all the cells that are colored either in the left section (Color A) or the right section (Color B).\n\n3. **Transform Colors**: In the output grid, change the color of all identified cells from either Color A or Color B to a new color, specifically Color 6.\n\n4. **Maintain Background**: Leave all other cells that were not colored in the input grid unchanged, maintaining their original background color.\n\n5. **Optional Mirroring**: With a 50% chance, mirror both the input and output grids along their diagonal before applying the above transformations.\n\nThis process ensures that the output grid highlights all areas that were originally colored in either section of the input grid by changing them to Color 6, while preserving the background."
    },
    {
        "id": "db3e9e38",
        "pattern": "To transform the input grid into the output grid, follow these steps:\n\n1. **Initialize the Grid**: Fill the entire grid with a selected background color.\n\n2. **Add the Main Bar**: Place a single horizontal bar with a specified thickness and a chosen foreground color at a random vertical and horizontal position within the grid.\n\n3. **Create Shifted Copies**:\n    - Generate multiple copies of the main bar by shifting it diagonally upwards to both the left and right.\n    - For each shift step, increase the shift distance by the bar's thickness.\n    - Alternate the color of each shifted bar between the original foreground color and color 8.\n\n4. **Apply Rotation**: Rotate the entire grid by a randomly chosen angle of 0\u00b0, 90\u00b0, 180\u00b0, or 270\u00b0.\n\nThis sequence results in the output grid having the original bar along with several diagonally shifted copies in alternating colors, all potentially rotated by a multiple of 90 degrees."
    },
    {
        "id": "db93a21d",
        "pattern": "For each colored object in the input grid, the output grid is created by surrounding that object with a border of color\u202f3 and drawing a horizontal line of color\u202f1 extending from the bottom edge of this border."
    },
    {
        "id": "dbc1a6ce",
        "pattern": "For each row in the input grid that has two or more cells colored with the foreground color, draw a horizontal line of color\u202f8 connecting the leftmost and rightmost foreground cells in that row. Additionally, for each column that contains two or more foreground-colored cells, draw a vertical line of color\u202f8 connecting the topmost and bottommost foreground cells in that column. All original foreground-colored cells remain unchanged in the output grid."
    },
    {
        "id": "dc0a314f",
        "pattern": "To transform the input grid into the output grid, follow these steps:\n\n1. **Select Two Positions**: Choose two specific locations within the input grid.\n\n2. **Determine Bounding Box**: Identify the smallest rectangular area that encompasses both selected positions.\n\n3. **Extract Subgrid**: Create the output grid by extracting the portion of the input grid that lies within the determined bounding box.\n\n4. **Fill Bounding Box Area**: In the input grid, replace all cells within the bounding box with the color value `3`.\n\n5. **Apply Rotation**: Rotate both the modified input grid and the extracted output grid by the same random angle. The rotation angle can be 0\u00b0, 90\u00b0, 180\u00b0, or 270\u00b0.\n\nThese steps ensure that the output grid represents the original content of the specified bounding box from the input grid before it was filled with color, maintaining any rotational symmetry applied."
    },
    {
        "id": "dc1df850",
        "pattern": "For each cell in the input grid that is colored with color\u202f2, identify all neighboring cells horizontally, vertically, and diagonally adjacent to it. If any of these neighboring cells are of the background color, change their color to\u202f1. All other cells remain unchanged. The resulting grid after these modifications is the output grid."
    },
    {
        "id": "dc433765",
        "pattern": "To transform the input grid into the output grid, follow these precise steps:\n\n1. **Choose a Transformation Type**:\n   - **Single Cell Movement**:\n     - Identify a single source cell in the input grid.\n     - In the output grid, move this source cell one position diagonally down and to the right.\n     - Ensure that a specific endpoint cell remains filled with color 4 in both input and output grids.\n   \n   - **Horizontal Segment Shift**:\n     - Select a horizontal line segment of at least three consecutive source-colored cells in a random row of the input grid.\n     - In the output grid, shift the entire horizontal segment one position to the right.\n     - Maintain the endpoint cell of this segment with color 4 in both input and output grids.\n\n2. **Apply Geometric Transformations** *(Optional)*:\n   - Optionally apply one or two geometric transformations such as rotation (90\u00b0, 180\u00b0, or 270\u00b0), horizontal mirroring, or vertical mirroring to both the input and output grids. These transformations should be consistent for both grids to preserve the relative movement pattern.\n\nBy following these steps, the output grid is derived by either moving a single source cell diagonally or shifting a horizontal segment to the right, while keeping designated endpoint cells unchanged. Any applied geometric transformations ensure variation in grid orientation or reflection without altering the core movement pattern."
    },
    {
        "id": "ddf7fa4f",
        "pattern": "To transform the input grid into the output grid, follow these steps:\n\n1. **Identify Each Rectangle:**\n   - Locate each distinct rectangular region in the input grid that is filled with a color different from the background.\n\n2. **Determine the Rectangle's Color:**\n   - Within the first row of each identified rectangle, find the specific cell that has a color different from the background color.\n   - Note the color of this specific cell.\n\n3. **Color the Entire Rectangle:**\n   - In the output grid, fill the entire corresponding rectangular region with the color identified from the specific cell in the input grid.\n\n4. **Maintain Background:**\n   - Ensure that all areas of the grid not covered by these rectangles retain the original background color.\n\nBy following these steps, each rectangle in the input grid is uniformly colored in the output grid based on the designated color from its first row."
    },
    {
        "id": "de1cd16c",
        "pattern": "To convert the input grid to the output grid, follow these steps:\n\n1. **Identify Large Regions**: Locate all distinct continuous colored areas (objects) in the input grid that have a height or width greater than five cells.\n\n2. **Calculate Allowances**: For each identified large region, compute an allowance by multiplying its height minus two by its width minus two, then divide the result by two. Ensure that each allowance is at least one.\n\n3. **Determine Average Allowance**: Calculate the average allowance across all large regions. If the average is less than one, set it to one.\n\n4. **Assign Noise Counts**: For each large region, randomly choose a number of noise placements. This number should be between zero and the smaller of the region's individual allowance and the average allowance calculated in the previous step.\n\n5. **Ensure Minimum Noise**: Verify that at least one region has at least one noise placement. If not, repeat the noise assignment step until this condition is met.\n\n6. **Select Dominant Color**: Identify the region(s) with the highest number of noise placements. Select the color of the first such region as the dominant color.\n\n7. **Apply Noise**: For each region, place the assigned number of noise cells within the inner area of its bounding box (excluding the borders). This is done by randomly selecting cells inside this area and changing their color to a predefined noise color.\n\n8. **Generate Output**: Create the output grid as a single cell colored with the dominant color determined in the previous steps."
    },
    {
        "id": "ded97339",
        "pattern": "To transform the input grid into the output grid:\n\n1. **Connect Rows Horizontally**:\n   - For each row in the input grid, identify the leftmost and rightmost dots.\n   - Draw a horizontal line connecting these two dots within the row.\n\n2. **Connect Columns Vertically**:\n   - For each column in the input grid, identify the topmost and bottommost dots.\n   - Draw a vertical line connecting these two dots within the column.\n\nThe resulting output grid will have horizontal lines linking the extreme dots in each row and vertical lines linking the extreme dots in each column."
    },
    {
        "id": "e179c5f4",
        "pattern": "1. **Transform the Original Line**: Apply one or two random operations\u2014such as rotating the line by 90\u00b0, 180\u00b0, or 270\u00b0, or mirroring it horizontally or vertically\u2014to the single line present in the input grid.\n\n2. **Add Mirrored Copies**:\n   - **Horizontal Mirror**: If adding a horizontal mirror, create a copy of the transformed line reflected across the vertical axis of the grid.\n   - **Vertical Mirror**: If adding a vertical mirror, create a copy of the transformed line reflected across the horizontal axis of the grid.\n   - **Both Mirrors**: If adding both, create copies reflected across both the vertical and horizontal axes.\n\n   The number of mirrored copies added depends on a randomly selected number between 1 and 4, allowing for up to three additional lines.\n\n3. **Update Background Color**: Change all cells that were originally the background color to the color value 8 in the output grid.\n\n**Summary**: Starting with a single line on a uniform background, the pattern transforms the line through rotation and/or mirroring, adds additional mirrored lines based on random selection, and updates the background color to produce the output grid."
    },
    {
        "id": "e21d9049",
        "pattern": "To transform the input grid into the output grid, follow these steps:\n\n1. **Initialize the Grid**: Start with a grid filled entirely with a chosen background color.\n\n2. **Draw the Initial Bars**:\n   - **Vertical Bar**: Draw a vertical line (bar) of a specified height and width at a random vertical and horizontal position within the grid.\n   - **Horizontal Bar**: Draw a horizontal line (bar) of a specified width and height at a different random vertical and horizontal position within the grid.\n\n3. **Modify Specific Cells**: Change the color of certain cells within both the vertical and horizontal bars to a different chosen color. This introduces variation into the pattern.\n\n4. **Replicate the Vertical Bar**:\n   - Copy the original vertical bar and shift it downward by intervals equal to its height.\n   - Similarly, copy and shift the vertical bar upward by the same interval.\n   - Continue this replication until the entire grid is filled vertically with evenly spaced vertical bars.\n\n5. **Replicate the Horizontal Bar**:\n   - Copy the original horizontal bar and shift it to the right by intervals equal to its width.\n   - Similarly, copy and shift the horizontal bar to the left by the same interval.\n   - Continue this replication until the entire grid is filled horizontally with evenly spaced horizontal bars.\n\n6. **Combine Replications**: Overlay all the replicated vertical and horizontal bars onto the grid. The intersections of these bars form a grid-like pattern with regularly spaced lines.\n\nThe resulting output grid consists of multiple evenly spaced vertical and horizontal lines, each having specific cells with altered colors, creating a consistent and repeating tiled pattern across the entire grid."
    },
    {
        "id": "e26a3af2",
        "pattern": "1. **Identify Vertical Strips:** Locate each vertical colored region (strip) within the input grid.\n\n2. **Ensure Dominant Colors in Edges:** For every identified strip, make sure that at least half of the cells in both the first and last rows of the strip are filled with the strip's original color.\n\n3. **Remove Noise:** Within each strip, change all cells that do not match the strip's original color back to the original color, effectively eliminating any noise or unintended color variations.\n\n4. **Apply Optional Mirroring:** Optionally, flip the entire grid along its diagonal axis to produce a mirrored version of the cleaned grid."
    },
    {
        "id": "e3497940",
        "pattern": "1. **Initialize the Grid**: Start with a blank grid filled with a background color.\n\n2. **Select Colors**:\n   - Choose two distinct colors: one for the background (`bgc`) and one as a barrier (`barc`).\n   - From the remaining colors, randomly select a subset (`ccols`) to be used for drawing lines.\n\n3. **Determine Grid Dimensions**:\n   - Randomly set the grid's height (`h`) between 4 and 30 units.\n   - Randomly set the grid's width (`w`) between 3 and 14 units.\n\n4. **Choose Rows for Lines**:\n   - Randomly select a number of rows (`nlinesocc`) where horizontal lines will be drawn within the grid's height.\n\n5. **Draw Horizontal Lines**:\n   - For each selected row:\n     a. **Random Length**: Choose a random length (`j`) for the horizontal line segment, ensuring it fits within the grid's width.\n     b. **Color Selection**: Assign a color to each cell in the segment by randomly picking from the selected color subset (`ccols`).\n     c. **Split the Segment**:\n        - Randomly decide a split point (`slen`) to divide the segment into two parts.\n        - Optionally swap the two parts based on a random choice.\n     d. **Paint the Grid**:\n        - Paint the full segment on the right side of the grid.\n        - Paint the partial segment on the left side of the grid.\n\n6. **Assemble the Input Grid**:\n   - **Left Side**: Vertically mirror the partially painted left segments.\n   - **Center Barrier**: Insert a vertical column filled with the barrier color (`barc`).\n   - **Right Side**: Add the fully painted right segments.\n   - Concatenate these three parts horizontally to form the input grid (`gi`).\n\n7. **Generate the Output Grid**:\n   - Vertically mirror the grid containing all fully painted lines (`go`) to create the output grid.\n\n8. **Final Output**:\n   - The input grid displays partially painted lines on the left and fully painted lines on the right, separated by a barrier.\n   - The output grid shows the fully painted lines mirrored vertically."
    },
    {
        "id": "e40b9e2f",
        "pattern": "1. **Select a Region:** Choose a square area within the input grid at a random position, ensuring the square is sized between 4\u00d74 and slightly smaller than the grid's dimensions to fit comfortably.\n\n2. **Set Background Color:** Fill the entire selected square region with a randomly chosen background color from a predefined set of colors.\n\n3. **Define Central Area and Rings:** Within this square, identify the central portion and create one or more concentric square rings around it. The number of rings is randomly determined based on the size of the square.\n\n4. **Select and Color Cells:** Randomly pick several cells within the central area, ensuring that the selection does not exhibit horizontal or vertical symmetry. Assign each selected cell a randomly chosen color different from the background colors.\n\n5. **Apply Rotational Variations:** Rotate the colored pattern 90 degrees clockwise four times. After each rotation, apply the rotated colors back onto the square region to introduce rotational symmetry and complexity.\n\n6. **Recolor Central Cells:** Change the color of the central cells to a new randomly selected color, differentiating them from the previously assigned colors.\n\n7. **Split and Rotate Groups:** Divide the colored cells into one to four separate groups randomly. For each group, perform an additional 90-degree clockwise rotation and paint the rotated group back onto the square region. This step adds further variation and breaks potential symmetry.\n\n8. **Final Rotation:** Apply a random final rotation (0\u00b0, 90\u00b0, 180\u00b0, or 270\u00b0) to the entire square region to randomize its orientation within the grid.\n\n9. **Integrate into Output Grid:** Place the fully transformed and rotated square region back onto the original input grid at the position where it was initially selected, resulting in the output grid with the newly patterned region."
    },
    {
        "id": "e48d4e1a",
        "pattern": "To obtain the output grid from the input grid, shift the horizontal line downward and the vertical line to the right by the same number of cells, effectively moving their intersection diagonally. Then, rotate the entire grid by a randomly chosen multiple of 90 degrees."
    },
    {
        "id": "e5062a87",
        "pattern": "1. **Identify the Target Shape:** Examine the input grid to find all connected groups of cells that match a specific predefined shape (the object).\n\n2. **Recolor Each Shape:** For every identified group of cells that form the target shape, change the color of each cell within that group to a designated color called `objc`.\n\n3. **Maintain Other Cells:** Leave all other cells in the grid unchanged, ensuring that only the identified shapes are recolored while the rest of the grid remains as in the input."
    },
    {
        "id": "e509e548",
        "pattern": "1. **Identify Objects:** Locate each distinct object in the input grid, categorizing them as either L-shaped, U-shaped, or H-shaped.\n\n2. **Determine Shape Type:** For every identified object, determine whether it is an L-shape, U-shape, or H-shape.\n\n3. **Place Objects in Output:** In the output grid, place each object in the exact same position as it appears in the input grid.\n\n4. **Assign Colors Based on Shape:**\n   - **L-shaped objects:** Color them with color **1**.\n   - **U-shaped objects:** Color them with color **6**.\n   - **H-shaped objects:** Color them with color **2**.\n\n5. **Maintain Background:** Ensure that the background color of the grid remains unchanged from the input to the output grid."
    },
    {
        "id": "e50d258f",
        "pattern": "To obtain the output grid from the input grid, follow these steps:\n\n1. **Identify the First Colored Rectangle**: Locate the first rectangular region in the input grid that has a distinct color different from the background.\n\n2. **Preserve the Rectangle's Colors**: Retain all the original colors of this identified rectangle in the output grid.\n\n3. **Highlight Specific Cells**: Within this rectangle, select a subset of cells and change their color to a marker color (e.g., color 2) to highlight them.\n\n4. **Set All Other Cells to Background**: Change the color of every cell outside this first rectangle to the background color, effectively removing all other colored regions from the output grid.\n\nThe result is an output grid that exclusively displays the first colored rectangle from the input grid with certain cells highlighted, while all other areas revert to the background color."
    },
    {
        "id": "e6721834",
        "pattern": "1. **Divide the Input Grid:** Split the input grid vertically into two equal sections, each with a distinct background color.\n\n2. **Place Rectangular Regions in Each Section:**\n   - In both the top and bottom sections, randomly place multiple rectangular areas. Each rectangle has a randomly chosen height and width within specified limits.\n   - Fill each rectangular area entirely with a designated square color.\n\n3. **Recolor Subsets Within Rectangles:**\n   - Within each filled rectangle, randomly select a subset of cells.\n   - Change the color of these selected cells to randomly chosen colors different from both background and square colors.\n\n4. **Apply Identical Transformations:**\n   - Apply the same geometric transformations (such as rotations by 90\u00b0, 180\u00b0, 270\u00b0, horizontal/vertical mirroring, or diagonal mirroring) to both the top and bottom sections of the input grid.\n\n5. **Generate the Output Grid:**\n   - Extract the transformed colored subsets from the bottom section of the input grid.\n   - Assemble these extracted parts into a new grid, maintaining their transformed positions and colors.\n\n**Summary:**  \nTo transform the input grid into the output grid, the process involves splitting the grid into two sections with different backgrounds, randomly placing and coloring rectangular regions in each section, applying the same geometric transformations to both sections, and then extracting the transformed colored parts from the second section to form the output grid."
    },
    {
        "id": "e73095fd",
        "pattern": "1. Start with the input grid filled entirely with a background color.\n2. Draw several horizontal or vertical lines of a different foreground color across large areas of the grid, ensuring each line is at least three cells away from the grid's edges.\n3. Identify intersection points where these foreground lines meet specific neighborhood conditions.\n4. At each selected intersection point:\n   - Surround the intersection with a small box by filling the surrounding cells with the background color.\n   - Fill the cells within the box with the foreground color.\n   - Mark the area surrounding the box with a distinct color (e.g., color 4) in the output grid.\n5. Remove the outermost rows and columns from the grid to finalize the output.\n6. The resulting grid is the output grid, which now contains structured lines and marked boxes based on the modifications."
    },
    {
        "id": "e76a88a6",
        "pattern": "To transform the input grid into the output grid:\n\n1. **Identify the Main Shape**: Locate the single colored shape present in the input grid on a uniform background.\n2. **Create Colored Copies**: Generate multiple copies of this main shape, assigning each copy a different random color.\n3. **Randomly Place Copies**: Distribute each colored copy at distinct, non-overlapping locations on the grid.\n4. **Assemble Output Grid**: Combine the background with all the colored shape copies, resulting in the output grid that displays the original shape along with its colored duplicates."
    },
    {
        "id": "e8593010",
        "pattern": "To transform the input grid into the output grid, follow these precise steps:\n\n1. **Identify Patterns**:\n   - **Single Cell**: Locate every individual cell in the input grid.\n   - **Pairs**: Find every horizontal or vertical pair of adjacent cells.\n   - **Larger Shapes**: Detect predefined larger patterns, such as specific L-shaped or other multi-cell configurations.\n\n2. **Assign Colors Based on Pattern Type**:\n   - **Single Cells**: Change the color of each single cell to color **3** in the output grid.\n   - **Pairs**: Change the color of each horizontal or vertical pair of cells to color **2** in the output grid.\n   - **Larger Shapes**: Change the color of each larger predefined pattern to color **1** in the output grid.\n\n3. **Maintain Background**:\n   - All cells that do not match any of the above patterns remain unchanged, retaining the original background color.\n\nIn summary, the transformation maps specific shapes in the input grid to designated colors in the output grid, ensuring that each pattern type is consistently colored while preserving the background."
    },
    {
        "id": "e8dc4411",
        "pattern": "1. **Identify the Main Object:** Locate and select the primary object present in the input grid.\n\n2. **Determine Shift Distance:** Based on the size of the main object, calculate a fixed diagonal shift distance.\n\n3. **Place Shifted Copies:** Iteratively place copies of the main object on the grid, each shifted diagonally by the determined distance from the previous copy. Continue this process up to 30 times or until no additional copies can be placed without overlapping.\n\n4. **Apply Rotation:** Rotate the entire grid by a randomly chosen angle of 0\u00b0, 90\u00b0, 180\u00b0, or 270\u00b0.\n\nThe final grid after these steps is the output grid."
    },
    {
        "id": "e9614598",
        "pattern": "To transform the input grid into the output grid, follow these steps:\n\n1. **Identify the Two Distinct Cells:**\n   - Locate the two cells that have the same distinct color different from the background and are positioned on the same row.\n\n2. **Determine the Central Cell:**\n   - Find the cell that is horizontally centered between these two distinct cells.\n\n3. **Modify the Output Grid:**\n   - Retain all cells from the input grid unchanged.\n   - In the output grid, set the central cell and its four directly adjacent cells (above, below, left, and right) to color 3.\n\n4. **Optional Mirroring:**\n   - With a 50% probability, transpose the entire grid along its main diagonal (mirror the grid diagonally)."
    },
    {
        "id": "e98196ab",
        "pattern": "Given an input grid with two colored regions separated by a horizontal line:\n1. Remove the horizontal line that divides the grid.\n2. Combine the top and bottom regions into a single grid, keeping each region's original color unchanged."
    },
    {
        "id": "e9afcf9a",
        "pattern": "For each column in the input grid, copy it unchanged to the output grid if its position is even, and copy it in reverse order if its position is odd. This alternates the direction of each column across the grid."
    },
    {
        "id": "ea32f347",
        "pattern": "To transform the input grid into the output grid, follow these precise steps:\n\n1. **Maintain the Background:**\n   - Keep the entire grid filled with the original background color unchanged.\n\n2. **Identify Three Lines:**\n   - Locate three distinct lines within the input grid. Each line can be either horizontal or vertical and has a specific length determined by parameters `a`, `b`, and `c`.\n\n3. **Recolor the Lines:**\n   - **First Line:** Change its color to **1**.\n   - **Second Line:** Change its color to **4**.\n   - **Third Line:** Change its color to **2**.\n\n4. **Ensure Line Placement:**\n   - Position each recolored line in the same location and orientation as their corresponding lines in the input grid.\n\nBy following these steps, the output grid will have the same structural lines as the input grid, but with the first, second, and third lines colored specifically with colors 1, 4, and 2 respectively, while the background remains consistent."
    },
    {
        "id": "ea786f4a",
        "pattern": "To transform the input grid into the output grid, follow these steps:\n\n1. **Identify the Central Cell**: Locate the central cell of the grid based on its height and width.\n\n2. **Draw Four Diagonal Lines**: From the central cell, extend four diagonal lines in all four diagonal directions:\n   - **Up-Left Diagonal**: Extend the line upwards and to the left.\n   - **Up-Right Diagonal**: Extend the line upwards and to the right.\n   - **Down-Left Diagonal**: Extend the line downwards and to the left.\n   - **Down-Right Diagonal**: Extend the line downwards and to the right.\n\n3. **Fill the Diagonal Lines with a Specific Color**: Change the color of all cells along each of the four diagonal lines to a chosen color.\n\nAll other cells in the grid remain unchanged."
    },
    {
        "id": "eb281b96",
        "pattern": "To obtain the output grid from the input grid, follow these steps:\n\n1. **Create a horizontally mirrored version of the input grid**, excluding its last row.\n2. **Stack this mirrored grid below the original input grid**.\n3. **Create a horizontally mirrored version of the new combined grid**, excluding its last row.\n4. **Stack this second mirrored grid below the combined grid from step 2**.\n\nThe resulting grid after these steps is the output grid."
    },
    {
        "id": "eb5a1d5d",
        "pattern": "To transform the input grid into the output grid, follow these steps:\n\n1. Create a square grid with an odd number of rows and columns based on a chosen size.\n2. Select a specific number of distinct colors from a predefined range.\n3. For each selected color, place a box at two symmetric positions along both the main diagonal and the anti-diagonal of the grid.\n4. Ensure that each pair of symmetric boxes is filled with the same color.\n5. Leave the remaining cells of the grid with a default background color.\n\nThe resulting output grid will display multiple colored boxes arranged symmetrically along both diagonals against a uniform background."
    },
    {
        "id": "ec883f72",
        "pattern": "1. **Start with a blank grid filled with a background color.**\n\n2. **Select a rectangular area within the grid and fill it with a specific square color.**\n\n3. **Draw a double border around this colored rectangle using a different line color.**\n\n4. **From each corner of the outer double border, extend diagonal lines outward in four directions (down-right, up-left, down-left, and up-right).**\n\n5. **Color these diagonal lines with the same square color, but only where the grid still has the background color.**\n\nThe final output grid will display a central colored rectangle with a double-colored border and four diagonal lines radiating outward from each corner of the outer border."
    },
    {
        "id": "ecdecbb3",
        "pattern": "Start with a grid filled with a background color. Add several horizontal lines of one color, ensuring each line is separated by at least two rows. Then, place a number of dots of a second color on rows that do not contain horizontal lines and ensure that no two dots are in adjacent columns. For each dot, draw a vertical line connecting it to the nearest horizontal line above or below. Additionally, color the cells adjacent to each connection point with the line color. Finally, optionally mirror the entire grid horizontally."
    },
    {
        "id": "ed36ccf7",
        "pattern": "Rotate the input grid 90 degrees counter-clockwise to produce the output grid."
    },
    {
        "id": "ef135b50",
        "pattern": "To transform the input grid into the output grid, follow these steps:\n\n1. **Identify Colored Regions**: Locate all non-overlapping, non-adjacent rectangular areas in the input grid that are filled with colors different from the background.\n\n2. **Find Horizontally Aligned Pairs**: For every pair of these colored rectangles that share at least one common row, determine the smallest rectangular area that completely encompasses both rectangles.\n\n3. **Select Background Cells Within Encompassing Areas**: Within each of these encompassing rectangles, identify all cells that are part of the background (i.e., cells that were not part of the original colored rectangles) and exclude the border of the encompassing rectangle.\n\n4. **Fill Selected Background Cells with Color 9**: Change the color of the selected background cells within each encompassing area to color 9.\n\nThe resulting output grid will highlight the regions between horizontally aligned colored rectangles by coloring the intervening background areas with color 9."
    },
    {
        "id": "f15e1fac",
        "pattern": "1. **Identify Marked Positions:** In the input grid, some cells in the top row are colored with a line color, and some cells in the first column are colored with a specific color other than the background.\n2. **Draw Connecting Lines:** For each colored cell in the first column, draw a vertical line starting from that cell downward to just before the next colored cell in the column. Each subsequent vertical line is shifted one column to the right relative to the previous line.\n3. **Apply Geometric Transformations:** Randomly apply one or two geometric transformations (such as rotations or reflections) to the entire grid to produce the final output grid."
    },
    {
        "id": "f1cefba8",
        "pattern": "Given an input grid featuring a colored rectangular border and an inner border, first randomly select several non-corner cells from the inner border. For each selected cell, extend a full horizontal line across its entire row or a full vertical line down its entire column. In the output grid, fill all background cells along these extended lines with the inner color, and change any inner color cells that lie on these lines to the border color."
    },
    {
        "id": "f25fbde4",
        "pattern": "To transform the input grid into the output grid:\n\n1. **Remove Empty Borders**: Eliminate all rows and columns that are completely filled with the background color.\n\n2. **Enlarge the Grid**: Scale up the resulting grid by a factor of two in both dimensions, replacing each cell with a 2\u00d72 block of the same color."
    },
    {
        "id": "f25ffba3",
        "pattern": "To obtain the output grid from the input grid:\n\n1. **Extract the Left Section**: Take the left half of the input grid.\n\n2. **Create a Vertical Mirror**: Vertically mirror this left section.\n\n3. **Concatenate Horizontally**: Place the original left section next to its vertically mirrored version, aligning them side by side horizontally.\n\n4. **Optional Mirroring**: With a 50% chance each, optionally apply a vertical mirror and/or a horizontal mirror to the entire concatenated grid.\n\nThis results in the output grid by combining the original pattern with its vertical reflection, potentially further mirrored horizontally and/or vertically."
    },
    {
        "id": "f2829549",
        "pattern": "To transform the input grid into the output grid, follow these steps:\n\n1. **Identify Sections**:\n   - Divide the input grid vertically into three parts:\n     - **Left Section**: The first part of the grid.\n     - **Central Bar**: A single-column-wide section separating the left and right sections.\n     - **Right Section**: The last part of the grid.\n\n2. **Maintain Colored Regions**:\n   - In the **Left Section**, certain cells are filled with a specific color (`acol`).\n   - In the **Right Section**, certain cells are filled with another specific color (`bcol`).\n   - The **Central Bar** is filled with a distinct color (`linc`).\n\n3. **Modify the Output Grid**:\n   - Start with a blank grid of the same height as the input, but only the width of one of the colored sections.\n   - In this output grid, set all cells that are **not** part of the colored regions (`acol` in the left and `bcol` in the right) to the color `3`.\n   - The cells that are part of the colored regions remain unchanged.\n\n4. **Optional Mirroring**:\n   - With a 50% probability, apply a diagonal mirror to both the input and output grids. This flips the grids along their diagonal axis.\n\nBy following these steps, the output grid highlights the areas not occupied by the two distinct colored regions from the input grid by filling them with the color `3`, while optionally mirroring the entire pattern."
    },
    {
        "id": "f35d900a",
        "pattern": "1. **Retain the Background and Corners:**\n   - Keep the entire grid filled with the original background color.\n   - Identify the rectangular box within the grid.\n   - In this box, color the top-left and lower-right corners with color\u202f**c\u2081**.\n   - Color the top-right and lower-left corners of the box with color\u202f**c\u2082**.\n\n2. **Color Adjacent Cells to Specific Corners:**\n   - **For Color\u202fc\u2081:**\n     - Fill all cells neighboring the top-right and lower-left corners of the box with color\u202f**c\u2081**.\n   - **For Color\u202fc\u2082:**\n     - Fill all cells neighboring the top-left and lower-right corners of the box with color\u202f**c\u2082**.\n\n3. **Fill Specific Interior Cells with Color\u202f5:**\n   - For each of the four corners of the box:\n     - Identify the region within the box that is closest to that corner.\n     - Within this region, locate all cells that are at an even Manhattan distance greater than one from the corner.\n     - Fill these identified cells with color\u202f**5**."
    },
    {
        "id": "f5b8619d",
        "pattern": "To transform the input grid into the output grid, follow these steps:\n\n1. **Identify Colored Columns**: For each column in the input grid that contains one or more colored cells, proceed to the next step.\n\n2. **Fill Columns with Color 8**: In each identified column, change the color of every cell to color 8, except for the cells that were originally colored.\n\n3. **Duplicate the Grid**: Create the output grid by placing four copies of this modified grid arranged in a 2x2 layout, effectively doubling the grid both horizontally and vertically."
    },
    {
        "id": "f76d97a5",
        "pattern": "To transform the input grid into the output grid, follow these steps:\n\n1. **Select a Color:** Choose a specific color from the set {1, 2, 3, 4, 6, 7, 8, 9}.\n2. **Determine the Number of Cells:** Decide on a number of cells to modify. This number should be either up to half the total number of cells in the grid or at least half the total number of cells.\n3. **Modify the Input Grid:**\n   - Fill the entire input grid with the color 5.\n   - Randomly select the determined number of cells and change their color to the chosen color from step 1.\n4. **Create the Output Grid:**\n   - Fill the entire output grid with the color selected in step 1.\n   - Change the color of the same selected cells to 0.\n\nThis results in the output grid being entirely filled with the chosen color except for the specific cells, which are set to 0."
    },
    {
        "id": "f8a8fe49",
        "pattern": "To transform the input grid into the output grid, follow these steps:\n\n1. **Identify the Main Object**: Locate the primary object within the input grid.\n\n2. **Horizontal Reflection**: Reflect the identified object horizontally, creating a mirror image of it.\n\n3. **Optional Diagonal Reflection**: With a 50% probability, additionally reflect the horizontally mirrored object diagonally.\n\n4. **Placement**: Position the transformed object in the same location on a background grid to form the output grid.\n\nThe output grid is thus a horizontally mirrored version of the input object, possibly further mirrored diagonally, while the background remains unchanged."
    },
    {
        "id": "f8b3ba0a",
        "pattern": "To transform the input grid into the output grid, follow these precise steps:\n\n1. **Initialize the Grid**:\n   - Start with a grid entirely filled with a background color.\n\n2. **Place Regular Patches**:\n   - Arrange multiple non-overlapping rectangular patches of a secondary color at evenly spaced intervals across the grid.\n\n3. **Select New Colors**:\n   - Choose a set of distinct colors from a predefined palette, excluding the background and secondary colors.\n\n4. **Assign Colors to Patches**:\n   - For each selected new color, randomly assign it to a specific number of existing patches, ensuring each color is used a designated number of times.\n\n5. **Apply Diagonal Mirroring**:\n   - Reflect the entire arrangement of colored patches across the grid's main diagonal, effectively mirroring their positions from top-left to bottom-right.\n\n6. **Finalize the Output Grid**:\n   - The resulting grid maintains the original background color, with certain patches now recolored with the new colors and their positions mirrored diagonally."
    },
    {
        "id": "f8c80d96",
        "pattern": "To transform the input grid into the output grid, follow these steps:\n\n1. **Identify the Central Rectangle**: Locate the central rectangular area within the input grid.\n\n2. **Generate Concentric Borders**: Surround the central rectangle with multiple concentric rectangular outlines, each expanded outward by fixed horizontal and vertical offsets.\n\n3. **Fill All Borders**: Ensure that every generated concentric rectangular border is filled with the same specific color.\n\n4. **Set Background Color**: Change all cells outside the outermost concentric border to a fixed background color (for example, color 5).\n\nThis process ensures that the output grid contains a fully bordered central rectangle with all surrounding rectangular outlines filled consistently, and the background is uniformly set to the specified color."
    },
    {
        "id": "f8ff0b80",
        "pattern": "To transform the input grid into the output grid, follow these steps:\n\n1. **Identify Objects**: Detect each distinct colored object present on the input grid, distinguishing them from the background.\n\n2. **Record Colors**: For every identified object, note its specific color.\n\n3. **Create Output List**: Arrange all recorded colors into a single vertical column, where each row of the output grid contains the color of one object from the input grid."
    },
    {
        "id": "f9012d9b",
        "pattern": "To transform the input grid into the output grid, follow these precise steps:\n\n1. **Select a Rectangular Region:**\n   - Choose a rectangular area within the input grid by specifying its top-left corner coordinates and determining its height and width.\n\n2. **Extract the Selected Region:**\n   - Remove the chosen rectangular region from the input grid. This extracted region becomes the output grid.\n\n3. **Replace the Extracted Area with Background:**\n   - In the input grid, fill the area where the rectangular region was removed with the background color (typically black).\n\n4. **Apply a Consistent Transformation:**\n   - Apply the same rotation or mirroring transformation (such as 90\u00b0, 180\u00b0, 270\u00b0 rotations or horizontal/vertical/diagonal flips) to both the modified input grid and the output grid.\n\nThe result is that the output grid contains the originally selected rectangular region, while the input grid has that region replaced by the background color, both possibly rotated or mirrored in the same manner."
    },
    {
        "id": "fafffa47",
        "pattern": "To transform the input grid into the output grid, follow these steps:\n\n1. **Divide the Input Grid:**\n   - Split the input grid vertically into two equal-width sections: the left section and the right section.\n\n2. **Identify Filled Cells:**\n   - In the **left section**, identify all cells that are filled with a specific color (let's call this color A). All other cells in this section have the background color.\n   - In the **right section**, identify all cells that are filled with another specific color (let's call this color B). All other cells in this section also have the background color.\n\n3. **Create the Output Grid:**\n   - Initialize the output grid with the same height as the input grid's sections and the same width as one of the sections, filled entirely with the background color.\n   \n4. **Set Cells to Color 2:**\n   - For each cell position in the output grid:\n     - If the corresponding cell in **both** the left and right input sections is **not** filled with color A or color B (i.e., both have the background color), set this cell in the output grid to color 2.\n     - Otherwise, leave the cell with the background color.\n\n5. **Optional Mirroring:**\n   - With a 50% chance, mirror both the input and output grids diagonally. This means reflecting the grid over its main diagonal, swapping rows with columns.\n\nThis process ensures that the output grid highlights areas where neither the left nor the right input sections have colored cells by setting those areas to color 2, while all other areas retain the background color."
    },
    {
        "id": "fcb5c309",
        "pattern": "Locate a square region filled with a specific color in the input grid and replace every cell within that square with dots of a different color, leaving all other parts of the grid unchanged."
    },
    {
        "id": "fcc82909",
        "pattern": "To transform the input grid into the output grid, follow these steps for each object present in the input:\n\n1. **Identify the Object's Position:**\n   - Locate the two adjacent columns directly beneath the object in the input grid.\n\n2. **Determine Extension Length:**\n   - Randomly choose a number of cells (within specified lower and upper bounds) by which to extend these two columns downward.\n\n3. **Add Vertical Extensions:**\n   - In the output grid, color the identified cells in the two columns below the object with color **3** for the determined number of cells.\n\nAs a result, the output grid will contain all the original objects from the input grid, each accompanied by their respective vertical extensions colored in color 3 directly below them."
    },
    {
        "id": "feca6190",
        "pattern": "Each colored cell in the single-row input grid is transformed into a diagonal line of the same color in the output grid. Specifically, for every colored cell at column\u202f*j* in the input, a line starts at column\u202f*j* in the bottom row of the output grid and extends diagonally upwards to the right until it reaches the edge of the output grid."
    },
    {
        "id": "ff28f65a",
        "pattern": "To transform the input grid into the output grid, follow these steps:\n\n1. **Identify Red Regions**: \n   - Locate and count all distinct, non-overlapping rectangular areas in the input grid that are colored red (color value `2`).\n\n2. **Initialize Output Grid**:\n   - Create a new 3x3 grid filled entirely with the background color.\n\n3. **Mark Red Regions**:\n   - For each red rectangular region found in the input grid, mark a specific cell in the output grid with color `1` based on the following order:\n     - **First Red Region**: Set the cell at position (0,\u202f0).\n     - **Second Red Region**: Set the cell at position (0,\u202f2).\n     - **Third Red Region**: Set the cell at position (1,\u202f1).\n     - **Fourth Red Region**: Set the cell at position (2,\u202f0).\n     - **Fifth Red Region**: Set the cell at position (2,\u202f2).\n\n4. **Result**:\n   - The output grid will have up to five cells marked with color `1` in the predefined positions corresponding to the number of red regions identified in the input grid. All other cells in the output grid remain in the background color."
    },
    {
        "id": "ff805c23",
        "pattern": "1. Select two specific cell locations within the input grid to define the opposite corners of a rectangular region.\n2. Replace every cell within this defined rectangle in the input grid with the background color.\n3. Extract the original contents of the rectangular region before it was replaced; this extracted area becomes the output grid.\n4. Rotate both the modified input grid and the output grid by the same randomly chosen multiple of 90 degrees."
    }
]