If you see two different colors but one appears in all training examples while the other is rare, choose the consistent color. If a color occurs only once, the rule still applies (build a 1×1 filled cell of that color) — the mapping is simply \\\"count → side length\\\".</example>\\n</note5>\",\n \"<note1>\\n<description>Look for the \\\"active\\\" color: the non-zero color that appears in the input(s) and is carried into the outputs. This color is the element being transformed and is the only one you need to track across examples.</description>\\n<example>Imagine a grid that contains only black (0) except for a few blue pixels; the blue is the active color. In the output you should expect the same blue to appear (not a new color) and to be treated consistently across examples.</example>\\n</note1>\\n\\n<note2>\\n<description>Count the occurrences of that active color in each input. The transformation depends on how many of those pixels there are, so the numeric count is a key parameter to compare examples.</description>\\n<example>For example, if one input has a single green pixel and another has three green pixels, record counts 1 and 3. These counts are the quantities you will compare to the size of the output in each example.</example>\\n</note2>\\n\\n<note3>\\n<description>Compare counts to output sizes across the training examples to infer a mapping: the output's height and width are determined by the number of active pixels. The relationship is simple and consistent across examples.</description>\\n<example>If every example with one active pixel corresponds to a small square output, and examples with three active pixels correspond to a larger square, you can infer that the side length of the output square is derived directly from the pixel count (e.g., it is a fixed multiple of the count).</example>\\n</note3>\\n\\n<note4>\\n<description>Construct the output by filling a square of the inferred side length entirely with the active color. The output is a uniform block of that color, not a shape that preserves the original spatial arrangement of the pixels.</description>\\n<example>If the inferred rule gives a side length of 2 for a particular count, create a 2×2 block filled with the active color. The original positions of the input pixels are not used to place the block — only the color and the count matter.</example>\\n</note4>\\n\\n<note5>\\n<description>Use simple checks and avoid common pitfalls: ignore zeros when choosing the active color, ensure the same color is used in every example, and confirm the mapping is consistent (no exceptions). If multiple non-zero colors appear, the examples usually single out the recurring one.</description>\\n<example>If an input contains two different non-zero colors but only one of them appears in every training output, pick that recurring color. Also verify that the output size rule works for every example before applying it to the test case.</example>\\n</note5>\",\n \"<note1>\\n<description>Find the \\\"seed\\\" color by scanning the input for non-background (non-zero) pixels. If a single non-background color appears, that color is the one the transformation uses; multiple non-zero colors are handled differently.</description>\\n<example>For example, if a grid contains only zeros except for one green pixel, treat green as the seed color. If a grid contains two different non-zero colors, you should not assume a single color will be used in the output.</example>\\n</note1>\\n\\n<note2>\\n<description>Observe the output shape: the examples produce a small, fixed-size square regardless of the input dimensions. This means the transformation ignores the input grid size and produces the same output size every time.</description>\\n<example>Imagine several inputs of different widths and heights; in each case the output is a 2×2 square. So you should prepare to create a small square rather than trying to preserve the original input shape.</example>\\n</note2>\\n\\n<note3>\\n<description>Decide how the seed color is applied: the output is a uniform fill of that color (every cell in the small square uses the same non-background color). The rule does not mix colors or create patterns inside the small square.</description>\\n<example>If the seed color is blue, the small square should be filled entirely with blue. If there were two different seed colors, you would not blend them into one uniform block.</example>\\n</note3>\\n\\n<note4>\\n<description>Do not base the small square's size or placement on the input's colored pixels: the transformation is independent of where the seed pixels sit. The output is a compact, canonical block rather than a scaled or relocated version of the input object.</description>\\n<example>For instance, a single colored pixel in the corner or a vertical pair in the center both lead to the same small uniform square in the output. So focus on the color and the fixed output size, not on preserving original coordinates.</example>\\n</note4>\\n\\n<note5>\\n<description>Run quick checks before applying the rule: confirm there is exactly one non-background color and that the output size is consistent across examples. If either check fails, the simple rule may not apply and you should look for a different pattern.</description>\\n<example>Count non-zero colors and compare input dimensions across examples; if you find exactly one non-zero color and every example produces the same small square, the rule is likely correct. If you see multiple non-zero colors or varying output sizes, reconsider whether a different transformation is intended.</example>\\n</note5>\",\n \"<note1>\\n<description>Look for the single non-background color that appears in each input; that color is the element being transformed. When exactly one color (besides the background) is present, it is typically the \\\"seed\\\" for the output.</description>\\n<example>Imagine a grid with one blue pixel on a black background. That lone blue pixel is the object of interest: record its color and treat it as the thing you must reproduce or transform in the output.</example>\\n</note1>\\n\\n<note2>\\n<description>Count the colored pixels (the seed's multiplicity). The number of seed pixels is a small integer parameter that often controls how many copies of the seed appear in the output.</description>\\n<example>If the input contains three green pixels, note the value 3 — many tasks use that count to decide how many green cells to place in the result (for example, to form a small block or repeated pattern).</example>\\n</note2>\\n\\n<note3>\\n<description>Consider packing the seed color into a small, compact square whose side length is a simple function of the seed count (a common choice is side = count + 1). Packing into a small square turns scattered or single pixels into a tidy, regular object.</description>\\n<example>With two red pixels you might form a 3×3 filled square of red; with one yellow pixel you might form a 2×2 filled square. The rule is: make a small filled square whose size is tied to the number of seed pixels.</example>\\n</note3>\\n\\n<note4>\\n<description>Place the constructed square consistently relative to the original seed location (for example, flush to the same corner or edge where the seed sits). Use the seed's coordinates as the anchor for positioning the square.</description>\\n<example>If the seed sits in the top-left area of the input, align your small filled square so it also occupies that top-left region of the output; if the seed is centered, center the square similarly.</example>\\n</note4>\\n\\n<note5>\\n<description>Do not introduce other colors or shapes: the output should be a single filled square of the seed color. Verify the rule by checking that it reproduces each training output when applied to its input.</description>\\n<example>After choosing the seed color, the count, the side-length rule, and the anchor, build the filled square and compare it to the example outputs; if they match for all examples, apply the same construction to the test input.</example>\\n</note5>\",\n \"<note1>\\n<description>Isolate the active color: find the non-background color(s) that appear in the input and are the only ones used in the outputs. When a single color is the only one that matters, the transformation usually depends only on that color's identity and multiplicity, not on its exact coordinates.</description>\\n<example>Imagine a grid with only one colored pixel (color X) and the rest background. If the output contains only color X (and no other colors), then the rule is likely about X itself — for example, using X to fill a new shape — rather than about moving or copying the original pixel's location.</example>\\n</note1>\\n\\n<note2>\\n<description>Look for a canonical target shape: check whether the outputs all share the same small, regular geometry (for instance, a filled square or rectangle). A consistent target shape across examples indicates the transformation maps the input color to that fixed shape regardless of the input's size or position.</description>\\n<example>If every output you see is a compact filled square of identical dimensions, that suggests the operation is \\\"paint a fixed-size square\\\" using the input color. The exact dimensions of that square are the key parameter to determine from the examples.</example>\\n</note2>\\n\\n<note3>\\n<description>Decide how multiplicity is handled: determine whether the rule uses one instance of the color (one seed) or all occurrences. Compare inputs that have a single colored pixel with those that have several colored pixels — the outputs tell you which interpretation is consistent.</description>\\n<example>Suppose one training input has a single colored pixel and another has two colored pixels, but both outputs are the same small filled shape. That pattern implies the rule uses a single representative instance (the color) to produce the shape rather than aggregating all pixels.</example>\\n</note3>\\n\\n<note4>\\n<description>Check position invariance: verify whether outputs keep the input color's original coordinates or simply ignore them. If outputs are identical despite different input locations, the transformation is likely position-independent and depends only on color identity.</description>\\n<example>Two inputs where the colored pixel sits in different corners that both produce the same output shape indicate the rule does not rely on the pixel's location — it only needs the color to create the output.</example>\\n</note4>\\n\\n<note5>\\n<description>Validate and watch for pitfalls: apply your inferred rule to each training example to ensure it reproduces the outputs. If any example fails, reconsider whether the rule uses all occurrences, a different canonical size, or some other invariant; avoid assuming the original grid dimensions are preserved.</description>\\n<example>After hypothesizing \\\"fill a small fixed square with the input color,\\\" mentally apply that to each training input. If every output matches, your rule is likely correct; if not, inspect which example differs and adjust whether the shape size or the multiplicity interpretation should change.</example>\\n</note5>\",\n \"<note1>\\n<description>Focus first on which color(s) matter: ignore the background (usually 0) and list the distinct non-background colors and how many times each appears. This tells you whether the rule depends on color identity or on color frequency. Counting is a simple, robust first step because many ARC tasks choose colors by how often they occur.</description>\\n<example>Imagine a grid with three cells of color A and one cell of color B. The frequency counts are A:3, B:1. Knowing these counts narrows the set of candidate colors for the transformation.</example>\\n</note1>\\n\\n<note2>\\n<description>Decide which color is selected by the rule: often it is the color with the highest frequency (the mode). If two colors tie, look for a consistent secondary cue in the examples (e.g., color that appears in a corner, or the color that appears first when scanning). This selection step tells you which color will be used to paint the output block.</description>\\n<example>If a training input has A:4 and B:2, A is the natural candidate. If another example has A:2 and B:2 but A is always in the top-left in the examples, then \\\"top-left occurrence\\\" becomes the tie-breaker.</example>\\n</note2>\\n\\n<note3>\\n<description>Check how the chosen color is represented in the output: many tasks convert the selected color into a small filled square (a uniform block) rather than preserving its original shape or location. The output shape is usually constant across examples, so treat it as a fixed template to fill with the chosen color. Recognizing that the output is a canonical filled block simplifies reconstruction.</description>\\n<example>For instance, if every example output is a compact 2×2 filled square, then after choosing the color you should produce a 2×2 block entirely in that color rather than trying to copy the input's scattered pixels.</example>\\n</note3>\\n\\n<note4>\\n<description>Do not carry spatial layout or orientation of the input pixels into the output unless the examples explicitly show that. When the transformation uses frequency and a canonical shape, the input's positions are irrelevant; only the color identity and count matter. This helps avoid overfitting to the original arrangement.</description>\\n<example>If the input has the chosen color scattered in different places, the output should still be the same uniform block (same size and color), not a rearrangement of those scattered pixels.</example>\\n</note4>\\n\\n<note5>\\n<description>Validate your hypothesis by applying the selection + canonical-shape rule to every training pair: pick the most frequent non-background color, create the fixed-size filled block with that color, and check for exact matches. If it matches all examples, the rule is likely correct; if not, revisit tie-breakers or whether the shape is constant. This verification step prevents overgeneralization.</description>\\n<example>Try the rule on a new input: count non-zero colors, choose the dominant one (or use your tie-breaker if needed), then produce the fixed-size filled block with that color. If that reproduces each training output, you have a reliable transformation to apply to the test case.</example>\\n</note5>\",\n \"<note1>\\n<description>Isolate the salient color: find the color that is not the background and treat it as the object to transform. This reduces the problem to how that one color is moved or enlarged in the output. Focusing on the single non-background color avoids being distracted by empty space.</description>\\n<example>Imagine a mostly-black grid with a single blue pixel. That blue pixel is the only candidate for change, so your first step is to record its color and its coordinates. Once you have that, ignore all background cells when reasoning about the transformation.</example>\\n</note1>\\n\\n<note2>\\n<description>Look for a consistent output size: check whether every training output has the same dimensions. If the outputs are all the same small rectangle, the rule likely creates that fixed-size block rather than preserving the original grid size. The output size is a global parameter you must apply to the test case.</description>\\n<example>Suppose three different inputs (different shapes and positions) all produce outputs that are 2×2 squares. That strongly suggests the transformation always produces a 2×2 block, so you should aim to produce a 2×2 block for the test input as well.</example>\\n</note2>\\n\\n<note3>\\n<description>Decide how the object's color is used inside the new block: is it copied into every cell of the block, or only into a subset? In many tasks the single non-background color is expanded to fill the entire output rectangle. This tells you whether to replicate the color across the whole block.</description>\\n<example>If the input has a single green pixel and the output is a small square, try filling that square with green rather than preserving the original pixel's position. If training outputs always show the block uniformly one color, filling the whole block is the right choice.</example>\\n</note3>\\n\\n<note4>\\n<description>Check whether the original location matters: if outputs are identical despite the input pixel appearing in different places, the transformation is position-invariant. That means you should not try to preserve coordinates—only the color and the block size matter. This simplifies where you place the block in the output.</description>\\n<example>When a red pixel appears in the top-left of one input and the bottom-right of another, yet both outputs are the same small red square, the rule ignores input coordinates. For the test, place the filled block in the output according to the fixed-size convention rather than copying the input pixel's coordinates.</example>\\n</note4>\\n\\n<note5>\\n<description>Use simple heuristics and watch for pitfalls: prefer the single non-background color as the object color; if multiple non-background colors appear in other problems, pick the unique or most frequent one. Also verify that the output always uses the same color as the input object rather than introducing a new color.</description>\\n<example>If an input contains one blue pixel and the rest are background, blue is the natural candidate to fill the output block. If you instead see two different colored pixels in a different task, look for a tie-breaker such as the one that appears most often or the one that matches training outputs.</example>\\n</note5>\",\n \"<note1>\\n<description>Look for the single non-background color that stands out in each input; that color is usually the \\\"seed\\\" the transformation uses. This seed is often the only color that appears in the input examples and is the one that reappears in the outputs.</description>\\n<example>Imagine a grid with only one blue pixel among black cells. That blue pixel is the seed: it is the only color you need to track when predicting the output, because the output will be built from that color rather than from black.</example>\\n</note1>\\n\\n<note2>\\n<description>Check whether the outputs all share the same small shape and size regardless of the input grid dimensions. If the outputs are identical in shape across examples, the rule is likely \\\"always produce that fixed shape\\\" rather than \\\"resize to the input.\\\"</description>\\n<example>If several different-sized inputs all produce the same 2×2 pattern in their outputs, then the transformation ignores the input's original width and height and always outputs a 2×2 block.</example>\\n</note2>\\n\\n<note3>\\n<description>Decide whether the seed color is used as a fill for the entire target shape. In many tasks the seed color is not preserved at its original coordinates but is instead used to paint every cell of the fixed shape.</description>\\n<example>Given a lone green pixel in an input, the output may be a small filled square where every cell is green — the original pixel's location is irrelevant, only its color matters.</example>\\n</note3>\\n\\n<note4>\\n<description>When there are multiple colored pixels, determine whether the rule selects a single color (e.g., the only non-background color) or aggregates them. If all examples use the same single color, the transformation likely chooses that color and ignores other colors or positions.</description>\\n<example>If two different inputs both have only red pixels (even at different positions), and their outputs are the same small red shape, that indicates the rule picks the single non-background color and produces a uniform shape from it.</example>\\n</note4>\\n\\n<note5>\\n<description>Assemble the rule: pick the seed color from the input, create the fixed-size shape seen in the outputs, and fill that shape uniformly with the seed color. Finally, check that this rule reproduces every training output before applying it to the test input.</description>\\n<example>Take the non-background color you identified, form the same small square shape that appears in the example outputs, and fill every cell of that square with the chosen color. If this reproduces all training outputs, it is the correct transformation to apply to the test grid.</example>\\n</note5>\"\n]","isConversational":false},"train":{"kind":"string","value":"[{\"input\": [[8, 0, 0, 0, 0, 0], [0, 0, 0, 0, 0, 0], [0, 0, 0, 0, 0, 0], [0, 0, 0, 0, 0, 0], [0, 0, 0, 0, 0, 0], [0, 0, 0, 0, 0, 0]], \"output\": [[8, 8], [8, 8]]}, {\"input\": [[0, 7, 0, 0, 0, 0, 0], [0, 0, 0, 0, 0, 0, 0], [0, 0, 0, 0, 0, 0, 0], [0, 0, 0, 0, 0, 0, 0], [0, 0, 0, 0, 0, 0, 0], [0, 0, 0, 0, 0, 0, 0], [0, 0, 0, 0, 0, 0, 0]], \"output\": [[7, 7], [7, 7]]}, {\"input\": [[5, 0, 0, 0, 0], [0, 0, 0, 0, 0], [0, 0, 0, 0, 0], [0, 0, 0, 0, 0], [0, 0, 0, 0, 0]], \"output\": [[5, 5], [5, 5]]}]"},"test":{"kind":"string","value":"[{\"input\": [[5, 5, 0, 0, 0, 0, 0], [0, 5, 0, 0, 0, 0, 0], [0, 0, 0, 0, 0, 0, 0], [0, 0, 0, 0, 0, 0, 0], [0, 0, 0, 0, 0, 0, 0], [0, 0, 0, 0, 0, 0, 0], [0, 0, 0, 0, 0, 0, 0]], \"output\": [[0, 0, 5, 5], [0, 0, 5, 5], [5, 5, 5, 5], [5, 5, 5, 5]]}]"},"source":{"kind":"string","value":"barc_heavy"},"prompt":{"kind":"string","value":"You will be given some number of paired example inputs and outputs grids. The outputs were produced by applying a transformation rule to the input grids. In addition to the paired example inputs and outputs, there is also one test input without a known output. The inputs and outputs are each “grids”. A grid is a rectangular matrix of integers between 0 and 9 (inclusive). Each number corresponds to a color. 0 is black. Your task is to determine the transformation rule from examples and find out the answer, involving determining the size of the output grid for the test and correctly filling each cell of the grid with the appropriate color or number. The transformation only needs to be unambiguous and applicable to the example inputs and the test input. It doesn't need to work for all possible inputs. Observe the examples carefully, imagine the grid visually, and try to find the pattern. Please output your answer within a code block (```), formatted as a grid of numbers. \n\n# Examples\n## Example 1\nInput:\n```\n8 0 0 0 0 0\n0 0 0 0 0 0\n0 0 0 0 0 0\n0 0 0 0 0 0\n0 0 0 0 0 0\n0 0 0 0 0 0\n```\n\nOutput:\n```\n8 8\n8 8\n```\n\n## Example 2\nInput:\n```\n0 7 0 0 0 0 0\n0 0 0 0 0 0 0\n0 0 0 0 0 0 0\n0 0 0 0 0 0 0\n0 0 0 0 0 0 0\n0 0 0 0 0 0 0\n0 0 0 0 0 0 0\n```\n\nOutput:\n```\n7 7\n7 7\n```\n\n## Example 3\nInput:\n```\n5 0 0 0 0\n0 0 0 0 0\n0 0 0 0 0\n0 0 0 0 0\n0 0 0 0 0\n```\n\nOutput:\n```\n5 5\n5 5\n```\n\n# Test Problem:\n```\n5 5 0 0 0 0 0\n0 5 0 0 0 0 0\n0 0 0 0 0 0 0\n0 0 0 0 0 0 0\n0 0 0 0 0 0 0\n0 0 0 0 0 0 0\n0 0 0 0 0 0 0\n```"},"answer":{"kind":"string","value":"```\n0 0 5 5\n0 0 5 5\n5 5 5 5\n5 5 5 5\n```"},"num_tokens":{"kind":"number","value":608,"string":"608"}}},{"rowIdx":94,"cells":{"abstraction_prompt":{"kind":"string","value":"<|im_start|>user\n# ARC HINT GENERATOR\n\n## Role & Goal\nYou are an expert ARC (Abstraction and Reasoning Corpus) analyst. Your task is to generate a concise, actionable hint for a user who is struggling with an ARC problem. Analyze the problem and its correct solution to produce a single standalone, targeted hint that helps the user discover the core transformation principle for themselves without revealing the answer.\n\n---\n\n## Hint Generation Strategy\n1. **Compare** the input and output grids for each example. Identify the shared transformation pattern that allows the input grid to be converted into the output grid.\n2. **Identify the Core Principle**: Review the problem description and ground-truth solution to fully discern the key transformation rule. Break it down into its essential operations (e.g., object completion, pattern repetition, symmetry, gravity), paying close attention to properties such as object count, shapes, colors, sizes, symmetry, repetition, relative positioning, and broader grid-level patterns.\n3. **Craft a Targeted Hint**: Generate a hint that guides the user toward the core insight needed to solve the problem. The hint should assist the user during their attempt without revealing the solution.\n4. Structure each note using the template below:\n - **Description** (up to 3 sentences): Explain the concept, when and why it applies, and why it is effective. Include any relevant general formula or principle in its most general form.\n - **Example** (up to 6 sentences): Present a worked example covering all aspects of the description, using a simplified yet representative scenario (not necessarily from the current problem).\n - Optionally, include **Heuristics** or **Pitfalls** in the note where relevant.\n - Focus on methodologies and core principles over specific calculations or problem details.\n - Ensure each hint applies broadly—at least 80% of analogous problems.\n\nAfter generating a hint, verify that no specifics of the solution are revealed, and that the hint remains at the level of guiding the approach.\n\n### Design Guidelines\n- Clarity: Use precise language and correct sentence structure.\n- Atomicity: Each note addresses one recognizable sub-problem.\n- Self-containment: All information needed to understand the idea and its application is within the note.\n- Generalizability: Avoid problem-specific details or variables.\n- Transferability: Notes should apply across a class of problems.\n- Distinctness: Each note addresses a distinct principle.\n\n---\n\n## Guidelines\n- **Guide, Don't Solve**: Illuminate the approach, not the answer. Emphasize what to observe or consider.\n- **Specific yet Abstract**: Use concrete grid details (e.g., \"note the relationship between the blue and red pixels\") to ground abstract patterns (e.g., \"think about one color containing another\").\n\nValidate your generated hint: confirm it is self-contained, actionable, and nondirective. If any aspect is too revealing, revise before finalizing.\n\n---\n\n## Inputs\n### Problem Description\nA full ARC problem, including input/output pairs for training and testing.\n\n## Example 1\nInput:\n```\n6 1 6 6\n9 1 9 9\n6 1 6 6\n6 1 6 6\n2 1 2 2\n6 1 6 6\n6 1 6 6\n6 1 6 6\n1 1 1 1\n6 1 6 6\n1 1 1 1\n6 1 6 6\n4 1 4 4\n6 1 6 6\n6 1 6 6\n1 1 1 1\n6 1 6 6\n6 1 6 6\n6 1 6 6\n6 1 6 6\n0 1 0 0\n6 1 6 6\n```\n\nOutput:\n```\n6 6\n6 6\n6 6\n6 6\n6 6\n6 6\n6 6\n6 6\n```\n\n## Example 2\nInput:\n```\n6 9 6\n1 9 1\n6 9 6\n6 9 6\n6 9 6\n3 9 3\n6 9 6\n6 9 6\n6 9 6\n6 9 6\n2 9 2\n6 9 6\n5 9 5\n6 9 6\n7 9 7\n6 9 6\n6 9 6\n6 9 6\n6 9 6\n9 9 9\n6 9 6\n9 9 9\n6 9 6\n```\n\nOutput:\n```\n6 6\n6 6\n6 6\n6 6\n6 6\n6 6\n6 6\n6 6\n```\n\n## Example 3\nInput:\n```\n0 0 0 0 4 0 7 0 1 0 8 0 8 0 0\n5 5 5 5 4 5 7 5 1 5 8 5 8 5 5\n0 0 0 0 4 0 7 0 1 0 8 0 8 0 0\n0 0 0 0 4 0 7 0 1 0 8 0 8 0 0\n```\n\nOutput:\n```\n0 0 0 0 0 0\n0 0 0 0 0 0\n```\n\n### Test Input\nHere is the input for the test problem.\n\n```\n3 3 3 3 2 3 3 2 3 3\n3 3 3 3 2 3 3 2 3 3\n2 2 2 2 2 2 2 2 2 2\n3 3 3 3 2 3 3 2 3 3\n5 5 5 5 2 5 5 2 5 5\n3 3 3 3 2 3 3 2 3 3\n3 3 3 3 2 3 3 2 3 3\n4 4 4 4 2 4 4 2 4 4\n3 3 3 3 2 3 3 2 3 3\n```\n\n\n### Output Format\nOnly produce a **sequence of 5** notes in the structure:\n<note1>\n<description>...</description>\n<example>...</example>\n</note1>\n<note2>\n<description>...</description>\n<example>...</example>\n</note2>\n...\n\nDO NOT generate any other text\n\n---\n\n\n# Generated Hint<|im_end|>\n<|im_start|>assistant\n"},"abstraction_prompt_length":{"kind":"number","value":1461,"string":"1,461"},"generated_abstractions":{"kind":"list like","value":["<note1>\n<description>Look for full rows or full columns that are a single color; these often act as separators that split the grid into independent bands. When a whole row or whole column is identical across its length, it is usually a deliberate divider rather than part of a tile. Treat such lines as boundaries when you want to isolate the repeating region.</description>\n<example>Imagine a grid where every 4th row is entirely green; those green rows are not part of the repeating motif but divide the grid into horizontal bands. Remove (or ignore) those green rows and you will see a sequence of bands that are easier to analyze. A similar idea applies if a column is entirely one color: it separates left and right blocks.</example>\n</note1>\n\n<note2>\n<description>After removing separator rows/columns, group adjacent rows (or columns) that are identical into contiguous runs; each run corresponds to a single repetition of the underlying tile. Counting these runs gives you the number of repeated blocks along that axis. This reduces the problem from a large grid to a smaller grid of repeated blocks.</description>\n<example>For example, if the non-separator rows read A,A,B,B,C,C (where A,B,C are distinct row patterns), there are three runs: A-run, B-run, C-run. Those runs tell you there are three stacked tiles vertically. Do the same for columns to get the horizontal count.</example>\n</note2>\n\n<note3>\n<description>Find the tile’s interior color by inspecting the non-separator cells: the color that appears most often (or forms the repeated interior pattern) is usually the one to use for the output. Separator colors are typically different and should be ignored when choosing the representative color. This gives you the color to fill the compact output.</description>\n<example>Suppose after removing separators the interior cells are mostly blue, with occasional single different pixels; blue is the dominant interior color and is the natural choice to represent the tile. If two interior colors tie, prefer the one that appears in the central or majority of tiles.</example>\n</note3>\n\n<note4>\n<description>Construct the output as a compact grid whose dimensions equal the counts of the contiguous runs you found: rows = number of horizontal runs, columns = number of vertical runs. Fill every cell of that small grid with the chosen interior color. This preserves the tiling structure but in a condensed form.</description>\n<example>If you discovered two horizontal runs and three vertical runs, produce a 2×3 grid and fill every cell with the interior color you identified. That small grid is a direct representation of how many repeats occurred in each direction.</example>\n</note4>\n\n<note5>\n<description>Be careful not to confuse separator lines with the tile interior: separators may appear as a different color that repeats across the whole row/column and should be excluded from the run counts. Also, if a separator color sometimes appears inside tiles, use the full-row/full-column test (uniform across the entire row/column) to decide whether it is a divider. This avoids miscounting runs.</description>\n<example>For instance, a color that appears only as a complete column should be treated as a separator and removed before counting runs; if the same color also appears sporadically inside tiles, only the columns/rows that are entirely that color count as separators. A quick check: verify whether a candidate separator is uniform across its entire length before excluding it.</example>\n</note5>","<note1>\n<description>Look for a vertical axis: a column whose color is identical in every row. Such a column usually serves as a divider that separates the grid into left and right regions; finding it simplifies the problem into two independent areas.</description>\n<example>Imagine a 7×5 grid where column 3 is color X in every row. That column cleanly splits the grid into a left block (columns 1–2) and a right block (columns 4–5). Treat the two blocks separately rather than trying to operate across the whole grid.</example>\n</note1>\n\n<note2>\n<description>After locating the divider, split the grid into the left and right blocks and inspect their internal structure. One side will typically be a repeated tile (same small pattern across many rows or columns) while the other side may be mostly uniform or act as a separator.</description>\n<example>For example, if the left block contains the same 3-column pattern repeated down the rows while the right block is mostly a single color, the left block is the repeating region and the right block is a separator or filler.</example>\n</note2>\n\n<note3>\n<description>Identify the dominant (most frequent) color inside the repeating region. The transformation usually extracts the color that appears most often in that region, ignoring the divider and any filler color that appears only in separators or at edges.</description>\n<example>If the left block is made of a small tile repeated many times and color A occupies the majority of those tiles, then A is the dominant color to use in the output rather than a color that appears only in the divider or occasional filler rows.</example>\n</note3>\n\n<note4>\n<description>Derive the output size from the repeating region: count how many rows and how many columns the repeating tile occupies. The output grid’s dimensions are typically the height and width of that repeating tile (not the whole input grid).</description>\n<example>If the left block is 8 rows tall and its repeating unit is 2 columns wide, the output should be an 8×2 rectangle (one rectangle per row of the repeating tile), filled with the dominant color.</example>\n</note4>\n\n<note5>\n<description>Construct the final grid by creating a rectangle with the measured height and width and filling every cell with the dominant color. Be careful to exclude the divider column and any uniform separator rows/columns when measuring size and choosing the dominant color.</description>\n<example>For instance, if you find a repeating region 6 rows high and 2 columns wide whose most frequent color is A, produce a 6×2 grid where every cell is A. A common pitfall is including the divider column in the size or selecting the divider’s color by mistake—avoid that.</example>\n</note5>","<note1>\n<description>Look for a single color that forms uninterrupted vertical stripes across many rows — this color is usually a divider, not part of the motif. Treat those divider columns as separators and remove them to reveal the repeating motif between them.</description>\n<example>Imagine a grid where column 3 is the same color in every row and column 7 is the same color in every row; those two columns split the grid into three vertical bands. Removing the two uniform columns exposes the bands you should analyze next.</example>\n</note1>\n\n<note2>\n<description>After removing divider columns, each remaining band is a small tile that repeats across the width. Identify the minimal horizontal period: the smallest number of adjacent columns that, when repeated, reconstructs the non-divider columns.</description>\n<example>If the non-divider columns read [A B C A B C A B C], the minimal horizontal period is 3 (A B C). If they read [X Y X Y X Y], the period is 2 (X Y). Use that period to slice the grid into equal-width tiles.</example>\n</note2>\n\n<note3>\n<description>Do the same vertically: find columns that are uniform down the grid and remove them to reveal stacked tiles. Then determine the minimal vertical period — the smallest number of rows that repeats to cover the non-divider rows.</description>\n<example>If rows look like [R S R S R], the vertical period is 2 (R S). If rows are [T U T U T U], the period is 2 (T U). These vertical periods define how many stacked tiles to consider.</example>\n</note3>\n\n<note4>\n<description>The number of distinct horizontal tiles (the number of non-divider bands) is the output width, and the number of distinct vertical tiles (stacked bands) is the output height. The output grid size is therefore (#vertical tiles) × (#horizontal tiles).</description>\n<example>If you find 4 stacked bands and 3 horizontal bands after removing dividers, the output should be 4 rows by 3 columns. If you find 2 stacked bands and 5 horizontal bands, the output should be 2×5.</example>\n</note4>\n\n<note5>\n<description>Fill the output rectangle with a single color that is consistent across the tiles — typically the dominant non-divider color (the color that appears most often inside the repeating tiles). This gives a uniform block that mirrors the repeated structure.</description>\n<example>If the repeated tiles are mostly color 6, produce an output grid of the computed dimensions filled entirely with 6. Pitfall: do not include the divider color in this fill — dividers are structural and should be ignored when choosing the fill color.</example>\n</note5>","<note1>\n<description>Look for a column whose color is identical in every row; such a column acts as a vertical divider and splits the grid into left and right regions. This divider is usually a single color repeated down the whole grid and is the first structural clue to the transformation.</description>\n<example>Imagine a 5×7 grid where column 3 contains the same color in every row while other columns vary. That column cleanly separates the grid into a left block (columns 0–2) and a right block (columns 4–6); treat that uniform column as a divider and ignore it when extracting the repeating pattern.</example>\n</note1>\n\n<note2>\n<description>After locating the divider, focus on the side that repeats the same small pattern across many rows (the left or right region). The repeating region is what you should compress — the divider and the non-repeating side are usually irrelevant to the final output.</description>\n<example>If the left block contains the same 4-column pattern in most rows while the right block shows many different colors, extract the left block and ignore the divider and right block. The repeating left block is the region you will compress into the output.</example>\n</note2>\n\n<note3>\n<description>Compress each row of the chosen repeating block horizontally by collapsing consecutive identical cells into a single cell. This preserves the order of runs but reduces width to the number of distinct horizontal runs per row.</description>\n<example>A row like [A,A,A,B,B,C,C] becomes [A,B,C] after collapsing consecutive runs. Do this for every row in the repeating block so each row becomes a shorter sequence of distinct horizontal runs.</example>\n</note3>\n\n<note4>\n<description>After collapsing, remove any rows that are entirely the same color (all-collapsed cells equal). Those uniform rows are often padding and should be deleted so the result reflects only the meaningful vertical runs.</description>\n<example>If after collapsing you have rows [X,X,X], [Y,Y,Y], [X,X,X] (where X and Y are single-cell colors), drop the first and third rows because they are identical uniform rows and keep only the middle row [Y,Y,Y].</example>\n</note4>\n\n<note5>\n<description>Finally, take the collapsed-and-pruned block and make the output square: if the block has more rows than columns, duplicate the top rows until you reach the target size; if it has fewer rows, repeat the bottom rows. The result is a square grid whose side length equals the maximum of the collapsed row and column counts.</description>\n<example>If your collapsed block is 3×2 (3 rows, 2 columns), append a copy of the first row to make 4×2, then append another copy of the first row to reach 6×2, and finally append the last row to reach 6×6. This keeps the original vertical order and produces a square output.</example>\n</note5>","<note1>\n<description>Look for a column that is the same color in every row: such a column usually acts as a vertical divider or separator. Finding it simplifies the problem because it partitions the grid into a left block and a right block (or a single block if the divider is the only column).</description>\n<example>Imagine a grid where column 3 is color X in every row. That column separates the left columns (before X) from the right columns (after X). Treat that column as a boundary when reasoning about the repeating structure.</example>\n</note1>\n\n<note2>\n<description>Compare the left and right blocks to see if they are mirror images. Often the right block is just a horizontal reflection of the left block, so you only need to examine one side to understand the full pattern.</description>\n<example>For example, if the left block's columns read [A, B, C] and the right block reads [C, B, A], the right side is a mirror of the left. Once you identify the left block, the right block is determined by that mirror.</example>\n</note2>\n\n<note3>\n<description>Within the repeating block (the left or right side), identify the dominant color — the one that appears most frequently across that block. The transformation typically uses that dominant color as the output fill.</description>\n<example>If the left block contains mostly color 0 with occasional other colors, 0 is the dominant color. Use that color as the single color to fill the output rectangle.</example>\n</note3>\n\n<note4>\n<description>Decide the output size from the repeating block's dimensions. Count how many columns (or rows) the repeating block occupies before the divider; that count becomes the output width (or height), and the output height is taken from the input height.</description>\n<example>If the repeating block occupies 4 columns across the grid, the output width will be 4. If the repeating block occupies 2 rows, the output height will be 2. Combine those counts to get the rectangle dimensions.</example>\n</note4>\n\n<note5>\n<description>Assemble the final grid by creating a rectangle with the computed dimensions and filling every cell with the dominant color from the repeating block. This produces a uniform block that summarizes the repeated structure.</description>\n<example>After determining the block width and height and the dominant color, produce a rectangle of that size and fill it entirely with the dominant color. That rectangle is the intended output representation of the repeating pattern.</example>\n</note5>","<note1>\n<description>Look for columns that are the same color from top to bottom: these are strong structural separators. When a column's color never changes across rows, it usually marks a boundary between repeating blocks and is best treated as a divider rather than part of the repeating content.</description>\n<example>Imagine a grid where column 4 is blue in every row while other columns vary. That blue column splits the grid into left and right regions; you can treat the blue column as a separator and focus on the two regions it creates.</example>\n</note1>\n\n<note2>\n<description>After removing separator columns, compare the remaining columns in groups of two (pair adjacent columns). If the first column of a pair matches the second, they form a repeated column-pair; if not, that pair is a separator/exception and should be removed before pairing.</description>\n<example>Suppose the non-separator columns read [A, A, B, C, A, A, D, E]. Pairing adjacent columns gives (A,A),(B,C),(A,A),(D,E). The first and third pairs are identical and therefore represent one repeated column-pair; the middle pair is an exception and should be dropped before pairing.</example>\n</note2>\n\n<note3>\n<description>Count distinct column-pairs that are identical: each identical adjacent pair reduces the number of distinct columns by one. The final number of distinct column-pairs (distinct after removing separator columns) is the output width.</description>\n<example>If after removing separators you find the sequence of column-pairs [X,X,Y,Z,X,X], the distinct pairs are {X,Y,Z}, so the output width is 3 (one column for each distinct pair).</example>\n</note3>\n\n<note4>\n<description>Decide the output height by counting the number of rows that contain the repeated block. Rows that contain the repeated pattern are the ones that contribute to the output height; rows that are uniform or otherwise different should not be counted.</description>\n<example>If the patterned rows (those containing the repeated column-pairs) appear in rows 2, 4 and 7, the output height is 3. If a whole row is a uniform color and does not show the repeated pattern, it does not increase the height.</example>\n</note4>\n\n<note5>\n<description>Fill the output grid with the dominant (most frequent) non-separator color that appears in the repeated blocks. Use the distinct-pair count for width and the pattern-row count for height, then color every cell with that dominant color.</description>\n<example>After determining width = 4 and height = 3, and finding that color A is the most common non-separator color, the final output is a 3×4 grid where every cell is A. This preserves the structural counts while using the repeated-color as the fill.</example>\n</note5>","<note1>\n<description>Look for a vertical divider: a column whose cells all share the same color and run the full height of the grid. Such a column usually acts as a seam separating two repeating regions and is the first structural clue to the transformation.</description>\n<example>Imagine a 7×5 grid where column 4 is entirely color X while the other columns vary. That column is a clear vertical seam; treat it as a boundary rather than part of the repeating motif. If you find multiple such full-height columns, treat them as multiple separators.</example>\n</note1>\n\n<note2>\n<description>Measure the repetition period between separators: the number of columns between two adjacent full-height separator columns (or between a separator and the grid edge) gives the horizontal tile width. The repeating block is the region that appears identically on both sides of the seam(s).</description>\n<example>For example, if you find full-height columns at positions 3 and 7, the gap between them is 3 columns, so the repeating tile width is 3. If the pattern repeats every 3 columns, that width is the unit you should extract.</example>\n</note2>\n\n<note3>\n<description>Extract the basic tile (the rectangle of columns between separators) and then reduce it to its background color: the tile often contains a single dominant color that represents the motif. Replacing the tile with that dominant color produces the compact motif you need.</description>\n<example>Suppose a 3-column tile contains mostly color A with a few other pixels; the motif is best represented by a 3×H block filled with color A (H = tile height). If the tile is already uniform, the reduced motif is that single color.</example>\n</note3>\n\n<note4>\n<description>Decide the output height by counting full motif occurrences: count how many times the full-height separator appears (or how many full motifs fit vertically). That count typically becomes the number of rows in the final output.</description>\n<example>If the input shows two full-height separator columns (so two separators total), you would expect two stacked motif blocks; the output height would be 2. If separators are absent, count how many complete tiles appear vertically in the input instead.</example>\n</note4>\n\n<note5>\n<description>Assemble the final grid: place the reduced motif block (width = tile width, height = motif height) in a square whose side equals the number of motif occurrences (or the number of separators). The output is a compact square showing the repeating unit in isolation.</description>\n<example>For instance, if you determine the tile is 2 columns wide and you counted 4 full-height separators, produce a 4×4 grid where every cell is the tile’s dominant color. This yields a clean, square representation of the repeating motif.</example>\n</note5>","<note1>\n<description>Look for vertical divider columns: a column whose color is the same in every row usually separates independent column-blocks. Treat each contiguous set of columns between such dividers as one block to analyze.</description>\n<example>Imagine a grid where column 4 is all color X and column 8 is all color X; those two columns split the grid into three blocks (columns 1–3, 5–7, 9–end). Work on each block separately rather than the whole grid at once.</example>\n</note1>\n\n<note2>\n<description>Within a block, identify the dominant color: the color that appears most often across that block (ignore the divider color). That dominant color is typically the one you should extract or use to form the output.</description>\n<example>If a block of 3 columns contains mostly color A with a few B and C pixels, choose A as the block’s representative. If two colors tie, prefer the one that is more frequent overall or more centrally placed in the block.</example>\n</note2>\n\n<note3>\n<description>Compute the block’s vertical span: find the topmost and bottommost rows where the block’s dominant color appears, and take the count of those rows as the block height. That height becomes the output height for the block.</description>\n<example>If the dominant color in a block appears from row 2 to row 10, the block height is 9. If it appears in only a single row, the height is 1.</example>\n</note3>\n\n<note4>\n<description>Assemble the final grid by repeating the dominant-color block for each contiguous block: each repeated block has the block’s height and a width equal to the block’s width. The final output is a stack of these blocks in left-to-right order.</description>\n<example>Two blocks of widths 2 and 3 with heights 5 and 1 become a 5-row output whose first two columns are filled with the first block’s color and the next three columns are filled with the second block’s color.</example>\n</note4>\n\n<note5>\n<description>Handle edge cases consistently: ignore divider columns when counting colors; if a block contains no occurrences of its dominant color, treat that block as height 1 (a single row) and fill it with the dominant color. Always preserve the left-to-right order of blocks.</description>\n<example>If a block is entirely filled with the dominant color, its height is the full block height; if a block has no dominant-color pixels, output a single row of that color. This keeps the output compact and ordered.</example>\n</note5>","<note1>\n<description>Look for rows or columns that are entirely one color; such uniform lines usually serve as separators that partition the grid into independent bands. Treat those full-color rows/columns as boundaries rather than as part of the repeated content.</description>\n<example>Imagine a grid where every cell in column 3 is color A while other columns contain mixed colors. Column 3 is a vertical divider: split the grid at that column and analyze the left and right bands separately. This reduces the problem to smaller, simpler subgrids.</example>\n</note1>\n\n<note2>\n<description>After splitting, inspect each band for a repeating structure: many tasks use a small tile repeated across the band. Determine the minimal horizontal and vertical period by finding the smallest shift that reproduces the same pattern inside the band.</description>\n<example>For a band of width 8 made by repeating a 2-column pattern, shifting two columns will show the same arrangement. The minimal period is 2 columns; similarly, if rows repeat every 4 rows, the vertical period is 4. Use those periods to infer the tile size.</example>\n</note2>\n\n<note3>\n<description>Within a band, identify the color that consistently occupies the same relative positions inside the tile — this is the motif color. It is typically the color that appears in the same positions across many repeats and is not the divider color.</description>\n<example>Suppose each 2×2 tile contains the same color in its top-left corner while the rest of the tile varies. That color is the motif; you can mark it by checking the same relative cell in several tiles. Once found, that color is the one you will use to fill the output block.</example>\n</note3>\n\n<note4>\n<description>Count how many tiles fit horizontally and vertically: divide the band width by the horizontal period and the band height by the vertical period. Those counts determine the dimensions of the abstracted output grid.</description>\n<example>If a band is 12 columns wide and the horizontal period is 3, there are 4 tiles across. If the band height is 6 and the vertical period is 3, there are 2 tiles down. The output grid should have 4 columns and 2 rows (one cell per tile).</example>\n</note4>\n\n<note5>\n<description>Build the final output by creating a grid with the tile-count dimensions and filling every cell with the motif color you identified. This compresses the repeated structure into a compact representation.</description>\n<example>From the previous counts (4×2) and motif color X, produce a 4×2 grid where every cell is X. Verify by mentally expanding that output back into the original tile layout — the motif should appear in the same relative positions as in the input.</example>\n</note5>","<note1>\n<description>Look for full-length uniform lines: a column or row whose every cell is the same color. These lines usually act as separators that split the grid into repeating blocks and are easy to spot because they span the entire grid dimension.</description>\n<example>Imagine a 7×5 grid where column 3 is entirely color X while other columns vary. That column cleanly divides the grid into left and right regions; treat it as a separator rather than part of the repeating pattern.</example>\n</note1>\n\n<note2>\n<description>Use those separator lines to segment the grid into rectangular tiles: the regions between successive separator rows and columns form the tiles. The tile dimensions are simply the gaps between separators (or edges).</description>\n<example>If you find two vertical separators and one horizontal separator, you get three vertical bands and two horizontal bands, so the grid is partitioned into a 3×2 array of tiles. Each tile is the rectangle between adjacent separators or between a separator and the edge.</example>\n</note2>\n\n<note3>\n<description>Identify the tile interior by excluding any row/column that is a uniform separator. Inside a tile, pick a color that appears repeatedly across tiles (ignore separator colors) — that recurring interior color is the one to use for the output.</description>\n<example>Suppose every tile (except the separator rows/columns) contains many pixels of color A while separators are color B. A is the tile interior color; choose A rather than B or the occasional stray color.</example>\n</note3>\n\n<note4>\n<description>Form the output by taking the count of tile rows and the count of tile columns (the number of horizontal bands and vertical bands). Create an output grid of that size and fill every cell with the chosen interior color.</description>\n<example>If the partitioning yields 4 horizontal bands and 3 vertical bands, produce a 4×3 grid where every cell is the selected interior color — the output is a compact representation of the tile array.</example>\n</note4>\n\n<note5>\n<description>Heuristics and pitfalls: only treat a line as a separator if it is uniform across its entire length; do not confuse a mostly-uniform line with a separator. If several colors repeat inside tiles, prefer the color that appears most consistently across tiles; always exclude separator colors from the final fill.</description>\n<example>If a column has one or two different pixels, it is not a separator — keep it as part of the tile. If two interior colors appear but one occurs in every tile while the other is sporadic, pick the consistent one and ignore any full-length separator lines when computing tile counts.</example>\n</note5>","<note1>\n<description>Search the grid for a column or row whose cells are all the same color; such a uniform line usually acts as a divider or background. When present, it separates the grid into independent regions (left/right or top/bottom) that you should treat separately.</description>\n<example>Imagine a grid where column 4 is entirely color 7 while the other columns vary. That column is a clear vertical divider: everything left of it is one region and everything right of it is another. Treat that column as a boundary rather than part of the repeating content.</example>\n</note1>\n\n<note2>\n<description>After you identify a divider, split the grid into the contiguous blocks on either side of it. Each block is a subgrid whose columns (or rows) are independent of the other block and can be analyzed on its own.</description>\n<example>With a vertical divider at column 5, you get a left block made of columns 1–4 and a right block made of columns 6–end. Work with those two blocks separately — you will count colors and look for repetition inside each block.</example>\n</note2>\n\n<note3>\n<description>Within each block, ignore the divider color and find the most frequent non-divider color; that color is the block’s representative. The transformation typically uses that representative color to form the output.</description>\n<example>If the left block contains many 6s and a few other colors while the right block contains many 6s too, then 6 is the dominant color in both blocks. That dominant color is the one you will use to fill the result.</example>\n</note3>\n\n<note4>\n<description>Compute the output dimensions from the block sizes: the number of rows equals the number of rows in the original grid, and the number of columns equals the number of columns on the side you chose (the side that contains the repeated motif). This gives a compact representation of the repeating structure.</description>\n<example>If the original has 8 rows and the right block has 4 columns, the output should be an 8×4 rectangle. If you had chosen the left block instead, the output would be 8×(left-block width).</example>\n</note4>\n\n<note5>\n<description>Fill the entire output rectangle with the chosen dominant color and verify consistency across examples: the same side and the same dominant color should explain all training pairs. If a training pair contradicts your choice, try the other side or re-check which color is truly dominant.</description>\n<example>After deciding the right block’s dominant color is 6 and the grid has 8 rows and 4 columns on that side, produce an 8×4 rectangle filled with 6. If that matches every training output, you have the correct rule; otherwise, re-evaluate which block or color to use.</example>\n</note5>","<note1>\n<description>Look for full-length rows or columns made of a single color: these act as separators that partition the grid into independent bands or tiles. Treat such a uniform row/column as a boundary rather than as part of the repeating unit. This reduces the problem to analyzing the blocks between separators.</description>\n<example>Imagine a grid where column 3 is entirely color X from top to bottom. That column splits the grid into a left block (columns 0–2) and a right block (columns 4–end). You can ignore the X column when determining the repeating pattern inside each block because it only separates tiles.</example>\n</note1>\n\n<note2>\n<description>Within each band, identify the dominant color that fills most cells (the background). The repeating unit you need to extract is typically the background color inside those bands. Focus on the color that appears most frequently inside the non-separator areas.</description>\n<example>For instance, if most cells in a band are color A and a few are other colors, treat A as the background. That background is what you should extract when forming the output tile, not the occasional other colors that appear inside the band.</example>\n</note2>\n\n<note3>\n<description>Compute the minimal bounding rectangle that contains all occurrences of the background color across the entire grid. That bounding rectangle is the canonical tile shape (height × width) to extract. Use the global min/max row and column indices of that color to get the rectangle.</description>\n<example>Suppose color A appears in scattered positions but always lies within rows 2–7 and columns 0–3. The bounding rectangle is rows 2..7 by columns 0..3; extract that rectangle as your tile. This captures the full repeating unit even if A appears in multiple places.</example>\n</note3>\n\n<note4>\n<description>Produce the output by repeating that extracted rectangle across the grid axes to cover the same dimensions as the input. Repeat the tile horizontally and vertically (tiling) until the output grid matches the input’s width and height. This preserves the repeating structure of the original.</description>\n<example>If your extracted tile is 3×2 and the input is 6×4, place two copies side-by-side and two copies top-to-bottom to make a 6×4 output. The result is a tiled copy of the canonical unit that reflects the original pattern.</example>\n</note4>\n\n<note5>\n<description>Watch for edge cases: separators can be horizontal or vertical, and the background may appear in several disconnected places. Always ignore separator rows/columns when computing the bounding rectangle, and choose the color that dominates inside the non-separator areas. If multiple candidate colors exist, pick the one with the largest total count (or the one that forms a contiguous block).</description>\n<example>If color B appears in several separate blocks while color C fills most of a single block, B is the likely background because it has the larger global count. If a full row of a color spans the entire width, treat it as a separator and do not include it in the bounding rectangle.</example>\n</note5>","<note1>\n<description>Look for a color that forms a continuous vertical line (the same color down many columns) and a continuous horizontal line (the same color across many rows). Those two lines usually act as separators that partition the grid into four rectangular regions.</description>\n<example>Imagine a 7×7 grid where column 3 is entirely blue and row 4 is entirely blue. Those blue lines split the grid into four blocks: top-left, top-right, bottom-left and bottom-right. Treat those blocks as independent subgrids to analyze further.</example>\n</note1>\n\n<note2>\n<description>Within each quadrant, ignore the separator color and find the dominant (most frequent) color — that is the quadrant’s fill color. The quadrant’s size (number of rows × number of columns) is the natural shape to extract for that fill color.</description>\n<example>For example, if the top-left block (rows 1–3, cols 1–2) contains mostly green pixels, record “green” and the block size 3×2. Do the same for the other three blocks, using their non-separator colors and sizes.</example>\n</note2>\n\n<note3>\n<description>Compare the four quadrant sizes and pick the largest one. If two or more quadrants tie for largest area, break the tie by preferring the quadrant that is more uniformly filled (higher fraction of its cells equal to its fill color).</description>\n<example>Suppose you have quadrant sizes 2×2, 2×4, 4×2 and 4×4. The 4×4 is the largest so it is the target. If two quadrants are both 4×4, check which one contains a higher proportion of its fill color (e.g., 100% vs 70%) and choose that one.</example>\n</note3>\n\n<note4>\n<description>Construct the output as a rectangle whose dimensions equal the chosen quadrant’s dimensions, and fill every cell with that quadrant’s dominant color. The output is therefore a uniform block of that color sized exactly like the selected quadrant.</description>\n<example>If the chosen quadrant is 2 rows by 4 columns and its dominant color is red, your output should be a 2×4 grid where every cell is red. This keeps the output shape and color consistent with the selected region.</example>\n</note4>\n\n<note5>\n<description>Be careful not to include the separator lines in the quadrant selection; separators can be more than one column or more than one row thick. Always verify that a candidate separator is continuous across the grid before using it to split quadrants.</description>\n<example>If a vertical divider is two columns wide, treat both columns as the divider and compute quadrant sizes from the remaining columns. If a supposed “divider” color appears only in isolated pixels, it is not a true separator and should be ignored when partitioning.</example>\n</note5>","<note1>\n<description>Search for vertical separators: a column whose cells are the same color down the entire height usually marks a boundary between repeated regions. Removing such columns simplifies the problem by exposing the repeating structure.</description>\n<example>Imagine a 7×5 grid where column 3 is color X in every row while other columns vary. If you remove column 3 you get two blocks (left and right) that are easier to compare; that X-column is acting as a divider between repeated patterns.</example>\n</note1>\n\n<note2>\n<description>After removing separators, compare the remaining columns pairwise from the outside in: often the first and last columns form a repeated pair, the second and second-last another, and so on. Identifying these mirror pairs reveals the fundamental tile width.</description>\n<example>For a 6-column region [A, B, C, B, A] (with separators removed), columns 1 and 6 match, 2 and 5 match, and 3 and 4 match. That tells you the pattern is built from three mirrored pairs rather than a single wide tile.</example>\n</note2>\n\n<note3>\n<description>Choose one representative column per mirrored pair by a consistent rule (for example, always take the rightmost column of each pair). This produces a smaller, unambiguous sequence of columns that captures the repeating motif.</description>\n<example>From [A, B, C, B, A] selecting the rightmost of each pair gives [C, B, A] (or equivalently [A, B, C] if you prefer the leftmost). Using the same side for every pair keeps the transformation deterministic.</example>\n</note3>\n\n<note4>\n<description>Decide which color to use for the output by counting the colors in the input: the most frequent color is usually the intended fill. Use that dominant color to color every cell of the reduced grid.</description>\n<example>If the input contains many more cells of color 6 than any other color, the reduced grid should be uniformly filled with 6. Counting colors gives a simple, robust rule for choosing the fill color.</example>\n</note4>\n\n<note5>\n<description>Assemble the final answer as a rectangle whose height equals the input height and whose width equals the number of representative columns you selected. Fill every cell with the chosen dominant color to produce the output grid.</description>\n<example>If your input is 9 rows tall and you determined there are 4 representative columns after collapsing mirrored pairs, the output should be a 9×4 rectangle where every cell is the dominant color from the input. This preserves the vertical extent while compressing the horizontal repetition.</example>\n</note5>","<note1>\n<description>Search for vertical \"spines\": columns whose color is identical in every row. These columns usually act as separators and are not part of the repeated content you need to extract.</description>\n<example>Imagine a 6×5 grid where column 3 is all color A while the other columns vary. Column 3 is a vertical spine; removing it leaves two side-by-side blocks that contain the repeating content. If you find one or more such constant columns, treat them as dividers rather than as part of the pattern.</example>\n</note1>\n\n<note2>\n<description>After removing spines, split the remaining columns into contiguous horizontal blocks and compare them. The correct block is the one that repeats across the grid (identical or nearly identical copies).</description>\n<example>For example, if the non-spine columns read [X X X X] then [Y Y Y Y] then [X X X X] you have two blocks (X and Y) with X repeating. The repeating block (X) is the one you should extract. If a block repeats more than once, that repetition is the key clue.</example>\n</note2>\n\n<note3>\n<description>Within the chosen repeating block, identify the dominant (most frequent) color — this is typically the color used to fill the final output. The output is uniformly that dominant color.</description>\n<example>Suppose the selected block is 3 columns wide and its rows are [C C C], [C C C], [B C C]. The dominant color is C (appears most often). The final output will be filled entirely with that dominant color.</example>\n</note3>\n\n<note4>\n<description>Decide the output dimensions by counting occurrences of the dominant color in the selected block: each row contributes exactly one cell for each occurrence of that color, so the height equals the number of rows and the width equals the number of occurrences of the dominant color per row (or equivalently the total count divided by the number of rows).</description>\n<example>If the chosen block has 2 rows and each row contains 4 occurrences of the dominant color, then the output should be 2 rows by 4 columns and filled with that color. If the block is 5 rows tall and each row has 2 occurrences, the output is 5×2 filled with the dominant color.</example>\n</note4>\n\n<note5>\n<description>Practical heuristics and pitfalls: ignore full-height constant columns when counting; if several candidate blocks repeat, prefer the block that repeats most consistently; if a block has ties, prefer the color that appears in every row of the block. Don’t confuse a color that only appears in spines with the dominant color inside the repeating block.</description>\n<example>For instance, if two blocks both repeat but one repeats exactly twice while the other repeats only once, choose the twice-repeating block. If a candidate block contains a color that also appears in the constant columns, still count the color only where it appears inside the block (not in the spine columns).</example>\n</note5>","<note1>\n<description>Look for a single color that runs straight across many rows or columns; such a color usually acts as a divider or separator. When a color appears as an uninterrupted vertical or horizontal stripe, treat it as a boundary that splits the grid into independent regions.</description>\n<example>Imagine a 6×6 grid where every row contains a blue pixel in the same column. That blue column is a vertical divider: it separates the left and right areas and should be considered a boundary rather than part of the repeating content.</example>\n</note1>\n\n<note2>\n<description>Once you find separators, remove (ignore) them and examine the remaining blocks between separators. The blocks between those boundaries are the true tiles or repeating units you should analyze.</description>\n<example>If you have vertical separators at two columns, removing them leaves three vertical blocks. Work on each block separately (they are the repeated pieces you need to count and compare).</example>\n</note2>\n\n<note3>\n<description>Inside each block, search for the dominant color — the one that fills most cells of that block. That dominant color is typically the content color to preserve; small accents or the separator color are usually not the target.</description>\n<example>For a 4×4 block that is mostly green with a few red pixels, choose green as the block's representative color. If a block is entirely one color, that color is trivially the representative.</example>\n</note3>\n\n<note4>\n<description>Decide which block(s) to keep by checking uniformity and repetition: keep the block(s) that are uniform or that repeat across the grid. If multiple blocks share the same representative color, include all of them; if only one block is uniform, keep just that one.</description>\n<example>If every block between separators is uniformly yellow, then the set of blocks is the whole pattern and you should keep them all. If only the middle block is uniform while others vary, keep only the uniform block.</example>\n</note4>\n\n<note5>\n<description>Construct the output as a rectangle whose height equals the number of kept blocks and whose width equals the width of each kept block. Fill every cell of that rectangle with the chosen representative color; do not include separator columns/rows in the output.</description>\n<example>If you keep two identical 3×3 blocks and their representative color is red, the output should be a 2×3 grid filled with red (two rows, three columns), not the original grid with separators.</example>\n</note5>"],"string":"[\n \"<note1>\\n<description>Look for full rows or full columns that are a single color; these often act as separators that split the grid into independent bands. When a whole row or whole column is identical across its length, it is usually a deliberate divider rather than part of a tile. Treat such lines as boundaries when you want to isolate the repeating region.</description>\\n<example>Imagine a grid where every 4th row is entirely green; those green rows are not part of the repeating motif but divide the grid into horizontal bands. Remove (or ignore) those green rows and you will see a sequence of bands that are easier to analyze. A similar idea applies if a column is entirely one color: it separates left and right blocks.</example>\\n</note1>\\n\\n<note2>\\n<description>After removing separator rows/columns, group adjacent rows (or columns) that are identical into contiguous runs; each run corresponds to a single repetition of the underlying tile. Counting these runs gives you the number of repeated blocks along that axis. This reduces the problem from a large grid to a smaller grid of repeated blocks.</description>\\n<example>For example, if the non-separator rows read A,A,B,B,C,C (where A,B,C are distinct row patterns), there are three runs: A-run, B-run, C-run. Those runs tell you there are three stacked tiles vertically. Do the same for columns to get the horizontal count.</example>\\n</note2>\\n\\n<note3>\\n<description>Find the tile’s interior color by inspecting the non-separator cells: the color that appears most often (or forms the repeated interior pattern) is usually the one to use for the output. Separator colors are typically different and should be ignored when choosing the representative color. This gives you the color to fill the compact output.</description>\\n<example>Suppose after removing separators the interior cells are mostly blue, with occasional single different pixels; blue is the dominant interior color and is the natural choice to represent the tile. If two interior colors tie, prefer the one that appears in the central or majority of tiles.</example>\\n</note3>\\n\\n<note4>\\n<description>Construct the output as a compact grid whose dimensions equal the counts of the contiguous runs you found: rows = number of horizontal runs, columns = number of vertical runs. Fill every cell of that small grid with the chosen interior color. This preserves the tiling structure but in a condensed form.</description>\\n<example>If you discovered two horizontal runs and three vertical runs, produce a 2×3 grid and fill every cell with the interior color you identified. That small grid is a direct representation of how many repeats occurred in each direction.</example>\\n</note4>\\n\\n<note5>\\n<description>Be careful not to confuse separator lines with the tile interior: separators may appear as a different color that repeats across the whole row/column and should be excluded from the run counts. Also, if a separator color sometimes appears inside tiles, use the full-row/full-column test (uniform across the entire row/column) to decide whether it is a divider. This avoids miscounting runs.</description>\\n<example>For instance, a color that appears only as a complete column should be treated as a separator and removed before counting runs; if the same color also appears sporadically inside tiles, only the columns/rows that are entirely that color count as separators. A quick check: verify whether a candidate separator is uniform across its entire length before excluding it.</example>\\n</note5>\",\n \"<note1>\\n<description>Look for a vertical axis: a column whose color is identical in every row. Such a column usually serves as a divider that separates the grid into left and right regions; finding it simplifies the problem into two independent areas.</description>\\n<example>Imagine a 7×5 grid where column 3 is color X in every row. That column cleanly splits the grid into a left block (columns 1–2) and a right block (columns 4–5). Treat the two blocks separately rather than trying to operate across the whole grid.</example>\\n</note1>\\n\\n<note2>\\n<description>After locating the divider, split the grid into the left and right blocks and inspect their internal structure. One side will typically be a repeated tile (same small pattern across many rows or columns) while the other side may be mostly uniform or act as a separator.</description>\\n<example>For example, if the left block contains the same 3-column pattern repeated down the rows while the right block is mostly a single color, the left block is the repeating region and the right block is a separator or filler.</example>\\n</note2>\\n\\n<note3>\\n<description>Identify the dominant (most frequent) color inside the repeating region. The transformation usually extracts the color that appears most often in that region, ignoring the divider and any filler color that appears only in separators or at edges.</description>\\n<example>If the left block is made of a small tile repeated many times and color A occupies the majority of those tiles, then A is the dominant color to use in the output rather than a color that appears only in the divider or occasional filler rows.</example>\\n</note3>\\n\\n<note4>\\n<description>Derive the output size from the repeating region: count how many rows and how many columns the repeating tile occupies. The output grid’s dimensions are typically the height and width of that repeating tile (not the whole input grid).</description>\\n<example>If the left block is 8 rows tall and its repeating unit is 2 columns wide, the output should be an 8×2 rectangle (one rectangle per row of the repeating tile), filled with the dominant color.</example>\\n</note4>\\n\\n<note5>\\n<description>Construct the final grid by creating a rectangle with the measured height and width and filling every cell with the dominant color. Be careful to exclude the divider column and any uniform separator rows/columns when measuring size and choosing the dominant color.</description>\\n<example>For instance, if you find a repeating region 6 rows high and 2 columns wide whose most frequent color is A, produce a 6×2 grid where every cell is A. A common pitfall is including the divider column in the size or selecting the divider’s color by mistake—avoid that.</example>\\n</note5>\",\n \"<note1>\\n<description>Look for a single color that forms uninterrupted vertical stripes across many rows — this color is usually a divider, not part of the motif. Treat those divider columns as separators and remove them to reveal the repeating motif between them.</description>\\n<example>Imagine a grid where column 3 is the same color in every row and column 7 is the same color in every row; those two columns split the grid into three vertical bands. Removing the two uniform columns exposes the bands you should analyze next.</example>\\n</note1>\\n\\n<note2>\\n<description>After removing divider columns, each remaining band is a small tile that repeats across the width. Identify the minimal horizontal period: the smallest number of adjacent columns that, when repeated, reconstructs the non-divider columns.</description>\\n<example>If the non-divider columns read [A B C A B C A B C], the minimal horizontal period is 3 (A B C). If they read [X Y X Y X Y], the period is 2 (X Y). Use that period to slice the grid into equal-width tiles.</example>\\n</note2>\\n\\n<note3>\\n<description>Do the same vertically: find columns that are uniform down the grid and remove them to reveal stacked tiles. Then determine the minimal vertical period — the smallest number of rows that repeats to cover the non-divider rows.</description>\\n<example>If rows look like [R S R S R], the vertical period is 2 (R S). If rows are [T U T U T U], the period is 2 (T U). These vertical periods define how many stacked tiles to consider.</example>\\n</note3>\\n\\n<note4>\\n<description>The number of distinct horizontal tiles (the number of non-divider bands) is the output width, and the number of distinct vertical tiles (stacked bands) is the output height. The output grid size is therefore (#vertical tiles) × (#horizontal tiles).</description>\\n<example>If you find 4 stacked bands and 3 horizontal bands after removing dividers, the output should be 4 rows by 3 columns. If you find 2 stacked bands and 5 horizontal bands, the output should be 2×5.</example>\\n</note4>\\n\\n<note5>\\n<description>Fill the output rectangle with a single color that is consistent across the tiles — typically the dominant non-divider color (the color that appears most often inside the repeating tiles). This gives a uniform block that mirrors the repeated structure.</description>\\n<example>If the repeated tiles are mostly color 6, produce an output grid of the computed dimensions filled entirely with 6. Pitfall: do not include the divider color in this fill — dividers are structural and should be ignored when choosing the fill color.</example>\\n</note5>\",\n \"<note1>\\n<description>Look for a column whose color is identical in every row; such a column acts as a vertical divider and splits the grid into left and right regions. This divider is usually a single color repeated down the whole grid and is the first structural clue to the transformation.</description>\\n<example>Imagine a 5×7 grid where column 3 contains the same color in every row while other columns vary. That column cleanly separates the grid into a left block (columns 0–2) and a right block (columns 4–6); treat that uniform column as a divider and ignore it when extracting the repeating pattern.</example>\\n</note1>\\n\\n<note2>\\n<description>After locating the divider, focus on the side that repeats the same small pattern across many rows (the left or right region). The repeating region is what you should compress — the divider and the non-repeating side are usually irrelevant to the final output.</description>\\n<example>If the left block contains the same 4-column pattern in most rows while the right block shows many different colors, extract the left block and ignore the divider and right block. The repeating left block is the region you will compress into the output.</example>\\n</note2>\\n\\n<note3>\\n<description>Compress each row of the chosen repeating block horizontally by collapsing consecutive identical cells into a single cell. This preserves the order of runs but reduces width to the number of distinct horizontal runs per row.</description>\\n<example>A row like [A,A,A,B,B,C,C] becomes [A,B,C] after collapsing consecutive runs. Do this for every row in the repeating block so each row becomes a shorter sequence of distinct horizontal runs.</example>\\n</note3>\\n\\n<note4>\\n<description>After collapsing, remove any rows that are entirely the same color (all-collapsed cells equal). Those uniform rows are often padding and should be deleted so the result reflects only the meaningful vertical runs.</description>\\n<example>If after collapsing you have rows [X,X,X], [Y,Y,Y], [X,X,X] (where X and Y are single-cell colors), drop the first and third rows because they are identical uniform rows and keep only the middle row [Y,Y,Y].</example>\\n</note4>\\n\\n<note5>\\n<description>Finally, take the collapsed-and-pruned block and make the output square: if the block has more rows than columns, duplicate the top rows until you reach the target size; if it has fewer rows, repeat the bottom rows. The result is a square grid whose side length equals the maximum of the collapsed row and column counts.</description>\\n<example>If your collapsed block is 3×2 (3 rows, 2 columns), append a copy of the first row to make 4×2, then append another copy of the first row to reach 6×2, and finally append the last row to reach 6×6. This keeps the original vertical order and produces a square output.</example>\\n</note5>\",\n \"<note1>\\n<description>Look for a column that is the same color in every row: such a column usually acts as a vertical divider or separator. Finding it simplifies the problem because it partitions the grid into a left block and a right block (or a single block if the divider is the only column).</description>\\n<example>Imagine a grid where column 3 is color X in every row. That column separates the left columns (before X) from the right columns (after X). Treat that column as a boundary when reasoning about the repeating structure.</example>\\n</note1>\\n\\n<note2>\\n<description>Compare the left and right blocks to see if they are mirror images. Often the right block is just a horizontal reflection of the left block, so you only need to examine one side to understand the full pattern.</description>\\n<example>For example, if the left block's columns read [A, B, C] and the right block reads [C, B, A], the right side is a mirror of the left. Once you identify the left block, the right block is determined by that mirror.</example>\\n</note2>\\n\\n<note3>\\n<description>Within the repeating block (the left or right side), identify the dominant color — the one that appears most frequently across that block. The transformation typically uses that dominant color as the output fill.</description>\\n<example>If the left block contains mostly color 0 with occasional other colors, 0 is the dominant color. Use that color as the single color to fill the output rectangle.</example>\\n</note3>\\n\\n<note4>\\n<description>Decide the output size from the repeating block's dimensions. Count how many columns (or rows) the repeating block occupies before the divider; that count becomes the output width (or height), and the output height is taken from the input height.</description>\\n<example>If the repeating block occupies 4 columns across the grid, the output width will be 4. If the repeating block occupies 2 rows, the output height will be 2. Combine those counts to get the rectangle dimensions.</example>\\n</note4>\\n\\n<note5>\\n<description>Assemble the final grid by creating a rectangle with the computed dimensions and filling every cell with the dominant color from the repeating block. This produces a uniform block that summarizes the repeated structure.</description>\\n<example>After determining the block width and height and the dominant color, produce a rectangle of that size and fill it entirely with the dominant color. That rectangle is the intended output representation of the repeating pattern.</example>\\n</note5>\",\n \"<note1>\\n<description>Look for columns that are the same color from top to bottom: these are strong structural separators. When a column's color never changes across rows, it usually marks a boundary between repeating blocks and is best treated as a divider rather than part of the repeating content.</description>\\n<example>Imagine a grid where column 4 is blue in every row while other columns vary. That blue column splits the grid into left and right regions; you can treat the blue column as a separator and focus on the two regions it creates.</example>\\n</note1>\\n\\n<note2>\\n<description>After removing separator columns, compare the remaining columns in groups of two (pair adjacent columns). If the first column of a pair matches the second, they form a repeated column-pair; if not, that pair is a separator/exception and should be removed before pairing.</description>\\n<example>Suppose the non-separator columns read [A, A, B, C, A, A, D, E]. Pairing adjacent columns gives (A,A),(B,C),(A,A),(D,E). The first and third pairs are identical and therefore represent one repeated column-pair; the middle pair is an exception and should be dropped before pairing.</example>\\n</note2>\\n\\n<note3>\\n<description>Count distinct column-pairs that are identical: each identical adjacent pair reduces the number of distinct columns by one. The final number of distinct column-pairs (distinct after removing separator columns) is the output width.</description>\\n<example>If after removing separators you find the sequence of column-pairs [X,X,Y,Z,X,X], the distinct pairs are {X,Y,Z}, so the output width is 3 (one column for each distinct pair).</example>\\n</note3>\\n\\n<note4>\\n<description>Decide the output height by counting the number of rows that contain the repeated block. Rows that contain the repeated pattern are the ones that contribute to the output height; rows that are uniform or otherwise different should not be counted.</description>\\n<example>If the patterned rows (those containing the repeated column-pairs) appear in rows 2, 4 and 7, the output height is 3. If a whole row is a uniform color and does not show the repeated pattern, it does not increase the height.</example>\\n</note4>\\n\\n<note5>\\n<description>Fill the output grid with the dominant (most frequent) non-separator color that appears in the repeated blocks. Use the distinct-pair count for width and the pattern-row count for height, then color every cell with that dominant color.</description>\\n<example>After determining width = 4 and height = 3, and finding that color A is the most common non-separator color, the final output is a 3×4 grid where every cell is A. This preserves the structural counts while using the repeated-color as the fill.</example>\\n</note5>\",\n \"<note1>\\n<description>Look for a vertical divider: a column whose cells all share the same color and run the full height of the grid. Such a column usually acts as a seam separating two repeating regions and is the first structural clue to the transformation.</description>\\n<example>Imagine a 7×5 grid where column 4 is entirely color X while the other columns vary. That column is a clear vertical seam; treat it as a boundary rather than part of the repeating motif. If you find multiple such full-height columns, treat them as multiple separators.</example>\\n</note1>\\n\\n<note2>\\n<description>Measure the repetition period between separators: the number of columns between two adjacent full-height separator columns (or between a separator and the grid edge) gives the horizontal tile width. The repeating block is the region that appears identically on both sides of the seam(s).</description>\\n<example>For example, if you find full-height columns at positions 3 and 7, the gap between them is 3 columns, so the repeating tile width is 3. If the pattern repeats every 3 columns, that width is the unit you should extract.</example>\\n</note2>\\n\\n<note3>\\n<description>Extract the basic tile (the rectangle of columns between separators) and then reduce it to its background color: the tile often contains a single dominant color that represents the motif. Replacing the tile with that dominant color produces the compact motif you need.</description>\\n<example>Suppose a 3-column tile contains mostly color A with a few other pixels; the motif is best represented by a 3×H block filled with color A (H = tile height). If the tile is already uniform, the reduced motif is that single color.</example>\\n</note3>\\n\\n<note4>\\n<description>Decide the output height by counting full motif occurrences: count how many times the full-height separator appears (or how many full motifs fit vertically). That count typically becomes the number of rows in the final output.</description>\\n<example>If the input shows two full-height separator columns (so two separators total), you would expect two stacked motif blocks; the output height would be 2. If separators are absent, count how many complete tiles appear vertically in the input instead.</example>\\n</note4>\\n\\n<note5>\\n<description>Assemble the final grid: place the reduced motif block (width = tile width, height = motif height) in a square whose side equals the number of motif occurrences (or the number of separators). The output is a compact square showing the repeating unit in isolation.</description>\\n<example>For instance, if you determine the tile is 2 columns wide and you counted 4 full-height separators, produce a 4×4 grid where every cell is the tile’s dominant color. This yields a clean, square representation of the repeating motif.</example>\\n</note5>\",\n \"<note1>\\n<description>Look for vertical divider columns: a column whose color is the same in every row usually separates independent column-blocks. Treat each contiguous set of columns between such dividers as one block to analyze.</description>\\n<example>Imagine a grid where column 4 is all color X and column 8 is all color X; those two columns split the grid into three blocks (columns 1–3, 5–7, 9–end). Work on each block separately rather than the whole grid at once.</example>\\n</note1>\\n\\n<note2>\\n<description>Within a block, identify the dominant color: the color that appears most often across that block (ignore the divider color). That dominant color is typically the one you should extract or use to form the output.</description>\\n<example>If a block of 3 columns contains mostly color A with a few B and C pixels, choose A as the block’s representative. If two colors tie, prefer the one that is more frequent overall or more centrally placed in the block.</example>\\n</note2>\\n\\n<note3>\\n<description>Compute the block’s vertical span: find the topmost and bottommost rows where the block’s dominant color appears, and take the count of those rows as the block height. That height becomes the output height for the block.</description>\\n<example>If the dominant color in a block appears from row 2 to row 10, the block height is 9. If it appears in only a single row, the height is 1.</example>\\n</note3>\\n\\n<note4>\\n<description>Assemble the final grid by repeating the dominant-color block for each contiguous block: each repeated block has the block’s height and a width equal to the block’s width. The final output is a stack of these blocks in left-to-right order.</description>\\n<example>Two blocks of widths 2 and 3 with heights 5 and 1 become a 5-row output whose first two columns are filled with the first block’s color and the next three columns are filled with the second block’s color.</example>\\n</note4>\\n\\n<note5>\\n<description>Handle edge cases consistently: ignore divider columns when counting colors; if a block contains no occurrences of its dominant color, treat that block as height 1 (a single row) and fill it with the dominant color. Always preserve the left-to-right order of blocks.</description>\\n<example>If a block is entirely filled with the dominant color, its height is the full block height; if a block has no dominant-color pixels, output a single row of that color. This keeps the output compact and ordered.</example>\\n</note5>\",\n \"<note1>\\n<description>Look for rows or columns that are entirely one color; such uniform lines usually serve as separators that partition the grid into independent bands. Treat those full-color rows/columns as boundaries rather than as part of the repeated content.</description>\\n<example>Imagine a grid where every cell in column 3 is color A while other columns contain mixed colors. Column 3 is a vertical divider: split the grid at that column and analyze the left and right bands separately. This reduces the problem to smaller, simpler subgrids.</example>\\n</note1>\\n\\n<note2>\\n<description>After splitting, inspect each band for a repeating structure: many tasks use a small tile repeated across the band. Determine the minimal horizontal and vertical period by finding the smallest shift that reproduces the same pattern inside the band.</description>\\n<example>For a band of width 8 made by repeating a 2-column pattern, shifting two columns will show the same arrangement. The minimal period is 2 columns; similarly, if rows repeat every 4 rows, the vertical period is 4. Use those periods to infer the tile size.</example>\\n</note2>\\n\\n<note3>\\n<description>Within a band, identify the color that consistently occupies the same relative positions inside the tile — this is the motif color. It is typically the color that appears in the same positions across many repeats and is not the divider color.</description>\\n<example>Suppose each 2×2 tile contains the same color in its top-left corner while the rest of the tile varies. That color is the motif; you can mark it by checking the same relative cell in several tiles. Once found, that color is the one you will use to fill the output block.</example>\\n</note3>\\n\\n<note4>\\n<description>Count how many tiles fit horizontally and vertically: divide the band width by the horizontal period and the band height by the vertical period. Those counts determine the dimensions of the abstracted output grid.</description>\\n<example>If a band is 12 columns wide and the horizontal period is 3, there are 4 tiles across. If the band height is 6 and the vertical period is 3, there are 2 tiles down. The output grid should have 4 columns and 2 rows (one cell per tile).</example>\\n</note4>\\n\\n<note5>\\n<description>Build the final output by creating a grid with the tile-count dimensions and filling every cell with the motif color you identified. This compresses the repeated structure into a compact representation.</description>\\n<example>From the previous counts (4×2) and motif color X, produce a 4×2 grid where every cell is X. Verify by mentally expanding that output back into the original tile layout — the motif should appear in the same relative positions as in the input.</example>\\n</note5>\",\n \"<note1>\\n<description>Look for full-length uniform lines: a column or row whose every cell is the same color. These lines usually act as separators that split the grid into repeating blocks and are easy to spot because they span the entire grid dimension.</description>\\n<example>Imagine a 7×5 grid where column 3 is entirely color X while other columns vary. That column cleanly divides the grid into left and right regions; treat it as a separator rather than part of the repeating pattern.</example>\\n</note1>\\n\\n<note2>\\n<description>Use those separator lines to segment the grid into rectangular tiles: the regions between successive separator rows and columns form the tiles. The tile dimensions are simply the gaps between separators (or edges).</description>\\n<example>If you find two vertical separators and one horizontal separator, you get three vertical bands and two horizontal bands, so the grid is partitioned into a 3×2 array of tiles. Each tile is the rectangle between adjacent separators or between a separator and the edge.</example>\\n</note2>\\n\\n<note3>\\n<description>Identify the tile interior by excluding any row/column that is a uniform separator. Inside a tile, pick a color that appears repeatedly across tiles (ignore separator colors) — that recurring interior color is the one to use for the output.</description>\\n<example>Suppose every tile (except the separator rows/columns) contains many pixels of color A while separators are color B. A is the tile interior color; choose A rather than B or the occasional stray color.</example>\\n</note3>\\n\\n<note4>\\n<description>Form the output by taking the count of tile rows and the count of tile columns (the number of horizontal bands and vertical bands). Create an output grid of that size and fill every cell with the chosen interior color.</description>\\n<example>If the partitioning yields 4 horizontal bands and 3 vertical bands, produce a 4×3 grid where every cell is the selected interior color — the output is a compact representation of the tile array.</example>\\n</note4>\\n\\n<note5>\\n<description>Heuristics and pitfalls: only treat a line as a separator if it is uniform across its entire length; do not confuse a mostly-uniform line with a separator. If several colors repeat inside tiles, prefer the color that appears most consistently across tiles; always exclude separator colors from the final fill.</description>\\n<example>If a column has one or two different pixels, it is not a separator — keep it as part of the tile. If two interior colors appear but one occurs in every tile while the other is sporadic, pick the consistent one and ignore any full-length separator lines when computing tile counts.</example>\\n</note5>\",\n \"<note1>\\n<description>Search the grid for a column or row whose cells are all the same color; such a uniform line usually acts as a divider or background. When present, it separates the grid into independent regions (left/right or top/bottom) that you should treat separately.</description>\\n<example>Imagine a grid where column 4 is entirely color 7 while the other columns vary. That column is a clear vertical divider: everything left of it is one region and everything right of it is another. Treat that column as a boundary rather than part of the repeating content.</example>\\n</note1>\\n\\n<note2>\\n<description>After you identify a divider, split the grid into the contiguous blocks on either side of it. Each block is a subgrid whose columns (or rows) are independent of the other block and can be analyzed on its own.</description>\\n<example>With a vertical divider at column 5, you get a left block made of columns 1–4 and a right block made of columns 6–end. Work with those two blocks separately — you will count colors and look for repetition inside each block.</example>\\n</note2>\\n\\n<note3>\\n<description>Within each block, ignore the divider color and find the most frequent non-divider color; that color is the block’s representative. The transformation typically uses that representative color to form the output.</description>\\n<example>If the left block contains many 6s and a few other colors while the right block contains many 6s too, then 6 is the dominant color in both blocks. That dominant color is the one you will use to fill the result.</example>\\n</note3>\\n\\n<note4>\\n<description>Compute the output dimensions from the block sizes: the number of rows equals the number of rows in the original grid, and the number of columns equals the number of columns on the side you chose (the side that contains the repeated motif). This gives a compact representation of the repeating structure.</description>\\n<example>If the original has 8 rows and the right block has 4 columns, the output should be an 8×4 rectangle. If you had chosen the left block instead, the output would be 8×(left-block width).</example>\\n</note4>\\n\\n<note5>\\n<description>Fill the entire output rectangle with the chosen dominant color and verify consistency across examples: the same side and the same dominant color should explain all training pairs. If a training pair contradicts your choice, try the other side or re-check which color is truly dominant.</description>\\n<example>After deciding the right block’s dominant color is 6 and the grid has 8 rows and 4 columns on that side, produce an 8×4 rectangle filled with 6. If that matches every training output, you have the correct rule; otherwise, re-evaluate which block or color to use.</example>\\n</note5>\",\n \"<note1>\\n<description>Look for full-length rows or columns made of a single color: these act as separators that partition the grid into independent bands or tiles. Treat such a uniform row/column as a boundary rather than as part of the repeating unit. This reduces the problem to analyzing the blocks between separators.</description>\\n<example>Imagine a grid where column 3 is entirely color X from top to bottom. That column splits the grid into a left block (columns 0–2) and a right block (columns 4–end). You can ignore the X column when determining the repeating pattern inside each block because it only separates tiles.</example>\\n</note1>\\n\\n<note2>\\n<description>Within each band, identify the dominant color that fills most cells (the background). The repeating unit you need to extract is typically the background color inside those bands. Focus on the color that appears most frequently inside the non-separator areas.</description>\\n<example>For instance, if most cells in a band are color A and a few are other colors, treat A as the background. That background is what you should extract when forming the output tile, not the occasional other colors that appear inside the band.</example>\\n</note2>\\n\\n<note3>\\n<description>Compute the minimal bounding rectangle that contains all occurrences of the background color across the entire grid. That bounding rectangle is the canonical tile shape (height × width) to extract. Use the global min/max row and column indices of that color to get the rectangle.</description>\\n<example>Suppose color A appears in scattered positions but always lies within rows 2–7 and columns 0–3. The bounding rectangle is rows 2..7 by columns 0..3; extract that rectangle as your tile. This captures the full repeating unit even if A appears in multiple places.</example>\\n</note3>\\n\\n<note4>\\n<description>Produce the output by repeating that extracted rectangle across the grid axes to cover the same dimensions as the input. Repeat the tile horizontally and vertically (tiling) until the output grid matches the input’s width and height. This preserves the repeating structure of the original.</description>\\n<example>If your extracted tile is 3×2 and the input is 6×4, place two copies side-by-side and two copies top-to-bottom to make a 6×4 output. The result is a tiled copy of the canonical unit that reflects the original pattern.</example>\\n</note4>\\n\\n<note5>\\n<description>Watch for edge cases: separators can be horizontal or vertical, and the background may appear in several disconnected places. Always ignore separator rows/columns when computing the bounding rectangle, and choose the color that dominates inside the non-separator areas. If multiple candidate colors exist, pick the one with the largest total count (or the one that forms a contiguous block).</description>\\n<example>If color B appears in several separate blocks while color C fills most of a single block, B is the likely background because it has the larger global count. If a full row of a color spans the entire width, treat it as a separator and do not include it in the bounding rectangle.</example>\\n</note5>\",\n \"<note1>\\n<description>Look for a color that forms a continuous vertical line (the same color down many columns) and a continuous horizontal line (the same color across many rows). Those two lines usually act as separators that partition the grid into four rectangular regions.</description>\\n<example>Imagine a 7×7 grid where column 3 is entirely blue and row 4 is entirely blue. Those blue lines split the grid into four blocks: top-left, top-right, bottom-left and bottom-right. Treat those blocks as independent subgrids to analyze further.</example>\\n</note1>\\n\\n<note2>\\n<description>Within each quadrant, ignore the separator color and find the dominant (most frequent) color — that is the quadrant’s fill color. The quadrant’s size (number of rows × number of columns) is the natural shape to extract for that fill color.</description>\\n<example>For example, if the top-left block (rows 1–3, cols 1–2) contains mostly green pixels, record “green” and the block size 3×2. Do the same for the other three blocks, using their non-separator colors and sizes.</example>\\n</note2>\\n\\n<note3>\\n<description>Compare the four quadrant sizes and pick the largest one. If two or more quadrants tie for largest area, break the tie by preferring the quadrant that is more uniformly filled (higher fraction of its cells equal to its fill color).</description>\\n<example>Suppose you have quadrant sizes 2×2, 2×4, 4×2 and 4×4. The 4×4 is the largest so it is the target. If two quadrants are both 4×4, check which one contains a higher proportion of its fill color (e.g., 100% vs 70%) and choose that one.</example>\\n</note3>\\n\\n<note4>\\n<description>Construct the output as a rectangle whose dimensions equal the chosen quadrant’s dimensions, and fill every cell with that quadrant’s dominant color. The output is therefore a uniform block of that color sized exactly like the selected quadrant.</description>\\n<example>If the chosen quadrant is 2 rows by 4 columns and its dominant color is red, your output should be a 2×4 grid where every cell is red. This keeps the output shape and color consistent with the selected region.</example>\\n</note4>\\n\\n<note5>\\n<description>Be careful not to include the separator lines in the quadrant selection; separators can be more than one column or more than one row thick. Always verify that a candidate separator is continuous across the grid before using it to split quadrants.</description>\\n<example>If a vertical divider is two columns wide, treat both columns as the divider and compute quadrant sizes from the remaining columns. If a supposed “divider” color appears only in isolated pixels, it is not a true separator and should be ignored when partitioning.</example>\\n</note5>\",\n \"<note1>\\n<description>Search for vertical separators: a column whose cells are the same color down the entire height usually marks a boundary between repeated regions. Removing such columns simplifies the problem by exposing the repeating structure.</description>\\n<example>Imagine a 7×5 grid where column 3 is color X in every row while other columns vary. If you remove column 3 you get two blocks (left and right) that are easier to compare; that X-column is acting as a divider between repeated patterns.</example>\\n</note1>\\n\\n<note2>\\n<description>After removing separators, compare the remaining columns pairwise from the outside in: often the first and last columns form a repeated pair, the second and second-last another, and so on. Identifying these mirror pairs reveals the fundamental tile width.</description>\\n<example>For a 6-column region [A, B, C, B, A] (with separators removed), columns 1 and 6 match, 2 and 5 match, and 3 and 4 match. That tells you the pattern is built from three mirrored pairs rather than a single wide tile.</example>\\n</note2>\\n\\n<note3>\\n<description>Choose one representative column per mirrored pair by a consistent rule (for example, always take the rightmost column of each pair). This produces a smaller, unambiguous sequence of columns that captures the repeating motif.</description>\\n<example>From [A, B, C, B, A] selecting the rightmost of each pair gives [C, B, A] (or equivalently [A, B, C] if you prefer the leftmost). Using the same side for every pair keeps the transformation deterministic.</example>\\n</note3>\\n\\n<note4>\\n<description>Decide which color to use for the output by counting the colors in the input: the most frequent color is usually the intended fill. Use that dominant color to color every cell of the reduced grid.</description>\\n<example>If the input contains many more cells of color 6 than any other color, the reduced grid should be uniformly filled with 6. Counting colors gives a simple, robust rule for choosing the fill color.</example>\\n</note4>\\n\\n<note5>\\n<description>Assemble the final answer as a rectangle whose height equals the input height and whose width equals the number of representative columns you selected. Fill every cell with the chosen dominant color to produce the output grid.</description>\\n<example>If your input is 9 rows tall and you determined there are 4 representative columns after collapsing mirrored pairs, the output should be a 9×4 rectangle where every cell is the dominant color from the input. This preserves the vertical extent while compressing the horizontal repetition.</example>\\n</note5>\",\n \"<note1>\\n<description>Search for vertical \\\"spines\\\": columns whose color is identical in every row. These columns usually act as separators and are not part of the repeated content you need to extract.</description>\\n<example>Imagine a 6×5 grid where column 3 is all color A while the other columns vary. Column 3 is a vertical spine; removing it leaves two side-by-side blocks that contain the repeating content. If you find one or more such constant columns, treat them as dividers rather than as part of the pattern.</example>\\n</note1>\\n\\n<note2>\\n<description>After removing spines, split the remaining columns into contiguous horizontal blocks and compare them. The correct block is the one that repeats across the grid (identical or nearly identical copies).</description>\\n<example>For example, if the non-spine columns read [X X X X] then [Y Y Y Y] then [X X X X] you have two blocks (X and Y) with X repeating. The repeating block (X) is the one you should extract. If a block repeats more than once, that repetition is the key clue.</example>\\n</note2>\\n\\n<note3>\\n<description>Within the chosen repeating block, identify the dominant (most frequent) color — this is typically the color used to fill the final output. The output is uniformly that dominant color.</description>\\n<example>Suppose the selected block is 3 columns wide and its rows are [C C C], [C C C], [B C C]. The dominant color is C (appears most often). The final output will be filled entirely with that dominant color.</example>\\n</note3>\\n\\n<note4>\\n<description>Decide the output dimensions by counting occurrences of the dominant color in the selected block: each row contributes exactly one cell for each occurrence of that color, so the height equals the number of rows and the width equals the number of occurrences of the dominant color per row (or equivalently the total count divided by the number of rows).</description>\\n<example>If the chosen block has 2 rows and each row contains 4 occurrences of the dominant color, then the output should be 2 rows by 4 columns and filled with that color. If the block is 5 rows tall and each row has 2 occurrences, the output is 5×2 filled with the dominant color.</example>\\n</note4>\\n\\n<note5>\\n<description>Practical heuristics and pitfalls: ignore full-height constant columns when counting; if several candidate blocks repeat, prefer the block that repeats most consistently; if a block has ties, prefer the color that appears in every row of the block. Don’t confuse a color that only appears in spines with the dominant color inside the repeating block.</description>\\n<example>For instance, if two blocks both repeat but one repeats exactly twice while the other repeats only once, choose the twice-repeating block. If a candidate block contains a color that also appears in the constant columns, still count the color only where it appears inside the block (not in the spine columns).</example>\\n</note5>\",\n \"<note1>\\n<description>Look for a single color that runs straight across many rows or columns; such a color usually acts as a divider or separator. When a color appears as an uninterrupted vertical or horizontal stripe, treat it as a boundary that splits the grid into independent regions.</description>\\n<example>Imagine a 6×6 grid where every row contains a blue pixel in the same column. That blue column is a vertical divider: it separates the left and right areas and should be considered a boundary rather than part of the repeating content.</example>\\n</note1>\\n\\n<note2>\\n<description>Once you find separators, remove (ignore) them and examine the remaining blocks between separators. The blocks between those boundaries are the true tiles or repeating units you should analyze.</description>\\n<example>If you have vertical separators at two columns, removing them leaves three vertical blocks. Work on each block separately (they are the repeated pieces you need to count and compare).</example>\\n</note2>\\n\\n<note3>\\n<description>Inside each block, search for the dominant color — the one that fills most cells of that block. That dominant color is typically the content color to preserve; small accents or the separator color are usually not the target.</description>\\n<example>For a 4×4 block that is mostly green with a few red pixels, choose green as the block's representative color. If a block is entirely one color, that color is trivially the representative.</example>\\n</note3>\\n\\n<note4>\\n<description>Decide which block(s) to keep by checking uniformity and repetition: keep the block(s) that are uniform or that repeat across the grid. If multiple blocks share the same representative color, include all of them; if only one block is uniform, keep just that one.</description>\\n<example>If every block between separators is uniformly yellow, then the set of blocks is the whole pattern and you should keep them all. If only the middle block is uniform while others vary, keep only the uniform block.</example>\\n</note4>\\n\\n<note5>\\n<description>Construct the output as a rectangle whose height equals the number of kept blocks and whose width equals the width of each kept block. Fill every cell of that rectangle with the chosen representative color; do not include separator columns/rows in the output.</description>\\n<example>If you keep two identical 3×3 blocks and their representative color is red, the output should be a 2×3 grid filled with red (two rows, three columns), not the original grid with separators.</example>\\n</note5>\"\n]","isConversational":false},"train":{"kind":"string","value":"[{\"input\": [[6, 1, 6, 6], [9, 1, 9, 9], [6, 1, 6, 6], [6, 1, 6, 6], [2, 1, 2, 2], [6, 1, 6, 6], [6, 1, 6, 6], [6, 1, 6, 6], [1, 1, 1, 1], [6, 1, 6, 6], [1, 1, 1, 1], [6, 1, 6, 6], [4, 1, 4, 4], [6, 1, 6, 6], [6, 1, 6, 6], [1, 1, 1, 1], [6, 1, 6, 6], [6, 1, 6, 6], [6, 1, 6, 6], [6, 1, 6, 6], [0, 1, 0, 0], [6, 1, 6, 6]], \"output\": [[6, 6], [6, 6], [6, 6], [6, 6], [6, 6], [6, 6], [6, 6], [6, 6]]}, {\"input\": [[6, 9, 6], [1, 9, 1], [6, 9, 6], [6, 9, 6], [6, 9, 6], [3, 9, 3], [6, 9, 6], [6, 9, 6], [6, 9, 6], [6, 9, 6], [2, 9, 2], [6, 9, 6], [5, 9, 5], [6, 9, 6], [7, 9, 7], [6, 9, 6], [6, 9, 6], [6, 9, 6], [6, 9, 6], [9, 9, 9], [6, 9, 6], [9, 9, 9], [6, 9, 6]], \"output\": [[6, 6], [6, 6], [6, 6], [6, 6], [6, 6], [6, 6], [6, 6], [6, 6]]}, {\"input\": [[0, 0, 0, 0, 4, 0, 7, 0, 1, 0, 8, 0, 8, 0, 0], [5, 5, 5, 5, 4, 5, 7, 5, 1, 5, 8, 5, 8, 5, 5], [0, 0, 0, 0, 4, 0, 7, 0, 1, 0, 8, 0, 8, 0, 0], [0, 0, 0, 0, 4, 0, 7, 0, 1, 0, 8, 0, 8, 0, 0]], \"output\": [[0, 0, 0, 0, 0, 0], [0, 0, 0, 0, 0, 0]]}]"},"test":{"kind":"string","value":"[{\"input\": [[3, 3, 3, 3, 2, 3, 3, 2, 3, 3], [3, 3, 3, 3, 2, 3, 3, 2, 3, 3], [2, 2, 2, 2, 2, 2, 2, 2, 2, 2], [3, 3, 3, 3, 2, 3, 3, 2, 3, 3], [5, 5, 5, 5, 2, 5, 5, 2, 5, 5], [3, 3, 3, 3, 2, 3, 3, 2, 3, 3], [3, 3, 3, 3, 2, 3, 3, 2, 3, 3], [4, 4, 4, 4, 2, 4, 4, 2, 4, 4], [3, 3, 3, 3, 2, 3, 3, 2, 3, 3]], \"output\": [[3, 3, 3], [3, 3, 3], [3, 3, 3], [3, 3, 3]]}]"},"source":{"kind":"string","value":"rearc"},"prompt":{"kind":"string","value":"You will be given some number of paired example inputs and outputs grids. The outputs were produced by applying a transformation rule to the input grids. In addition to the paired example inputs and outputs, there is also one test input without a known output. The inputs and outputs are each “grids”. A grid is a rectangular matrix of integers between 0 and 9 (inclusive). Each number corresponds to a color. 0 is black. Your task is to determine the transformation rule from examples and find out the answer, involving determining the size of the output grid for the test and correctly filling each cell of the grid with the appropriate color or number. The transformation only needs to be unambiguous and applicable to the example inputs and the test input. It doesn't need to work for all possible inputs. Observe the examples carefully, imagine the grid visually, and try to find the pattern. Please output your answer within a code block (```), formatted as a grid of numbers. \n\n# Examples\n## Example 1\nInput:\n```\n6 1 6 6\n9 1 9 9\n6 1 6 6\n6 1 6 6\n2 1 2 2\n6 1 6 6\n6 1 6 6\n6 1 6 6\n1 1 1 1\n6 1 6 6\n1 1 1 1\n6 1 6 6\n4 1 4 4\n6 1 6 6\n6 1 6 6\n1 1 1 1\n6 1 6 6\n6 1 6 6\n6 1 6 6\n6 1 6 6\n0 1 0 0\n6 1 6 6\n```\n\nOutput:\n```\n6 6\n6 6\n6 6\n6 6\n6 6\n6 6\n6 6\n6 6\n```\n\n## Example 2\nInput:\n```\n6 9 6\n1 9 1\n6 9 6\n6 9 6\n6 9 6\n3 9 3\n6 9 6\n6 9 6\n6 9 6\n6 9 6\n2 9 2\n6 9 6\n5 9 5\n6 9 6\n7 9 7\n6 9 6\n6 9 6\n6 9 6\n6 9 6\n9 9 9\n6 9 6\n9 9 9\n6 9 6\n```\n\nOutput:\n```\n6 6\n6 6\n6 6\n6 6\n6 6\n6 6\n6 6\n6 6\n```\n\n## Example 3\nInput:\n```\n0 0 0 0 4 0 7 0 1 0 8 0 8 0 0\n5 5 5 5 4 5 7 5 1 5 8 5 8 5 5\n0 0 0 0 4 0 7 0 1 0 8 0 8 0 0\n0 0 0 0 4 0 7 0 1 0 8 0 8 0 0\n```\n\nOutput:\n```\n0 0 0 0 0 0\n0 0 0 0 0 0\n```\n\n# Test Problem:\n```\n3 3 3 3 2 3 3 2 3 3\n3 3 3 3 2 3 3 2 3 3\n2 2 2 2 2 2 2 2 2 2\n3 3 3 3 2 3 3 2 3 3\n5 5 5 5 2 5 5 2 5 5\n3 3 3 3 2 3 3 2 3 3\n3 3 3 3 2 3 3 2 3 3\n4 4 4 4 2 4 4 2 4 4\n3 3 3 3 2 3 3 2 3 3\n```"},"answer":{"kind":"string","value":"```\n3 3 3\n3 3 3\n3 3 3\n3 3 3\n```"},"num_tokens":{"kind":"number","value":968,"string":"968"}}},{"rowIdx":95,"cells":{"abstraction_prompt":{"kind":"string","value":"<|im_start|>user\n# ARC HINT GENERATOR\n\n## Role & Goal\nYou are an expert ARC (Abstraction and Reasoning Corpus) analyst. Your task is to generate a concise, actionable hint for a user who is struggling with an ARC problem. Analyze the problem and its correct solution to produce a single standalone, targeted hint that helps the user discover the core transformation principle for themselves without revealing the answer.\n\n---\n\n## Hint Generation Strategy\n1. **Compare** the input and output grids for each example. Identify the shared transformation pattern that allows the input grid to be converted into the output grid.\n2. **Identify the Core Principle**: Review the problem description and ground-truth solution to fully discern the key transformation rule. Break it down into its essential operations (e.g., object completion, pattern repetition, symmetry, gravity), paying close attention to properties such as object count, shapes, colors, sizes, symmetry, repetition, relative positioning, and broader grid-level patterns.\n3. **Craft a Targeted Hint**: Generate a hint that guides the user toward the core insight needed to solve the problem. The hint should assist the user during their attempt without revealing the solution.\n4. Structure each note using the template below:\n - **Description** (up to 3 sentences): Explain the concept, when and why it applies, and why it is effective. Include any relevant general formula or principle in its most general form.\n - **Example** (up to 6 sentences): Present a worked example covering all aspects of the description, using a simplified yet representative scenario (not necessarily from the current problem).\n - Optionally, include **Heuristics** or **Pitfalls** in the note where relevant.\n - Focus on methodologies and core principles over specific calculations or problem details.\n - Ensure each hint applies broadly—at least 80% of analogous problems.\n\nAfter generating a hint, verify that no specifics of the solution are revealed, and that the hint remains at the level of guiding the approach.\n\n### Design Guidelines\n- Clarity: Use precise language and correct sentence structure.\n- Atomicity: Each note addresses one recognizable sub-problem.\n- Self-containment: All information needed to understand the idea and its application is within the note.\n- Generalizability: Avoid problem-specific details or variables.\n- Transferability: Notes should apply across a class of problems.\n- Distinctness: Each note addresses a distinct principle.\n\n---\n\n## Guidelines\n- **Guide, Don't Solve**: Illuminate the approach, not the answer. Emphasize what to observe or consider.\n- **Specific yet Abstract**: Use concrete grid details (e.g., \"note the relationship between the blue and red pixels\") to ground abstract patterns (e.g., \"think about one color containing another\").\n\nValidate your generated hint: confirm it is self-contained, actionable, and nondirective. If any aspect is too revealing, revise before finalizing.\n\n---\n\n## Inputs\n### Problem Description\nA full ARC problem, including input/output pairs for training and testing.\n\n## Example 1\nInput:\n```\n0 0 0 0 0 0 0 0 0 2 2 0 0 0 0 0 0\n0 0 0 0 0 0 0 0 0 2 2 0 0 0 0 0 0\n0 0 0 0 0 0 0 0 0 2 2 0 0 0 0 0 0\n0 0 0 2 2 0 0 0 0 2 2 0 2 0 0 2 0\n0 0 2 2 2 0 0 0 0 0 0 0 2 2 2 2 0\n0 0 2 2 2 0 0 0 0 0 0 0 2 2 2 2 0\n2 0 0 2 2 0 0 0 0 0 0 0 0 0 0 0 0\n2 2 0 0 0 0 2 2 2 0 0 0 0 0 0 0 0\n2 0 0 0 0 0 0 2 2 2 0 0 0 0 0 0 0\n2 0 0 0 0 0 0 0 2 2 0 0 0 0 0 0 0\n2 0 0 0 0 0 0 0 0 2 0 0 0 0 0 2 0\n0 0 0 0 0 0 0 0 0 0 0 0 0 0 2 2 2\n0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 2 0\n```\n\nOutput:\n```\n0 0 0 0 0 0 0 0 0 6 6 0 0 0 0 0 0\n0 0 0 0 0 0 0 0 0 6 6 0 0 0 0 0 0\n0 0 0 0 0 0 0 0 0 6 6 0 0 0 0 0 0\n0 0 0 6 6 0 0 0 0 6 6 0 6 0 0 6 0\n0 0 6 6 6 0 0 0 0 0 0 0 6 6 6 6 0\n0 0 6 6 6 0 0 0 0 0 0 0 6 6 6 6 0\n6 0 0 6 6 0 0 0 0 0 0 0 0 0 0 0 0\n6 6 0 0 0 0 6 6 6 0 0 0 0 0 0 0 0\n6 0 0 0 0 0 0 6 6 6 0 0 0 0 0 0 0\n6 0 0 0 0 0 0 0 6 6 0 0 0 0 0 0 0\n6 0 0 0 0 0 0 0 0 6 0 0 0 0 0 4 0\n0 0 0 0 0 0 0 0 0 0 0 0 0 0 4 4 4\n0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 4 0\n```\n\n## Example 2\nInput:\n```\n0 0 0 0 0 0 0 0 0 0 0 0 0 0 0\n0 0 0 0 0 0 0 0 0 0 0 0 0 0 0\n0 0 0 0 2 0 0 2 0 0 0 0 0 0 0\n0 0 0 0 2 2 2 2 0 0 2 2 0 0 0\n0 0 0 0 2 2 2 2 0 0 2 2 0 0 0\n0 0 0 0 2 2 2 2 0 0 2 2 0 0 0\n0 0 0 0 2 2 2 2 0 0 2 2 0 0 0\n2 0 0 0 0 0 0 0 0 0 2 2 0 0 0\n2 2 2 0 0 0 0 2 2 0 0 0 0 0 0\n0 0 0 0 0 0 0 2 2 0 0 2 0 0 2\n0 0 0 0 0 0 0 2 2 0 0 2 2 2 2\n0 0 0 0 0 0 0 0 0 0 0 2 2 2 2\n```\n\nOutput:\n```\n0 0 0 0 0 0 0 0 0 0 0 0 0 0 0\n0 0 0 0 0 0 0 0 0 0 0 0 0 0 0\n0 0 0 0 6 0 0 6 0 0 0 0 0 0 0\n0 0 0 0 6 6 6 6 0 0 6 6 0 0 0\n0 0 0 0 6 6 6 6 0 0 6 6 0 0 0\n0 0 0 0 6 6 6 6 0 0 6 6 0 0 0\n0 0 0 0 6 6 6 6 0 0 6 6 0 0 0\n4 0 0 0 0 0 0 0 0 0 6 6 0 0 0\n4 4 4 0 0 0 0 6 6 0 0 0 0 0 0\n0 0 0 0 0 0 0 6 6 0 0 6 0 0 6\n0 0 0 0 0 0 0 6 6 0 0 6 6 6 6\n0 0 0 0 0 0 0 0 0 0 0 6 6 6 6\n```\n\n## Example 3\nInput:\n```\n0 0 0 0 0 0 0 0 0 0 0 2 2 0 0 0\n0 0 0 0 0 2 0 0 0 0 0 2 2 0 0 0\n0 0 0 0 2 2 2 0 0 0 0 2 2 0 0 0\n2 2 0 2 2 2 2 2 0 0 0 2 2 0 0 0\n2 0 0 0 2 2 2 0 0 0 0 0 0 0 0 0\n2 2 0 0 0 2 0 0 0 0 0 0 0 0 0 0\n0 0 0 0 0 0 0 0 0 0 0 2 2 2 2 2\n0 0 0 0 0 0 0 0 0 0 0 0 2 2 2 0\n0 0 0 0 2 2 0 0 0 0 0 0 0 0 0 0\n0 0 0 0 2 2 2 0 0 0 2 2 2 0 0 0\n0 0 0 0 2 2 2 0 0 0 2 2 2 0 0 0\n0 0 0 0 2 2 0 0 0 0 2 0 2 0 0 0\n```\n\nOutput:\n```\n0 0 0 0 0 0 0 0 0 0 0 6 6 0 0 0\n0 0 0 0 0 6 0 0 0 0 0 6 6 0 0 0\n0 0 0 0 6 6 6 0 0 0 0 6 6 0 0 0\n4 4 0 6 6 6 6 6 0 0 0 6 6 0 0 0\n4 0 0 0 6 6 6 0 0 0 0 0 0 0 0 0\n4 4 0 0 0 6 0 0 0 0 0 0 0 0 0 0\n0 0 0 0 0 0 0 0 0 0 0 6 6 6 6 6\n0 0 0 0 0 0 0 0 0 0 0 0 6 6 6 0\n0 0 0 0 6 6 0 0 0 0 0 0 0 0 0 0\n0 0 0 0 6 6 6 0 0 0 6 6 6 0 0 0\n0 0 0 0 6 6 6 0 0 0 6 6 6 0 0 0\n0 0 0 0 6 6 0 0 0 0 6 0 6 0 0 0\n```\n\n### Test Input\nHere is the input for the test problem.\n\n```\n0 0 2 2 0 2 2 0 0 0 0 0 0 0\n0 0 2 2 2 2 2 0 0 2 2 0 0 0\n0 0 0 0 0 0 0 0 0 2 2 0 0 0\n2 2 0 0 0 0 0 0 0 2 2 0 0 0\n2 2 0 0 0 0 0 0 0 0 0 0 0 0\n2 2 0 0 0 0 0 0 0 0 0 0 0 0\n2 2 0 0 0 0 0 0 0 0 2 0 2 0\n0 0 0 0 0 0 0 0 0 2 2 2 2 2\n0 0 0 0 0 0 2 2 0 0 0 0 0 0\n0 0 0 0 0 0 2 2 0 0 0 0 0 0\n0 2 2 0 0 0 2 2 0 0 0 0 0 0\n2 2 0 0 0 0 2 2 0 0 0 0 0 0\n2 2 0 0 0 0 2 2 0 0 2 2 2 0\n0 2 2 0 0 0 0 0 0 0 2 2 2 0\n```\n\n\n### Output Format\nOnly produce a **sequence of 5** notes in the structure:\n<note1>\n<description>...</description>\n<example>...</example>\n</note1>\n<note2>\n<description>...</description>\n<example>...</example>\n</note2>\n...\n\nDO NOT generate any other text\n\n---\n\n\n# Generated Hint<|im_end|>\n<|im_start|>assistant\n"},"abstraction_prompt_length":{"kind":"number","value":3523,"string":"3,523"},"generated_abstractions":{"kind":"list like","value":["<note1>\n<description>Look for the single non-background color that is being transformed across examples; that color's pixels are the only ones whose color changes. Isolating that color first simplifies the rest of the task because you only need to reason about its components.</description>\n<example>Imagine a grid where only the green pixels differ between input and output while black stays black. Mark all green pixels as the \"active\" set and ignore all other colors for now — this narrows the problem to what happens to those green components.</example>\n</note1>\n\n<note2>\n<description>Split the active-color pixels into connected components using orthogonal adjacency (up/down/left/right). Treat each contiguous block as one object to be analyzed and recolored as a unit.</description>\n<example>For instance, a 2×2 square of the active color is one component; two pixels touching only at a corner are two separate components. Label each component so you can compare them across the grid.</example>\n</note2>\n\n<note3>\n<description>Count the number of pixels in each component (its area). The transformation in these examples depends on that area, so compute sizes for every component rather than looking at shape or orientation alone.</description>\n<example>Suppose you find three components with sizes 1, 2 and 4. These sizes are the primary attribute that will determine how each component is treated in the output.</example>\n</note3>\n\n<note4>\n<description>Use the size ranking to decide recoloring: all components of the same size receive the same new color, while components of different sizes receive different colors. In the training examples the smallest components are treated differently from the larger ones, so identify which size is the \"special\" one.</description>\n<example>Given component sizes {1,2,4}, the rule assigns one color to the 1-pixel component and a different color to every component of size 2 or 4. Apply that assignment consistently to every component of the same size.</example>\n</note4>\n\n<note5>\n<description>When you apply the recoloring, do not move or reshape components — only change their color in place. After recoloring, verify that the pattern of changed pixels matches the original component footprints and that the background and other colors are unchanged.</description>\n<example>If a component occupies a particular set of coordinates in the input, those same coordinates should be the only ones changed in the output; everything else should remain exactly as it was. A common pitfall is recoloring every pixel of the original color globally instead of per-component.</example>\n</note5>","<note1>\n<description>Treat each contiguous patch of the non-background color as an object. Use 4‑connectivity (up/down/left/right) so diagonally touching pixels do not join objects. This separates the scene into a small set of discrete items you can compare.</description>\n<example>Imagine a grid with three blue blobs: a 3×3 square, a 2×2 square, and a single isolated pixel. Using 4‑connectivity you get three objects with areas 9, 4 and 1. You should not join the single pixel with the squares because they are not orthogonally adjacent.</example>\n</note1>\n\n<note2>\n<description>Count the number of pixels in each object and compare those counts. The transformation depends on which object is smallest (fewest pixels) versus the others. The smallest object is singled out for a different treatment.</description>\n<example>Given object areas {12, 8, 5, 3}, the object with area 3 is the smallest. That smallest object is the one you will treat differently from the rest when producing the output.</example>\n</note2>\n\n<note3>\n<description>Recolor every pixel of the smallest object to a single distinct color while leaving its shape and position unchanged. The rest of the grid (the other objects) are recolored uniformly to a second color. This highlights the unique object without moving it.</description>\n<example>Start with three objects: a 3×3 block, a 2×2 block, and a single pixel. After the step, the single pixel is painted color A and both the 3×3 and 2×2 blocks are painted color B, but all objects remain exactly where they were.</example>\n</note3>\n\n<note4>\n<description>Do not alter background pixels or object geometry: only change colors. The output should be the same grid dimensions with the same object shapes and placements, only with two colors applied to the objects (one for the smallest, one for the others). This preserves spatial relationships for comparison.</description>\n<example>If a grid has a black background and several colored blobs, the final grid still has black background and the same blobs in the same positions; only the blob colors differ — one color for the unique small blob, another for all the other blobs.</example>\n</note4>\n\n<note5>\n<description>Watch for edge cases: if there is only one object, it is the smallest and should be recolored as the unique object; if two objects tie for smallest, use the training examples to decide which tie‑breaking rule applies (often a consistent positional tie‑break such as topmost/leftmost is used). Always verify connectivity before counting.</description>\n<example>If you see a single isolated pixel and a large cluster, treat the single pixel as the unique object and recolor it separately. If two isolated pixels appear, check the examples to see whether the topmost or leftmost one is chosen; apply the same consistent rule to the test case.</example>\n</note5>","<note1>\n<description>Look for a single non-background color that appears in multiple disconnected islands; those islands are the objects to compare. This is effective because the transformation operates on whole objects (connected components) rather than individual stray pixels.</description>\n<example>Imagine a grid with several blue islands on a black background. First mark every contiguous group of blue pixels (use orthogonal adjacency). You now have a list of distinct objects to analyze, which is easier than comparing every blue pixel one-by-one.</example>\n</note1>\n\n<note2>\n<description>For each object, compute its bounding box (min/max row and column) and derive width and height. The bounding box gives a compact description of an object’s horizontal and vertical span and is a robust way to compare shapes.</description>\n<example>If an object occupies rows 2–5 and columns 7–9, its bounding box is width=3 and height=4. Do this for every object so you can compare sizes and positions without looking at every pixel.</example>\n</note2>\n\n<note3>\n<description>Decide whether an object is “wide” (wider than tall) by comparing width and height. A simple numeric threshold (for example, width > height) cleanly separates horizontal bars from vertical bars and is easy to apply consistently.</description>\n<example>With width=4 and height=2 you would call that object wide; with width=2 and height=4 you would call it tall. Using a single inequality makes the classification unambiguous across examples.</example>\n</note3>\n\n<note4>\n<description>Recolor every object according to its class: one replacement color for wide objects and a different replacement color for tall objects; leave the background unchanged. This preserves each object’s shape and location while highlighting the two classes.</description>\n<example>After classifying, paint every wide island with color A and every tall island with color B. The grid will show two distinct groups of objects (by their new colors) while the black background remains intact.</example>\n</note4>\n\n<note5>\n<description>Watch for edge cases: use orthogonal connectivity (not diagonal), ignore single isolated pixels unless they form a connected component, and check that the same classification rule explains every training example. If any example breaks the rule, revisit the bounding-box test or the threshold.</description>\n<example>If a lone pixel appears it should be treated as a 1×1 object; if two pixels touch only at a corner they are separate objects. Confirm your rule by applying it to all training pairs—if it reproduces their outputs, it is likely correct.</example>\n</note5>","<note1>\n<description>Focus first on the one color that is being changed between input and output: treat that color as the \"object\" to analyze. Isolating that color reduces the problem to a small set of pixels you can group and compare.</description>\n<example>Imagine a grid where only the blue pixels differ between input and output. Ignore all other colors and extract just the blue pixels; these are the only elements you need to study for the transformation.</example>\n</note1>\n\n<note2>\n<description>Group the object pixels into connected components using orthogonal adjacency (up/down/left/right). Each connected component is an independent object to be classified and recolored.</description>\n<example>For instance, a 2×2 block of blue pixels is one component, while a single isolated blue pixel elsewhere is a second component. Treat each component separately when you look for patterns.</example>\n</note2>\n\n<note3>\n<description>Characterize each component by simple geometric features: bounding box dimensions, pixel count, and whether the bounding box is fully filled or only a border. These small measurements often reveal a small set of distinct object types.</description>\n<example>A filled 2×2 square has bounding box 2×2 and count 4; an L-shaped 3-pixel component has bounding box 2×2 but count 3; a straight 4-pixel line has bounding box 1×4 or 4×1 and count 4. Use these signatures to separate shapes.</example>\n</note3>\n\n<note4>\n<description>Look for a single geometric feature that cleanly separates the components into two groups across all training examples (for example: whether the bounding box is completely filled, or whether the component is a straight line vs a compact block). That feature is the classifier used to decide recoloring.</description>\n<example>Suppose every component whose bounding box is fully filled and has area 4 is treated one way, and every other component is treated differently; then \"is the bounding box fully filled and area=4?\" is the right classifier. Verify this holds for every example before applying it.</example>\n</note4>\n\n<note5>\n<description>Apply the discovered rule: recolor every component according to its class while leaving all other pixels unchanged. Use two distinct replacement colors (one for each class) consistently across the grid.</description>\n<example>If you have two classes (e.g., \"compact filled squares\" and \"all other shapes\"), fill each class's pixels with one replacement color and the other class's pixels with a different replacement color. Check that the training outputs are reproduced by this mapping before using it on the test grid.</example>\n</note5>","<note1>\n<description>Start by isolating the non-background color that appears repeatedly; treat each contiguous patch of that color as a separate object. This reduces the problem to a small set of discrete shapes to compare rather than many scattered pixels.</description>\n<example>Imagine a grid where one color appears in several disconnected blobs on a black background. Mark each blob as an object (a connected component) so you can analyze their shapes independently. Don’t mix separate blobs even if they are similar in shape.</example>\n</note1>\n\n<note2>\n<description>Normalize each object by cropping to its bounding box and translating that box to the origin; this produces a canonical representation so you can compare shapes regardless of position. Comparing these normalized masks is the standard way to detect identical shapes.</description>\n<example>Two L-shaped blobs in different places become the same small matrix after cropping and shifting to (0,0). If their normalized matrices match exactly, they are the same shape even though their coordinates differ.</example>\n</note2>\n\n<note3>\n<description>Compare the normalized masks exactly (pixel-by-pixel) to group identical shapes. Count how many objects belong to each group and look for a group with a different frequency — that frequency difference is often the key to deciding which group to treat differently.</description>\n<example>If you find three identical small blocks and one small block with a different arrangement, you will see three groups: one group of size 3 and one of size 1. The unique frequency (size 1) flags the exceptional object.</example>\n</note3>\n\n<note4>\n<description>Once you have the groups, recolor every pixel of each group consistently: give all objects in the common group one color and the exceptional object a different color; leave the background unchanged. The transformation is a recoloring of whole objects, not a movement or reshaping.</description>\n<example>With three identical blocks and one different block, paint all three blocks the same new color and paint the single different block a second new color. Do not alter any other pixels or move the objects.</example>\n</note4>\n\n<note5>\n<description>Be careful about orientation and edge cases: only count rotations/reflections as the same shape if the examples show them; also check whether the exceptional object is unique in count or in a unique property. Use the examples to decide whether to treat rotated copies as equivalent.</description>\n<example>If two blocks are mirror images but the examples never show mirror symmetry, treat them as different shapes. If the examples do show rotated copies being considered the same, then include rotations when comparing masks.</example>\n</note5>","<note1>\n<description>First, isolate every contiguous group of the target color (the non-zero color that appears repeatedly). Use orthogonal adjacency (up/down/left/right) to decide whether pixels belong to the same object; this separates distinct shapes that might otherwise look similar.</description>\n<example>Imagine a grid with three separated blue blobs: one at the top-left, one in the middle, and one at the bottom-right. Treat each blob as an independent object even if they have the same color. Marking these components makes it clear which pieces are being transformed in the output.</example>\n</note1>\n\n<note2>\n<description>Measure each object's size by counting its pixels (area). The transformation in the examples depends on this size rather than on shape or orientation, so ranking objects by area is a reliable first step.</description>\n<example>Given three objects with areas 12, 5 and 2, you now have a clear ordering: largest (12), middle (5), smallest (2). Use these counts to decide which object is treated differently in the output.</example>\n</note2>\n\n<note3>\n<description>Compare the input and output to see how objects are recolored: one color is used for all objects except the singled-out one, and a different color is used for the singled-out object. The key is to identify which object is singled out by position (the one that is farthest down and, if tied, farthest right).</description>\n<example>Suppose the output shows two objects in a common color and a third object in a different color. That tells you the rule is: recolor every object except the lowest/rightmost one with one color, and recolor that lowest/rightmost object with another color.</example>\n</note3>\n\n<note4>\n<description>When recoloring, change only the pixels that belong to each object; do not move, resize, or fill gaps. The background (zeros) and any other colors remain unchanged, so the output should preserve the original object geometry while changing only their colors.</description>\n<example>If an object is a small L-shape of blue pixels, recolor that exact L-shape to the chosen color(s) in place. Do not add or remove pixels — only substitute the object's color with the new color.</example>\n</note4>\n\n<note5>\n<description>Handle ties and edge cases consistently: if two objects share the same bottom row, pick the one with the larger column index; if they share the same bottom-right corner, treat that as the singled-out object. Verify your choice by checking that the recoloring pattern matches the examples.</description>\n<example>Two identical squares sit on the same bottom row, one at column 4 and one at column 9. The square at column 9 is the one to treat as the singled-out object. If the two bottom-most objects are also in the same column, the one at the greater row index (lower down) is the singled-out one.</example>\n</note5>","<note1>\n<description>Start by isolating the single non-background color that is being transformed across examples. That color appears in multiple disconnected patches; treat each disconnected patch as an independent object to analyze.</description>\n<example>Imagine a grid with many blue pixels scattered in several places. Those blue pixels are not one shape but several separate objects; mark each object (each connected group of blue pixels) so you can compare them across the grid.</example>\n</note1>\n\n<note2>\n<description>Use orthogonal connectivity (up/down/left/right) to define objects: pixels that touch diagonally are separate objects. This choice changes how many objects you see and is important for distinguishing shapes.</description>\n<example>Two blue pixels that touch only at a corner are two objects under 4‑connectivity. Count and list each object so you can measure its size and shape independently.</example>\n</note2>\n\n<note3>\n<description>Compute the size of each object by counting how many pixels it contains. Size is the key numeric feature used to decide how to recolor objects.</description>\n<example>Suppose you find three objects with pixel counts 12, 7 and 2. Record these counts — the largest and smallest will be the ones you treat differently, the rest form the middle group.</example>\n</note3>\n\n<note4>\n<description>Apply a size-based recoloring rule: assign one replacement color to the largest object(s) and a different replacement color to the smallest object(s); give the remaining objects a third replacement color. If there are multiple objects with the same extreme size, recolor all of them the same way.</description>\n<example>With object sizes 12, 7 and 2, recolor the 12‑pixel object with color A, the 2‑pixel object with color B, and the 7‑pixel object with color C. If two objects both had size 2, both would be recolored to B.</example>\n</note4>\n\n<note5>\n<description>Keep the transformation minimal and local: do not move, reshape, or otherwise alter object geometry — only change their colors. Also ensure the background and unrelated colors remain unchanged.</description>\n<example>If a blue object occupies a fixed set of coordinates, it should occupy the same coordinates after the transformation but with a different color. Do not add or remove pixels from an object when recoloring it.</example>\n</note5>","<note1>\n<description>Group same-colored pixels into connected components using orthogonal adjacency (up/down/left/right). Treat each connected cluster as one object to be analyzed and transformed. This isolates individual shapes even when they share the same color.</description>\n<example>Imagine a small grid with three blue blobs: one 3×3 square, one 2×2 square, and one single blue pixel. Using 4‑connectivity, these are three separate components because no two blue pixels touch orthogonally. Label each component so you can reason about them individually.</example>\n</note1>\n\n<note2>\n<description>For every component compute its area (the count of cells in that component). Area is the simplest, robust metric to distinguish objects by size. Use this numeric measure rather than visual heuristics like “looks small”.</description>\n<example>Continuing the previous example, the three components have areas 9, 4 and 1 respectively. Record these counts for each component so you can compare them across the grid. Area is invariant to translation and orientation, so it’s a reliable discriminator.</example>\n</note2>\n\n<note3>\n<description>Find the smallest area among all components and select that component as the special one to treat differently. If only one component has that minimum area, it is the unique special object. If several components tie for smallest, the task usually expects you to pick a consistent tie-break (e.g., the one encountered first in a fixed scan order).</description>\n<example>If component areas are {9,4,1}, the area‑1 component is the smallest and is the special object. If areas are {9,4,4,1}, there are two smallest components (area 1) — in that case pick one consistently (for instance, the component whose topmost pixel is highest, or the leftmost if tied).</example>\n</note3>\n\n<note4>\n<description>Recolor the grid by replacing every cell of the special component with one distinct color and every other component with a single other color, while leaving the background unchanged. The transformation is a recoloring of whole components, not a reshaping or relocation of pixels. This highlights the smallest object against the rest.</description>\n<example>Using the three-component example, recolor the smallest (area‑1) blob to color A and recolor both larger blobs to color B, keeping zeros as background. The blobs keep their exact coordinates and shapes; only their colors change.</example>\n</note4>\n\n<note5>\n<description>Watch for common pitfalls: use 4‑connectivity (not diagonal), count every pixel in a component (even if disconnected parts are separated by background), and apply the same tie-break rule if multiple smallest components exist. After recoloring, verify that only the intended components changed and that background pixels remain unchanged.</description>\n<example>If two single‑pixel components are the smallest, do not accidentally merge them by diagonal adjacency; pick one by a consistent rule (e.g., the one with the smallest row index, then smallest column). After recoloring, scan the grid to confirm no background cell was altered and only whole components were recolored.</example>\n</note5>","<note1>\n<description>Look for objects by grouping contiguous non-background pixels. Use 4‑connectivity (up/down/left/right) so that diagonally touching pixels do not join objects. This isolates each separate shape you must reason about.</description>\n<example>Imagine a grid with three blue blobs separated by at least one row or column of background. Treat each blob as an independent object even if they look similar. Label them A, B, C so you can compare them one by one.</example>\n</note1>\n\n<note2>\n<description>Quantify each object by counting its pixels (area). The transformation often depends on these counts rather than on absolute position or orientation. Ranking objects by area reveals which ones are the largest or smallest.</description>\n<example>For instance, if object areas are 12, 7 and 3, you can immediately see there is a single smallest object (area 3) and two larger ones (12 and 7). That numeric ranking is the key for deciding which objects get special treatment.</example>\n</note2>\n\n<note3>\n<description>Compare input and output to see how objects are recolored. Often the rule is: recolor every object except the smallest one to one color, and recolor the smallest object to a different color. Check that shapes and positions remain unchanged — only colors change.</description>\n<example>Suppose two large blobs and one tiny blob in the input become two uniform colors in the output while the tiny blob becomes a distinct color. That indicates the operation is \"preserve geometry, change color by object rank.\"</example>\n</note3>\n\n<note4>\n<description>Decide a deterministic tie-breaker for equal-size objects. If two or more objects share the minimal area, choose one consistently (for example, the object whose topmost pixel is highest, then the leftmost if needed). Consistency avoids ambiguity when sizes are equal.</description>\n<example>If two blobs both have area 4, pick the one whose topmost pixel has the smallest row index; if those match, pick the one with the smallest column index. Apply the same rule across the grid so your choice is unambiguous.</example>\n</note4>\n\n<note5>\n<description>Watch for common pitfalls: use 4‑connectivity (not diagonal), do not merge background pixels, and only recolor the identified objects while leaving all other cells (background and other colors) unchanged. Verify that the shapes and positions remain exactly as in the input after recoloring.</description>\n<example>A frequent error is to treat diagonally touching pixels as one object or to recolor stray background pixels; instead, only recolor whole connected components of the target color and keep all other colors and positions identical to the input.</example>\n</note5>","<note1>\n<description>Separate the picture into objects by grouping same-colored pixels that touch orthogonally (up/down/left/right). This converts the problem from pixel-level noise into a small set of discrete objects to compare. Use 4-way connectivity (not diagonal) so that only orthogonally adjacent pixels form one object.</description>\n<example>Imagine a grid with several blue blobs on a black background. If two blue pixels share an edge they belong to the same object; if they only touch at a corner they are different objects. Label each connected patch as a distinct object before doing any counting or recoloring.</example>\n</note1>\n\n<note2>\n<description>Count how many pixels belong to each object and sort them by size. Many ARC tasks single out an object by its size (for example, the smallest object is treated differently from the rest). Ranking by pixel count makes that selection unambiguous.</description>\n<example>Suppose you find objects with sizes 12, 7 and 2 pixels. The object with 2 pixels is the smallest and should be singled out for a special treatment, while the 12- and 7-pixel objects are handled together.</example>\n</note2>\n\n<note3>\n<description>Recolor every pixel of the singled-out object with one new color, and recolor every pixel of all remaining objects with a different color, leaving the background unchanged. The transformation is a uniform recoloring of whole objects, not partial or shape-changing edits. This makes the special object visually distinct while preserving object shapes.</description>\n<example>If the smallest object is a tiny two-pixel cluster, change both of its pixels to color A and change every pixel of the other objects to color B. The shapes and positions remain identical; only the colors differ.</example>\n</note3>\n\n<note4>\n<description>Do not move, resize, or otherwise alter object geometry — only change their colors. The output should be the same grid size with the same object masks, but with colors reassigned according to the selection rule. This keeps spatial relationships intact and avoids introducing unintended transformations.</description>\n<example>Take a 12×12 grid with several blobs: after recoloring, the blobs still occupy the same coordinates and have the same outlines; only their color values differ. If a shape looks shifted or split, you likely altered geometry instead of recoloring.</example>\n</note4>\n\n<note5>\n<description>Handle ties and edge cases consistently: if multiple objects share the minimal size, treat them all as the special set; if there is no single smallest object (e.g., only one object), then apply the alternate rule shown in the examples (often recoloring all objects with the same new color). Also ensure you only consider orthogonally connected pixels when deciding sizes.</description>\n<example>If two tiny blobs both have size 2, recolor both with the special color and recolor the rest with the alternate color. If there is only one blob, follow the pattern from the examples (for instance, recolor every blob to the alternate color) so your rule matches the intended transformation.</example>\n</note5>","<note1>\n<description>First isolate the foreground color that is being transformed across examples. Work at the object level: group contiguous pixels of that color into separate objects (use orthogonal adjacency). This separates the grid into a small set of candidate shapes to analyze.</description>\n<example>Imagine a grid with several blue blobs on a black background. Treat each contiguous blue blob (connected by up/down/left/right) as an individual object. You now have a list of objects (not individual pixels) to compare and classify.</example>\n</note1>\n\n<note2>\n<description>For each object compute a simple numeric descriptor such as its pixel count (area). Area is robust to translation and is often the decisive feature in ARC tasks that recolor whole objects. Use area as the primary key to distinguish objects.</description>\n<example>Suppose you have three blue objects with areas 9, 4 and 1. Those three numbers immediately tell you which object is smallest (area=1), which is medium (area=4), and which is large (area=9). Counting pixels is faster and less error-prone than trying to eyeball shape complexity.</example>\n</note2>\n\n<note3>\n<description>Look for a unique smallest object: if exactly one object has the minimum area, that object is typically treated differently in the output. The rule often recolors every object except that unique smallest one. If there is no unique minimum (multiple objects tie), the examples usually recolor all objects the same way instead.</description>\n<example>If only one blob has area 1 while others have larger areas, expect that blob to be handled specially (e.g., given a different color). If two blobs both have area 1, check the examples to see whether both are changed or all are changed uniformly; the examples will show which behavior to follow.</example>\n</note3>\n\n<note4>\n<description>When applying the recoloring, preserve each object's shape and position exactly — only change its color. The transformation is a recoloring operation, not a move, resize, or mirror of shapes. This keeps spatial relationships identical while changing appearance.</description>\n<example>Take a 3×2 rectangular object at a fixed location: in the output it should still occupy the same cells but with a new color. Do this for every object; the only change is the color value per object, not the geometry.</example>\n</note4>\n\n<note5>\n<description>Use the training examples to determine which color is used for the \"special\" object and which color is used for the other objects, then apply that mapping consistently. If multiple smallest objects exist, follow the pattern shown by the examples (either recolor all objects the same or recolor the smallest ones specially). Always verify by checking counts and positions against the examples.</description>\n<example>Scan the example outputs: if the unique smallest blob is colored green in the examples while all other blobs are colored yellow, then in the test you should recolor the unique smallest blob to green and all other blobs to yellow. If examples show no unique smallest, recolor every object to the same color instead.</example>\n</note5>","<note1>\n<description>Start by isolating the non-background color that appears as multiple disconnected blobs in the inputs. Treat each connected blob (orthogonal adjacency) as an object and record its pixel coordinates and bounding box. This gives you a small set of objects to compare instead of the whole grid.</description>\n<example>Imagine a grid with several blue blobs on a black background. Find each blue connected component and compute its bounding box and list of pixel coordinates. Now you have a handful of objects (e.g., three blobs) to analyze rather than scanning the entire grid.</example>\n</note1>\n\n<note2>\n<description>Compare the objects by simple shape features: pixel count, bounding-box width and height, and whether the box is fully filled or has holes. Often one object will stand out because it has a different pixel count or a different aspect ratio. Counting pixels is a robust, implementation‑independent discriminator.</description>\n<example>Suppose you have three blobs with pixel counts 8, 8 and 12. The blob with 12 pixels is the odd one out by count. If two blobs share the same count, compare bounding-box dimensions (e.g., 4×2 vs 2×4) to find a size-based distinction.</example>\n</note2>\n\n<note3>\n<description>Once you identify the odd object, the transformation usually recolors all objects the same way except the odd one, which receives a different color. The operation is a recoloring per object, not a move or reshaping. So your task is to find which object is singled out and recolor accordingly.</description>\n<example>With three identical shapes and one larger shape, the output will show two shapes in one new color and the larger shape in a second new color. The shapes keep their exact positions and forms; only their colors change.</example>\n</note3>\n\n<note4>\n<description>Use simple heuristics to break ties: prefer pixel-count first, then bounding-box area, then aspect ratio, then whether the box is solid or hollow. Also check for repeated sub-shapes (identical small tiles) — the odd object is often the one that is not part of a repeated motif. These checks are quick and reliable.</description>\n<example>If two blobs have the same pixel count but one fits a 4×2 box while the other fits 2×4, pick the one with the different aspect ratio. If three blobs are identical and one is larger, choose the larger one by pixel count.</example>\n</note4>\n\n<note5>\n<description>Finally, apply the recoloring consistently: change every pixel of each object to the chosen new color while preserving background. After recoloring, verify that only the identified object uses the alternate color and that all other objects share the same color. This final check ensures you applied the intended transformation.</description>\n<example>After selecting the odd blob, recolor all pixels of that blob to the alternate color and recolor the remaining blobs to the common color. Then scan the grid to confirm no object was moved or resized and that the background stayed unchanged.</example>\n</note5>","<note1>\n<description>Look for the single non-background color that appears in the inputs and is being transformed in the outputs. That color is the one you should analyze for grouping and recoloring; everything else (background and other colors) is left alone.</description>\n<example>Imagine a grid with only zeros and some green pixels. The output only changes those green pixels while zeros remain zeros. So focus on that green color as the object to be processed — ignore other colors and the background.</example>\n</note1>\n\n<note2>\n<description>Split the target-color pixels into separate objects using 4‑connectivity (up/down/left/right). Each connected component is an independent object whose shape and position you must preserve.</description>\n<example>For example, a 2×2 block of the target color is one object, and a single isolated pixel elsewhere is a second object. Treat each of these as a whole when you later decide how to recolor them.</example>\n</note2>\n\n<note3>\n<description>Compute a simple size metric for each object (e.g., number of pixels) and sort the objects by that metric. The transformation distinguishes objects by their size rank (largest vs. smallest) rather than by arbitrary coordinates.</description>\n<example>Suppose you find three objects with pixel counts 12, 5 and 3. The rule will treat the 12‑pixel object differently from the 5‑ and 3‑pixel objects; the exact ordering (largest → smallest) is what matters, not absolute positions.</example>\n</note3>\n\n<note4>\n<description>Recolor each object uniformly according to its size rank: one replacement color for the largest object(s) and a different replacement color for all smaller objects. Do not change the object's shape or location — only change the color of every pixel in that object.</description>\n<example>In a toy case, a 3×4 block becomes entirely color A and every smaller isolated pixel becomes color B. The background stays the same and every pixel inside an object keeps the same relative coordinates.</example>\n</note4>\n\n<note5>\n<description>Handle ties and edge cases explicitly: if several objects share the maximal size, recolor all of them the same way; if there is only one object, it gets the \"largest\" treatment. Also ensure you use 4‑connectivity (not diagonal) when grouping and do not alter any other colors.</description>\n<example>If two objects both have 6 pixels and no object has more than 6, both should be recolored with the largest‑object color. If there is only a single object, it is treated as the largest and receives that color.</example>\n</note5>","<note1>\n<description>Look for a single color that is being transformed into two different colors in the outputs while the background stays the same. This often means the input has several disconnected objects of that color and the rule treats them differently. Identifying that color narrows the problem to handling a small set of objects rather than many pixels.</description>\n<example>Imagine a grid where several blue blobs appear on a black background and the outputs show some blue blobs turned green while other blue blobs turned yellow. That pattern suggests the transformation targets blue blobs specifically and recolors them based on their object-level properties.</example>\n</note1>\n\n<note2>\n<description>Split the target color into connected components using orthogonal (up/down/left/right) adjacency. Each connected component is an independent object whose properties you can count and compare. This decomposition is essential because the rule usually operates on whole objects, not on individual pixels.</description>\n<example>On a small grid, three blue blobs separated by black cells are three components. Label them A, B, C and treat each as a unit when comparing sizes, positions, and other attributes.</example>\n</note2>\n\n<note3>\n<description>Measure each component's size (the number of pixels) and rank them. Many ARC tasks pick the smallest or largest component as the special one to treat differently. Counting pixels is robust and gives a clear numeric criterion for selection.</description>\n<example>If component sizes are 12, 6 and 4, the component with 4 pixels is the smallest. That smallest component is a natural candidate for being handled differently from the others.</example>\n</note3>\n\n<note4>\n<description>Recolor components according to their rank: typically give the smallest component one new color and recolor every other component with a different new color, leaving the background unchanged. The spatial arrangement and shapes remain the same — only the color labels change. This produces a consistent mapping from object rank to output color.</description>\n<example>Given three blue components sized 12, 6 and 4, change all 12- and 6-pixel blobs to green and the 4-pixel blob to yellow; the blobs stay in place but now show two new colors.</example>\n</note4>\n\n<note5>\n<description>Watch for edge cases: use 4-neighbor connectivity (diagonals do not connect), and if two components tie for smallest size choose a consistent tie-breaker (for example, the component whose topmost pixel is higher, then the leftmost). Also confirm the rule by checking that every example applies the same selection-and-recolor logic. These checks prevent ambiguous interpretations.</description>\n<example>If two components both have size 4, pick the one whose topmost pixel has the smaller row index; if those are equal, pick the one with the smaller column index. Apply this rule consistently across the grid so the transformation is unambiguous.</example>\n</note5>","<note1>\n<description>Work at the object level: treat each connected group of the non-background color as a single entity. This reduces the problem from many pixels to a small set of shapes you can compare and classify.</description>\n<example>Imagine a grid with three separate blue blobs. Instead of comparing every blue pixel, extract each blob (using 4‑connectivity) and record its pixels and bounding box. You now have three objects to analyze rather than many individual pixels.</example>\n</note1>\n\n<note2>\n<description>Normalize shapes by translating each object's pixels so their top-left corner is (0,0). For a robust comparison, also generate rotated and reflected versions of the normalized shape and compare these variants.</description>\n<example>Take an L‑shaped blob and a 2×2 square: translate both to (0,0). The L and square have different signatures, so they are distinct. If you also try 90° rotations or flips, you can still tell which are the same up to rotation/reflection.</example>\n</note2>\n\n<note3>\n<description>Group objects into shape classes by matching their normalized signatures. Objects that match under translation (or under rotation/reflection) belong to the same class.</description>\n<example>If you find two objects whose normalized pixel sets are identical, they are the same shape-class even if they sit in different places. If a third object only matches after a 90° rotation, treat it as a different class unless the task explicitly allows rotated matches.</example>\n</note3>\n\n<note4>\n<description>Choose one representative color per class and recolor every pixel of each object with that class color; leave background pixels unchanged. The transformation is about class identity, not moving or reshaping objects.</description>\n<example>Suppose there are three classes: a common shape, a small irregular shape, and a tiny 2‑pixel shape. Pick one color for the common shape, another for the irregular, and a third for the tiny one, then fill every pixel of each object with its class color so the grid highlights classes rather than individual pixels.</example>\n</note4>\n\n<note5>\n<description>Decide whether to treat rotated/reflected versions as the same class by checking the examples: if rotated copies are recolored identically, include rotations; if they are recolored differently, do not. This choice determines whether you merge or split classes.</description>\n<example>Compare two blobs that look like the same shape but one is rotated. If the training outputs recolor both the same way, consider them one class (allow rotations). If the outputs give them different colors, treat them as distinct classes and recolor separately.</example>\n</note5>","<note1>\n<description>Look for a single non-background color that appears in multiple disconnected blobs; the transformation usually treats those blobs as the primary objects to analyze. This is effective when the background is uniform and the same color recurs in several separate patches. Identifying that color reduces the problem to object-level reasoning instead of pixel-level noise.</description>\n<example>Imagine a grid where black is the background and many small red blobs appear scattered. Those red blobs are the objects to focus on — ignore any isolated black pixels or other colors that do not repeat. Once you have the repeated-color objects, you can reason about them as whole shapes rather than individual pixels.</example>\n</note1>\n\n<note2>\n<description>Define objects by connectivity: group pixels of the same color that touch orthogonally (up/down/left/right) into connected components. This gives you exact object boundaries and counts so you can compare shapes reliably. Use the same connectivity rule consistently across the grid.</description>\n<example>For example, three red pixels that meet side-by-side form one object of size 3, while a lone red pixel separated by black is a separate object of size 1. By listing each connected component and its size you obtain a clear inventory of the shapes present. That inventory is what you will compare to the outputs.</example>\n</note2>\n\n<note3>\n<description>Compare the counts of objects and the counts of pixels in the input to the output: the transformation typically changes only the colors of whole objects, not their positions or shapes. In other words, objects keep their geometry and coordinates; only their color labels change. Use this to pair each input object with the corresponding output object.</description>\n<example>Suppose an input has three red blobs of sizes 5, 3 and 1 and the output shows three colored blobs in the same places with sizes 5, 3 and 1 but different colors. That indicates a recoloring of entire objects rather than moving or reshaping them. Pair the input objects by size and location to see which color each was recolored to.</example>\n</note3>\n\n<note4>\n<description>Look for a simple size-based rule: many tasks recolor all objects of one size class with one new color and all objects of another size class with a different new color. The size class is usually a small integer (for example, singletons vs. multi-cell objects). Formulate the rule in terms of object pixel count and test it against the examples.</description>\n<example>Imagine the examples show that every object of size 1 becomes color A and every object of size >1 becomes color B. If you find that pattern consistently in the training pairs, apply the same rule to the test input: recolor each object according to whether its pixel count matches the special class or not. This turns a visual pattern into a repeatable rule.</example>\n</note4>\n\n<note5>\n<description>When you apply the rule, recolor entire connected components and leave the background unchanged; do not alter object geometry or move pixels. After recoloring, verify that the number and relative placement of objects match the input and that only color labels changed. This final check catches mistakes like accidentally merging or splitting objects.</description>\n<example>After deciding which objects are the special size class, change every pixel of those components to the new color and change the rest to the other new color; keep all zeros as background. Then confirm the output has the same set of objects in the same positions but with different color labels. If counts or positions differ, revisit your component detection or the size rule.</example>\n</note5>"],"string":"[\n \"<note1>\\n<description>Look for the single non-background color that is being transformed across examples; that color's pixels are the only ones whose color changes. Isolating that color first simplifies the rest of the task because you only need to reason about its components.</description>\\n<example>Imagine a grid where only the green pixels differ between input and output while black stays black. Mark all green pixels as the \\\"active\\\" set and ignore all other colors for now — this narrows the problem to what happens to those green components.</example>\\n</note1>\\n\\n<note2>\\n<description>Split the active-color pixels into connected components using orthogonal adjacency (up/down/left/right). Treat each contiguous block as one object to be analyzed and recolored as a unit.</description>\\n<example>For instance, a 2×2 square of the active color is one component; two pixels touching only at a corner are two separate components. Label each component so you can compare them across the grid.</example>\\n</note2>\\n\\n<note3>\\n<description>Count the number of pixels in each component (its area). The transformation in these examples depends on that area, so compute sizes for every component rather than looking at shape or orientation alone.</description>\\n<example>Suppose you find three components with sizes 1, 2 and 4. These sizes are the primary attribute that will determine how each component is treated in the output.</example>\\n</note3>\\n\\n<note4>\\n<description>Use the size ranking to decide recoloring: all components of the same size receive the same new color, while components of different sizes receive different colors. In the training examples the smallest components are treated differently from the larger ones, so identify which size is the \\\"special\\\" one.</description>\\n<example>Given component sizes {1,2,4}, the rule assigns one color to the 1-pixel component and a different color to every component of size 2 or 4. Apply that assignment consistently to every component of the same size.</example>\\n</note4>\\n\\n<note5>\\n<description>When you apply the recoloring, do not move or reshape components — only change their color in place. After recoloring, verify that the pattern of changed pixels matches the original component footprints and that the background and other colors are unchanged.</description>\\n<example>If a component occupies a particular set of coordinates in the input, those same coordinates should be the only ones changed in the output; everything else should remain exactly as it was. A common pitfall is recoloring every pixel of the original color globally instead of per-component.</example>\\n</note5>\",\n \"<note1>\\n<description>Treat each contiguous patch of the non-background color as an object. Use 4‑connectivity (up/down/left/right) so diagonally touching pixels do not join objects. This separates the scene into a small set of discrete items you can compare.</description>\\n<example>Imagine a grid with three blue blobs: a 3×3 square, a 2×2 square, and a single isolated pixel. Using 4‑connectivity you get three objects with areas 9, 4 and 1. You should not join the single pixel with the squares because they are not orthogonally adjacent.</example>\\n</note1>\\n\\n<note2>\\n<description>Count the number of pixels in each object and compare those counts. The transformation depends on which object is smallest (fewest pixels) versus the others. The smallest object is singled out for a different treatment.</description>\\n<example>Given object areas {12, 8, 5, 3}, the object with area 3 is the smallest. That smallest object is the one you will treat differently from the rest when producing the output.</example>\\n</note2>\\n\\n<note3>\\n<description>Recolor every pixel of the smallest object to a single distinct color while leaving its shape and position unchanged. The rest of the grid (the other objects) are recolored uniformly to a second color. This highlights the unique object without moving it.</description>\\n<example>Start with three objects: a 3×3 block, a 2×2 block, and a single pixel. After the step, the single pixel is painted color A and both the 3×3 and 2×2 blocks are painted color B, but all objects remain exactly where they were.</example>\\n</note3>\\n\\n<note4>\\n<description>Do not alter background pixels or object geometry: only change colors. The output should be the same grid dimensions with the same object shapes and placements, only with two colors applied to the objects (one for the smallest, one for the others). This preserves spatial relationships for comparison.</description>\\n<example>If a grid has a black background and several colored blobs, the final grid still has black background and the same blobs in the same positions; only the blob colors differ — one color for the unique small blob, another for all the other blobs.</example>\\n</note4>\\n\\n<note5>\\n<description>Watch for edge cases: if there is only one object, it is the smallest and should be recolored as the unique object; if two objects tie for smallest, use the training examples to decide which tie‑breaking rule applies (often a consistent positional tie‑break such as topmost/leftmost is used). Always verify connectivity before counting.</description>\\n<example>If you see a single isolated pixel and a large cluster, treat the single pixel as the unique object and recolor it separately. If two isolated pixels appear, check the examples to see whether the topmost or leftmost one is chosen; apply the same consistent rule to the test case.</example>\\n</note5>\",\n \"<note1>\\n<description>Look for a single non-background color that appears in multiple disconnected islands; those islands are the objects to compare. This is effective because the transformation operates on whole objects (connected components) rather than individual stray pixels.</description>\\n<example>Imagine a grid with several blue islands on a black background. First mark every contiguous group of blue pixels (use orthogonal adjacency). You now have a list of distinct objects to analyze, which is easier than comparing every blue pixel one-by-one.</example>\\n</note1>\\n\\n<note2>\\n<description>For each object, compute its bounding box (min/max row and column) and derive width and height. The bounding box gives a compact description of an object’s horizontal and vertical span and is a robust way to compare shapes.</description>\\n<example>If an object occupies rows 2–5 and columns 7–9, its bounding box is width=3 and height=4. Do this for every object so you can compare sizes and positions without looking at every pixel.</example>\\n</note2>\\n\\n<note3>\\n<description>Decide whether an object is “wide” (wider than tall) by comparing width and height. A simple numeric threshold (for example, width > height) cleanly separates horizontal bars from vertical bars and is easy to apply consistently.</description>\\n<example>With width=4 and height=2 you would call that object wide; with width=2 and height=4 you would call it tall. Using a single inequality makes the classification unambiguous across examples.</example>\\n</note3>\\n\\n<note4>\\n<description>Recolor every object according to its class: one replacement color for wide objects and a different replacement color for tall objects; leave the background unchanged. This preserves each object’s shape and location while highlighting the two classes.</description>\\n<example>After classifying, paint every wide island with color A and every tall island with color B. The grid will show two distinct groups of objects (by their new colors) while the black background remains intact.</example>\\n</note4>\\n\\n<note5>\\n<description>Watch for edge cases: use orthogonal connectivity (not diagonal), ignore single isolated pixels unless they form a connected component, and check that the same classification rule explains every training example. If any example breaks the rule, revisit the bounding-box test or the threshold.</description>\\n<example>If a lone pixel appears it should be treated as a 1×1 object; if two pixels touch only at a corner they are separate objects. Confirm your rule by applying it to all training pairs—if it reproduces their outputs, it is likely correct.</example>\\n</note5>\",\n \"<note1>\\n<description>Focus first on the one color that is being changed between input and output: treat that color as the \\\"object\\\" to analyze. Isolating that color reduces the problem to a small set of pixels you can group and compare.</description>\\n<example>Imagine a grid where only the blue pixels differ between input and output. Ignore all other colors and extract just the blue pixels; these are the only elements you need to study for the transformation.</example>\\n</note1>\\n\\n<note2>\\n<description>Group the object pixels into connected components using orthogonal adjacency (up/down/left/right). Each connected component is an independent object to be classified and recolored.</description>\\n<example>For instance, a 2×2 block of blue pixels is one component, while a single isolated blue pixel elsewhere is a second component. Treat each component separately when you look for patterns.</example>\\n</note2>\\n\\n<note3>\\n<description>Characterize each component by simple geometric features: bounding box dimensions, pixel count, and whether the bounding box is fully filled or only a border. These small measurements often reveal a small set of distinct object types.</description>\\n<example>A filled 2×2 square has bounding box 2×2 and count 4; an L-shaped 3-pixel component has bounding box 2×2 but count 3; a straight 4-pixel line has bounding box 1×4 or 4×1 and count 4. Use these signatures to separate shapes.</example>\\n</note3>\\n\\n<note4>\\n<description>Look for a single geometric feature that cleanly separates the components into two groups across all training examples (for example: whether the bounding box is completely filled, or whether the component is a straight line vs a compact block). That feature is the classifier used to decide recoloring.</description>\\n<example>Suppose every component whose bounding box is fully filled and has area 4 is treated one way, and every other component is treated differently; then \\\"is the bounding box fully filled and area=4?\\\" is the right classifier. Verify this holds for every example before applying it.</example>\\n</note4>\\n\\n<note5>\\n<description>Apply the discovered rule: recolor every component according to its class while leaving all other pixels unchanged. Use two distinct replacement colors (one for each class) consistently across the grid.</description>\\n<example>If you have two classes (e.g., \\\"compact filled squares\\\" and \\\"all other shapes\\\"), fill each class's pixels with one replacement color and the other class's pixels with a different replacement color. Check that the training outputs are reproduced by this mapping before using it on the test grid.</example>\\n</note5>\",\n \"<note1>\\n<description>Start by isolating the non-background color that appears repeatedly; treat each contiguous patch of that color as a separate object. This reduces the problem to a small set of discrete shapes to compare rather than many scattered pixels.</description>\\n<example>Imagine a grid where one color appears in several disconnected blobs on a black background. Mark each blob as an object (a connected component) so you can analyze their shapes independently. Don’t mix separate blobs even if they are similar in shape.</example>\\n</note1>\\n\\n<note2>\\n<description>Normalize each object by cropping to its bounding box and translating that box to the origin; this produces a canonical representation so you can compare shapes regardless of position. Comparing these normalized masks is the standard way to detect identical shapes.</description>\\n<example>Two L-shaped blobs in different places become the same small matrix after cropping and shifting to (0,0). If their normalized matrices match exactly, they are the same shape even though their coordinates differ.</example>\\n</note2>\\n\\n<note3>\\n<description>Compare the normalized masks exactly (pixel-by-pixel) to group identical shapes. Count how many objects belong to each group and look for a group with a different frequency — that frequency difference is often the key to deciding which group to treat differently.</description>\\n<example>If you find three identical small blocks and one small block with a different arrangement, you will see three groups: one group of size 3 and one of size 1. The unique frequency (size 1) flags the exceptional object.</example>\\n</note3>\\n\\n<note4>\\n<description>Once you have the groups, recolor every pixel of each group consistently: give all objects in the common group one color and the exceptional object a different color; leave the background unchanged. The transformation is a recoloring of whole objects, not a movement or reshaping.</description>\\n<example>With three identical blocks and one different block, paint all three blocks the same new color and paint the single different block a second new color. Do not alter any other pixels or move the objects.</example>\\n</note4>\\n\\n<note5>\\n<description>Be careful about orientation and edge cases: only count rotations/reflections as the same shape if the examples show them; also check whether the exceptional object is unique in count or in a unique property. Use the examples to decide whether to treat rotated copies as equivalent.</description>\\n<example>If two blocks are mirror images but the examples never show mirror symmetry, treat them as different shapes. If the examples do show rotated copies being considered the same, then include rotations when comparing masks.</example>\\n</note5>\",\n \"<note1>\\n<description>First, isolate every contiguous group of the target color (the non-zero color that appears repeatedly). Use orthogonal adjacency (up/down/left/right) to decide whether pixels belong to the same object; this separates distinct shapes that might otherwise look similar.</description>\\n<example>Imagine a grid with three separated blue blobs: one at the top-left, one in the middle, and one at the bottom-right. Treat each blob as an independent object even if they have the same color. Marking these components makes it clear which pieces are being transformed in the output.</example>\\n</note1>\\n\\n<note2>\\n<description>Measure each object's size by counting its pixels (area). The transformation in the examples depends on this size rather than on shape or orientation, so ranking objects by area is a reliable first step.</description>\\n<example>Given three objects with areas 12, 5 and 2, you now have a clear ordering: largest (12), middle (5), smallest (2). Use these counts to decide which object is treated differently in the output.</example>\\n</note2>\\n\\n<note3>\\n<description>Compare the input and output to see how objects are recolored: one color is used for all objects except the singled-out one, and a different color is used for the singled-out object. The key is to identify which object is singled out by position (the one that is farthest down and, if tied, farthest right).</description>\\n<example>Suppose the output shows two objects in a common color and a third object in a different color. That tells you the rule is: recolor every object except the lowest/rightmost one with one color, and recolor that lowest/rightmost object with another color.</example>\\n</note3>\\n\\n<note4>\\n<description>When recoloring, change only the pixels that belong to each object; do not move, resize, or fill gaps. The background (zeros) and any other colors remain unchanged, so the output should preserve the original object geometry while changing only their colors.</description>\\n<example>If an object is a small L-shape of blue pixels, recolor that exact L-shape to the chosen color(s) in place. Do not add or remove pixels — only substitute the object's color with the new color.</example>\\n</note4>\\n\\n<note5>\\n<description>Handle ties and edge cases consistently: if two objects share the same bottom row, pick the one with the larger column index; if they share the same bottom-right corner, treat that as the singled-out object. Verify your choice by checking that the recoloring pattern matches the examples.</description>\\n<example>Two identical squares sit on the same bottom row, one at column 4 and one at column 9. The square at column 9 is the one to treat as the singled-out object. If the two bottom-most objects are also in the same column, the one at the greater row index (lower down) is the singled-out one.</example>\\n</note5>\",\n \"<note1>\\n<description>Start by isolating the single non-background color that is being transformed across examples. That color appears in multiple disconnected patches; treat each disconnected patch as an independent object to analyze.</description>\\n<example>Imagine a grid with many blue pixels scattered in several places. Those blue pixels are not one shape but several separate objects; mark each object (each connected group of blue pixels) so you can compare them across the grid.</example>\\n</note1>\\n\\n<note2>\\n<description>Use orthogonal connectivity (up/down/left/right) to define objects: pixels that touch diagonally are separate objects. This choice changes how many objects you see and is important for distinguishing shapes.</description>\\n<example>Two blue pixels that touch only at a corner are two objects under 4‑connectivity. Count and list each object so you can measure its size and shape independently.</example>\\n</note2>\\n\\n<note3>\\n<description>Compute the size of each object by counting how many pixels it contains. Size is the key numeric feature used to decide how to recolor objects.</description>\\n<example>Suppose you find three objects with pixel counts 12, 7 and 2. Record these counts — the largest and smallest will be the ones you treat differently, the rest form the middle group.</example>\\n</note3>\\n\\n<note4>\\n<description>Apply a size-based recoloring rule: assign one replacement color to the largest object(s) and a different replacement color to the smallest object(s); give the remaining objects a third replacement color. If there are multiple objects with the same extreme size, recolor all of them the same way.</description>\\n<example>With object sizes 12, 7 and 2, recolor the 12‑pixel object with color A, the 2‑pixel object with color B, and the 7‑pixel object with color C. If two objects both had size 2, both would be recolored to B.</example>\\n</note4>\\n\\n<note5>\\n<description>Keep the transformation minimal and local: do not move, reshape, or otherwise alter object geometry — only change their colors. Also ensure the background and unrelated colors remain unchanged.</description>\\n<example>If a blue object occupies a fixed set of coordinates, it should occupy the same coordinates after the transformation but with a different color. Do not add or remove pixels from an object when recoloring it.</example>\\n</note5>\",\n \"<note1>\\n<description>Group same-colored pixels into connected components using orthogonal adjacency (up/down/left/right). Treat each connected cluster as one object to be analyzed and transformed. This isolates individual shapes even when they share the same color.</description>\\n<example>Imagine a small grid with three blue blobs: one 3×3 square, one 2×2 square, and one single blue pixel. Using 4‑connectivity, these are three separate components because no two blue pixels touch orthogonally. Label each component so you can reason about them individually.</example>\\n</note1>\\n\\n<note2>\\n<description>For every component compute its area (the count of cells in that component). Area is the simplest, robust metric to distinguish objects by size. Use this numeric measure rather than visual heuristics like “looks small”.</description>\\n<example>Continuing the previous example, the three components have areas 9, 4 and 1 respectively. Record these counts for each component so you can compare them across the grid. Area is invariant to translation and orientation, so it’s a reliable discriminator.</example>\\n</note2>\\n\\n<note3>\\n<description>Find the smallest area among all components and select that component as the special one to treat differently. If only one component has that minimum area, it is the unique special object. If several components tie for smallest, the task usually expects you to pick a consistent tie-break (e.g., the one encountered first in a fixed scan order).</description>\\n<example>If component areas are {9,4,1}, the area‑1 component is the smallest and is the special object. If areas are {9,4,4,1}, there are two smallest components (area 1) — in that case pick one consistently (for instance, the component whose topmost pixel is highest, or the leftmost if tied).</example>\\n</note3>\\n\\n<note4>\\n<description>Recolor the grid by replacing every cell of the special component with one distinct color and every other component with a single other color, while leaving the background unchanged. The transformation is a recoloring of whole components, not a reshaping or relocation of pixels. This highlights the smallest object against the rest.</description>\\n<example>Using the three-component example, recolor the smallest (area‑1) blob to color A and recolor both larger blobs to color B, keeping zeros as background. The blobs keep their exact coordinates and shapes; only their colors change.</example>\\n</note4>\\n\\n<note5>\\n<description>Watch for common pitfalls: use 4‑connectivity (not diagonal), count every pixel in a component (even if disconnected parts are separated by background), and apply the same tie-break rule if multiple smallest components exist. After recoloring, verify that only the intended components changed and that background pixels remain unchanged.</description>\\n<example>If two single‑pixel components are the smallest, do not accidentally merge them by diagonal adjacency; pick one by a consistent rule (e.g., the one with the smallest row index, then smallest column). After recoloring, scan the grid to confirm no background cell was altered and only whole components were recolored.</example>\\n</note5>\",\n \"<note1>\\n<description>Look for objects by grouping contiguous non-background pixels. Use 4‑connectivity (up/down/left/right) so that diagonally touching pixels do not join objects. This isolates each separate shape you must reason about.</description>\\n<example>Imagine a grid with three blue blobs separated by at least one row or column of background. Treat each blob as an independent object even if they look similar. Label them A, B, C so you can compare them one by one.</example>\\n</note1>\\n\\n<note2>\\n<description>Quantify each object by counting its pixels (area). The transformation often depends on these counts rather than on absolute position or orientation. Ranking objects by area reveals which ones are the largest or smallest.</description>\\n<example>For instance, if object areas are 12, 7 and 3, you can immediately see there is a single smallest object (area 3) and two larger ones (12 and 7). That numeric ranking is the key for deciding which objects get special treatment.</example>\\n</note2>\\n\\n<note3>\\n<description>Compare input and output to see how objects are recolored. Often the rule is: recolor every object except the smallest one to one color, and recolor the smallest object to a different color. Check that shapes and positions remain unchanged — only colors change.</description>\\n<example>Suppose two large blobs and one tiny blob in the input become two uniform colors in the output while the tiny blob becomes a distinct color. That indicates the operation is \\\"preserve geometry, change color by object rank.\\\"</example>\\n</note3>\\n\\n<note4>\\n<description>Decide a deterministic tie-breaker for equal-size objects. If two or more objects share the minimal area, choose one consistently (for example, the object whose topmost pixel is highest, then the leftmost if needed). Consistency avoids ambiguity when sizes are equal.</description>\\n<example>If two blobs both have area 4, pick the one whose topmost pixel has the smallest row index; if those match, pick the one with the smallest column index. Apply the same rule across the grid so your choice is unambiguous.</example>\\n</note4>\\n\\n<note5>\\n<description>Watch for common pitfalls: use 4‑connectivity (not diagonal), do not merge background pixels, and only recolor the identified objects while leaving all other cells (background and other colors) unchanged. Verify that the shapes and positions remain exactly as in the input after recoloring.</description>\\n<example>A frequent error is to treat diagonally touching pixels as one object or to recolor stray background pixels; instead, only recolor whole connected components of the target color and keep all other colors and positions identical to the input.</example>\\n</note5>\",\n \"<note1>\\n<description>Separate the picture into objects by grouping same-colored pixels that touch orthogonally (up/down/left/right). This converts the problem from pixel-level noise into a small set of discrete objects to compare. Use 4-way connectivity (not diagonal) so that only orthogonally adjacent pixels form one object.</description>\\n<example>Imagine a grid with several blue blobs on a black background. If two blue pixels share an edge they belong to the same object; if they only touch at a corner they are different objects. Label each connected patch as a distinct object before doing any counting or recoloring.</example>\\n</note1>\\n\\n<note2>\\n<description>Count how many pixels belong to each object and sort them by size. Many ARC tasks single out an object by its size (for example, the smallest object is treated differently from the rest). Ranking by pixel count makes that selection unambiguous.</description>\\n<example>Suppose you find objects with sizes 12, 7 and 2 pixels. The object with 2 pixels is the smallest and should be singled out for a special treatment, while the 12- and 7-pixel objects are handled together.</example>\\n</note2>\\n\\n<note3>\\n<description>Recolor every pixel of the singled-out object with one new color, and recolor every pixel of all remaining objects with a different color, leaving the background unchanged. The transformation is a uniform recoloring of whole objects, not partial or shape-changing edits. This makes the special object visually distinct while preserving object shapes.</description>\\n<example>If the smallest object is a tiny two-pixel cluster, change both of its pixels to color A and change every pixel of the other objects to color B. The shapes and positions remain identical; only the colors differ.</example>\\n</note3>\\n\\n<note4>\\n<description>Do not move, resize, or otherwise alter object geometry — only change their colors. The output should be the same grid size with the same object masks, but with colors reassigned according to the selection rule. This keeps spatial relationships intact and avoids introducing unintended transformations.</description>\\n<example>Take a 12×12 grid with several blobs: after recoloring, the blobs still occupy the same coordinates and have the same outlines; only their color values differ. If a shape looks shifted or split, you likely altered geometry instead of recoloring.</example>\\n</note4>\\n\\n<note5>\\n<description>Handle ties and edge cases consistently: if multiple objects share the minimal size, treat them all as the special set; if there is no single smallest object (e.g., only one object), then apply the alternate rule shown in the examples (often recoloring all objects with the same new color). Also ensure you only consider orthogonally connected pixels when deciding sizes.</description>\\n<example>If two tiny blobs both have size 2, recolor both with the special color and recolor the rest with the alternate color. If there is only one blob, follow the pattern from the examples (for instance, recolor every blob to the alternate color) so your rule matches the intended transformation.</example>\\n</note5>\",\n \"<note1>\\n<description>First isolate the foreground color that is being transformed across examples. Work at the object level: group contiguous pixels of that color into separate objects (use orthogonal adjacency). This separates the grid into a small set of candidate shapes to analyze.</description>\\n<example>Imagine a grid with several blue blobs on a black background. Treat each contiguous blue blob (connected by up/down/left/right) as an individual object. You now have a list of objects (not individual pixels) to compare and classify.</example>\\n</note1>\\n\\n<note2>\\n<description>For each object compute a simple numeric descriptor such as its pixel count (area). Area is robust to translation and is often the decisive feature in ARC tasks that recolor whole objects. Use area as the primary key to distinguish objects.</description>\\n<example>Suppose you have three blue objects with areas 9, 4 and 1. Those three numbers immediately tell you which object is smallest (area=1), which is medium (area=4), and which is large (area=9). Counting pixels is faster and less error-prone than trying to eyeball shape complexity.</example>\\n</note2>\\n\\n<note3>\\n<description>Look for a unique smallest object: if exactly one object has the minimum area, that object is typically treated differently in the output. The rule often recolors every object except that unique smallest one. If there is no unique minimum (multiple objects tie), the examples usually recolor all objects the same way instead.</description>\\n<example>If only one blob has area 1 while others have larger areas, expect that blob to be handled specially (e.g., given a different color). If two blobs both have area 1, check the examples to see whether both are changed or all are changed uniformly; the examples will show which behavior to follow.</example>\\n</note3>\\n\\n<note4>\\n<description>When applying the recoloring, preserve each object's shape and position exactly — only change its color. The transformation is a recoloring operation, not a move, resize, or mirror of shapes. This keeps spatial relationships identical while changing appearance.</description>\\n<example>Take a 3×2 rectangular object at a fixed location: in the output it should still occupy the same cells but with a new color. Do this for every object; the only change is the color value per object, not the geometry.</example>\\n</note4>\\n\\n<note5>\\n<description>Use the training examples to determine which color is used for the \\\"special\\\" object and which color is used for the other objects, then apply that mapping consistently. If multiple smallest objects exist, follow the pattern shown by the examples (either recolor all objects the same or recolor the smallest ones specially). Always verify by checking counts and positions against the examples.</description>\\n<example>Scan the example outputs: if the unique smallest blob is colored green in the examples while all other blobs are colored yellow, then in the test you should recolor the unique smallest blob to green and all other blobs to yellow. If examples show no unique smallest, recolor every object to the same color instead.</example>\\n</note5>\",\n \"<note1>\\n<description>Start by isolating the non-background color that appears as multiple disconnected blobs in the inputs. Treat each connected blob (orthogonal adjacency) as an object and record its pixel coordinates and bounding box. This gives you a small set of objects to compare instead of the whole grid.</description>\\n<example>Imagine a grid with several blue blobs on a black background. Find each blue connected component and compute its bounding box and list of pixel coordinates. Now you have a handful of objects (e.g., three blobs) to analyze rather than scanning the entire grid.</example>\\n</note1>\\n\\n<note2>\\n<description>Compare the objects by simple shape features: pixel count, bounding-box width and height, and whether the box is fully filled or has holes. Often one object will stand out because it has a different pixel count or a different aspect ratio. Counting pixels is a robust, implementation‑independent discriminator.</description>\\n<example>Suppose you have three blobs with pixel counts 8, 8 and 12. The blob with 12 pixels is the odd one out by count. If two blobs share the same count, compare bounding-box dimensions (e.g., 4×2 vs 2×4) to find a size-based distinction.</example>\\n</note2>\\n\\n<note3>\\n<description>Once you identify the odd object, the transformation usually recolors all objects the same way except the odd one, which receives a different color. The operation is a recoloring per object, not a move or reshaping. So your task is to find which object is singled out and recolor accordingly.</description>\\n<example>With three identical shapes and one larger shape, the output will show two shapes in one new color and the larger shape in a second new color. The shapes keep their exact positions and forms; only their colors change.</example>\\n</note3>\\n\\n<note4>\\n<description>Use simple heuristics to break ties: prefer pixel-count first, then bounding-box area, then aspect ratio, then whether the box is solid or hollow. Also check for repeated sub-shapes (identical small tiles) — the odd object is often the one that is not part of a repeated motif. These checks are quick and reliable.</description>\\n<example>If two blobs have the same pixel count but one fits a 4×2 box while the other fits 2×4, pick the one with the different aspect ratio. If three blobs are identical and one is larger, choose the larger one by pixel count.</example>\\n</note4>\\n\\n<note5>\\n<description>Finally, apply the recoloring consistently: change every pixel of each object to the chosen new color while preserving background. After recoloring, verify that only the identified object uses the alternate color and that all other objects share the same color. This final check ensures you applied the intended transformation.</description>\\n<example>After selecting the odd blob, recolor all pixels of that blob to the alternate color and recolor the remaining blobs to the common color. Then scan the grid to confirm no object was moved or resized and that the background stayed unchanged.</example>\\n</note5>\",\n \"<note1>\\n<description>Look for the single non-background color that appears in the inputs and is being transformed in the outputs. That color is the one you should analyze for grouping and recoloring; everything else (background and other colors) is left alone.</description>\\n<example>Imagine a grid with only zeros and some green pixels. The output only changes those green pixels while zeros remain zeros. So focus on that green color as the object to be processed — ignore other colors and the background.</example>\\n</note1>\\n\\n<note2>\\n<description>Split the target-color pixels into separate objects using 4‑connectivity (up/down/left/right). Each connected component is an independent object whose shape and position you must preserve.</description>\\n<example>For example, a 2×2 block of the target color is one object, and a single isolated pixel elsewhere is a second object. Treat each of these as a whole when you later decide how to recolor them.</example>\\n</note2>\\n\\n<note3>\\n<description>Compute a simple size metric for each object (e.g., number of pixels) and sort the objects by that metric. The transformation distinguishes objects by their size rank (largest vs. smallest) rather than by arbitrary coordinates.</description>\\n<example>Suppose you find three objects with pixel counts 12, 5 and 3. The rule will treat the 12‑pixel object differently from the 5‑ and 3‑pixel objects; the exact ordering (largest → smallest) is what matters, not absolute positions.</example>\\n</note3>\\n\\n<note4>\\n<description>Recolor each object uniformly according to its size rank: one replacement color for the largest object(s) and a different replacement color for all smaller objects. Do not change the object's shape or location — only change the color of every pixel in that object.</description>\\n<example>In a toy case, a 3×4 block becomes entirely color A and every smaller isolated pixel becomes color B. The background stays the same and every pixel inside an object keeps the same relative coordinates.</example>\\n</note4>\\n\\n<note5>\\n<description>Handle ties and edge cases explicitly: if several objects share the maximal size, recolor all of them the same way; if there is only one object, it gets the \\\"largest\\\" treatment. Also ensure you use 4‑connectivity (not diagonal) when grouping and do not alter any other colors.</description>\\n<example>If two objects both have 6 pixels and no object has more than 6, both should be recolored with the largest‑object color. If there is only a single object, it is treated as the largest and receives that color.</example>\\n</note5>\",\n \"<note1>\\n<description>Look for a single color that is being transformed into two different colors in the outputs while the background stays the same. This often means the input has several disconnected objects of that color and the rule treats them differently. Identifying that color narrows the problem to handling a small set of objects rather than many pixels.</description>\\n<example>Imagine a grid where several blue blobs appear on a black background and the outputs show some blue blobs turned green while other blue blobs turned yellow. That pattern suggests the transformation targets blue blobs specifically and recolors them based on their object-level properties.</example>\\n</note1>\\n\\n<note2>\\n<description>Split the target color into connected components using orthogonal (up/down/left/right) adjacency. Each connected component is an independent object whose properties you can count and compare. This decomposition is essential because the rule usually operates on whole objects, not on individual pixels.</description>\\n<example>On a small grid, three blue blobs separated by black cells are three components. Label them A, B, C and treat each as a unit when comparing sizes, positions, and other attributes.</example>\\n</note2>\\n\\n<note3>\\n<description>Measure each component's size (the number of pixels) and rank them. Many ARC tasks pick the smallest or largest component as the special one to treat differently. Counting pixels is robust and gives a clear numeric criterion for selection.</description>\\n<example>If component sizes are 12, 6 and 4, the component with 4 pixels is the smallest. That smallest component is a natural candidate for being handled differently from the others.</example>\\n</note3>\\n\\n<note4>\\n<description>Recolor components according to their rank: typically give the smallest component one new color and recolor every other component with a different new color, leaving the background unchanged. The spatial arrangement and shapes remain the same — only the color labels change. This produces a consistent mapping from object rank to output color.</description>\\n<example>Given three blue components sized 12, 6 and 4, change all 12- and 6-pixel blobs to green and the 4-pixel blob to yellow; the blobs stay in place but now show two new colors.</example>\\n</note4>\\n\\n<note5>\\n<description>Watch for edge cases: use 4-neighbor connectivity (diagonals do not connect), and if two components tie for smallest size choose a consistent tie-breaker (for example, the component whose topmost pixel is higher, then the leftmost). Also confirm the rule by checking that every example applies the same selection-and-recolor logic. These checks prevent ambiguous interpretations.</description>\\n<example>If two components both have size 4, pick the one whose topmost pixel has the smaller row index; if those are equal, pick the one with the smaller column index. Apply this rule consistently across the grid so the transformation is unambiguous.</example>\\n</note5>\",\n \"<note1>\\n<description>Work at the object level: treat each connected group of the non-background color as a single entity. This reduces the problem from many pixels to a small set of shapes you can compare and classify.</description>\\n<example>Imagine a grid with three separate blue blobs. Instead of comparing every blue pixel, extract each blob (using 4‑connectivity) and record its pixels and bounding box. You now have three objects to analyze rather than many individual pixels.</example>\\n</note1>\\n\\n<note2>\\n<description>Normalize shapes by translating each object's pixels so their top-left corner is (0,0). For a robust comparison, also generate rotated and reflected versions of the normalized shape and compare these variants.</description>\\n<example>Take an L‑shaped blob and a 2×2 square: translate both to (0,0). The L and square have different signatures, so they are distinct. If you also try 90° rotations or flips, you can still tell which are the same up to rotation/reflection.</example>\\n</note2>\\n\\n<note3>\\n<description>Group objects into shape classes by matching their normalized signatures. Objects that match under translation (or under rotation/reflection) belong to the same class.</description>\\n<example>If you find two objects whose normalized pixel sets are identical, they are the same shape-class even if they sit in different places. If a third object only matches after a 90° rotation, treat it as a different class unless the task explicitly allows rotated matches.</example>\\n</note3>\\n\\n<note4>\\n<description>Choose one representative color per class and recolor every pixel of each object with that class color; leave background pixels unchanged. The transformation is about class identity, not moving or reshaping objects.</description>\\n<example>Suppose there are three classes: a common shape, a small irregular shape, and a tiny 2‑pixel shape. Pick one color for the common shape, another for the irregular, and a third for the tiny one, then fill every pixel of each object with its class color so the grid highlights classes rather than individual pixels.</example>\\n</note4>\\n\\n<note5>\\n<description>Decide whether to treat rotated/reflected versions as the same class by checking the examples: if rotated copies are recolored identically, include rotations; if they are recolored differently, do not. This choice determines whether you merge or split classes.</description>\\n<example>Compare two blobs that look like the same shape but one is rotated. If the training outputs recolor both the same way, consider them one class (allow rotations). If the outputs give them different colors, treat them as distinct classes and recolor separately.</example>\\n</note5>\",\n \"<note1>\\n<description>Look for a single non-background color that appears in multiple disconnected blobs; the transformation usually treats those blobs as the primary objects to analyze. This is effective when the background is uniform and the same color recurs in several separate patches. Identifying that color reduces the problem to object-level reasoning instead of pixel-level noise.</description>\\n<example>Imagine a grid where black is the background and many small red blobs appear scattered. Those red blobs are the objects to focus on — ignore any isolated black pixels or other colors that do not repeat. Once you have the repeated-color objects, you can reason about them as whole shapes rather than individual pixels.</example>\\n</note1>\\n\\n<note2>\\n<description>Define objects by connectivity: group pixels of the same color that touch orthogonally (up/down/left/right) into connected components. This gives you exact object boundaries and counts so you can compare shapes reliably. Use the same connectivity rule consistently across the grid.</description>\\n<example>For example, three red pixels that meet side-by-side form one object of size 3, while a lone red pixel separated by black is a separate object of size 1. By listing each connected component and its size you obtain a clear inventory of the shapes present. That inventory is what you will compare to the outputs.</example>\\n</note2>\\n\\n<note3>\\n<description>Compare the counts of objects and the counts of pixels in the input to the output: the transformation typically changes only the colors of whole objects, not their positions or shapes. In other words, objects keep their geometry and coordinates; only their color labels change. Use this to pair each input object with the corresponding output object.</description>\\n<example>Suppose an input has three red blobs of sizes 5, 3 and 1 and the output shows three colored blobs in the same places with sizes 5, 3 and 1 but different colors. That indicates a recoloring of entire objects rather than moving or reshaping them. Pair the input objects by size and location to see which color each was recolored to.</example>\\n</note3>\\n\\n<note4>\\n<description>Look for a simple size-based rule: many tasks recolor all objects of one size class with one new color and all objects of another size class with a different new color. The size class is usually a small integer (for example, singletons vs. multi-cell objects). Formulate the rule in terms of object pixel count and test it against the examples.</description>\\n<example>Imagine the examples show that every object of size 1 becomes color A and every object of size >1 becomes color B. If you find that pattern consistently in the training pairs, apply the same rule to the test input: recolor each object according to whether its pixel count matches the special class or not. This turns a visual pattern into a repeatable rule.</example>\\n</note4>\\n\\n<note5>\\n<description>When you apply the rule, recolor entire connected components and leave the background unchanged; do not alter object geometry or move pixels. After recoloring, verify that the number and relative placement of objects match the input and that only color labels changed. This final check catches mistakes like accidentally merging or splitting objects.</description>\\n<example>After deciding which objects are the special size class, change every pixel of those components to the new color and change the rest to the other new color; keep all zeros as background. Then confirm the output has the same set of objects in the same positions but with different color labels. If counts or positions differ, revisit your component detection or the size rule.</example>\\n</note5>\"\n]","isConversational":false},"train":{"kind":"string","value":"[{\"input\": [[0, 0, 0, 0, 0, 0, 0, 0, 0, 2, 2, 0, 0, 0, 0, 0, 0], [0, 0, 0, 0, 0, 0, 0, 0, 0, 2, 2, 0, 0, 0, 0, 0, 0], [0, 0, 0, 0, 0, 0, 0, 0, 0, 2, 2, 0, 0, 0, 0, 0, 0], [0, 0, 0, 2, 2, 0, 0, 0, 0, 2, 2, 0, 2, 0, 0, 2, 0], [0, 0, 2, 2, 2, 0, 0, 0, 0, 0, 0, 0, 2, 2, 2, 2, 0], [0, 0, 2, 2, 2, 0, 0, 0, 0, 0, 0, 0, 2, 2, 2, 2, 0], [2, 0, 0, 2, 2, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0], [2, 2, 0, 0, 0, 0, 2, 2, 2, 0, 0, 0, 0, 0, 0, 0, 0], [2, 0, 0, 0, 0, 0, 0, 2, 2, 2, 0, 0, 0, 0, 0, 0, 0], [2, 0, 0, 0, 0, 0, 0, 0, 2, 2, 0, 0, 0, 0, 0, 0, 0], [2, 0, 0, 0, 0, 0, 0, 0, 0, 2, 0, 0, 0, 0, 0, 2, 0], [0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 2, 2, 2], [0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 2, 0]], \"output\": [[0, 0, 0, 0, 0, 0, 0, 0, 0, 6, 6, 0, 0, 0, 0, 0, 0], [0, 0, 0, 0, 0, 0, 0, 0, 0, 6, 6, 0, 0, 0, 0, 0, 0], [0, 0, 0, 0, 0, 0, 0, 0, 0, 6, 6, 0, 0, 0, 0, 0, 0], [0, 0, 0, 6, 6, 0, 0, 0, 0, 6, 6, 0, 6, 0, 0, 6, 0], [0, 0, 6, 6, 6, 0, 0, 0, 0, 0, 0, 0, 6, 6, 6, 6, 0], [0, 0, 6, 6, 6, 0, 0, 0, 0, 0, 0, 0, 6, 6, 6, 6, 0], [6, 0, 0, 6, 6, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0], [6, 6, 0, 0, 0, 0, 6, 6, 6, 0, 0, 0, 0, 0, 0, 0, 0], [6, 0, 0, 0, 0, 0, 0, 6, 6, 6, 0, 0, 0, 0, 0, 0, 0], [6, 0, 0, 0, 0, 0, 0, 0, 6, 6, 0, 0, 0, 0, 0, 0, 0], [6, 0, 0, 0, 0, 0, 0, 0, 0, 6, 0, 0, 0, 0, 0, 4, 0], [0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 4, 4, 4], [0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 4, 0]]}, {\"input\": [[0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0], [0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0], [0, 0, 0, 0, 2, 0, 0, 2, 0, 0, 0, 0, 0, 0, 0], [0, 0, 0, 0, 2, 2, 2, 2, 0, 0, 2, 2, 0, 0, 0], [0, 0, 0, 0, 2, 2, 2, 2, 0, 0, 2, 2, 0, 0, 0], [0, 0, 0, 0, 2, 2, 2, 2, 0, 0, 2, 2, 0, 0, 0], [0, 0, 0, 0, 2, 2, 2, 2, 0, 0, 2, 2, 0, 0, 0], [2, 0, 0, 0, 0, 0, 0, 0, 0, 0, 2, 2, 0, 0, 0], [2, 2, 2, 0, 0, 0, 0, 2, 2, 0, 0, 0, 0, 0, 0], [0, 0, 0, 0, 0, 0, 0, 2, 2, 0, 0, 2, 0, 0, 2], [0, 0, 0, 0, 0, 0, 0, 2, 2, 0, 0, 2, 2, 2, 2], [0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 2, 2, 2, 2]], \"output\": [[0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0], [0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0], [0, 0, 0, 0, 6, 0, 0, 6, 0, 0, 0, 0, 0, 0, 0], [0, 0, 0, 0, 6, 6, 6, 6, 0, 0, 6, 6, 0, 0, 0], [0, 0, 0, 0, 6, 6, 6, 6, 0, 0, 6, 6, 0, 0, 0], [0, 0, 0, 0, 6, 6, 6, 6, 0, 0, 6, 6, 0, 0, 0], [0, 0, 0, 0, 6, 6, 6, 6, 0, 0, 6, 6, 0, 0, 0], [4, 0, 0, 0, 0, 0, 0, 0, 0, 0, 6, 6, 0, 0, 0], [4, 4, 4, 0, 0, 0, 0, 6, 6, 0, 0, 0, 0, 0, 0], [0, 0, 0, 0, 0, 0, 0, 6, 6, 0, 0, 6, 0, 0, 6], [0, 0, 0, 0, 0, 0, 0, 6, 6, 0, 0, 6, 6, 6, 6], [0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 6, 6, 6, 6]]}, {\"input\": [[0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 2, 2, 0, 0, 0], [0, 0, 0, 0, 0, 2, 0, 0, 0, 0, 0, 2, 2, 0, 0, 0], [0, 0, 0, 0, 2, 2, 2, 0, 0, 0, 0, 2, 2, 0, 0, 0], [2, 2, 0, 2, 2, 2, 2, 2, 0, 0, 0, 2, 2, 0, 0, 0], [2, 0, 0, 0, 2, 2, 2, 0, 0, 0, 0, 0, 0, 0, 0, 0], [2, 2, 0, 0, 0, 2, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0], [0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 2, 2, 2, 2, 2], [0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 2, 2, 2, 0], [0, 0, 0, 0, 2, 2, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0], [0, 0, 0, 0, 2, 2, 2, 0, 0, 0, 2, 2, 2, 0, 0, 0], [0, 0, 0, 0, 2, 2, 2, 0, 0, 0, 2, 2, 2, 0, 0, 0], [0, 0, 0, 0, 2, 2, 0, 0, 0, 0, 2, 0, 2, 0, 0, 0]], \"output\": [[0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 6, 6, 0, 0, 0], [0, 0, 0, 0, 0, 6, 0, 0, 0, 0, 0, 6, 6, 0, 0, 0], [0, 0, 0, 0, 6, 6, 6, 0, 0, 0, 0, 6, 6, 0, 0, 0], [4, 4, 0, 6, 6, 6, 6, 6, 0, 0, 0, 6, 6, 0, 0, 0], [4, 0, 0, 0, 6, 6, 6, 0, 0, 0, 0, 0, 0, 0, 0, 0], [4, 4, 0, 0, 0, 6, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0], [0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 6, 6, 6, 6, 6], [0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 6, 6, 6, 0], [0, 0, 0, 0, 6, 6, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0], [0, 0, 0, 0, 6, 6, 6, 0, 0, 0, 6, 6, 6, 0, 0, 0], [0, 0, 0, 0, 6, 6, 6, 0, 0, 0, 6, 6, 6, 0, 0, 0], [0, 0, 0, 0, 6, 6, 0, 0, 0, 0, 6, 0, 6, 0, 0, 0]]}]"},"test":{"kind":"string","value":"[{\"input\": [[0, 0, 2, 2, 0, 2, 2, 0, 0, 0, 0, 0, 0, 0], [0, 0, 2, 2, 2, 2, 2, 0, 0, 2, 2, 0, 0, 0], [0, 0, 0, 0, 0, 0, 0, 0, 0, 2, 2, 0, 0, 0], [2, 2, 0, 0, 0, 0, 0, 0, 0, 2, 2, 0, 0, 0], [2, 2, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0], [2, 2, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0], [2, 2, 0, 0, 0, 0, 0, 0, 0, 0, 2, 0, 2, 0], [0, 0, 0, 0, 0, 0, 0, 0, 0, 2, 2, 2, 2, 2], [0, 0, 0, 0, 0, 0, 2, 2, 0, 0, 0, 0, 0, 0], [0, 0, 0, 0, 0, 0, 2, 2, 0, 0, 0, 0, 0, 0], [0, 2, 2, 0, 0, 0, 2, 2, 0, 0, 0, 0, 0, 0], [2, 2, 0, 0, 0, 0, 2, 2, 0, 0, 0, 0, 0, 0], [2, 2, 0, 0, 0, 0, 2, 2, 0, 0, 2, 2, 2, 0], [0, 2, 2, 0, 0, 0, 0, 0, 0, 0, 2, 2, 2, 0]], \"output\": [[0, 0, 6, 6, 0, 6, 6, 0, 0, 0, 0, 0, 0, 0], [0, 0, 6, 6, 6, 6, 6, 0, 0, 4, 4, 0, 0, 0], [0, 0, 0, 0, 0, 0, 0, 0, 0, 4, 4, 0, 0, 0], [6, 6, 0, 0, 0, 0, 0, 0, 0, 4, 4, 0, 0, 0], [6, 6, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0], [6, 6, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0], [6, 6, 0, 0, 0, 0, 0, 0, 0, 0, 6, 0, 6, 0], [0, 0, 0, 0, 0, 0, 0, 0, 0, 6, 6, 6, 6, 6], [0, 0, 0, 0, 0, 0, 6, 6, 0, 0, 0, 0, 0, 0], [0, 0, 0, 0, 0, 0, 6, 6, 0, 0, 0, 0, 0, 0], [0, 6, 6, 0, 0, 0, 6, 6, 0, 0, 0, 0, 0, 0], [6, 6, 0, 0, 0, 0, 6, 6, 0, 0, 0, 0, 0, 0], [6, 6, 0, 0, 0, 0, 6, 6, 0, 0, 4, 4, 4, 0], [0, 6, 6, 0, 0, 0, 0, 0, 0, 0, 4, 4, 4, 0]]}]"},"source":{"kind":"string","value":"barc_heavy"},"prompt":{"kind":"string","value":"You will be given some number of paired example inputs and outputs grids. The outputs were produced by applying a transformation rule to the input grids. In addition to the paired example inputs and outputs, there is also one test input without a known output. The inputs and outputs are each “grids”. A grid is a rectangular matrix of integers between 0 and 9 (inclusive). Each number corresponds to a color. 0 is black. Your task is to determine the transformation rule from examples and find out the answer, involving determining the size of the output grid for the test and correctly filling each cell of the grid with the appropriate color or number. The transformation only needs to be unambiguous and applicable to the example inputs and the test input. It doesn't need to work for all possible inputs. Observe the examples carefully, imagine the grid visually, and try to find the pattern. Please output your answer within a code block (```), formatted as a grid of numbers. \n\n# Examples\n## Example 1\nInput:\n```\n0 0 0 0 0 0 0 0 0 2 2 0 0 0 0 0 0\n0 0 0 0 0 0 0 0 0 2 2 0 0 0 0 0 0\n0 0 0 0 0 0 0 0 0 2 2 0 0 0 0 0 0\n0 0 0 2 2 0 0 0 0 2 2 0 2 0 0 2 0\n0 0 2 2 2 0 0 0 0 0 0 0 2 2 2 2 0\n0 0 2 2 2 0 0 0 0 0 0 0 2 2 2 2 0\n2 0 0 2 2 0 0 0 0 0 0 0 0 0 0 0 0\n2 2 0 0 0 0 2 2 2 0 0 0 0 0 0 0 0\n2 0 0 0 0 0 0 2 2 2 0 0 0 0 0 0 0\n2 0 0 0 0 0 0 0 2 2 0 0 0 0 0 0 0\n2 0 0 0 0 0 0 0 0 2 0 0 0 0 0 2 0\n0 0 0 0 0 0 0 0 0 0 0 0 0 0 2 2 2\n0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 2 0\n```\n\nOutput:\n```\n0 0 0 0 0 0 0 0 0 6 6 0 0 0 0 0 0\n0 0 0 0 0 0 0 0 0 6 6 0 0 0 0 0 0\n0 0 0 0 0 0 0 0 0 6 6 0 0 0 0 0 0\n0 0 0 6 6 0 0 0 0 6 6 0 6 0 0 6 0\n0 0 6 6 6 0 0 0 0 0 0 0 6 6 6 6 0\n0 0 6 6 6 0 0 0 0 0 0 0 6 6 6 6 0\n6 0 0 6 6 0 0 0 0 0 0 0 0 0 0 0 0\n6 6 0 0 0 0 6 6 6 0 0 0 0 0 0 0 0\n6 0 0 0 0 0 0 6 6 6 0 0 0 0 0 0 0\n6 0 0 0 0 0 0 0 6 6 0 0 0 0 0 0 0\n6 0 0 0 0 0 0 0 0 6 0 0 0 0 0 4 0\n0 0 0 0 0 0 0 0 0 0 0 0 0 0 4 4 4\n0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 4 0\n```\n\n## Example 2\nInput:\n```\n0 0 0 0 0 0 0 0 0 0 0 0 0 0 0\n0 0 0 0 0 0 0 0 0 0 0 0 0 0 0\n0 0 0 0 2 0 0 2 0 0 0 0 0 0 0\n0 0 0 0 2 2 2 2 0 0 2 2 0 0 0\n0 0 0 0 2 2 2 2 0 0 2 2 0 0 0\n0 0 0 0 2 2 2 2 0 0 2 2 0 0 0\n0 0 0 0 2 2 2 2 0 0 2 2 0 0 0\n2 0 0 0 0 0 0 0 0 0 2 2 0 0 0\n2 2 2 0 0 0 0 2 2 0 0 0 0 0 0\n0 0 0 0 0 0 0 2 2 0 0 2 0 0 2\n0 0 0 0 0 0 0 2 2 0 0 2 2 2 2\n0 0 0 0 0 0 0 0 0 0 0 2 2 2 2\n```\n\nOutput:\n```\n0 0 0 0 0 0 0 0 0 0 0 0 0 0 0\n0 0 0 0 0 0 0 0 0 0 0 0 0 0 0\n0 0 0 0 6 0 0 6 0 0 0 0 0 0 0\n0 0 0 0 6 6 6 6 0 0 6 6 0 0 0\n0 0 0 0 6 6 6 6 0 0 6 6 0 0 0\n0 0 0 0 6 6 6 6 0 0 6 6 0 0 0\n0 0 0 0 6 6 6 6 0 0 6 6 0 0 0\n4 0 0 0 0 0 0 0 0 0 6 6 0 0 0\n4 4 4 0 0 0 0 6 6 0 0 0 0 0 0\n0 0 0 0 0 0 0 6 6 0 0 6 0 0 6\n0 0 0 0 0 0 0 6 6 0 0 6 6 6 6\n0 0 0 0 0 0 0 0 0 0 0 6 6 6 6\n```\n\n## Example 3\nInput:\n```\n0 0 0 0 0 0 0 0 0 0 0 2 2 0 0 0\n0 0 0 0 0 2 0 0 0 0 0 2 2 0 0 0\n0 0 0 0 2 2 2 0 0 0 0 2 2 0 0 0\n2 2 0 2 2 2 2 2 0 0 0 2 2 0 0 0\n2 0 0 0 2 2 2 0 0 0 0 0 0 0 0 0\n2 2 0 0 0 2 0 0 0 0 0 0 0 0 0 0\n0 0 0 0 0 0 0 0 0 0 0 2 2 2 2 2\n0 0 0 0 0 0 0 0 0 0 0 0 2 2 2 0\n0 0 0 0 2 2 0 0 0 0 0 0 0 0 0 0\n0 0 0 0 2 2 2 0 0 0 2 2 2 0 0 0\n0 0 0 0 2 2 2 0 0 0 2 2 2 0 0 0\n0 0 0 0 2 2 0 0 0 0 2 0 2 0 0 0\n```\n\nOutput:\n```\n0 0 0 0 0 0 0 0 0 0 0 6 6 0 0 0\n0 0 0 0 0 6 0 0 0 0 0 6 6 0 0 0\n0 0 0 0 6 6 6 0 0 0 0 6 6 0 0 0\n4 4 0 6 6 6 6 6 0 0 0 6 6 0 0 0\n4 0 0 0 6 6 6 0 0 0 0 0 0 0 0 0\n4 4 0 0 0 6 0 0 0 0 0 0 0 0 0 0\n0 0 0 0 0 0 0 0 0 0 0 6 6 6 6 6\n0 0 0 0 0 0 0 0 0 0 0 0 6 6 6 0\n0 0 0 0 6 6 0 0 0 0 0 0 0 0 0 0\n0 0 0 0 6 6 6 0 0 0 6 6 6 0 0 0\n0 0 0 0 6 6 6 0 0 0 6 6 6 0 0 0\n0 0 0 0 6 6 0 0 0 0 6 0 6 0 0 0\n```\n\n# Test Problem:\n```\n0 0 2 2 0 2 2 0 0 0 0 0 0 0\n0 0 2 2 2 2 2 0 0 2 2 0 0 0\n0 0 0 0 0 0 0 0 0 2 2 0 0 0\n2 2 0 0 0 0 0 0 0 2 2 0 0 0\n2 2 0 0 0 0 0 0 0 0 0 0 0 0\n2 2 0 0 0 0 0 0 0 0 0 0 0 0\n2 2 0 0 0 0 0 0 0 0 2 0 2 0\n0 0 0 0 0 0 0 0 0 2 2 2 2 2\n0 0 0 0 0 0 2 2 0 0 0 0 0 0\n0 0 0 0 0 0 2 2 0 0 0 0 0 0\n0 2 2 0 0 0 2 2 0 0 0 0 0 0\n2 2 0 0 0 0 2 2 0 0 0 0 0 0\n2 2 0 0 0 0 2 2 0 0 2 2 2 0\n0 2 2 0 0 0 0 0 0 0 2 2 2 0\n```"},"answer":{"kind":"string","value":"```\n0 0 6 6 0 6 6 0 0 0 0 0 0 0\n0 0 6 6 6 6 6 0 0 4 4 0 0 0\n0 0 0 0 0 0 0 0 0 4 4 0 0 0\n6 6 0 0 0 0 0 0 0 4 4 0 0 0\n6 6 0 0 0 0 0 0 0 0 0 0 0 0\n6 6 0 0 0 0 0 0 0 0 0 0 0 0\n6 6 0 0 0 0 0 0 0 0 6 0 6 0\n0 0 0 0 0 0 0 0 0 6 6 6 6 6\n0 0 0 0 0 0 6 6 0 0 0 0 0 0\n0 0 0 0 0 0 6 6 0 0 0 0 0 0\n0 6 6 0 0 0 6 6 0 0 0 0 0 0\n6 6 0 0 0 0 6 6 0 0 0 0 0 0\n6 6 0 0 0 0 6 6 0 0 4 4 4 0\n0 6 6 0 0 0 0 0 0 0 4 4 4 0\n```"},"num_tokens":{"kind":"number","value":3030,"string":"3,030"}}},{"rowIdx":96,"cells":{"abstraction_prompt":{"kind":"string","value":"<|im_start|>user\n# ARC HINT GENERATOR\n\n## Role & Goal\nYou are an expert ARC (Abstraction and Reasoning Corpus) analyst. Your task is to generate a concise, actionable hint for a user who is struggling with an ARC problem. Analyze the problem and its correct solution to produce a single standalone, targeted hint that helps the user discover the core transformation principle for themselves without revealing the answer.\n\n---\n\n## Hint Generation Strategy\n1. **Compare** the input and output grids for each example. Identify the shared transformation pattern that allows the input grid to be converted into the output grid.\n2. **Identify the Core Principle**: Review the problem description and ground-truth solution to fully discern the key transformation rule. Break it down into its essential operations (e.g., object completion, pattern repetition, symmetry, gravity), paying close attention to properties such as object count, shapes, colors, sizes, symmetry, repetition, relative positioning, and broader grid-level patterns.\n3. **Craft a Targeted Hint**: Generate a hint that guides the user toward the core insight needed to solve the problem. The hint should assist the user during their attempt without revealing the solution.\n4. Structure each note using the template below:\n - **Description** (up to 3 sentences): Explain the concept, when and why it applies, and why it is effective. Include any relevant general formula or principle in its most general form.\n - **Example** (up to 6 sentences): Present a worked example covering all aspects of the description, using a simplified yet representative scenario (not necessarily from the current problem).\n - Optionally, include **Heuristics** or **Pitfalls** in the note where relevant.\n - Focus on methodologies and core principles over specific calculations or problem details.\n - Ensure each hint applies broadly—at least 80% of analogous problems.\n\nAfter generating a hint, verify that no specifics of the solution are revealed, and that the hint remains at the level of guiding the approach.\n\n### Design Guidelines\n- Clarity: Use precise language and correct sentence structure.\n- Atomicity: Each note addresses one recognizable sub-problem.\n- Self-containment: All information needed to understand the idea and its application is within the note.\n- Generalizability: Avoid problem-specific details or variables.\n- Transferability: Notes should apply across a class of problems.\n- Distinctness: Each note addresses a distinct principle.\n\n---\n\n## Guidelines\n- **Guide, Don't Solve**: Illuminate the approach, not the answer. Emphasize what to observe or consider.\n- **Specific yet Abstract**: Use concrete grid details (e.g., \"note the relationship between the blue and red pixels\") to ground abstract patterns (e.g., \"think about one color containing another\").\n\nValidate your generated hint: confirm it is self-contained, actionable, and nondirective. If any aspect is too revealing, revise before finalizing.\n\n---\n\n## Inputs\n### Problem Description\nA full ARC problem, including input/output pairs for training and testing.\n\n## Example 1\nInput:\n```\n0 0 0 0 0 0 0 0 0\n0 0 0 0 0 0 0 0 0\n0 0 0 0 0 0 0 0 0\n0 0 0 0 0 0 0 0 0\n0 0 0 0 0 0 0 0 0\n0 0 0 0 0 0 4 0 0\n0 0 0 0 0 4 4 4 0\n0 0 0 0 4 4 4 4 0\n0 0 0 0 0 0 0 4 0\n```\n\nOutput:\n```\n0 0 0 0 0 0 0 0 0\n0 0 0 0 0 0 0 0 0\n0 0 0 0 0 0 0 0 0\n0 0 0 0 0 0 0 0 0\n0 0 0 0 0 0 0 0 0\n0 0 0 0 0 0 0 2 0\n0 0 0 0 0 0 2 2 2\n0 0 0 0 0 2 2 2 2\n0 0 0 0 0 0 0 0 2\n```\n\n## Example 2\nInput:\n```\n0 0 0 0 0 0 0 0 0 0\n0 0 0 0 0 0 0 0 0 0\n0 0 0 0 0 4 0 0 0 0\n0 0 0 0 4 4 4 0 0 0\n0 0 0 0 0 0 4 0 0 0\n0 0 0 0 0 0 0 0 0 0\n0 0 0 0 0 0 0 0 0 0\n0 0 0 0 0 0 0 0 0 0\n0 0 0 0 0 0 0 0 0 0\n0 0 0 0 0 0 0 0 0 0\n```\n\nOutput:\n```\n0 0 0 0 0 0 0 0 0 0\n0 0 0 0 0 0 0 0 0 0\n0 0 0 0 0 0 0 0 0 0\n0 0 0 0 0 0 0 0 0 0\n0 0 0 0 0 0 0 0 0 0\n0 0 0 0 0 0 0 0 0 0\n0 0 0 0 0 0 0 0 0 0\n0 0 0 0 0 0 0 0 2 0\n0 0 0 0 0 0 0 2 2 2\n0 0 0 0 0 0 0 0 0 2\n```\n\n## Example 3\nInput:\n```\n0 0 0 0 0 0 0 0 0 0\n0 0 0 0 0 0 0 0 0 0\n0 0 0 0 0 0 4 0 0 0\n0 0 0 0 0 4 4 4 0 0\n0 0 0 0 4 4 4 4 0 0\n0 0 0 0 0 0 0 4 0 0\n0 0 0 0 0 0 0 0 0 0\n0 0 0 0 0 0 0 0 0 0\n0 0 0 0 0 0 0 0 0 0\n0 0 0 0 0 0 0 0 0 0\n```\n\nOutput:\n```\n0 0 0 0 0 0 0 0 0 0\n0 0 0 0 0 0 0 0 0 0\n0 0 0 0 0 0 0 0 0 0\n0 0 0 0 0 0 0 0 0 0\n0 0 0 0 0 0 0 0 0 0\n0 0 0 0 0 0 0 0 0 0\n0 0 0 0 0 0 0 0 2 0\n0 0 0 0 0 0 0 2 2 2\n0 0 0 0 0 0 2 2 2 2\n0 0 0 0 0 0 0 0 0 2\n```\n\n### Test Input\nHere is the input for the test problem.\n\n```\n0 0 0 0 0 0 0 0\n0 0 0 0 0 0 0 0\n0 0 0 0 0 0 0 0\n0 0 0 0 0 0 0 0\n0 0 0 0 0 0 0 0\n0 0 0 0 0 0 0 4\n0 0 0 0 0 0 4 4\n0 0 0 0 0 0 0 0\n```\n\n\n### Output Format\nOnly produce a **sequence of 5** notes in the structure:\n<note1>\n<description>...</description>\n<example>...</example>\n</note1>\n<note2>\n<description>...</description>\n<example>...</example>\n</note2>\n...\n\nDO NOT generate any other text\n\n---\n\n\n# Generated Hint<|im_end|>\n<|im_start|>assistant\n"},"abstraction_prompt_length":{"kind":"number","value":2011,"string":"2,011"},"generated_abstractions":{"kind":"list like","value":["<note1>\n<description>Look for a single, compact non-background cluster in each input and treat it as one object. Represent that object by its minimal bounding rectangle (top, left, height, width) so you can compare its size and shape across examples.</description>\n<example>Imagine a small cluster of colored pixels that fits entirely inside a 3×3 box; record its top-left coordinate and that 3×3 size. If the output shows a similar cluster but in a different place, the bounding-box comparison quickly reveals whether the shape was moved or transformed.</example>\n</note1>\n\n<note2>\n<description>Compare the object's internal pattern between input and output: check whether the arrangement of filled vs. empty cells inside the bounding box is identical. If the pattern is preserved, the operation is a rigid translation (no rotation, reflection, or scaling).</description>\n<example>For a 3×3 \"pyramid\" pattern, if the output also has a pyramid of the same relative filled cells inside its bounding box, then the object was not rotated or flipped — only shifted. That tells you to look for a translation rather than a more complex transform.</example>\n</note2>\n\n<note3>\n<description>Compute the translation by subtracting the input bounding-box top-left from the output bounding-box top-left for each example; if those deltas are the same across examples, that constant vector is the rule. Use the same vector to move the test object.</description>\n<example>If in two training pairs the top-left of the object moves from (r1,c1)→(r2,c2) and from (r3,c3)→(r4,c4), then the displacement (dr,dc) = (r2−r1, c2−c1) should equal (r4−r3, c4−c3). Once you know (dr,dc), apply it to the test object's bounding box to get its new top-left.</example>\n</note3>\n\n<note4>\n<description>Observe color behavior: the object’s color in the outputs is consistently different from the input color. The rule replaces the object's color with a single other color while keeping the shape and placement (after translation).</description>\n<example>If every training input shows the object in color A and every corresponding output shows it in color B, then when you place the translated object on the test grid you should use color B (not A). This is a color-mapping step separate from the spatial translation.</example>\n</note4>\n\n<note5>\n<description>When applying the rule to the test grid, translate the object's pixels by the measured vector, recolor them, and leave all other cells as background. Check that the translated shape fits inside the grid; if it would overflow, re-check the measured vector against the training examples.</description>\n<example>Take the test object's bounding box, add the displacement (dr,dc) to its top-left coordinate, copy the exact pattern of filled cells into that new location using the output color, and set every other cell to background. If the result matches the pattern seen in the training outputs (shape preserved, same color mapping), you have the correct transformation.</example>\n</note5>","<note1>\n<description>Isolate the target object by finding the unique non-background color and its connected component. Treat that connected set of pixels as the object to be transformed; everything else is background.</description>\n<example>Imagine a grid with a single cluster of blue pixels on a black background. Collect all blue pixels and their coordinates — that collection is the object you will move or recolor. Do not include stray background pixels or other colors in this set.</example>\n</note1>\n\n<note2>\n<description>Compute the object's bounding box (min/max row and column) and record the internal pattern relative to that box. This gives a compact representation of the shape that can be translated or mirrored without changing its form.</description>\n<example>For example, if the object occupies rows 2..4 and columns 3..5, its bounding box is 3×3. Record which cells inside that 3×3 box are filled; that relative pattern is what you will copy when you relocate the object.</example>\n</note2>\n\n<note3>\n<description>Look for a consistent translation (a constant shift) that moves the object's bounding box from input to output across examples. If the same (Δrow, Δcol) applies to every example, use that translation for the test case.</description>\n<example>Suppose in two examples the object's top-left corner moves from (2,3) to (3,4) and from (1,4) to (2,5); both show the same +1 row, +1 column shift. That consistent offset tells you where to place the object in the test grid.</example>\n</note3>\n\n<note4>\n<description>Check whether the object's color is changed in the outputs: often the object is recolored uniformly to a single new color while the background stays the same. Apply that same recoloring to every pixel of the object after translating it.</description>\n<example>If every input object is blue but every output shows the object in green, then after you move the object in the test, recolor all its pixels to green and leave other cells as background.</example>\n</note4>\n\n<note5>\n<description>After applying the translation and recoloring, validate the result: the object's internal pattern should be identical (same relative offsets) to the input, the background should be unchanged, and the placement should match the observed shift across examples. If there is a collision with another non-background pixel, re-check whether the examples avoid such collisions.</description>\n<example>Place the recorded pattern at the computed offset and confirm that every filled cell corresponds to the same relative position inside the bounding box. If the examples never overwrite other colors, assume the translated object will fit cleanly into background cells.</example>\n</note5>","<note1>\n<description>Look for the single non-background cluster and treat it as the object to transform. Most tasks like this have one compact connected shape; isolating that cluster simplifies the rest of the work.</description>\n<example>Imagine a grid with one small L-shaped cluster of colored pixels on a black background. First mark all orthogonally connected pixels of that color and ignore the rest of the grid. Working with that bounding box reduces noise and focuses attention on the shape to be moved or recolored.</example>\n</note1>\n\n<note2>\n<description>Convert the object into a set of relative offsets from a consistent anchor (commonly the top-left of its bounding box). Representing the shape as offsets makes it easy to move or rotate without losing its internal layout.</description>\n<example>Suppose the object's bounding box starts at (r0,c0) and has a pixel at (r0+1,c0+2). Record that as an offset (1,2). Do this for every pixel of the object so you have a list like {(0,0),(1,0),(1,1),(1,2)} describing the shape independently of its location.</example>\n</note2>\n\n<note3>\n<description>Try a 90° rotation of the offset set. For a clockwise rotation, swap each offset (dr,dc) to (dc, -dr); for counterclockwise, swap and negate appropriately (dr,dc) → (-dc, dr). Rotation preserves the shape but changes its orientation.</description>\n<example>Take a small L described by offsets {(0,0),(1,0),(1,1),(1,2)}. A clockwise rotation produces {(0,0),(0,1),(0,2),(1,2)} — the same pattern turned to the right. Apply the same swap-and-sign rule to every offset to get the rotated pattern.</example>\n</note3>\n\n<note4>\n<description>After rotating, translate the rotated offsets so the rotated shape sits against the grid's bottom-right corner (i.e., align its bottom and right edges with the grid). Compute the new anchor by subtracting the rotated shape's min offset from the grid's last row and last column.</description>\n<example>If the rotated offsets have a minimum row rmin and column cmin, place the rotated shape with top-left at (grid_height - 1 - rmin, grid_width - 1 - cmin). This moves the rotated object to the lower-right quadrant without changing its internal offsets.</example>\n</note4>\n\n<note5>\n<description>Finally, recolor the moved/rotated object with a single uniform color and leave all other cells as background. Do not alter any other colored pixels; the transformation is a relocation, rotation, and recolor of the identified object.</description>\n<example>After placing the rotated offsets at the chosen anchor, set every cell in that set to one new color (different from the background and the original object color). Verify that only that set of cells changed and that the background remains unchanged.</example>\n</note5>","<note1>\n<description>Find the single non-background cluster and treat it as the object to transform. This is usually the only color that differs from the background and appears in a compact shape.</description>\n<example>Imagine a mostly-zero grid with one cluster of blue pixels forming a small triangle; first mark every blue pixel and ignore zeros. That set of pixels is the object you will operate on in every example.</example>\n</note1>\n\n<note2>\n<description>Compute the object's bounding box (min/max row and column) and record its relative pixel offsets from the box's top-left corner. Working with offsets lets you move the whole shape without recalculating each pixel individually.</description>\n<example>If the object spans rows 2–4 and columns 5–7, the bounding box is those rows/cols; a pixel at (3,6) has offset (1,1) from the box's top-left. Keep that offset for every pixel of the object.</example>\n</note2>\n\n<note3>\n<description>Translate the object by a fixed, uniform vector so its bounding box is moved to a canonical location in the grid (for example, flush against the bottom-right). Apply the same translation to every pixel so the shape and orientation remain identical.</description>\n<example>Suppose you decide to move the bounding box so its bottom-right corner sits at the grid's bottom-right; for an H×W grid and a box of height h and width w, the new top-left is (H−h, W−w). Add that (H−h, W−w) to every pixel's coordinates to get the new positions.</example>\n</note3>\n\n<note4>\n<description>When you place the object at its new location, recolor it uniformly to a single distinct color (different from the background and the original object color) and erase the original pixels. The output should show only the relocated, recolored shape.</description>\n<example>If the object was blue in the input, replace every blue pixel with a single new color (e.g., green) at the translated coordinates and set the original blue cells back to background. The result is one clean copy of the shape in its new place and color.</example>\n</note4>\n\n<note5>\n<description>Verify the transformation by checking invariants: the number of object pixels, their relative arrangement (no rotation/reflection), and that they fit entirely inside the grid after translation. If any example violates these, adjust the translation or recoloring rule accordingly.</description>\n<example>Count the object's pixels before and after and compare the offsets of the pixels; they should match after translation. Also confirm the translated pixels do not go outside the grid bounds—if they do, try a different canonical placement that keeps the whole shape inside.</example>\n</note5>","<note1>\n<description>Find the single colored object to track: ignore the uniform background and locate the contiguous cluster of non-background pixels. This cluster is the element that the examples consistently move or recolor.</description>\n<example>Imagine a 7×7 grid with a small L-shaped cluster of color A in the upper-left and all other cells background. Mark that cluster as the object to follow; treat every other color or isolated pixel as irrelevant for the transformation.</example>\n</note1>\n\n<note2>\n<description>Summarize the object by its bounding box: record the smallest and largest row and column indices that contain the object. The bounding box gives a compact representation of position and size to compare between input and output.</description>\n<example>For example, if the object occupies rows 1–3 and columns 2–4, its bounding box is rows [1,3] × cols [2,4]. Use these four numbers (minRow, maxRow, minCol, maxCol) to describe where the object sits.</example>\n</note2>\n\n<note3>\n<description>Compare input and output bounding boxes to infer a translation: compute the difference in minRow and minCol between the two boxes. If that difference is the same across all training pairs, it is the translation vector to apply to the test object.</description>\n<example>Suppose one example's input box is at rows [1,3], cols [2,4] and the corresponding output box is at rows [4,6], cols [5,7]. The row difference is +3 and the column difference is +3, so the object was shifted by (+3 rows, +3 cols) in that example; check other examples for the same vector.</example>\n</note3>\n\n<note4>\n<description>Apply the translation to the test object and redraw it with the output color: move every pixel of the object by the translation vector and recolor those pixels with the new color seen in the outputs. Do not rotate or reflect the shape—only translate and recolor.</description>\n<example>If the test object is a small triangle occupying rows [0,2], cols [1,3] and the inferred translation is (+3 rows, +3 cols), place the triangle at rows [3,5], cols [4,6] and fill those cells with the output color; leave all other cells unchanged.</example>\n</note4>\n\n<note5>\n<description>Watch for edge cases and validate: ensure the translated object stays inside the grid and that the background remains untouched. If multiple colored clusters exist, prefer the cluster that matches the training examples' size/shape or use the unique cluster that appears in every input.</description>\n<example>If the object is close to the bottom edge and the translation would push it outside, re-check the examples to confirm whether the translation was applied or whether the object was instead clipped or ignored. Also verify that the same color-to-color mapping (input color → output color) is used consistently across examples.</example>\n</note5>","<note1>\n<description>Find the single object to act on: there is one non-background color that forms a compact cluster; treat that whole cluster as the thing to move. Isolating it reduces the problem to transforming one shape rather than many pixels.</description>\n<example>Imagine a grid with a small L-shaped cluster of colored pixels and the rest background. Mark every cell of that color — those are the pixels you will copy and reposition. You do not need to consider other background cells when planning the transformation.</example>\n</note1>\n\n<note2>\n<description>Record the object's shape as a relative pattern: list the offsets of its filled pixels relative to a chosen anchor (for example, the top-left of its bounding box). This representation preserves the exact arrangement independent of absolute coordinates.</description>\n<example>For a 3×3 cluster, write down which offsets inside the 3×3 box are filled (e.g., offsets (0,1),(1,0),(1,1),(1,2),(2,0),(2,1),(2,2)). That set of offsets is what you will paste elsewhere, unchanged in shape.</example>\n</note2>\n\n<note3>\n<description>Look for a consistent translation across examples: the same shape appears in the output shifted by a fixed vector (same direction and magnitude) relative to its input location. Determine that vector from the training pairs and apply it to the test shape.</description>\n<example>If in every example the shape's top-left moves down by two rows and right by one column, then when you place the shape in the test input you should also move it down two rows and right one column. Use the examples to infer that fixed offset rather than guessing a different one.</example>\n</note3>\n\n<note4>\n<description>Check color behavior: the object's pixels are recolored uniformly in the outputs. When you paste the shape at the new position, replace its original color with the single output color observed in the examples.</description>\n<example>If the input object is color A and every output shows that object in color B, then when you paste the pattern at the translated location paint those pixels with color B. Do not mix colors or leave original-color pixels behind.</example>\n</note4>\n\n<note5>\n<description>Handle edges and overlaps carefully: place the translated shape exactly (no rotation or reflection), but if part of it would fall outside the grid, clip those pixels. If the pasted shape overlaps other non-background pixels in an example, follow the example's overwrite rule.</description>\n<example>If shifting the shape would push a pixel past the bottom or right border, drop that pixel (clip it) rather than wrapping or mirroring. If the examples show the moved shape replacing existing pixels, do the same when the pasted pixels land on non-background cells.</example>\n</note5>","<note1>\n<description>Isolate the object by finding the unique non-background color and computing its minimal bounding rectangle. Working with that box reduces the problem to a small subgrid you can compare across examples.</description>\n<example>Imagine a grid with a single cluster of color A on a black background. Draw the smallest rectangle that contains all A pixels; that rectangle is the object you will analyze. All further steps operate on that rectangle rather than the whole grid.</example>\n</note1>\n\n<note2>\n<description>Look for a uniform translation: check whether every pixel of the object in the output is simply shifted by the same row and column offset relative to the input. This is a rigid translation — the pattern inside the box is unchanged, only its position changes.</description>\n<example>Take a small L-shaped pattern. If in the output you see the same L shape but all its pixels are one row lower and one column to the right, that indicates a translation by (+1 row, +1 column). Verify the same offset for every pixel of the object.</example>\n</note2>\n\n<note3>\n<description>Check for a consistent color mapping: the object's color in the input may be replaced by a single different color in the output. Treat this as a separate step from spatial movement.</description>\n<example>If every pixel of color A in the input becomes color B in the output, that is a uniform recolor. You can record the mapping A→B and apply it after you move the object.</example>\n</note3>\n\n<note4>\n<description>Decide what happens to pixels that would move outside the grid: translations that push pixels beyond the border are usually clipped (those pixels are not wrapped or reflected). That explains why some examples show fewer visible pixels than the input.</description>\n<example>If you translate a shape downward by one and one of its pixels lies on the bottom row, that pixel will no longer appear after the move. When you apply the translation, drop any pixels whose new coordinates are outside the grid bounds.</example>\n</note4>\n\n<note5>\n<description>Combine the observations into a single procedure: extract the object, translate it by the same offset you observed, recolor it uniformly, and clip any parts that fall off the grid. Apply that same sequence to the test input to produce the output.</description>\n<example>For a new input, find the object's bounding box, shift every pixel by the deduced offset, change its color according to the mapping you found, and remove any pixels that would land outside the grid. The resulting grid should match the pattern seen in the training outputs.</example>\n</note5>","<note1>\n<description>Find the single non-background object and isolate it by computing its minimal bounding rectangle. Working with the bounding box turns a scattered set of pixels into a small, comparable pattern you can reason about.</description>\n<example>Imagine a 5×5 grid where a small L-shaped cluster of color A sits in the top-left. Draw the smallest rectangle that contains all A pixels; now you have a compact 3×2 pattern to compare instead of scanning the whole grid. This makes it easier to spot how the shape is transformed.</example>\n</note1>\n\n<note2>\n<description>Compare the internal arrangement of pixels inside the bounding box between input and output. If the pattern of filled vs empty cells is identical, the transformation is a rigid motion (rotation/flip/translation) rather than a resize or fill operation.</description>\n<example>Take a 3×3 \"staircase\" pattern: if the output shows the same staircase arrangement but in a different orientation, that indicates a rotation or reflection. Noticing identical relative offsets confirms you should look for a rigid transform.</example>\n</note2>\n\n<note3>\n<description>Look for a consistent color mapping: the object's original color is often replaced by a single new color in the output while background stays the same. Treat color change as a separate step from spatial rearrangement.</description>\n<example>If every pixel of color A in the input becomes color B in the output and no other colors are altered, then the rule includes \"recolor A → B.\" This simplifies the task: first decide how the shape is moved, then recolor.</example>\n</note3>\n\n<note4>\n<description>Use an anchor point (e.g., the bounding-box top-left or a uniquely placed pixel) to determine the translation vector between input and output. If that vector is the same across examples, you can apply it to the test input.</description>\n<example>Suppose the bounding box top-left in each training input is at (r1,c1) and the corresponding top-left in the outputs is at (r2,c2); the difference (r2−r1, c2−c1) is the consistent translation. Compute that offset for the test case by applying the same vector to the test bounding-box anchor.</example>\n</note4>\n\n<note5>\n<description>Decide whether the transform is a rotation, reflection, or simple translation by checking orientation and whether the pattern is flipped. If orientation is preserved but the shape is shifted, prefer translation; if orientation is reversed, prefer rotation/reflection.</description>\n<example>If a left-leaning staircase in the input appears as a right-leaning staircase in the output, a reflection/rotation is likely. If it remains left-leaning but appears elsewhere, a pure translation is the simpler explanation. Use this distinction to choose the correct rigid motion before recoloring.</example>\n</note5>","<note1>\n<description>Focus on the single non-background object: locate the unique color that forms a contiguous shape and treat all its pixels as one object. This isolates the part of the grid that is being transformed and avoids confusion from background noise.</description>\n<example>Imagine a grid of zeros with one small cluster of color A; collect every cell equal to A and ignore all zeros. Those collected cells define the object you will analyze and transform.</example>\n</note1>\n\n<note2>\n<description>Compute the object's bounding box and the center of that box. The bounding box (min/max row and column) gives a stable reference for position and orientation; the center can be an integer cell (odd dimension) or a half-cell (even dimension).</description>\n<example>For a cluster occupying rows 2–4 and columns 3–5, the bounding box center is at (3,4). For an even-sized box (rows 2–5) the center lies between rows 3 and 4 (a half-cell). Use these coordinates as the object's reference point.</example>\n</note2>\n\n<note3>\n<description>Check the object's internal geometry and orientation: in these tasks the object is a small symmetric \"pyramid\" (rows have odd counts 1,3,5,3,1). That pattern indicates a vertical axis of symmetry and a clear top and bottom row.</description>\n<example>Visualize a shape with rows of 1,3,5,3,1 pixels: the widest row is the middle and the rows above and below mirror each other. Noticing this tells you the object has a central row and a predictable top/bottom.</example>\n</note3>\n\n<note4>\n<description>Translate the whole object by a single, consistent vector: move every object pixel by the same offset (same sign and magnitude for rows and columns) so the object's internal geometry is preserved but its position changes. In these examples the translation is the same for every training pair.</description>\n<example>Take the bounding-box center and shift it by one cell down and one cell right; add that offset to every pixel coordinate of the object. The shape stays identical, only its location changes, and its center moves accordingly.</example>\n</note4>\n\n<note5>\n<description>After translation, recolor the moved object with a single new color and leave all other cells as background. Ensure the recolored object fits inside the grid and that you do not alter any other colored pixels.</description>\n<example>Once the shape is translated, change every pixel of the object from the original color to the new color while keeping zeros elsewhere. If the translated shape would run off the grid, re-check the offset — in the examples the chosen offset keeps the object fully inside the grid.</example>\n</note5>","<note1>\n<description>Look for the single non-background connected component and treat it as the \"object\" to follow. If there is exactly one colored cluster in the input, that cluster is the element being transformed in every example.</description>\n<example>Imagine a grid with a small L-shaped cluster of blue pixels surrounded by black. That L is the object: ignore other zeros and focus on the cluster's pixels, their shape, and how many pixels belong to it.</example>\n</note1>\n\n<note2>\n<description>Compare the object's pixel coordinates between input and output to detect a uniform translation. If every pixel of the object moves by the same (Δrow, Δcol), the rule is a pure translation (no rotation, reflection, or resizing).</description>\n<example>Take an L-shape at positions (1,1),(2,1),(2,2). In the output the same L appears at (4,3),(5,3),(5,4). Because every pixel was shifted by the same vector (Δrow=+3, Δcol=+2), you can conclude the transformation is a translation by that vector.</example>\n</note2>\n\n<note3>\n<description>Check whether the object's color is changed consistently. Often the object is moved but also recolored to a single different non-background color in the output.</description>\n<example>If the input object is blue and the output object is green (every blue pixel becomes green), record the color mapping blue→green. That mapping should be applied after you translate the object.</example>\n</note3>\n\n<note4>\n<description>Verify that the object's internal pattern and pixel count are preserved. A translation keeps the same arrangement of pixels; if counts and relative positions match after moving, you should not rotate, flip, or resize the object.</description>\n<example>If the object has 5 pixels arranged as a T-shape, the output should also contain exactly 5 pixels in the same T arrangement (just at different coordinates). If counts differ, a different operation (e.g., fill or cropping) is involved.</example>\n</note4>\n\n<note5>\n<description>Compute the translation by comparing bounding boxes or a reference pixel (e.g., top-left corner) between input and output examples, then apply that same vector and color mapping to the test input. Before finalizing, ensure the translated object fits entirely inside the grid.</description>\n<example>Find the bounding box top-left of the object in an input and its corresponding top-left in the output; subtract coordinates to get (Δrow,Δcol). Use that vector to shift every pixel of the test object, recolor them according to the learned mapping, and confirm no pixel would fall outside the grid.</example>\n</note5>","<note1>\n<description>First isolate the single non-background object: compute its bounding box and record the relative coordinates of every colored pixel inside that box. Working with relative coordinates (offsets from the box’s top-left) makes the pattern independent of absolute position and easier to compare across examples.</description>\n<example>Imagine a small triangular cluster of colored pixels. Find the minimum and maximum row and column that contain the color to get the bounding box, then list each pixel as an offset like (0,0), (1,0), (1,1), (2,1), … — that list is the object you will move and recolor.</example>\n</note1>\n\n<note2>\n<description>Compare the bounding-box coordinates between input and output examples to detect a consistent translation vector (Δrow, Δcol). If every training pair uses the same (Δrow, Δcol), apply that vector to the test object's bounding box to get its new absolute position.</description>\n<example>For example, if each input box’s top-left corner ends up 2 rows lower and 1 column to the right in the outputs, the translation vector is (2,1). Apply that same (2,1) shift to the test object’s top-left to find where to place it.</example>\n</note2>\n\n<note3>\n<description>Check whether the object’s shape is preserved exactly (no rotation or reflection) by comparing relative offsets. If the offsets match, you should copy the exact pattern of pixels when you move it — only translate and recolor.</description>\n<example>Take the offset list from note 1 and, after applying the translation vector, place pixels at the new absolute coordinates. If the output examples show identical pixel arrangements after the move, you’ve preserved shape correctly.</example>\n</note3>\n\n<note4>\n<description>Observe the color mapping: the object’s color in the input is replaced by a single new color in the output. Determine which input color becomes which output color from the examples and apply that same mapping to the moved pixels.</description>\n<example>If every training input uses color A for the object and every output shows that object in color B, then when you copy the object to the test output you should use color B for all its pixels (leave background pixels unchanged).</example>\n</note4>\n\n<note5>\n<description>Account for grid boundaries: if the translated bounding box would extend beyond the grid, only draw the portion that fits. Do not wrap or mirror pixels — simply clip the pattern to the grid area.</description>\n<example>If shifting a 3×3 pattern down by 2 rows would place some rows outside the grid, draw only the rows that fall inside the grid; the remaining rows are discarded. This explains why some examples show only a partial object after the move.</example>\n</note5>","<note1>\n<description>Isolate the object by finding the non-background color that forms the pattern. Represent the object by its pixels and a simple bounding box so you can reason about its shape and position without background noise. This makes comparisons between input and output straightforward.</description>\n<example>Imagine a black grid with a small cluster of blue pixels. Record the coordinates of every blue pixel and the rectangle that encloses them; that rectangle and the pixel list capture the object's size and shape for later comparisons.</example>\n</note1>\n\n<note2>\n<description>Check for a uniform recoloring: every pixel of the object's original color in the input becomes a single new color in the output. If that is true, treat color change as a separate step from any spatial transformation. Recognizing this avoids confusing color substitution with movement.</description>\n<example>For example, if every blue pixel in the input appears as red in the output (and no other colors change), then you can first map blue→red and then focus on how the red pixels are placed.</example>\n</note2>\n\n<note3>\n<description>Compare the object's shape and orientation between input and output. If the pattern of filled pixels is identical, the rule is likely a translation (no rotation/reflection) rather than a geometric transform. Verifying shape equality narrows the possible operations to simple shifts.</description>\n<example>If the input object is an L-shape and the output also shows an L-shape with the same relative pixel arrangement, you can assume the transformation did not rotate or mirror the object — only moved it.</example>\n</note3>\n\n<note4>\n<description>Compute the translation vector by matching a distinctive anchor point (e.g., the topmost-leftmost pixel) between input and output. Use that vector to map every input pixel to its output position, then apply the recoloring. This gives a deterministic way to place the object in the test grid.</description>\n<example>Suppose the anchor pixel is at (r,c) in the input and at (r',c') in the output; the translation is (Δr,Δc)=(r'−r,c'−c). Apply (Δr,Δc) to every pixel of the object to get its new coordinates, then recolor them.</example>\n</note4>\n\n<note5>\n<description>Check edge cases and validate the rule across examples: ensure the object fits after translation, confirm background remains unchanged, and verify the same anchor and vector work for every training pair. If all examples are consistent, apply the same steps to the test input.</description>\n<example>If every training pair uses the same anchor-based vector and the object always fits into the grid after applying it, then use that vector on the test object; if a training example would overflow the grid, reconsider whether clipping or a different anchor is intended.</example>\n</note5>","<note1>\n<description>Find the single non-background object and treat it as the unit of transformation. When the grid contains only one colored cluster, the task usually operates on that cluster as a whole rather than on individual pixels.</description>\n<example>Imagine a grid with a single L-shaped cluster of blue pixels and all other cells black. Instead of changing isolated pixels, the transformation will move or recolor the entire L-shape. First isolate that cluster so you know exactly which pixels to follow.</example>\n</note1>\n\n<note2>\n<description>Check whether the object's internal arrangement (relative offsets between its pixels) is preserved. If the pattern of occupied cells is identical before and after, the operation is a rigid translation (no rotation, reflection, or scaling).</description>\n<example>For example, if the object is a 3×3 block with a missing corner, and the output shows the same 3×3 arrangement (same missing corner) but elsewhere, then the block was translated. Use the relative offsets between pixels to confirm shape preservation.</example>\n</note2>\n\n<note3>\n<description>Determine the translation by comparing coordinates: pick a reference pixel (e.g., the topmost or leftmost) and subtract its input coordinates from its output coordinates. That difference is the translation vector; apply it to all object pixels to get their new positions.</description>\n<example>Suppose the topmost pixel of the object is at (r,c) in the input and at (r',c') in the output. The vector is (r'−r, c'−c). Move every pixel of the object by that same vector to place the object at the new location.</example>\n</note3>\n\n<note4>\n<description>Check for a uniform recoloring: the object's pixels are often changed to a single new color while the background remains unchanged. This is a separate step from translation and should be applied after placing the object.</description>\n<example>If the object is blue in the input and the output shows the same shape but in red, then after translating the shape you should recolor all its pixels to the new color (keeping the background black). Ensure the recoloring is consistent across the whole object.</example>\n</note4>\n\n<note5>\n<description>Use invariants and sanity checks to validate your result: the number of object pixels, the shape (relative offsets), and the background should match expectations. If any invariant fails, re-evaluate whether you chose the correct reference pixel or the correct translation vector.</description>\n<example>After applying your translation and recoloring, count the colored pixels and compare to the original object's count; also check that the pattern of occupied cells matches the original shape (only shifted). If counts or relative positions differ, adjust the translation or recoloring step.</example>\n</note5>","<note1>\n<description>Locate the single non-background object and summarize it by its bounding box and a simple anchor point (for example the top-left corner or the center). This gives a compact representation you can compare across input and output grids. Use that anchor to reason about where the object moved instead of tracking every pixel.</description>\n<example>Imagine a small L-shaped object made of one color. Compute its min/max row and column to get a bounding box, and take the top-left cell of that box as the anchor. If the anchor moves consistently between examples, you only need to follow that one coordinate to understand the transformation.</example>\n</note1>\n\n<note2>\n<description>Compare the anchor coordinates between each input and its output to detect a constant displacement vector (Δrow, Δcol). If the same vector appears in every example, the rule is a rigid translation of the object by that vector. This is faster and less error-prone than matching many pixels.</description>\n<example>Suppose the anchor is at (r,c) in an input and at (r',c') in the corresponding output. Compute (Δrow,Δcol) = (r'−r, c'−c). Repeat for all training pairs; if you get the same (Δrow,Δcol) each time, you have the translation to apply.</example>\n</note2>\n\n<note3>\n<description>Check whether the object’s internal pattern and orientation are preserved after the move. If the relative arrangement of pixels inside the bounding box is identical, the operation is a pure translation (no rotation or reflection). This tells you to copy the exact pixel pattern, not to rotate or flip it.</description>\n<example>Take a small 3×3 motif inside the bounding box. If after moving the motif the same relative offsets of colored pixels appear in the new location, then the transformation is a copy+translate. If offsets change, you would need to consider rotation or reflection instead.</example>\n</note3>\n\n<note4>\n<description>Observe color behavior: often the moved object is recolored uniformly in the output (the same replacement color across examples). Record that mapping and apply it when you place the translated pattern. Treat color change and spatial move as two separate steps: move first, then recolor.</description>\n<example>If every training output shows the moved object in a single different color than the input, note that mapping (e.g., input color A → output color B). When you copy the object to its new position, fill it with the mapped color so the output matches the examples’ appearance.</example>\n</note4>\n\n<note5>\n<description>Decide how to handle edges and background: check whether outputs ever clip or wrap the object when a translation would push it outside the grid. Use the training examples to infer the rule (usually clipping is applied and the rest of the grid remains background). This ensures you place the object correctly without altering other pixels.</description>\n<example>If a training input had the object near the border and the output shows only the visible portion of the object, that indicates clipping — drop any pixels that would fall outside the grid. If no clipping occurs in examples, assume the grid is large enough and the object is translated without wrapping.</example>\n</note5>","<note1>\n<description>Isolate the single non-background object by finding all cells of the same non-zero color and computing their minimal bounding rectangle. The bounding box gives you the object's size and orientation without needing to reason about individual pixels. This reduces the problem to a small, self-contained pattern.</description>\n<example>Imagine a grid with a small cluster of colored pixels; draw the smallest rectangle that contains them. That rectangle tells you the object's height and width and where its top-left corner sits in the grid. Use that rectangle as the unit you will move or copy.</example>\n</note1>\n\n<note2>\n<description>Look at the object's internal pattern row-by-row: the number of contiguous colored cells in each row is a simple signature (a triangular or staircase profile). That signature is preserved under translations and is a quick way to confirm you have the same object in different places. Use it to match candidate placements.</description>\n<example>For example, an object whose rows have lengths 1, 3, 5, 1 (top to bottom) is unmistakable: any translated copy will show the same sequence of contiguous counts. If you see that sequence in the output, you know the same shape was moved rather than redrawn.</example>\n</note2>\n\n<note3>\n<description>Check whether the object's orientation changes: compare left/right positions of the rows to see if columns have been swapped. If the leftmost row in the input appears as the top row in the output (and the top row becomes the rightmost), that indicates a 90° rotation rather than a simple shift. Rotation swaps width and height.</description>\n<example>Take a small staircase: if the input's first row is one cell on the left and the output's first row is one cell on the right, the shape has been rotated. The same check on the second and third rows confirms the rotation direction.</example>\n</note3>\n\n<note4>\n<description>Decide how the rotated object is placed: it will be translated so its bounding box sits flush against the grid's bottom and right edges (i.e., bottom-right corner). Compute the translation by subtracting the rotated box's top-left coordinates from the grid's bottom-right coordinates. This keeps the object fully inside the grid and aligned with the edges.</description>\n<example>If the rotated bounding box has top-left at (r0,c0) and the grid has height H and width W, place the box with top-left at (H-1-r0, W-1-c0). That moves the box so its bottom and right edges coincide with the grid's bottom and right edges.</example>\n</note4>\n\n<note5>\n<description>Finally, apply a uniform recoloring to the moved object and leave the background untouched. The examples show the object is not only relocated and possibly rotated but also painted with a single new color distinct from the background. Treat recoloring as the last step after placement.</description>\n<example>After you rotate and translate the bounding box, replace every pixel inside it with the output color while keeping all other cells as background. The result is the same shape, in the same orientation relative to the box, but in the new color and at the bottom-right location.</example>\n</note5>","<note1>\n<description>Isolate the object by finding the single non-background color and computing its minimal bounding box (min/max row and column). This box captures the object's shape and size so you can reason about how it moves or is transformed. Working with the bounding box reduces the problem to a simple geometric operation.</description>\n<example>Imagine a small L-shaped cluster of non-background pixels. Compute the smallest rectangle that contains every colored pixel (top, bottom, left, right). That rectangle tells you the object's height and width and gives you a stable reference to compare with the output.</example>\n</note1>\n\n<note2>\n<description>Look for a rigid translation: check whether every pixel of the object keeps the same relative offsets to the bounding-box corners in the output. If offsets are unchanged, the object was moved as a whole rather than rotated, flipped, or scaled. This distinguishes translation from other transformations.</description>\n<example>Take a 3×3 filled square and a 3×3 L-shape; if in the output each colored pixel is at the same row/column offset from the square's top-left corner as in the input, then the object was translated unchanged. If offsets differ, consider rotation or reflection instead.</example>\n</note2>\n\n<note3>\n<description>Check color mapping: determine whether the object's pixels in the input are uniformly replaced by a single different color in the output while the background remains unchanged. A consistent one-to-one color change indicates a recoloring step applied to the whole object. Confirm that no other colors are introduced or removed.</description>\n<example>If every pixel of the object that was color A in the input becomes color B in the output and all background pixels stay the same, that is a uniform recolor. Verify this holds for every pixel of the object before proceeding.</example>\n</note3>\n\n<note4>\n<description>Look for a fixed displacement vector (dx,dy) that maps input bounding-box corners to output bounding-box corners. Compute the vector from the input top-left (or center) to the output top-left (or center) and apply it to every pixel of the object. The same vector should explain all example pairs.</description>\n<example>If the input bounding-box top-left is at (r,c) and the output bounding-box top-left is at (r+dy,c+dx) in the examples, then dx and dy are the translation. Apply (dx,dy) to every pixel of the object in the test input to get its new coordinates.</example>\n</note4>\n\n<note5>\n<description>Apply the translation and recolor to the test object, then validate by checking invariants: the object's shape and orientation must be preserved, the count of colored pixels should match the input, and the background should remain unchanged. If any invariant fails, re-check the bounding box and the displacement vector.</description>\n<example>After moving and recoloring the object, count the colored pixels — it should equal the original count and the pattern should match the original shape. Also confirm no other pixels were altered and that the translated object fits entirely inside the grid.</example>\n</note5>"],"string":"[\n \"<note1>\\n<description>Look for a single, compact non-background cluster in each input and treat it as one object. Represent that object by its minimal bounding rectangle (top, left, height, width) so you can compare its size and shape across examples.</description>\\n<example>Imagine a small cluster of colored pixels that fits entirely inside a 3×3 box; record its top-left coordinate and that 3×3 size. If the output shows a similar cluster but in a different place, the bounding-box comparison quickly reveals whether the shape was moved or transformed.</example>\\n</note1>\\n\\n<note2>\\n<description>Compare the object's internal pattern between input and output: check whether the arrangement of filled vs. empty cells inside the bounding box is identical. If the pattern is preserved, the operation is a rigid translation (no rotation, reflection, or scaling).</description>\\n<example>For a 3×3 \\\"pyramid\\\" pattern, if the output also has a pyramid of the same relative filled cells inside its bounding box, then the object was not rotated or flipped — only shifted. That tells you to look for a translation rather than a more complex transform.</example>\\n</note2>\\n\\n<note3>\\n<description>Compute the translation by subtracting the input bounding-box top-left from the output bounding-box top-left for each example; if those deltas are the same across examples, that constant vector is the rule. Use the same vector to move the test object.</description>\\n<example>If in two training pairs the top-left of the object moves from (r1,c1)→(r2,c2) and from (r3,c3)→(r4,c4), then the displacement (dr,dc) = (r2−r1, c2−c1) should equal (r4−r3, c4−c3). Once you know (dr,dc), apply it to the test object's bounding box to get its new top-left.</example>\\n</note3>\\n\\n<note4>\\n<description>Observe color behavior: the object’s color in the outputs is consistently different from the input color. The rule replaces the object's color with a single other color while keeping the shape and placement (after translation).</description>\\n<example>If every training input shows the object in color A and every corresponding output shows it in color B, then when you place the translated object on the test grid you should use color B (not A). This is a color-mapping step separate from the spatial translation.</example>\\n</note4>\\n\\n<note5>\\n<description>When applying the rule to the test grid, translate the object's pixels by the measured vector, recolor them, and leave all other cells as background. Check that the translated shape fits inside the grid; if it would overflow, re-check the measured vector against the training examples.</description>\\n<example>Take the test object's bounding box, add the displacement (dr,dc) to its top-left coordinate, copy the exact pattern of filled cells into that new location using the output color, and set every other cell to background. If the result matches the pattern seen in the training outputs (shape preserved, same color mapping), you have the correct transformation.</example>\\n</note5>\",\n \"<note1>\\n<description>Isolate the target object by finding the unique non-background color and its connected component. Treat that connected set of pixels as the object to be transformed; everything else is background.</description>\\n<example>Imagine a grid with a single cluster of blue pixels on a black background. Collect all blue pixels and their coordinates — that collection is the object you will move or recolor. Do not include stray background pixels or other colors in this set.</example>\\n</note1>\\n\\n<note2>\\n<description>Compute the object's bounding box (min/max row and column) and record the internal pattern relative to that box. This gives a compact representation of the shape that can be translated or mirrored without changing its form.</description>\\n<example>For example, if the object occupies rows 2..4 and columns 3..5, its bounding box is 3×3. Record which cells inside that 3×3 box are filled; that relative pattern is what you will copy when you relocate the object.</example>\\n</note2>\\n\\n<note3>\\n<description>Look for a consistent translation (a constant shift) that moves the object's bounding box from input to output across examples. If the same (Δrow, Δcol) applies to every example, use that translation for the test case.</description>\\n<example>Suppose in two examples the object's top-left corner moves from (2,3) to (3,4) and from (1,4) to (2,5); both show the same +1 row, +1 column shift. That consistent offset tells you where to place the object in the test grid.</example>\\n</note3>\\n\\n<note4>\\n<description>Check whether the object's color is changed in the outputs: often the object is recolored uniformly to a single new color while the background stays the same. Apply that same recoloring to every pixel of the object after translating it.</description>\\n<example>If every input object is blue but every output shows the object in green, then after you move the object in the test, recolor all its pixels to green and leave other cells as background.</example>\\n</note4>\\n\\n<note5>\\n<description>After applying the translation and recoloring, validate the result: the object's internal pattern should be identical (same relative offsets) to the input, the background should be unchanged, and the placement should match the observed shift across examples. If there is a collision with another non-background pixel, re-check whether the examples avoid such collisions.</description>\\n<example>Place the recorded pattern at the computed offset and confirm that every filled cell corresponds to the same relative position inside the bounding box. If the examples never overwrite other colors, assume the translated object will fit cleanly into background cells.</example>\\n</note5>\",\n \"<note1>\\n<description>Look for the single non-background cluster and treat it as the object to transform. Most tasks like this have one compact connected shape; isolating that cluster simplifies the rest of the work.</description>\\n<example>Imagine a grid with one small L-shaped cluster of colored pixels on a black background. First mark all orthogonally connected pixels of that color and ignore the rest of the grid. Working with that bounding box reduces noise and focuses attention on the shape to be moved or recolored.</example>\\n</note1>\\n\\n<note2>\\n<description>Convert the object into a set of relative offsets from a consistent anchor (commonly the top-left of its bounding box). Representing the shape as offsets makes it easy to move or rotate without losing its internal layout.</description>\\n<example>Suppose the object's bounding box starts at (r0,c0) and has a pixel at (r0+1,c0+2). Record that as an offset (1,2). Do this for every pixel of the object so you have a list like {(0,0),(1,0),(1,1),(1,2)} describing the shape independently of its location.</example>\\n</note2>\\n\\n<note3>\\n<description>Try a 90° rotation of the offset set. For a clockwise rotation, swap each offset (dr,dc) to (dc, -dr); for counterclockwise, swap and negate appropriately (dr,dc) → (-dc, dr). Rotation preserves the shape but changes its orientation.</description>\\n<example>Take a small L described by offsets {(0,0),(1,0),(1,1),(1,2)}. A clockwise rotation produces {(0,0),(0,1),(0,2),(1,2)} — the same pattern turned to the right. Apply the same swap-and-sign rule to every offset to get the rotated pattern.</example>\\n</note3>\\n\\n<note4>\\n<description>After rotating, translate the rotated offsets so the rotated shape sits against the grid's bottom-right corner (i.e., align its bottom and right edges with the grid). Compute the new anchor by subtracting the rotated shape's min offset from the grid's last row and last column.</description>\\n<example>If the rotated offsets have a minimum row rmin and column cmin, place the rotated shape with top-left at (grid_height - 1 - rmin, grid_width - 1 - cmin). This moves the rotated object to the lower-right quadrant without changing its internal offsets.</example>\\n</note4>\\n\\n<note5>\\n<description>Finally, recolor the moved/rotated object with a single uniform color and leave all other cells as background. Do not alter any other colored pixels; the transformation is a relocation, rotation, and recolor of the identified object.</description>\\n<example>After placing the rotated offsets at the chosen anchor, set every cell in that set to one new color (different from the background and the original object color). Verify that only that set of cells changed and that the background remains unchanged.</example>\\n</note5>\",\n \"<note1>\\n<description>Find the single non-background cluster and treat it as the object to transform. This is usually the only color that differs from the background and appears in a compact shape.</description>\\n<example>Imagine a mostly-zero grid with one cluster of blue pixels forming a small triangle; first mark every blue pixel and ignore zeros. That set of pixels is the object you will operate on in every example.</example>\\n</note1>\\n\\n<note2>\\n<description>Compute the object's bounding box (min/max row and column) and record its relative pixel offsets from the box's top-left corner. Working with offsets lets you move the whole shape without recalculating each pixel individually.</description>\\n<example>If the object spans rows 2–4 and columns 5–7, the bounding box is those rows/cols; a pixel at (3,6) has offset (1,1) from the box's top-left. Keep that offset for every pixel of the object.</example>\\n</note2>\\n\\n<note3>\\n<description>Translate the object by a fixed, uniform vector so its bounding box is moved to a canonical location in the grid (for example, flush against the bottom-right). Apply the same translation to every pixel so the shape and orientation remain identical.</description>\\n<example>Suppose you decide to move the bounding box so its bottom-right corner sits at the grid's bottom-right; for an H×W grid and a box of height h and width w, the new top-left is (H−h, W−w). Add that (H−h, W−w) to every pixel's coordinates to get the new positions.</example>\\n</note3>\\n\\n<note4>\\n<description>When you place the object at its new location, recolor it uniformly to a single distinct color (different from the background and the original object color) and erase the original pixels. The output should show only the relocated, recolored shape.</description>\\n<example>If the object was blue in the input, replace every blue pixel with a single new color (e.g., green) at the translated coordinates and set the original blue cells back to background. The result is one clean copy of the shape in its new place and color.</example>\\n</note4>\\n\\n<note5>\\n<description>Verify the transformation by checking invariants: the number of object pixels, their relative arrangement (no rotation/reflection), and that they fit entirely inside the grid after translation. If any example violates these, adjust the translation or recoloring rule accordingly.</description>\\n<example>Count the object's pixels before and after and compare the offsets of the pixels; they should match after translation. Also confirm the translated pixels do not go outside the grid bounds—if they do, try a different canonical placement that keeps the whole shape inside.</example>\\n</note5>\",\n \"<note1>\\n<description>Find the single colored object to track: ignore the uniform background and locate the contiguous cluster of non-background pixels. This cluster is the element that the examples consistently move or recolor.</description>\\n<example>Imagine a 7×7 grid with a small L-shaped cluster of color A in the upper-left and all other cells background. Mark that cluster as the object to follow; treat every other color or isolated pixel as irrelevant for the transformation.</example>\\n</note1>\\n\\n<note2>\\n<description>Summarize the object by its bounding box: record the smallest and largest row and column indices that contain the object. The bounding box gives a compact representation of position and size to compare between input and output.</description>\\n<example>For example, if the object occupies rows 1–3 and columns 2–4, its bounding box is rows [1,3] × cols [2,4]. Use these four numbers (minRow, maxRow, minCol, maxCol) to describe where the object sits.</example>\\n</note2>\\n\\n<note3>\\n<description>Compare input and output bounding boxes to infer a translation: compute the difference in minRow and minCol between the two boxes. If that difference is the same across all training pairs, it is the translation vector to apply to the test object.</description>\\n<example>Suppose one example's input box is at rows [1,3], cols [2,4] and the corresponding output box is at rows [4,6], cols [5,7]. The row difference is +3 and the column difference is +3, so the object was shifted by (+3 rows, +3 cols) in that example; check other examples for the same vector.</example>\\n</note3>\\n\\n<note4>\\n<description>Apply the translation to the test object and redraw it with the output color: move every pixel of the object by the translation vector and recolor those pixels with the new color seen in the outputs. Do not rotate or reflect the shape—only translate and recolor.</description>\\n<example>If the test object is a small triangle occupying rows [0,2], cols [1,3] and the inferred translation is (+3 rows, +3 cols), place the triangle at rows [3,5], cols [4,6] and fill those cells with the output color; leave all other cells unchanged.</example>\\n</note4>\\n\\n<note5>\\n<description>Watch for edge cases and validate: ensure the translated object stays inside the grid and that the background remains untouched. If multiple colored clusters exist, prefer the cluster that matches the training examples' size/shape or use the unique cluster that appears in every input.</description>\\n<example>If the object is close to the bottom edge and the translation would push it outside, re-check the examples to confirm whether the translation was applied or whether the object was instead clipped or ignored. Also verify that the same color-to-color mapping (input color → output color) is used consistently across examples.</example>\\n</note5>\",\n \"<note1>\\n<description>Find the single object to act on: there is one non-background color that forms a compact cluster; treat that whole cluster as the thing to move. Isolating it reduces the problem to transforming one shape rather than many pixels.</description>\\n<example>Imagine a grid with a small L-shaped cluster of colored pixels and the rest background. Mark every cell of that color — those are the pixels you will copy and reposition. You do not need to consider other background cells when planning the transformation.</example>\\n</note1>\\n\\n<note2>\\n<description>Record the object's shape as a relative pattern: list the offsets of its filled pixels relative to a chosen anchor (for example, the top-left of its bounding box). This representation preserves the exact arrangement independent of absolute coordinates.</description>\\n<example>For a 3×3 cluster, write down which offsets inside the 3×3 box are filled (e.g., offsets (0,1),(1,0),(1,1),(1,2),(2,0),(2,1),(2,2)). That set of offsets is what you will paste elsewhere, unchanged in shape.</example>\\n</note2>\\n\\n<note3>\\n<description>Look for a consistent translation across examples: the same shape appears in the output shifted by a fixed vector (same direction and magnitude) relative to its input location. Determine that vector from the training pairs and apply it to the test shape.</description>\\n<example>If in every example the shape's top-left moves down by two rows and right by one column, then when you place the shape in the test input you should also move it down two rows and right one column. Use the examples to infer that fixed offset rather than guessing a different one.</example>\\n</note3>\\n\\n<note4>\\n<description>Check color behavior: the object's pixels are recolored uniformly in the outputs. When you paste the shape at the new position, replace its original color with the single output color observed in the examples.</description>\\n<example>If the input object is color A and every output shows that object in color B, then when you paste the pattern at the translated location paint those pixels with color B. Do not mix colors or leave original-color pixels behind.</example>\\n</note4>\\n\\n<note5>\\n<description>Handle edges and overlaps carefully: place the translated shape exactly (no rotation or reflection), but if part of it would fall outside the grid, clip those pixels. If the pasted shape overlaps other non-background pixels in an example, follow the example's overwrite rule.</description>\\n<example>If shifting the shape would push a pixel past the bottom or right border, drop that pixel (clip it) rather than wrapping or mirroring. If the examples show the moved shape replacing existing pixels, do the same when the pasted pixels land on non-background cells.</example>\\n</note5>\",\n \"<note1>\\n<description>Isolate the object by finding the unique non-background color and computing its minimal bounding rectangle. Working with that box reduces the problem to a small subgrid you can compare across examples.</description>\\n<example>Imagine a grid with a single cluster of color A on a black background. Draw the smallest rectangle that contains all A pixels; that rectangle is the object you will analyze. All further steps operate on that rectangle rather than the whole grid.</example>\\n</note1>\\n\\n<note2>\\n<description>Look for a uniform translation: check whether every pixel of the object in the output is simply shifted by the same row and column offset relative to the input. This is a rigid translation — the pattern inside the box is unchanged, only its position changes.</description>\\n<example>Take a small L-shaped pattern. If in the output you see the same L shape but all its pixels are one row lower and one column to the right, that indicates a translation by (+1 row, +1 column). Verify the same offset for every pixel of the object.</example>\\n</note2>\\n\\n<note3>\\n<description>Check for a consistent color mapping: the object's color in the input may be replaced by a single different color in the output. Treat this as a separate step from spatial movement.</description>\\n<example>If every pixel of color A in the input becomes color B in the output, that is a uniform recolor. You can record the mapping A→B and apply it after you move the object.</example>\\n</note3>\\n\\n<note4>\\n<description>Decide what happens to pixels that would move outside the grid: translations that push pixels beyond the border are usually clipped (those pixels are not wrapped or reflected). That explains why some examples show fewer visible pixels than the input.</description>\\n<example>If you translate a shape downward by one and one of its pixels lies on the bottom row, that pixel will no longer appear after the move. When you apply the translation, drop any pixels whose new coordinates are outside the grid bounds.</example>\\n</note4>\\n\\n<note5>\\n<description>Combine the observations into a single procedure: extract the object, translate it by the same offset you observed, recolor it uniformly, and clip any parts that fall off the grid. Apply that same sequence to the test input to produce the output.</description>\\n<example>For a new input, find the object's bounding box, shift every pixel by the deduced offset, change its color according to the mapping you found, and remove any pixels that would land outside the grid. The resulting grid should match the pattern seen in the training outputs.</example>\\n</note5>\",\n \"<note1>\\n<description>Find the single non-background object and isolate it by computing its minimal bounding rectangle. Working with the bounding box turns a scattered set of pixels into a small, comparable pattern you can reason about.</description>\\n<example>Imagine a 5×5 grid where a small L-shaped cluster of color A sits in the top-left. Draw the smallest rectangle that contains all A pixels; now you have a compact 3×2 pattern to compare instead of scanning the whole grid. This makes it easier to spot how the shape is transformed.</example>\\n</note1>\\n\\n<note2>\\n<description>Compare the internal arrangement of pixels inside the bounding box between input and output. If the pattern of filled vs empty cells is identical, the transformation is a rigid motion (rotation/flip/translation) rather than a resize or fill operation.</description>\\n<example>Take a 3×3 \\\"staircase\\\" pattern: if the output shows the same staircase arrangement but in a different orientation, that indicates a rotation or reflection. Noticing identical relative offsets confirms you should look for a rigid transform.</example>\\n</note2>\\n\\n<note3>\\n<description>Look for a consistent color mapping: the object's original color is often replaced by a single new color in the output while background stays the same. Treat color change as a separate step from spatial rearrangement.</description>\\n<example>If every pixel of color A in the input becomes color B in the output and no other colors are altered, then the rule includes \\\"recolor A → B.\\\" This simplifies the task: first decide how the shape is moved, then recolor.</example>\\n</note3>\\n\\n<note4>\\n<description>Use an anchor point (e.g., the bounding-box top-left or a uniquely placed pixel) to determine the translation vector between input and output. If that vector is the same across examples, you can apply it to the test input.</description>\\n<example>Suppose the bounding box top-left in each training input is at (r1,c1) and the corresponding top-left in the outputs is at (r2,c2); the difference (r2−r1, c2−c1) is the consistent translation. Compute that offset for the test case by applying the same vector to the test bounding-box anchor.</example>\\n</note4>\\n\\n<note5>\\n<description>Decide whether the transform is a rotation, reflection, or simple translation by checking orientation and whether the pattern is flipped. If orientation is preserved but the shape is shifted, prefer translation; if orientation is reversed, prefer rotation/reflection.</description>\\n<example>If a left-leaning staircase in the input appears as a right-leaning staircase in the output, a reflection/rotation is likely. If it remains left-leaning but appears elsewhere, a pure translation is the simpler explanation. Use this distinction to choose the correct rigid motion before recoloring.</example>\\n</note5>\",\n \"<note1>\\n<description>Focus on the single non-background object: locate the unique color that forms a contiguous shape and treat all its pixels as one object. This isolates the part of the grid that is being transformed and avoids confusion from background noise.</description>\\n<example>Imagine a grid of zeros with one small cluster of color A; collect every cell equal to A and ignore all zeros. Those collected cells define the object you will analyze and transform.</example>\\n</note1>\\n\\n<note2>\\n<description>Compute the object's bounding box and the center of that box. The bounding box (min/max row and column) gives a stable reference for position and orientation; the center can be an integer cell (odd dimension) or a half-cell (even dimension).</description>\\n<example>For a cluster occupying rows 2–4 and columns 3–5, the bounding box center is at (3,4). For an even-sized box (rows 2–5) the center lies between rows 3 and 4 (a half-cell). Use these coordinates as the object's reference point.</example>\\n</note2>\\n\\n<note3>\\n<description>Check the object's internal geometry and orientation: in these tasks the object is a small symmetric \\\"pyramid\\\" (rows have odd counts 1,3,5,3,1). That pattern indicates a vertical axis of symmetry and a clear top and bottom row.</description>\\n<example>Visualize a shape with rows of 1,3,5,3,1 pixels: the widest row is the middle and the rows above and below mirror each other. Noticing this tells you the object has a central row and a predictable top/bottom.</example>\\n</note3>\\n\\n<note4>\\n<description>Translate the whole object by a single, consistent vector: move every object pixel by the same offset (same sign and magnitude for rows and columns) so the object's internal geometry is preserved but its position changes. In these examples the translation is the same for every training pair.</description>\\n<example>Take the bounding-box center and shift it by one cell down and one cell right; add that offset to every pixel coordinate of the object. The shape stays identical, only its location changes, and its center moves accordingly.</example>\\n</note4>\\n\\n<note5>\\n<description>After translation, recolor the moved object with a single new color and leave all other cells as background. Ensure the recolored object fits inside the grid and that you do not alter any other colored pixels.</description>\\n<example>Once the shape is translated, change every pixel of the object from the original color to the new color while keeping zeros elsewhere. If the translated shape would run off the grid, re-check the offset — in the examples the chosen offset keeps the object fully inside the grid.</example>\\n</note5>\",\n \"<note1>\\n<description>Look for the single non-background connected component and treat it as the \\\"object\\\" to follow. If there is exactly one colored cluster in the input, that cluster is the element being transformed in every example.</description>\\n<example>Imagine a grid with a small L-shaped cluster of blue pixels surrounded by black. That L is the object: ignore other zeros and focus on the cluster's pixels, their shape, and how many pixels belong to it.</example>\\n</note1>\\n\\n<note2>\\n<description>Compare the object's pixel coordinates between input and output to detect a uniform translation. If every pixel of the object moves by the same (Δrow, Δcol), the rule is a pure translation (no rotation, reflection, or resizing).</description>\\n<example>Take an L-shape at positions (1,1),(2,1),(2,2). In the output the same L appears at (4,3),(5,3),(5,4). Because every pixel was shifted by the same vector (Δrow=+3, Δcol=+2), you can conclude the transformation is a translation by that vector.</example>\\n</note2>\\n\\n<note3>\\n<description>Check whether the object's color is changed consistently. Often the object is moved but also recolored to a single different non-background color in the output.</description>\\n<example>If the input object is blue and the output object is green (every blue pixel becomes green), record the color mapping blue→green. That mapping should be applied after you translate the object.</example>\\n</note3>\\n\\n<note4>\\n<description>Verify that the object's internal pattern and pixel count are preserved. A translation keeps the same arrangement of pixels; if counts and relative positions match after moving, you should not rotate, flip, or resize the object.</description>\\n<example>If the object has 5 pixels arranged as a T-shape, the output should also contain exactly 5 pixels in the same T arrangement (just at different coordinates). If counts differ, a different operation (e.g., fill or cropping) is involved.</example>\\n</note4>\\n\\n<note5>\\n<description>Compute the translation by comparing bounding boxes or a reference pixel (e.g., top-left corner) between input and output examples, then apply that same vector and color mapping to the test input. Before finalizing, ensure the translated object fits entirely inside the grid.</description>\\n<example>Find the bounding box top-left of the object in an input and its corresponding top-left in the output; subtract coordinates to get (Δrow,Δcol). Use that vector to shift every pixel of the test object, recolor them according to the learned mapping, and confirm no pixel would fall outside the grid.</example>\\n</note5>\",\n \"<note1>\\n<description>First isolate the single non-background object: compute its bounding box and record the relative coordinates of every colored pixel inside that box. Working with relative coordinates (offsets from the box’s top-left) makes the pattern independent of absolute position and easier to compare across examples.</description>\\n<example>Imagine a small triangular cluster of colored pixels. Find the minimum and maximum row and column that contain the color to get the bounding box, then list each pixel as an offset like (0,0), (1,0), (1,1), (2,1), … — that list is the object you will move and recolor.</example>\\n</note1>\\n\\n<note2>\\n<description>Compare the bounding-box coordinates between input and output examples to detect a consistent translation vector (Δrow, Δcol). If every training pair uses the same (Δrow, Δcol), apply that vector to the test object's bounding box to get its new absolute position.</description>\\n<example>For example, if each input box’s top-left corner ends up 2 rows lower and 1 column to the right in the outputs, the translation vector is (2,1). Apply that same (2,1) shift to the test object’s top-left to find where to place it.</example>\\n</note2>\\n\\n<note3>\\n<description>Check whether the object’s shape is preserved exactly (no rotation or reflection) by comparing relative offsets. If the offsets match, you should copy the exact pattern of pixels when you move it — only translate and recolor.</description>\\n<example>Take the offset list from note 1 and, after applying the translation vector, place pixels at the new absolute coordinates. If the output examples show identical pixel arrangements after the move, you’ve preserved shape correctly.</example>\\n</note3>\\n\\n<note4>\\n<description>Observe the color mapping: the object’s color in the input is replaced by a single new color in the output. Determine which input color becomes which output color from the examples and apply that same mapping to the moved pixels.</description>\\n<example>If every training input uses color A for the object and every output shows that object in color B, then when you copy the object to the test output you should use color B for all its pixels (leave background pixels unchanged).</example>\\n</note4>\\n\\n<note5>\\n<description>Account for grid boundaries: if the translated bounding box would extend beyond the grid, only draw the portion that fits. Do not wrap or mirror pixels — simply clip the pattern to the grid area.</description>\\n<example>If shifting a 3×3 pattern down by 2 rows would place some rows outside the grid, draw only the rows that fall inside the grid; the remaining rows are discarded. This explains why some examples show only a partial object after the move.</example>\\n</note5>\",\n \"<note1>\\n<description>Isolate the object by finding the non-background color that forms the pattern. Represent the object by its pixels and a simple bounding box so you can reason about its shape and position without background noise. This makes comparisons between input and output straightforward.</description>\\n<example>Imagine a black grid with a small cluster of blue pixels. Record the coordinates of every blue pixel and the rectangle that encloses them; that rectangle and the pixel list capture the object's size and shape for later comparisons.</example>\\n</note1>\\n\\n<note2>\\n<description>Check for a uniform recoloring: every pixel of the object's original color in the input becomes a single new color in the output. If that is true, treat color change as a separate step from any spatial transformation. Recognizing this avoids confusing color substitution with movement.</description>\\n<example>For example, if every blue pixel in the input appears as red in the output (and no other colors change), then you can first map blue→red and then focus on how the red pixels are placed.</example>\\n</note2>\\n\\n<note3>\\n<description>Compare the object's shape and orientation between input and output. If the pattern of filled pixels is identical, the rule is likely a translation (no rotation/reflection) rather than a geometric transform. Verifying shape equality narrows the possible operations to simple shifts.</description>\\n<example>If the input object is an L-shape and the output also shows an L-shape with the same relative pixel arrangement, you can assume the transformation did not rotate or mirror the object — only moved it.</example>\\n</note3>\\n\\n<note4>\\n<description>Compute the translation vector by matching a distinctive anchor point (e.g., the topmost-leftmost pixel) between input and output. Use that vector to map every input pixel to its output position, then apply the recoloring. This gives a deterministic way to place the object in the test grid.</description>\\n<example>Suppose the anchor pixel is at (r,c) in the input and at (r',c') in the output; the translation is (Δr,Δc)=(r'−r,c'−c). Apply (Δr,Δc) to every pixel of the object to get its new coordinates, then recolor them.</example>\\n</note4>\\n\\n<note5>\\n<description>Check edge cases and validate the rule across examples: ensure the object fits after translation, confirm background remains unchanged, and verify the same anchor and vector work for every training pair. If all examples are consistent, apply the same steps to the test input.</description>\\n<example>If every training pair uses the same anchor-based vector and the object always fits into the grid after applying it, then use that vector on the test object; if a training example would overflow the grid, reconsider whether clipping or a different anchor is intended.</example>\\n</note5>\",\n \"<note1>\\n<description>Find the single non-background object and treat it as the unit of transformation. When the grid contains only one colored cluster, the task usually operates on that cluster as a whole rather than on individual pixels.</description>\\n<example>Imagine a grid with a single L-shaped cluster of blue pixels and all other cells black. Instead of changing isolated pixels, the transformation will move or recolor the entire L-shape. First isolate that cluster so you know exactly which pixels to follow.</example>\\n</note1>\\n\\n<note2>\\n<description>Check whether the object's internal arrangement (relative offsets between its pixels) is preserved. If the pattern of occupied cells is identical before and after, the operation is a rigid translation (no rotation, reflection, or scaling).</description>\\n<example>For example, if the object is a 3×3 block with a missing corner, and the output shows the same 3×3 arrangement (same missing corner) but elsewhere, then the block was translated. Use the relative offsets between pixels to confirm shape preservation.</example>\\n</note2>\\n\\n<note3>\\n<description>Determine the translation by comparing coordinates: pick a reference pixel (e.g., the topmost or leftmost) and subtract its input coordinates from its output coordinates. That difference is the translation vector; apply it to all object pixels to get their new positions.</description>\\n<example>Suppose the topmost pixel of the object is at (r,c) in the input and at (r',c') in the output. The vector is (r'−r, c'−c). Move every pixel of the object by that same vector to place the object at the new location.</example>\\n</note3>\\n\\n<note4>\\n<description>Check for a uniform recoloring: the object's pixels are often changed to a single new color while the background remains unchanged. This is a separate step from translation and should be applied after placing the object.</description>\\n<example>If the object is blue in the input and the output shows the same shape but in red, then after translating the shape you should recolor all its pixels to the new color (keeping the background black). Ensure the recoloring is consistent across the whole object.</example>\\n</note4>\\n\\n<note5>\\n<description>Use invariants and sanity checks to validate your result: the number of object pixels, the shape (relative offsets), and the background should match expectations. If any invariant fails, re-evaluate whether you chose the correct reference pixel or the correct translation vector.</description>\\n<example>After applying your translation and recoloring, count the colored pixels and compare to the original object's count; also check that the pattern of occupied cells matches the original shape (only shifted). If counts or relative positions differ, adjust the translation or recoloring step.</example>\\n</note5>\",\n \"<note1>\\n<description>Locate the single non-background object and summarize it by its bounding box and a simple anchor point (for example the top-left corner or the center). This gives a compact representation you can compare across input and output grids. Use that anchor to reason about where the object moved instead of tracking every pixel.</description>\\n<example>Imagine a small L-shaped object made of one color. Compute its min/max row and column to get a bounding box, and take the top-left cell of that box as the anchor. If the anchor moves consistently between examples, you only need to follow that one coordinate to understand the transformation.</example>\\n</note1>\\n\\n<note2>\\n<description>Compare the anchor coordinates between each input and its output to detect a constant displacement vector (Δrow, Δcol). If the same vector appears in every example, the rule is a rigid translation of the object by that vector. This is faster and less error-prone than matching many pixels.</description>\\n<example>Suppose the anchor is at (r,c) in an input and at (r',c') in the corresponding output. Compute (Δrow,Δcol) = (r'−r, c'−c). Repeat for all training pairs; if you get the same (Δrow,Δcol) each time, you have the translation to apply.</example>\\n</note2>\\n\\n<note3>\\n<description>Check whether the object’s internal pattern and orientation are preserved after the move. If the relative arrangement of pixels inside the bounding box is identical, the operation is a pure translation (no rotation or reflection). This tells you to copy the exact pixel pattern, not to rotate or flip it.</description>\\n<example>Take a small 3×3 motif inside the bounding box. If after moving the motif the same relative offsets of colored pixels appear in the new location, then the transformation is a copy+translate. If offsets change, you would need to consider rotation or reflection instead.</example>\\n</note3>\\n\\n<note4>\\n<description>Observe color behavior: often the moved object is recolored uniformly in the output (the same replacement color across examples). Record that mapping and apply it when you place the translated pattern. Treat color change and spatial move as two separate steps: move first, then recolor.</description>\\n<example>If every training output shows the moved object in a single different color than the input, note that mapping (e.g., input color A → output color B). When you copy the object to its new position, fill it with the mapped color so the output matches the examples’ appearance.</example>\\n</note4>\\n\\n<note5>\\n<description>Decide how to handle edges and background: check whether outputs ever clip or wrap the object when a translation would push it outside the grid. Use the training examples to infer the rule (usually clipping is applied and the rest of the grid remains background). This ensures you place the object correctly without altering other pixels.</description>\\n<example>If a training input had the object near the border and the output shows only the visible portion of the object, that indicates clipping — drop any pixels that would fall outside the grid. If no clipping occurs in examples, assume the grid is large enough and the object is translated without wrapping.</example>\\n</note5>\",\n \"<note1>\\n<description>Isolate the single non-background object by finding all cells of the same non-zero color and computing their minimal bounding rectangle. The bounding box gives you the object's size and orientation without needing to reason about individual pixels. This reduces the problem to a small, self-contained pattern.</description>\\n<example>Imagine a grid with a small cluster of colored pixels; draw the smallest rectangle that contains them. That rectangle tells you the object's height and width and where its top-left corner sits in the grid. Use that rectangle as the unit you will move or copy.</example>\\n</note1>\\n\\n<note2>\\n<description>Look at the object's internal pattern row-by-row: the number of contiguous colored cells in each row is a simple signature (a triangular or staircase profile). That signature is preserved under translations and is a quick way to confirm you have the same object in different places. Use it to match candidate placements.</description>\\n<example>For example, an object whose rows have lengths 1, 3, 5, 1 (top to bottom) is unmistakable: any translated copy will show the same sequence of contiguous counts. If you see that sequence in the output, you know the same shape was moved rather than redrawn.</example>\\n</note2>\\n\\n<note3>\\n<description>Check whether the object's orientation changes: compare left/right positions of the rows to see if columns have been swapped. If the leftmost row in the input appears as the top row in the output (and the top row becomes the rightmost), that indicates a 90° rotation rather than a simple shift. Rotation swaps width and height.</description>\\n<example>Take a small staircase: if the input's first row is one cell on the left and the output's first row is one cell on the right, the shape has been rotated. The same check on the second and third rows confirms the rotation direction.</example>\\n</note3>\\n\\n<note4>\\n<description>Decide how the rotated object is placed: it will be translated so its bounding box sits flush against the grid's bottom and right edges (i.e., bottom-right corner). Compute the translation by subtracting the rotated box's top-left coordinates from the grid's bottom-right coordinates. This keeps the object fully inside the grid and aligned with the edges.</description>\\n<example>If the rotated bounding box has top-left at (r0,c0) and the grid has height H and width W, place the box with top-left at (H-1-r0, W-1-c0). That moves the box so its bottom and right edges coincide with the grid's bottom and right edges.</example>\\n</note4>\\n\\n<note5>\\n<description>Finally, apply a uniform recoloring to the moved object and leave the background untouched. The examples show the object is not only relocated and possibly rotated but also painted with a single new color distinct from the background. Treat recoloring as the last step after placement.</description>\\n<example>After you rotate and translate the bounding box, replace every pixel inside it with the output color while keeping all other cells as background. The result is the same shape, in the same orientation relative to the box, but in the new color and at the bottom-right location.</example>\\n</note5>\",\n \"<note1>\\n<description>Isolate the object by finding the single non-background color and computing its minimal bounding box (min/max row and column). This box captures the object's shape and size so you can reason about how it moves or is transformed. Working with the bounding box reduces the problem to a simple geometric operation.</description>\\n<example>Imagine a small L-shaped cluster of non-background pixels. Compute the smallest rectangle that contains every colored pixel (top, bottom, left, right). That rectangle tells you the object's height and width and gives you a stable reference to compare with the output.</example>\\n</note1>\\n\\n<note2>\\n<description>Look for a rigid translation: check whether every pixel of the object keeps the same relative offsets to the bounding-box corners in the output. If offsets are unchanged, the object was moved as a whole rather than rotated, flipped, or scaled. This distinguishes translation from other transformations.</description>\\n<example>Take a 3×3 filled square and a 3×3 L-shape; if in the output each colored pixel is at the same row/column offset from the square's top-left corner as in the input, then the object was translated unchanged. If offsets differ, consider rotation or reflection instead.</example>\\n</note2>\\n\\n<note3>\\n<description>Check color mapping: determine whether the object's pixels in the input are uniformly replaced by a single different color in the output while the background remains unchanged. A consistent one-to-one color change indicates a recoloring step applied to the whole object. Confirm that no other colors are introduced or removed.</description>\\n<example>If every pixel of the object that was color A in the input becomes color B in the output and all background pixels stay the same, that is a uniform recolor. Verify this holds for every pixel of the object before proceeding.</example>\\n</note3>\\n\\n<note4>\\n<description>Look for a fixed displacement vector (dx,dy) that maps input bounding-box corners to output bounding-box corners. Compute the vector from the input top-left (or center) to the output top-left (or center) and apply it to every pixel of the object. The same vector should explain all example pairs.</description>\\n<example>If the input bounding-box top-left is at (r,c) and the output bounding-box top-left is at (r+dy,c+dx) in the examples, then dx and dy are the translation. Apply (dx,dy) to every pixel of the object in the test input to get its new coordinates.</example>\\n</note4>\\n\\n<note5>\\n<description>Apply the translation and recolor to the test object, then validate by checking invariants: the object's shape and orientation must be preserved, the count of colored pixels should match the input, and the background should remain unchanged. If any invariant fails, re-check the bounding box and the displacement vector.</description>\\n<example>After moving and recoloring the object, count the colored pixels — it should equal the original count and the pattern should match the original shape. Also confirm no other pixels were altered and that the translated object fits entirely inside the grid.</example>\\n</note5>\"\n]","isConversational":false},"train":{"kind":"string","value":"[{\"input\": [[0, 0, 0, 0, 0, 0, 0, 0, 0], [0, 0, 0, 0, 0, 0, 0, 0, 0], [0, 0, 0, 0, 0, 0, 0, 0, 0], [0, 0, 0, 0, 0, 0, 0, 0, 0], [0, 0, 0, 0, 0, 0, 0, 0, 0], [0, 0, 0, 0, 0, 0, 4, 0, 0], [0, 0, 0, 0, 0, 4, 4, 4, 0], [0, 0, 0, 0, 4, 4, 4, 4, 0], [0, 0, 0, 0, 0, 0, 0, 4, 0]], \"output\": [[0, 0, 0, 0, 0, 0, 0, 0, 0], [0, 0, 0, 0, 0, 0, 0, 0, 0], [0, 0, 0, 0, 0, 0, 0, 0, 0], [0, 0, 0, 0, 0, 0, 0, 0, 0], [0, 0, 0, 0, 0, 0, 0, 0, 0], [0, 0, 0, 0, 0, 0, 0, 2, 0], [0, 0, 0, 0, 0, 0, 2, 2, 2], [0, 0, 0, 0, 0, 2, 2, 2, 2], [0, 0, 0, 0, 0, 0, 0, 0, 2]]}, {\"input\": [[0, 0, 0, 0, 0, 0, 0, 0, 0, 0], [0, 0, 0, 0, 0, 0, 0, 0, 0, 0], [0, 0, 0, 0, 0, 4, 0, 0, 0, 0], [0, 0, 0, 0, 4, 4, 4, 0, 0, 0], [0, 0, 0, 0, 0, 0, 4, 0, 0, 0], [0, 0, 0, 0, 0, 0, 0, 0, 0, 0], [0, 0, 0, 0, 0, 0, 0, 0, 0, 0], [0, 0, 0, 0, 0, 0, 0, 0, 0, 0], [0, 0, 0, 0, 0, 0, 0, 0, 0, 0], [0, 0, 0, 0, 0, 0, 0, 0, 0, 0]], \"output\": [[0, 0, 0, 0, 0, 0, 0, 0, 0, 0], [0, 0, 0, 0, 0, 0, 0, 0, 0, 0], [0, 0, 0, 0, 0, 0, 0, 0, 0, 0], [0, 0, 0, 0, 0, 0, 0, 0, 0, 0], [0, 0, 0, 0, 0, 0, 0, 0, 0, 0], [0, 0, 0, 0, 0, 0, 0, 0, 0, 0], [0, 0, 0, 0, 0, 0, 0, 0, 0, 0], [0, 0, 0, 0, 0, 0, 0, 0, 2, 0], [0, 0, 0, 0, 0, 0, 0, 2, 2, 2], [0, 0, 0, 0, 0, 0, 0, 0, 0, 2]]}, {\"input\": [[0, 0, 0, 0, 0, 0, 0, 0, 0, 0], [0, 0, 0, 0, 0, 0, 0, 0, 0, 0], [0, 0, 0, 0, 0, 0, 4, 0, 0, 0], [0, 0, 0, 0, 0, 4, 4, 4, 0, 0], [0, 0, 0, 0, 4, 4, 4, 4, 0, 0], [0, 0, 0, 0, 0, 0, 0, 4, 0, 0], [0, 0, 0, 0, 0, 0, 0, 0, 0, 0], [0, 0, 0, 0, 0, 0, 0, 0, 0, 0], [0, 0, 0, 0, 0, 0, 0, 0, 0, 0], [0, 0, 0, 0, 0, 0, 0, 0, 0, 0]], \"output\": [[0, 0, 0, 0, 0, 0, 0, 0, 0, 0], [0, 0, 0, 0, 0, 0, 0, 0, 0, 0], [0, 0, 0, 0, 0, 0, 0, 0, 0, 0], [0, 0, 0, 0, 0, 0, 0, 0, 0, 0], [0, 0, 0, 0, 0, 0, 0, 0, 0, 0], [0, 0, 0, 0, 0, 0, 0, 0, 0, 0], [0, 0, 0, 0, 0, 0, 0, 0, 2, 0], [0, 0, 0, 0, 0, 0, 0, 2, 2, 2], [0, 0, 0, 0, 0, 0, 2, 2, 2, 2], [0, 0, 0, 0, 0, 0, 0, 0, 0, 2]]}]"},"test":{"kind":"string","value":"[{\"input\": [[0, 0, 0, 0, 0, 0, 0, 0], [0, 0, 0, 0, 0, 0, 0, 0], [0, 0, 0, 0, 0, 0, 0, 0], [0, 0, 0, 0, 0, 0, 0, 0], [0, 0, 0, 0, 0, 0, 0, 0], [0, 0, 0, 0, 0, 0, 0, 4], [0, 0, 0, 0, 0, 0, 4, 4], [0, 0, 0, 0, 0, 0, 0, 0]], \"output\": [[0, 0, 0, 0, 0, 0, 0, 0], [0, 0, 0, 0, 0, 0, 0, 0], [0, 0, 0, 0, 0, 0, 0, 0], [0, 0, 0, 0, 0, 0, 0, 0], [0, 0, 0, 0, 0, 0, 0, 0], [0, 0, 0, 0, 0, 0, 0, 0], [0, 0, 0, 0, 0, 0, 0, 2], [0, 0, 0, 0, 0, 0, 2, 2]]}]"},"source":{"kind":"string","value":"barc_heavy"},"prompt":{"kind":"string","value":"You will be given some number of paired example inputs and outputs grids. The outputs were produced by applying a transformation rule to the input grids. In addition to the paired example inputs and outputs, there is also one test input without a known output. The inputs and outputs are each “grids”. A grid is a rectangular matrix of integers between 0 and 9 (inclusive). Each number corresponds to a color. 0 is black. Your task is to determine the transformation rule from examples and find out the answer, involving determining the size of the output grid for the test and correctly filling each cell of the grid with the appropriate color or number. The transformation only needs to be unambiguous and applicable to the example inputs and the test input. It doesn't need to work for all possible inputs. Observe the examples carefully, imagine the grid visually, and try to find the pattern. Please output your answer within a code block (```), formatted as a grid of numbers. \n\n# Examples\n## Example 1\nInput:\n```\n0 0 0 0 0 0 0 0 0\n0 0 0 0 0 0 0 0 0\n0 0 0 0 0 0 0 0 0\n0 0 0 0 0 0 0 0 0\n0 0 0 0 0 0 0 0 0\n0 0 0 0 0 0 4 0 0\n0 0 0 0 0 4 4 4 0\n0 0 0 0 4 4 4 4 0\n0 0 0 0 0 0 0 4 0\n```\n\nOutput:\n```\n0 0 0 0 0 0 0 0 0\n0 0 0 0 0 0 0 0 0\n0 0 0 0 0 0 0 0 0\n0 0 0 0 0 0 0 0 0\n0 0 0 0 0 0 0 0 0\n0 0 0 0 0 0 0 2 0\n0 0 0 0 0 0 2 2 2\n0 0 0 0 0 2 2 2 2\n0 0 0 0 0 0 0 0 2\n```\n\n## Example 2\nInput:\n```\n0 0 0 0 0 0 0 0 0 0\n0 0 0 0 0 0 0 0 0 0\n0 0 0 0 0 4 0 0 0 0\n0 0 0 0 4 4 4 0 0 0\n0 0 0 0 0 0 4 0 0 0\n0 0 0 0 0 0 0 0 0 0\n0 0 0 0 0 0 0 0 0 0\n0 0 0 0 0 0 0 0 0 0\n0 0 0 0 0 0 0 0 0 0\n0 0 0 0 0 0 0 0 0 0\n```\n\nOutput:\n```\n0 0 0 0 0 0 0 0 0 0\n0 0 0 0 0 0 0 0 0 0\n0 0 0 0 0 0 0 0 0 0\n0 0 0 0 0 0 0 0 0 0\n0 0 0 0 0 0 0 0 0 0\n0 0 0 0 0 0 0 0 0 0\n0 0 0 0 0 0 0 0 0 0\n0 0 0 0 0 0 0 0 2 0\n0 0 0 0 0 0 0 2 2 2\n0 0 0 0 0 0 0 0 0 2\n```\n\n## Example 3\nInput:\n```\n0 0 0 0 0 0 0 0 0 0\n0 0 0 0 0 0 0 0 0 0\n0 0 0 0 0 0 4 0 0 0\n0 0 0 0 0 4 4 4 0 0\n0 0 0 0 4 4 4 4 0 0\n0 0 0 0 0 0 0 4 0 0\n0 0 0 0 0 0 0 0 0 0\n0 0 0 0 0 0 0 0 0 0\n0 0 0 0 0 0 0 0 0 0\n0 0 0 0 0 0 0 0 0 0\n```\n\nOutput:\n```\n0 0 0 0 0 0 0 0 0 0\n0 0 0 0 0 0 0 0 0 0\n0 0 0 0 0 0 0 0 0 0\n0 0 0 0 0 0 0 0 0 0\n0 0 0 0 0 0 0 0 0 0\n0 0 0 0 0 0 0 0 0 0\n0 0 0 0 0 0 0 0 2 0\n0 0 0 0 0 0 0 2 2 2\n0 0 0 0 0 0 2 2 2 2\n0 0 0 0 0 0 0 0 0 2\n```\n\n# Test Problem:\n```\n0 0 0 0 0 0 0 0\n0 0 0 0 0 0 0 0\n0 0 0 0 0 0 0 0\n0 0 0 0 0 0 0 0\n0 0 0 0 0 0 0 0\n0 0 0 0 0 0 0 4\n0 0 0 0 0 0 4 4\n0 0 0 0 0 0 0 0\n```"},"answer":{"kind":"string","value":"```\n0 0 0 0 0 0 0 0\n0 0 0 0 0 0 0 0\n0 0 0 0 0 0 0 0\n0 0 0 0 0 0 0 0\n0 0 0 0 0 0 0 0\n0 0 0 0 0 0 0 0\n0 0 0 0 0 0 0 2\n0 0 0 0 0 0 2 2\n```"},"num_tokens":{"kind":"number","value":1518,"string":"1,518"}}},{"rowIdx":97,"cells":{"abstraction_prompt":{"kind":"string","value":"<|im_start|>user\n# ARC HINT GENERATOR\n\n## Role & Goal\nYou are an expert ARC (Abstraction and Reasoning Corpus) analyst. Your task is to generate a concise, actionable hint for a user who is struggling with an ARC problem. Analyze the problem and its correct solution to produce a single standalone, targeted hint that helps the user discover the core transformation principle for themselves without revealing the answer.\n\n---\n\n## Hint Generation Strategy\n1. **Compare** the input and output grids for each example. Identify the shared transformation pattern that allows the input grid to be converted into the output grid.\n2. **Identify the Core Principle**: Review the problem description and ground-truth solution to fully discern the key transformation rule. Break it down into its essential operations (e.g., object completion, pattern repetition, symmetry, gravity), paying close attention to properties such as object count, shapes, colors, sizes, symmetry, repetition, relative positioning, and broader grid-level patterns.\n3. **Craft a Targeted Hint**: Generate a hint that guides the user toward the core insight needed to solve the problem. The hint should assist the user during their attempt without revealing the solution.\n4. Structure each note using the template below:\n - **Description** (up to 3 sentences): Explain the concept, when and why it applies, and why it is effective. Include any relevant general formula or principle in its most general form.\n - **Example** (up to 6 sentences): Present a worked example covering all aspects of the description, using a simplified yet representative scenario (not necessarily from the current problem).\n - Optionally, include **Heuristics** or **Pitfalls** in the note where relevant.\n - Focus on methodologies and core principles over specific calculations or problem details.\n - Ensure each hint applies broadly—at least 80% of analogous problems.\n\nAfter generating a hint, verify that no specifics of the solution are revealed, and that the hint remains at the level of guiding the approach.\n\n### Design Guidelines\n- Clarity: Use precise language and correct sentence structure.\n- Atomicity: Each note addresses one recognizable sub-problem.\n- Self-containment: All information needed to understand the idea and its application is within the note.\n- Generalizability: Avoid problem-specific details or variables.\n- Transferability: Notes should apply across a class of problems.\n- Distinctness: Each note addresses a distinct principle.\n\n---\n\n## Guidelines\n- **Guide, Don't Solve**: Illuminate the approach, not the answer. Emphasize what to observe or consider.\n- **Specific yet Abstract**: Use concrete grid details (e.g., \"note the relationship between the blue and red pixels\") to ground abstract patterns (e.g., \"think about one color containing another\").\n\nValidate your generated hint: confirm it is self-contained, actionable, and nondirective. If any aspect is too revealing, revise before finalizing.\n\n---\n\n## Inputs\n### Problem Description\nA full ARC problem, including input/output pairs for training and testing.\n\n## Example 1\nInput:\n```\n9 9 9 9 9 9 9 9 9 9 9 9 9 9\n9 9 9 9 9 9 9 9 9 9 9 9 9 9\n9 9 9 9 9 9 9 9 9 9 7 9 9 1\n9 9 9 9 9 9 9 9 9 9 9 9 9 9\n9 9 9 9 9 9 9 7 9 9 9 9 9 1\n9 9 9 9 9 9 9 9 9 9 9 9 9 9\n9 9 9 9 9 9 9 9 9 9 9 7 9 9\n9 9 9 9 9 9 9 9 9 9 9 9 9 1\n9 9 9 9 9 9 9 9 9 9 9 9 9 9\n9 9 9 9 9 9 9 7 9 9 9 9 9 9\n9 9 9 9 9 9 9 9 9 9 9 9 9 1\n9 9 9 9 9 9 9 9 9 9 9 9 9 9\n9 9 9 9 9 9 9 9 9 9 9 9 9 9\n9 9 9 9 7 9 9 9 9 9 9 9 9 1\n9 9 9 9 9 9 9 9 9 9 9 9 9 9\n9 9 9 9 9 9 9 9 9 9 9 9 9 9\n9 9 9 9 9 9 9 9 9 9 9 9 9 1\n9 9 9 9 9 9 9 9 9 9 9 9 9 9\n9 9 9 9 9 9 9 9 9 7 9 9 9 1\n9 9 9 9 9 9 9 9 9 9 9 9 9 9\n9 9 9 9 9 9 9 9 9 9 9 9 9 9\n```\n\nOutput:\n```\n9 9 9 9 9 9 9 9 9 9 9 9 9 9\n1 1 1 1 1 1 1 1 1 1 1 1 9 9\n9 9 9 9 9 9 9 9 9 9 7 1 1 1\n1 1 1 1 1 1 1 1 1 9 9 9 9 9\n9 9 9 9 9 9 9 7 1 1 1 1 1 1\n9 9 9 9 9 9 9 9 9 9 9 9 9 9\n9 9 9 9 9 9 9 9 9 9 9 7 9 9\n1 1 1 1 1 1 1 1 1 1 1 1 1 1\n9 9 9 9 9 9 9 9 9 9 9 9 9 9\n9 9 9 9 9 9 9 7 9 9 9 9 9 9\n1 1 1 1 1 1 1 1 1 1 1 1 1 1\n9 9 9 9 9 9 9 9 9 9 9 9 9 9\n1 1 1 1 1 1 9 9 9 9 9 9 9 9\n9 9 9 9 7 1 1 1 1 1 1 1 1 1\n9 9 9 9 9 9 9 9 9 9 9 9 9 9\n9 9 9 9 9 9 9 9 9 9 9 9 9 9\n1 1 1 1 1 1 1 1 1 1 1 1 1 1\n1 1 1 1 1 1 1 1 1 1 1 9 9 9\n9 9 9 9 9 9 9 9 9 7 1 1 1 1\n9 9 9 9 9 9 9 9 9 9 9 9 9 9\n9 9 9 9 9 9 9 9 9 9 9 9 9 9\n```\n\n## Example 2\nInput:\n```\n8 8 8 8 8 8 8 8 8 8 8 8 8 8\n8 8 8 8 8 8 8 8 8 8 8 8 8 8\n8 8 8 8 8 8 8 8 8 8 8 8 8 8\n8 8 8 8 8 8 8 8 8 8 8 8 8 8\n8 8 8 8 8 8 8 8 8 8 8 8 8 8\n8 3 8 8 8 8 8 8 8 8 8 8 8 8\n8 8 8 8 8 8 8 8 8 8 8 8 8 8\n8 8 8 8 8 8 8 8 8 8 8 8 8 8\n8 8 8 8 8 8 8 8 8 8 8 8 8 8\n8 8 8 8 8 8 8 8 8 8 8 8 8 8\n8 8 8 8 8 8 8 8 8 8 8 8 8 8\n8 8 9 8 8 8 9 8 8 8 8 8 8 8\n```\n\nOutput:\n```\n8 8 9 8 8 8 9 8 8 8 8 8 8 8\n8 8 9 8 8 8 9 8 8 8 8 8 8 8\n8 8 9 8 8 8 9 8 8 8 8 8 8 8\n8 8 9 8 8 8 9 8 8 8 8 8 8 8\n8 8 9 8 8 8 9 8 8 8 8 8 8 8\n8 3 9 8 8 8 9 8 8 8 8 8 8 8\n8 8 9 8 8 8 9 8 8 8 8 8 8 8\n8 8 9 8 8 8 9 8 8 8 8 8 8 8\n8 8 9 8 8 8 9 8 8 8 8 8 8 8\n8 8 9 8 8 8 9 8 8 8 8 8 8 8\n8 8 9 8 8 8 9 8 8 8 8 8 8 8\n8 8 9 8 8 8 9 8 8 8 8 8 8 8\n```\n\n## Example 3\nInput:\n```\n7 7 7 7 7 7 7 7 7 7 7 7\n7 7 7 7 7 7 7 7 7 7 7 7\n7 7 7 7 7 7 7 7 7 7 7 2\n7 7 7 7 7 7 7 7 7 7 7 7\n7 7 7 7 7 6 7 7 7 7 7 7\n7 7 7 7 7 7 7 7 7 7 7 7\n7 7 7 7 7 7 7 7 7 7 7 2\n7 7 7 6 7 7 7 7 7 7 7 7\n7 7 7 7 7 7 7 7 7 7 7 7\n7 7 7 7 7 7 7 7 7 7 7 7\n7 7 7 7 7 7 7 7 7 7 7 7\n7 7 7 7 7 7 7 7 7 7 7 7\n7 7 7 7 7 7 7 7 7 7 7 7\n7 7 7 6 7 7 7 7 7 7 7 7\n7 7 7 7 7 7 7 7 7 7 7 7\n```\n\nOutput:\n```\n7 7 7 7 7 7 7 7 7 7 7 7\n7 7 7 7 7 7 7 7 7 7 7 7\n2 2 2 2 2 2 2 2 2 2 2 2\n7 7 7 7 7 7 7 7 7 7 7 7\n7 7 7 7 7 6 7 7 7 7 7 7\n7 7 7 7 7 7 7 7 7 7 7 7\n2 2 2 2 2 2 2 2 2 2 2 2\n7 7 7 6 7 7 7 7 7 7 7 7\n7 7 7 7 7 7 7 7 7 7 7 7\n7 7 7 7 7 7 7 7 7 7 7 7\n7 7 7 7 7 7 7 7 7 7 7 7\n7 7 7 7 7 7 7 7 7 7 7 7\n7 7 7 7 7 7 7 7 7 7 7 7\n7 7 7 6 7 7 7 7 7 7 7 7\n7 7 7 7 7 7 7 7 7 7 7 7\n```\n\n### Test Input\nHere is the input for the test problem.\n\n```\n3 3 3 3 3 3 3 3 3 3 3 3\n3 3 3 3 3 3 3 6 3 3 3 3\n3 3 3 3 3 3 3 3 3 3 3 3\n3 3 3 6 3 3 3 3 3 3 3 3\n3 3 3 3 3 3 3 3 3 3 3 0\n3 3 3 3 3 3 6 3 3 3 3 3\n3 3 3 3 3 3 3 3 3 3 3 3\n3 3 3 3 3 3 3 3 3 3 3 3\n3 6 3 3 3 3 3 3 3 3 3 3\n3 3 3 3 3 3 3 3 3 3 3 3\n3 3 3 3 3 3 3 3 3 3 3 0\n3 3 3 3 3 3 6 3 3 3 3 3\n3 3 3 3 3 3 3 3 3 3 3 3\n3 3 3 3 3 3 3 3 3 3 3 3\n3 3 3 3 3 3 6 3 3 3 3 3\n3 3 3 3 3 3 3 3 3 3 3 0\n3 6 3 3 3 3 3 3 3 3 3 3\n3 3 3 3 3 3 3 3 3 3 3 3\n3 3 3 3 3 3 3 3 3 3 3 3\n```\n\n\n### Output Format\nOnly produce a **sequence of 5** notes in the structure:\n<note1>\n<description>...</description>\n<example>...</example>\n</note1>\n<note2>\n<description>...</description>\n<example>...</example>\n</note2>\n...\n\nDO NOT generate any other text\n\n---\n\n\n# Generated Hint<|im_end|>\n<|im_start|>assistant\n"},"abstraction_prompt_length":{"kind":"number","value":3783,"string":"3,783"},"generated_abstractions":{"kind":"list like","value":["<note1>\n<description>Look for the dominant (background) color and the minority colors. Often one minority color appears exactly once and acts as a “marker” or pivot; the other minority colors are the ones that get transformed. Recognizing these roles reduces the problem to a small set of objects to reason about.</description>\n<example>Imagine a grid that is mostly color A, with a single pixel of color B and several scattered pixels of color C. Treat A as the background, B as the marker, and C as the candidate to be changed. Counting occurrences (A: many, B: one, C: many) helps you decide which color will be copied or propagated.</example>\n</note1>\n\n<note2>\n<description>Compare the positions of the scattered pixels: are they all in the same column, same row, or aligned in a simple pattern? That alignment determines whether the rule is a row-wise or column-wise operation. The axis of alignment tells you the direction in which the marker color will be propagated.</description>\n<example>If several C pixels all lie in column X, that suggests a vertical (column) rule: the marker color will be copied along that column. If the C pixels lie in the same row, expect a horizontal (row) rule instead. Use this to pick the correct orientation before applying any fill.</example>\n</note2>\n\n<note3>\n<description>Use the unique marker pixel as the anchor: its row and column are the reference for where to apply the propagation. The marker’s coordinates (r,c) are the natural candidates to be extended along the axis indicated by the scattered pixels. Thinking in terms of (r,c) keeps the rule consistent across examples.</description>\n<example>Suppose the marker is at (r,c) and you have scattered C pixels in column c. Then the natural operation is to extend the marker color along column c (above and/or below r) rather than along the scattered pixels’ rows. If the scattered pixels share a row r, the anchor row r is the natural place to propagate horizontally.</example>\n</note3>\n\n<note4>\n<description>When you propagate the marker color, do not overwrite other non-background pixels: preserve the scattered pixels and any other distinct colors. The propagation fills only background cells along the chosen axis and leaves marker pixels and other objects intact. This keeps the original structure while applying the transformation.</description>\n<example>Imagine extending the marker color down a column but encountering a C pixel in that column at some row; leave that C unchanged and only replace the surrounding background cells with the marker color. The result is a continuous vertical stripe of the marker color that respects the original non-background pixels.</example>\n</note4>\n\n<note5>\n<description>Apply the same propagation rule everywhere the alignment pattern appears: if the scattered pixels repeat at multiple rows (or columns), repeat the fill at each occurrence. After applying the rule, check that every instance of the scattered color has been handled consistently and that no other colors were changed.</description>\n<example>If C appears in several rows but always in the same column, perform the column-wise fill for each row where C is present. Finally, scan the grid to confirm that every original C was accounted for and that the marker color now forms the expected stripes or rows without disturbing other colors.</example>\n</note5>","<note1>\n<description>Look for a color that appears in many rows but in different columns — that color is a row-seed. When a color’s occurrences are scattered across rows (not forming a single connected object), it usually signals a row-based operation rather than a column-based one.</description>\n<example>Imagine a 6×6 grid where color A appears somewhere in rows 1, 3 and 5, but never in the same column each time. That pattern suggests A is a row-seed: treat each of those rows as candidates for a row-level change rather than treating A as a single object to move.</example>\n</note1>\n\n<note2>\n<description>Decide the orientation of propagation by checking whether the seed pixels share the same column index. If they all lie in one column, the rule is column-wise; if they lie in different columns, the rule is row-wise. This choice determines whether you extend vertically or horizontally.</description>\n<example>If color B appears at (row1,col4), (row2,col4), (row3,col4) — same column — you should expect a vertical propagation (a column change). If color C appears at (row1,col1), (row3,col5), (row4,col2) — different columns — you should expect horizontal propagation (row changes).</example>\n</note2>\n\n<note3>\n<description>When you propagate, fill the entire line (the whole row or the whole column) with the seed color. The operation is \"paint the entire row/column\" rather than copying only the seed pixel’s neighborhood.</description>\n<example>With a row-seed at (r,c), set every cell in row r to that seed color. With a column-seed at (r,c), set every cell in column c to that color. This produces full horizontal or vertical stripes in the output.</example>\n</note3>\n\n<note4>\n<description>Apply the same propagation independently for each distinct seed color and for each occurrence of that color. Multiple seeds can produce multiple stripes; overlapping stripes will simply coincide in color.</description>\n<example>If color D appears in rows 2 and 7, paint both row 2 and row 7 entirely with D. If color E appears in several columns, paint each of those columns entirely with E. The final grid is the union of these painted lines.</example>\n</note4>\n\n<note5>\n<description>Do not overwrite other special pixels — treat other non-background colors as obstacles that should remain. Only replace background cells when painting lines; leave any distinct colored pixels untouched.</description>\n<example>If a row is to be painted with color F but that row already contains a cell of color G, keep G in place and only change the background cells to F. A common pitfall is to erase or move these anchor pixels instead of preserving them.</example>\n</note5>","<note1>\n<description>Look for a single non-background color that appears repeatedly in the same column(s). That color usually acts as an anchor or marker: its column (or columns) is the key feature the transformation uses.</description>\n<example>Imagine a grid where most cells are gray but blue appears only in column 4 at several different rows. Treat blue as the anchor color and note column 4 as the anchor column to investigate further.</example>\n</note1>\n\n<note2>\n<description>Check whether the anchor color is copied along the orthogonal axis: in many puzzles the anchor is extended into full rows or full columns. Determine which axis is used by comparing input and output examples.</description>\n<example>For example, if blue appears in column 4 in the input and the output shows entire rows filled with blue, then the rule is \"copy the anchor into full rows\" rather than copying it into columns or scattered pixels.</example>\n</note2>\n\n<note3>\n<description>Decide how the anchor is selected when multiple colors are present: pick the color that is most consistent across examples (most occurrences or most aligned). Use simple counts and alignment checks to disambiguate.</description>\n<example>If red occurs 10 times in one column and green occurs 3 times scattered, red is the better candidate for the anchor; prefer the color that appears repeatedly in the same column or with a regular spacing.</example>\n</note3>\n\n<note4>\n<description>When applying the extension, preserve other non-background colors: do not overwrite distinct colored pixels that are not the anchor. The anchor fills only background cells along the chosen axis.</description>\n<example>If a row is supposed to be filled with blue but already contains a red pixel, leave that red pixel unchanged and fill the remaining background cells with blue; do not replace the red.</example>\n</note4>\n\n<note5>\n<description>Handle multiple anchor columns or anchors by applying the same extension independently to each anchor column; also confirm the transformation is global (everywhere along the chosen axis) rather than local to a small region.</description>\n<example>If the anchor color appears in both column 2 and column 7, copy that color into full rows for each of those columns (or apply the same rule for each anchor column). If the examples show the same operation repeated for every anchor column, repeat it everywhere.</example>\n</note5>","<note1>\n<description>Look for a single color that appears as isolated pixels across many rows or columns. That color is usually the \"marker\" that determines where to apply a global change; it is distinct from the dominant background and from the other small, scattered color(s).</description>\n<example>Imagine a grid mostly filled with blue, with a few red pixels scattered in different rows. Those red pixels are the markers: they are not background and they repeat across rows, so they are the ones you should focus on when deciding where to change the grid.</example>\n</note1>\n\n<note2>\n<description>Decide the orientation of the rule by checking alignment: if the marker pixels share a column across many rows, the operation is column-wise; if they share a row across many columns, it is row-wise. The transformation usually acts along the axis parallel to that alignment.</description>\n<example>If red pixels appear in column 5 at rows 2, 6 and 9, treat column 5 as the marker axis and plan a column-wise operation. If instead red pixels appear in row 3 at columns 1, 4 and 7, treat row 3 as the marker axis and plan a row-wise operation.</example>\n</note2>\n\n<note3>\n<description>When you have a marker axis, apply a uniform fill to the entire line (all cells in that row or column) with the marker color. This turns a sparse set of marker pixels into a continuous stripe aligned with the axis.</description>\n<example>With red markers in column 5, set every cell in column 5 to red so the column becomes a continuous red stripe. With red markers in row 3, set every cell in row 3 to red so the row becomes a continuous red stripe.</example>\n</note3>\n\n<note4>\n<description>Handle multiple marker lines independently: there can be several marker rows or columns scattered across the grid. Apply the same fill rule to each marker line you identified, leaving other rows/columns unchanged.</description>\n<example>If red markers appear in columns 2 and 7, fill both column 2 and column 7 entirely with red. If red markers appear in rows 1 and 5, fill both row 1 and row 5 entirely with red.</example>\n</note4>\n\n<note5>\n<description>Do not overwrite other non-background colors when filling; the fill should replace only background cells. If a marker line would cross an already non-background pixel of a different color, keep that pixel as-is and only fill background cells.</description>\n<example>When filling a row with red, if a green pixel already sits in that row, leave the green pixel unchanged and set only the blue (background) cells to red. This preserves other distinct objects while making the marker lines uniform.</example>\n</note5>","<note1>\n<description>Look for a color that appears only a few times and is always aligned with the same axis (all occurrences share the same column or the same row). That alignment is usually the clue to the transformation: the rule acts along that axis rather than mixing rows and columns.</description>\n<example>Imagine a mostly-gray grid where a single red pixel appears in column 4 at several different rows. Because all red pixels share column 4, treat column 4 as a candidate \"stripe\" to inspect further. If instead blue pixels all appear in row 2, treat row 2 as a candidate stripe.</example>\n</note1>\n\n<note2>\n<description>Decide which axis to use by testing both directions: check whether the rare color's occurrences are confined to one column or one row. The correct axis is the one where the rare color's occurrences are perfectly aligned and repeated.</description>\n<example>Given a grid with green pixels only in column 7 and scattered elsewhere, pick the column axis. Conversely, if yellow pixels only appear in row 5, pick the row axis. If neither direction shows perfect alignment, re-check counts and positions before proceeding.</example>\n</note2>\n\n<note3>\n<description>Extend the identified stripe across the entire grid along its axis: fill every cell in that column (for a vertical stripe) or every cell in that row (for a horizontal stripe) with the stripe color. This produces a continuous band spanning the whole grid in that direction.</description>\n<example>If you selected column 4 as the stripe, change every cell in column 4 to the stripe color so the column becomes uniform top-to-bottom. If you selected row 2, change every cell in row 2 to the stripe color so the row becomes uniform left-to-right.</example>\n</note3>\n\n<note4>\n<description>When you extend the stripe, do not overwrite other non-background colors: only replace background cells. Other distinct colored pixels that are not the stripe color should remain in place so they act as anchors or obstacles.</description>\n<example>Suppose a column you plan to fill contains a few blue pixels among background cells; after filling, those blue pixels should still be blue while background cells in that column become the stripe color. This preserves the relative positions of other objects.</example>\n</note4>\n\n<note5>\n<description>Use simple heuristics to pick the stripe: the stripe color is typically rare and aligned, while the background is the most common color. If multiple colors appear, prefer the one whose occurrences are perfectly aligned in a single column or row.</description>\n<example>If one color appears dozens of times scattered across the grid and another color appears only a handful of times all in one column, choose the latter as the stripe. Avoid choosing the dominant background color as the stripe—focus on the rare, aligned color.</example>\n</note5>","<note1>\n<description>Start by separating background from the meaningful colors: the background is the color that fills most cells, and the other colors are the candidates for transformation. Focusing on a small set of colors reduces the search space and highlights which pixels are driving the change.</description>\n<example>Imagine a 6×6 grid mostly filled with color A, with a few scattered pixels of colors B and C. Treat A as the background and consider only B and C as the active colors to explain the output changes. This makes it easier to ask which of B or C is being copied or propagated.</example>\n</note1>\n\n<note2>\n<description>Count the occurrences of each non-background color and look for a color that appears exactly once (a singleton). A singleton often acts as an anchor or marker that determines where a larger change will occur.</description>\n<example>In a grid with three rows, suppose color X appears once and color Y appears many times. That single X is a strong candidate for the special marker: its position is likely used to decide where to apply a global operation, while Y is the color to be propagated.</example>\n</note2>\n\n<note3>\n<description>Decide the propagation direction by checking alignment: if the singleton sits in a column where the other color appears repeatedly in that column, the natural operation is a vertical fill (fill that column). If the singleton sits in a row where the other color appears repeatedly across that row, the natural operation is a horizontal fill (fill that row).</description>\n<example>For example, if the singleton is in column 4 and you see the other color in column 4 at several different rows, try filling column 4 with the other color. Conversely, if the singleton is in row 2 and the other color appears in row 2 at many columns, try filling row 2 with that color.</example>\n</note3>\n\n<note4>\n<description>When applying the fill, propagate the non-singleton color across the entire chosen axis, but do not overwrite the singleton cell itself. The singleton should remain its original color as an anchor; the rest of the axis becomes the other color.</description>\n<example>If you choose column 4 as the axis and the other color is Z, set every cell in column 4 to Z except the cell that held the singleton (which stays its original color). This preserves the marker while producing the full stripe of the other color.</example>\n</note4>\n\n<note5>\n<description>Validate your choice by checking consistency: the singleton should be unique and the chosen axis should align with the repeated color in the examples. If multiple singletons exist, prefer the one that lies in an axis already occupied by the other color; if no clear axis exists, consider the alternative axis.</description>\n<example>Suppose there are two singleton colors but only one sits in a column where the other color already appears repeatedly — pick that one and perform the vertical fill. If both singletons are isolated and neither axis is aligned, re-check which color is the true background and re-evaluate counts and alignments before deciding.</example>\n</note5>","<note1>\n<description>Separate the dominant background color from the small set of other colors that appear only a few times. Those rare colors are usually the \"signals\" the task uses to decide where to act. Identifying them first reduces the problem to handling a few special colors rather than the whole grid.</description>\n<example>Imagine a grid that is mostly gray with a handful of red and blue pixels scattered. Treat gray as background and list red and blue as the candidate signals; you will only need to reason about how red and blue are arranged, not about the gray area.</example>\n</note1>\n\n<note2>\n<description>Count how many times each rare color appears and check whether that count is the same for two different colors. If two colors both appear the same small number of times, that number is often the key size parameter used by the transformation (for example, it can indicate how many rows or columns to affect).</description>\n<example>For instance, if red appears exactly three times and blue also appears exactly three times, that \"3\" is a strong candidate for the size to use when creating horizontal or vertical bands.</example>\n</note2>\n\n<note3>\n<description>Decide which of the two equal-frequency colors is used to paint stripes: one color will be the stripe color and the other will act as anchors that must remain unchanged. A reliable way to pick the stripe color is to look for the color that appears in multiple rows (or multiple columns) — that color is typically the one extended into full rows or columns.</description>\n<example>If green occurs in several different rows while orange only appears in a few isolated rows, try using green to fill entire rows and keep orange pixels in place; if the result matches the examples, you have the correct choice.</example>\n</note3>\n\n<note4>\n<description>When you apply the stripe color, do it row-wise or column-wise depending on the orientation that matches the examples: paint every cell in the selected rows (or columns) with the stripe color, but do not overwrite the anchor color pixels. This produces full horizontal (or vertical) bands that respect existing anchor pixels.</description>\n<example>On a small grid, if you choose to paint rows, set every cell in each selected row to the stripe color except where an anchor color already sits; the anchors stay visible inside those painted rows.</example>\n</note4>\n\n<note5>\n<description>Validate your hypothesis by checking counts and preservation: the number of painted rows (or columns) should equal the common count you found, and no anchor pixels should be changed. If counts or preserved pixels don't match the examples, swap which color you treat as stripe vs. anchor and re-check.</description>\n<example>If your first attempt paints 4 rows but the examples show 3 painted rows, try choosing the other rare color as the stripe or re-evaluate whether the anchors should be preserved; the correct pairing will reproduce the training examples' counts and preserved pixels.</example>\n</note5>","<note1>\n<description>Look for a single color that appears repeatedly in the same column across many rows — that color is usually the \"anchor\" or marker. This anchor is distinct from the dominant background and from other sparse colors. Finding that column is the first step because it tells you where to focus.</description>\n<example>Imagine a grid where a single column contains the color X at several different rows while the rest of the grid is mostly Y. That column is the anchor: mark its column index and treat X as the candidate color to use for the transformation.</example>\n</note1>\n\n<note2>\n<description>Decide the propagation direction by checking the examples: does the anchor color appear as whole rows (horizontal stripes) or as vertical stripes in the outputs? The examples will show whether you should copy the anchor along rows or along columns. Use that consistent direction when you apply the rule.</description>\n<example>If the examples show that the anchor color becomes full rows in the output, then you should make entire rows that contain the anchor in the input become that color across all columns; if they show full columns, you would instead fill entire columns.</example>\n</note2>\n\n<note3>\n<description>Identify the second color that appears as isolated single pixels (not as a column) — this is the \"marker\" to be removed. The rule usually removes these markers by replacing them with the background color (the most common color in the grid). Treat this color as noise to be erased, not as a new anchor.</description>\n<example>For instance, if you see a few scattered pixels of color Z while the rest of the grid is color Y, then those Z pixels are markers: convert them to Y so they disappear from the output.</example>\n</note3>\n\n<note4>\n<description>Apply the propagation step: for every row that contains the anchor color, fill that entire row with the anchor color (in the chosen direction). Do this for all rows that contain the anchor, not just the rows where the anchor is most frequent. This creates the horizontal stripes seen in the examples.</description>\n<example>If color X appears in rows 2, 5 and 9, then in the output you should set all cells in rows 2, 5 and 9 to X across the grid (except where other rules say to overwrite them).</example>\n</note4>\n\n<note5>\n<description>After propagation, remove the marker pixels by converting them to the background color. If a marker lies in a row you filled with the anchor, check whether the examples preserve or overwrite such cells — follow that precedence. Also verify that the anchor column itself is preserved in the same column across rows.</description>\n<example>Suppose a marker Z sits in a row you decided to fill with X; if the examples show that markers are erased regardless of row, then convert that Z to the background color Y. If examples instead keep anchor rows intact, do not overwrite those cells.</example>\n</note5>","<note1>\n<description>Look for the two non-background colors that appear only a few times. One of them typically appears in many rows (row-aligned) and the other in many columns (column-aligned); the one that is aligned across rows is usually the candidate to be extended.</description>\n<example>Imagine a mostly gray grid with blue pixels scattered across many rows but always in the same column, and red pixels scattered down many columns but always in the same row. The blue color is row-aligned (it appears in many rows at the same column) and the red color is column-aligned (it appears in many columns at the same row). That alignment tells you which color will be propagated.</example>\n</note1>\n\n<note2>\n<description>Decide the propagation axis by checking alignment: if the candidate color appears at least once in many different rows at the same column index, treat it as a row-wise feature; if it appears at least once in many different columns at the same row index, treat it as a column-wise feature.</description>\n<example>For example, if you see green pixels at (row 1,col 4), (row 5,col 4), (row 9,col 4) — green is row-aligned and should be extended horizontally. If you see yellow pixels at (row 3,col 1), (row 3,col 6), (row 3,col 10) — yellow is column-aligned and should be extended vertically.</example>\n</note2>\n\n<note3>\n<description>Apply the propagation: for a row-aligned color, fill every cell in each of its rows with that color; for a column-aligned color, fill every cell in each of its columns with that color. Do this for all rows/columns where the color appears at least once.</description>\n<example>If blue is found in rows 2, 7 and 12 (all in column 5), then set every cell in rows 2, 7 and 12 to blue across the full width. If red is found in columns 4 and 9 (both in row 8), then set every cell in columns 4 and 9 to red across the full height.</example>\n</note3>\n\n<note4>\n<description>Do not overwrite other distinct colors when you propagate. Only replace background cells (or cells that are the same as the propagated color); leave any other special color pixels untouched so they remain visible.</description>\n<example>Suppose you are filling blue rows but encounter an orange pixel in one of those rows — keep the orange pixel as-is and fill the remaining cells in that row with blue. This preserves the original special pixels while extending the background color.</example>\n</note4>\n\n<note5>\n<description>Use simple counts and tie-breakers if needed: pick the color that is repeated across many rows (or many columns) as the propagating color, and prefer a color that occurs at least twice to avoid noise. If both colors appear in multiple rows/columns, choose the one that is more consistently aligned (more distinct rows/columns or more occurrences).</description>\n<example>If both purple and teal appear multiple times but purple appears in 10 different rows while teal appears only in 2 rows, choose purple to propagate. If a color appears only once, treat it as noise and do not propagate it.</example>\n</note5>","<note1>\n<description>Look for the background color first: it is the color that fills most cells and should be treated as \"empty\" space. The other colors are the seeds that drive the transformation, so separate them from the background.</description>\n<example>Imagine a grid mostly filled with color A and only a few B and C pixels scattered around. Treat A as background and list the coordinates of every B and C — those coordinates are the only places where the output differs from the input.</example>\n</note1>\n\n<note2>\n<description>Count how many times each non-background color appears. A color that appears exactly twice is special: its two occurrences usually indicate a horizontal span to be used (the two columns between them).</description>\n<example>If color X appears at (r1,c1) and (r2,c2), then the span to consider is columns c1..c2 (inclusive). That span will be the target area for a horizontal operation in the output.</example>\n</note2>\n\n<note3>\n<description>Once you have a horizontal span (the two columns), extend that color across the entire row at the other special color's row. In other words, paint the full row that contains the other special color using the span's color.</description>\n<example>Suppose X is at columns 2 and 6 and Y is at row 7. The rule fills row 7 with X across columns 2..6 (overwriting background and any other colors in those cells).</example>\n</note3>\n\n<note4>\n<description>If a color appears only once, treat it as a vertical seed: extend that color up and down the same column until you hit the grid boundary (or until another non-background pixel blocks you). This creates a continuous vertical stripe of that color.</description>\n<example>A single Z at (r,c) becomes a vertical line: set every cell (i,c) for i from the top to the bottom (except where a blocking pixel sits) to Z, producing a full column of Z in the output.</example>\n</note4>\n\n<note5>\n<description>When you apply these operations, preserve the special marker pixels (they are not overwritten) and apply the row- and column-fill rules consistently across the grid. If a fill would pass over a different special pixel, treat that pixel as a blocker (do not overwrite it) — the fill stops at or before that cell.</description>\n<example>If you are filling a row with color X but encounter a Y at some column, leave Y unchanged and stop the X fill at that column; apply the same rule for every row/column fill you perform.</example>\n</note5>","<note1>\n<description>Find the background by frequency: the color that fills most cells is usually the background and should be ignored when looking for the rule. Focusing on the other colors reduces noise and reveals the few meaningful pixels that drive the transformation.</description>\n<example>Imagine a grid where 90% of cells are color A and a handful are colors B and C. Treat A as background; list the coordinates of B and C only. This makes it easy to see whether B or C is being used as a template or a marker.</example>\n</note1>\n\n<note2>\n<description>Look for a color that appears in many rows but always in the same column(s) — a vertical alignment. That color often acts as a template: its column positions (or the union of those columns) are what the rule copies to other rows.</description>\n<example>Suppose color X appears in rows 2, 5 and 8 and each time it sits in column 7. X is vertically aligned and likely the template. Record the column(s) where X occurs in each row before deciding how to apply it.</example>\n</note2>\n\n<note3>\n<description>Find the marker color(s): a color that appears only a few times and is not aligned vertically. These sparse pixels often indicate which rows should receive the template. The marker is typically not the background and is much less frequent than the template.</description>\n<example>In a grid where color Y appears only three times, and those Ys are scattered across different rows, treat Y as a marker. Each row that contains at least one Y is a candidate row to be changed.</example>\n</note3>\n\n<note4>\n<description>Apply the template to each marker row by filling the template's column(s) across that entire row with the template color. Do this for every row that contains a marker; leave other rows unchanged unless they also contain a marker.</description>\n<example>If the template color X occupies column 7 in several rows and row 4 contains a single marker Y, then set every cell in row 4 to X (except where another non-background color must be preserved). Repeat for each marker-containing row.</example>\n</note4>\n\n<note5>\n<description>When multiple colors could be templates or markers, prefer the one that is consistently aligned (same column across multiple rows) as the template and the one that is rare as the marker. Also be careful not to overwrite other non-background colors that are not part of the marker/template pair.</description>\n<example>If both X and Z appear but X appears in the same column in many rows while Z is scattered, choose X as the template and the scattered Z as the marker. If a row contains both a marker and another non-background color, preserve that other color and only apply the template to the marker's column(s).</example>\n</note5>","<note1>\n<description>Look for a color that appears exactly twice and lies in the same column — that pair usually defines a vertical axis (the middle column) that the transformation will use. This axis is the reference for other operations because its column position is consistent across examples.</description>\n<example>Imagine a grid where the only non-background color appears at (r1,c) and (r2,c). Those two pixels tell you the axis is column c; you should treat that column as special (the “center”) when deciding where to apply changes.</example>\n</note1>\n\n<note2>\n<description>Count how many times each other non-background color appears and note their alignment: a color that appears multiple times in the same column is a vertical stripe candidate; a color that appears multiple times in the same row is a horizontal stripe candidate. The count and alignment (same column vs same row) determine the orientation of the stripe.</description>\n<example>If color A appears at (r1,c1), (r2,c1), (r3,c1) then A is a vertical stripe (column c1). If color B appears at (r1,c1), (r1,c2), (r1,c3) then B is a horizontal stripe (row r1).</example>\n</note2>\n\n<note3>\n<description>Decide which color is used to draw the stripe by comparing counts: the stripe color is the one that occurs more than once and is aligned (either in a column or a row). If two colors each occur multiple times, prefer the one that is aligned and whose occurrences are the most numerous or clearly form a contiguous band.</description>\n<example>Given two colors, each appearing three times, but one of them all in one column while the other is scattered, choose the column-aligned color as the stripe to be extended across the whole grid.</example>\n</note3>\n\n<note4>\n<description>Extend the chosen stripe to the grid boundary in its orientation: if it’s a vertical stripe, fill that entire column with the stripe color; if it’s a horizontal stripe, fill that entire row with the stripe color. This turns a small aligned group into a full stripe that spans the grid.</description>\n<example>If the stripe is column c, set every cell (r,c) to the stripe color for all rows r. If the stripe is row r, set every cell (r,c) to the stripe color for all columns c.</example>\n</note4>\n\n<note5>\n<description>When you draw the stripe, do not overwrite the two-occurrence axis pixels or any other distinct markers — treat them as anchors that must remain unchanged. Also be careful not to confuse a single isolated pixel with a true stripe: require alignment and multiple occurrences before extending.</description>\n<example>If the axis color sits at (r0,c0) and (r1,c0), leave those two pixels as they are; only paint the stripe color into cells that are not those anchor pixels. A common pitfall is to extend a single isolated pixel — only extend when the color appears multiple times in the same row or column.</example>\n</note5>","<note1>\n<description>Look for a color that appears exactly twice; those two pixels are usually the endpoints of a straight line in the output. This is effective because a single pair of identical, non-background pixels is the simplest signal that the task wants you to connect them.</description>\n<example>Imagine a mostly gray grid with two red pixels at (row 2, col 5) and (row 8, col 5). Those two red pixels are the only reds in the grid, so they are the likely endpoints to act on.</example>\n</note1>\n\n<note2>\n<description>Check the alignment of the two endpoints: if they share the same row, the connection is horizontal; if they share the same column, the connection is vertical. The line to draw is the straight straight line between those two coordinates.</description>\n<example>If the two endpoints are at (3,4) and (3,9), they lie on the same row (row 3), so you should consider a horizontal segment from column 4 through column 9 on that row. If they were at (6,2) and (12,2), you would consider a vertical segment from row 6 through row 12 in column 2.</example>\n</note2>\n\n<note3>\n<description>Fill every cell along that straight line (inclusive of the endpoints) with the endpoint color, overwriting whatever was there. This produces a continuous stripe that spans the gap between the two endpoints.</description>\n<example>Using the red endpoints in the previous example, change every cell in row 3 from column 4 to 9 to red, replacing background or other colors on that segment so the endpoints become one continuous red line.</example>\n</note3>\n\n<note4>\n<description>Do not alter cells outside the chosen straight segment. Other colored pixels elsewhere in the grid should remain unchanged; the transformation is local to the straight line connecting the two endpoints.</description>\n<example>If there is a blue pixel somewhere else in the grid, leave it as is. Only the cells along the horizontal or vertical line between the two red endpoints are converted to red.</example>\n</note4>\n\n<note5>\n<description>When multiple non-background colors exist, pick the color that appears exactly twice as the one to connect. If more than one color occurs twice, prefer the pair that yields a clean straight-line connection (same row or same column) and then apply the fill rule.</description>\n<example>Suppose green appears twice in the same column and yellow appears twice in the same row; both are candidates, but you should choose the pair that is aligned and then draw the straight line between them. A common pitfall is to choose a color that appears many times — that usually indicates it is background and not the endpoint pair.</example>\n</note5>","<note1>\n<description>Find the two minority colors and treat them as the two actors. One color will act as a \"marker\" (it appears in a regular, repeatable way) and the other as the \"fill\" (it appears in scattered positions that are candidates for change). Recognizing these roles reduces the task to a simple propagation operation.</description>\n<example>Imagine a grid with mostly gray cells, a few red pixels scattered, and several blue pixels that all lie on the same rows. If blue appears repeatedly at the same rows and red appears at a few isolated rows, label blue as the marker and red as the candidate to be propagated.</example>\n</note1>\n\n<note2>\n<description>Check alignment: determine whether the marker pixels share a column or share a row. The axis of alignment (vertical vs horizontal) tells you whether to propagate along rows or along columns. This is the key decision that determines the direction of the fill.</description>\n<example>If all marker pixels are in the same column, treat them as vertical markers and consider filling across rows; if they all lie in the same row, treat them as horizontal markers and consider filling down columns. For instance, blue pixels in column 4 suggest a vertical pattern and so you should examine rows for changes.</example>\n</note2>\n\n<note3>\n<description>Propagate the marker color along the orthogonal axis: for each row that contains a marker, paint the entire row with the marker color (or for each column that contains a marker, paint the entire column). This converts a sparse set of markers into full stripes aligned with the grid.</description>\n<example>Given a vertical marker column, every row that has at least one marker pixel becomes entirely that marker color. Conversely, a horizontal marker row would turn into a full-width stripe of that color.</example>\n</note3>\n\n<note4>\n<description>When you perform the fill, do not overwrite other non-background colors that are not the marker; those colors act as blockers and remain unchanged. Only background cells are replaced by the marker color when you fill a row or column.</description>\n<example>If a row contains a marker and also a special green pixel, fill the background cells in that row with the marker color but leave the green pixel intact. The blocker color preserves its original position in the result.</example>\n</note4>\n\n<note5>\n<description>After filling, verify consistency: the number and alignment of filled rows/columns should match the pattern of the marker pixels in the input (each marker row/column maps to one full stripe). If multiple candidate colors exist, choose the one that forms the consistent alignment (same row or same column) as the marker.</description>\n<example>If there are three marker rows in the input, you should end up with three full rows of the marker color in the output (unless blocked). If you see a color that appears repeatedly in a single column, that is the marker to use for the orthogonal propagation.</example>\n</note5>","<note1>\n<description>Look for a color that appears multiple times in the same column. When a color is repeated down one column, that column is the anchor for a transformation: the repeated color is used to paint that entire column in the output. This is effective when one color is clearly aligned vertically in the input.</description>\n<example>Imagine a grid where color A appears at (row 2, col 4) and (row 7, col 4). Treat column 4 as the anchor column: in the output you would expect column 4 to be filled with color A (every cell in that column becomes A), regardless of other colors elsewhere.</example>\n</note1>\n\n<note2>\n<description>Use the topmost and bottommost occurrences of the anchor color to define a contiguous row interval. The rows between those two extremes (inclusive) are the rows that receive the anchor color as horizontal stripes. This converts a vertical alignment into a horizontal band.</description>\n<example>If the anchor color A appears at rows 3 and 9 in the same column, the rows 3 through 9 (inclusive) are the target rows. In the output those rows will be painted with color A across their full width, forming a horizontal band.</example>\n</note2>\n\n<note3>\n<description>Do not overwrite other non-background pixels when you paint the anchor color. Any cell that already contains a different non-background color in the input should remain that color in the output; only background cells are replaced by the anchor color. This preserves other markers that the rule should not erase.</description>\n<example>Suppose row 5 falls inside the band but already has a different color B at column 2. When you paint the band with A, leave column 2 as B and only change the background cells to A. The result is a band of A with B preserved at that column.</example>\n</note3>\n\n<note4>\n<description>Apply the rule independently for each column that contains the anchor color. If the anchor appears in multiple columns, perform the same vertical→horizontal banding for each column separately; bands may overlap and simply coexist (with preserved non-background pixels taking precedence). This handles multiple parallel anchors across the grid.</description>\n<example>If color A appears at column 1 and column 6, create a band for column 1 using its top/bottom rows and a separate band for column 6 using its top/bottom rows. Where bands cross, background cells become A and any non-background cells remain unchanged.</example>\n</note4>\n\n<note5>\n<description>Choose the anchor color by looking for a color that is repeated in the same column (not the background). Prefer the color that forms a clear vertical alignment; if more than one color repeats in a column, the one that repeats most clearly (or the one that is not the dominant background) is usually the intended anchor. Avoid treating the most frequent background color as the anchor.</description>\n<example>Given a grid where color X appears several times in column 3 and color Y appears only once, pick X as the anchor. Compute X's topmost and bottommost occurrences in that column, create the horizontal band for X, and leave Y and background pixels untouched. A common pitfall is to pick the background color or to overwrite non-background markers—preserve them.</example>\n</note5>","<note1>\n<description>First separate background from signal: find the color that fills most cells and the small set of other colors that appear only a few times. Those rare colors are the likely \"seeds\" that drive the transformation.</description>\n<example>Imagine a grid of mostly color A with three isolated pixels of color B. Treat A as background and B as the candidate seed color to track; you will see whether B is copied or extended in the output.</example>\n</note1>\n\n<note2>\n<description>Count and classify the seed colors by frequency. A color that appears many times (often many times) usually indicates a pattern to propagate, while a color that appears only once (or very few times) often acts as a blocker or anchor.</description>\n<example>For example, if color X appears 10 times and color Y appears once, expect X to be the thing that gets copied or extended, and Y to be a special pixel that should remain unchanged or mark a boundary.</example>\n</note2>\n\n<note3>\n<description>Check alignment of the seed pixels: if all occurrences of a color share the same row, that color is being extended horizontally; if they share the same column, expect vertical extension. The orientation tells you whether to paint whole rows or whole columns.</description>\n<example>If color C appears at (r, c1), (r, c2) and (r, c3), try filling row r with C; if color D appears at (r1, c), (r2, c) and (r3, c), try filling column c with D.</example>\n</note3>\n\n<note4>\n<description>When you extend a seed, do not overwrite other non-background pixels: treat those as anchors or blockers. The propagation typically fills only background cells and leaves anchor pixels in place.</description>\n<example>Suppose you want to fill a column with color E but encounter a single pixel of color F in that column; paint the background cells in that column with E but keep F unchanged so it remains a boundary.</example>\n</note4>\n\n<note5>\n<description>Apply the rule systematically: for each seed color, extend it along its detected axis (row or column) across the grid, skipping over anchor pixels. If multiple seeds exist, repeat for each; conflicts are resolved by preserving anchors and leaving background elsewhere.</description>\n<example>Given several seed rows and a few anchor pixels, paint each seed row across its full width with that seed color but stop at or around anchor pixels; this reproduces the pattern seen in many ARC tasks where sparse colors are propagated along aligned axes.</example>\n</note5>"],"string":"[\n \"<note1>\\n<description>Look for the dominant (background) color and the minority colors. Often one minority color appears exactly once and acts as a “marker” or pivot; the other minority colors are the ones that get transformed. Recognizing these roles reduces the problem to a small set of objects to reason about.</description>\\n<example>Imagine a grid that is mostly color A, with a single pixel of color B and several scattered pixels of color C. Treat A as the background, B as the marker, and C as the candidate to be changed. Counting occurrences (A: many, B: one, C: many) helps you decide which color will be copied or propagated.</example>\\n</note1>\\n\\n<note2>\\n<description>Compare the positions of the scattered pixels: are they all in the same column, same row, or aligned in a simple pattern? That alignment determines whether the rule is a row-wise or column-wise operation. The axis of alignment tells you the direction in which the marker color will be propagated.</description>\\n<example>If several C pixels all lie in column X, that suggests a vertical (column) rule: the marker color will be copied along that column. If the C pixels lie in the same row, expect a horizontal (row) rule instead. Use this to pick the correct orientation before applying any fill.</example>\\n</note2>\\n\\n<note3>\\n<description>Use the unique marker pixel as the anchor: its row and column are the reference for where to apply the propagation. The marker’s coordinates (r,c) are the natural candidates to be extended along the axis indicated by the scattered pixels. Thinking in terms of (r,c) keeps the rule consistent across examples.</description>\\n<example>Suppose the marker is at (r,c) and you have scattered C pixels in column c. Then the natural operation is to extend the marker color along column c (above and/or below r) rather than along the scattered pixels’ rows. If the scattered pixels share a row r, the anchor row r is the natural place to propagate horizontally.</example>\\n</note3>\\n\\n<note4>\\n<description>When you propagate the marker color, do not overwrite other non-background pixels: preserve the scattered pixels and any other distinct colors. The propagation fills only background cells along the chosen axis and leaves marker pixels and other objects intact. This keeps the original structure while applying the transformation.</description>\\n<example>Imagine extending the marker color down a column but encountering a C pixel in that column at some row; leave that C unchanged and only replace the surrounding background cells with the marker color. The result is a continuous vertical stripe of the marker color that respects the original non-background pixels.</example>\\n</note4>\\n\\n<note5>\\n<description>Apply the same propagation rule everywhere the alignment pattern appears: if the scattered pixels repeat at multiple rows (or columns), repeat the fill at each occurrence. After applying the rule, check that every instance of the scattered color has been handled consistently and that no other colors were changed.</description>\\n<example>If C appears in several rows but always in the same column, perform the column-wise fill for each row where C is present. Finally, scan the grid to confirm that every original C was accounted for and that the marker color now forms the expected stripes or rows without disturbing other colors.</example>\\n</note5>\",\n \"<note1>\\n<description>Look for a color that appears in many rows but in different columns — that color is a row-seed. When a color’s occurrences are scattered across rows (not forming a single connected object), it usually signals a row-based operation rather than a column-based one.</description>\\n<example>Imagine a 6×6 grid where color A appears somewhere in rows 1, 3 and 5, but never in the same column each time. That pattern suggests A is a row-seed: treat each of those rows as candidates for a row-level change rather than treating A as a single object to move.</example>\\n</note1>\\n\\n<note2>\\n<description>Decide the orientation of propagation by checking whether the seed pixels share the same column index. If they all lie in one column, the rule is column-wise; if they lie in different columns, the rule is row-wise. This choice determines whether you extend vertically or horizontally.</description>\\n<example>If color B appears at (row1,col4), (row2,col4), (row3,col4) — same column — you should expect a vertical propagation (a column change). If color C appears at (row1,col1), (row3,col5), (row4,col2) — different columns — you should expect horizontal propagation (row changes).</example>\\n</note2>\\n\\n<note3>\\n<description>When you propagate, fill the entire line (the whole row or the whole column) with the seed color. The operation is \\\"paint the entire row/column\\\" rather than copying only the seed pixel’s neighborhood.</description>\\n<example>With a row-seed at (r,c), set every cell in row r to that seed color. With a column-seed at (r,c), set every cell in column c to that color. This produces full horizontal or vertical stripes in the output.</example>\\n</note3>\\n\\n<note4>\\n<description>Apply the same propagation independently for each distinct seed color and for each occurrence of that color. Multiple seeds can produce multiple stripes; overlapping stripes will simply coincide in color.</description>\\n<example>If color D appears in rows 2 and 7, paint both row 2 and row 7 entirely with D. If color E appears in several columns, paint each of those columns entirely with E. The final grid is the union of these painted lines.</example>\\n</note4>\\n\\n<note5>\\n<description>Do not overwrite other special pixels — treat other non-background colors as obstacles that should remain. Only replace background cells when painting lines; leave any distinct colored pixels untouched.</description>\\n<example>If a row is to be painted with color F but that row already contains a cell of color G, keep G in place and only change the background cells to F. A common pitfall is to erase or move these anchor pixels instead of preserving them.</example>\\n</note5>\",\n \"<note1>\\n<description>Look for a single non-background color that appears repeatedly in the same column(s). That color usually acts as an anchor or marker: its column (or columns) is the key feature the transformation uses.</description>\\n<example>Imagine a grid where most cells are gray but blue appears only in column 4 at several different rows. Treat blue as the anchor color and note column 4 as the anchor column to investigate further.</example>\\n</note1>\\n\\n<note2>\\n<description>Check whether the anchor color is copied along the orthogonal axis: in many puzzles the anchor is extended into full rows or full columns. Determine which axis is used by comparing input and output examples.</description>\\n<example>For example, if blue appears in column 4 in the input and the output shows entire rows filled with blue, then the rule is \\\"copy the anchor into full rows\\\" rather than copying it into columns or scattered pixels.</example>\\n</note2>\\n\\n<note3>\\n<description>Decide how the anchor is selected when multiple colors are present: pick the color that is most consistent across examples (most occurrences or most aligned). Use simple counts and alignment checks to disambiguate.</description>\\n<example>If red occurs 10 times in one column and green occurs 3 times scattered, red is the better candidate for the anchor; prefer the color that appears repeatedly in the same column or with a regular spacing.</example>\\n</note3>\\n\\n<note4>\\n<description>When applying the extension, preserve other non-background colors: do not overwrite distinct colored pixels that are not the anchor. The anchor fills only background cells along the chosen axis.</description>\\n<example>If a row is supposed to be filled with blue but already contains a red pixel, leave that red pixel unchanged and fill the remaining background cells with blue; do not replace the red.</example>\\n</note4>\\n\\n<note5>\\n<description>Handle multiple anchor columns or anchors by applying the same extension independently to each anchor column; also confirm the transformation is global (everywhere along the chosen axis) rather than local to a small region.</description>\\n<example>If the anchor color appears in both column 2 and column 7, copy that color into full rows for each of those columns (or apply the same rule for each anchor column). If the examples show the same operation repeated for every anchor column, repeat it everywhere.</example>\\n</note5>\",\n \"<note1>\\n<description>Look for a single color that appears as isolated pixels across many rows or columns. That color is usually the \\\"marker\\\" that determines where to apply a global change; it is distinct from the dominant background and from the other small, scattered color(s).</description>\\n<example>Imagine a grid mostly filled with blue, with a few red pixels scattered in different rows. Those red pixels are the markers: they are not background and they repeat across rows, so they are the ones you should focus on when deciding where to change the grid.</example>\\n</note1>\\n\\n<note2>\\n<description>Decide the orientation of the rule by checking alignment: if the marker pixels share a column across many rows, the operation is column-wise; if they share a row across many columns, it is row-wise. The transformation usually acts along the axis parallel to that alignment.</description>\\n<example>If red pixels appear in column 5 at rows 2, 6 and 9, treat column 5 as the marker axis and plan a column-wise operation. If instead red pixels appear in row 3 at columns 1, 4 and 7, treat row 3 as the marker axis and plan a row-wise operation.</example>\\n</note2>\\n\\n<note3>\\n<description>When you have a marker axis, apply a uniform fill to the entire line (all cells in that row or column) with the marker color. This turns a sparse set of marker pixels into a continuous stripe aligned with the axis.</description>\\n<example>With red markers in column 5, set every cell in column 5 to red so the column becomes a continuous red stripe. With red markers in row 3, set every cell in row 3 to red so the row becomes a continuous red stripe.</example>\\n</note3>\\n\\n<note4>\\n<description>Handle multiple marker lines independently: there can be several marker rows or columns scattered across the grid. Apply the same fill rule to each marker line you identified, leaving other rows/columns unchanged.</description>\\n<example>If red markers appear in columns 2 and 7, fill both column 2 and column 7 entirely with red. If red markers appear in rows 1 and 5, fill both row 1 and row 5 entirely with red.</example>\\n</note4>\\n\\n<note5>\\n<description>Do not overwrite other non-background colors when filling; the fill should replace only background cells. If a marker line would cross an already non-background pixel of a different color, keep that pixel as-is and only fill background cells.</description>\\n<example>When filling a row with red, if a green pixel already sits in that row, leave the green pixel unchanged and set only the blue (background) cells to red. This preserves other distinct objects while making the marker lines uniform.</example>\\n</note5>\",\n \"<note1>\\n<description>Look for a color that appears only a few times and is always aligned with the same axis (all occurrences share the same column or the same row). That alignment is usually the clue to the transformation: the rule acts along that axis rather than mixing rows and columns.</description>\\n<example>Imagine a mostly-gray grid where a single red pixel appears in column 4 at several different rows. Because all red pixels share column 4, treat column 4 as a candidate \\\"stripe\\\" to inspect further. If instead blue pixels all appear in row 2, treat row 2 as a candidate stripe.</example>\\n</note1>\\n\\n<note2>\\n<description>Decide which axis to use by testing both directions: check whether the rare color's occurrences are confined to one column or one row. The correct axis is the one where the rare color's occurrences are perfectly aligned and repeated.</description>\\n<example>Given a grid with green pixels only in column 7 and scattered elsewhere, pick the column axis. Conversely, if yellow pixels only appear in row 5, pick the row axis. If neither direction shows perfect alignment, re-check counts and positions before proceeding.</example>\\n</note2>\\n\\n<note3>\\n<description>Extend the identified stripe across the entire grid along its axis: fill every cell in that column (for a vertical stripe) or every cell in that row (for a horizontal stripe) with the stripe color. This produces a continuous band spanning the whole grid in that direction.</description>\\n<example>If you selected column 4 as the stripe, change every cell in column 4 to the stripe color so the column becomes uniform top-to-bottom. If you selected row 2, change every cell in row 2 to the stripe color so the row becomes uniform left-to-right.</example>\\n</note3>\\n\\n<note4>\\n<description>When you extend the stripe, do not overwrite other non-background colors: only replace background cells. Other distinct colored pixels that are not the stripe color should remain in place so they act as anchors or obstacles.</description>\\n<example>Suppose a column you plan to fill contains a few blue pixels among background cells; after filling, those blue pixels should still be blue while background cells in that column become the stripe color. This preserves the relative positions of other objects.</example>\\n</note4>\\n\\n<note5>\\n<description>Use simple heuristics to pick the stripe: the stripe color is typically rare and aligned, while the background is the most common color. If multiple colors appear, prefer the one whose occurrences are perfectly aligned in a single column or row.</description>\\n<example>If one color appears dozens of times scattered across the grid and another color appears only a handful of times all in one column, choose the latter as the stripe. Avoid choosing the dominant background color as the stripe—focus on the rare, aligned color.</example>\\n</note5>\",\n \"<note1>\\n<description>Start by separating background from the meaningful colors: the background is the color that fills most cells, and the other colors are the candidates for transformation. Focusing on a small set of colors reduces the search space and highlights which pixels are driving the change.</description>\\n<example>Imagine a 6×6 grid mostly filled with color A, with a few scattered pixels of colors B and C. Treat A as the background and consider only B and C as the active colors to explain the output changes. This makes it easier to ask which of B or C is being copied or propagated.</example>\\n</note1>\\n\\n<note2>\\n<description>Count the occurrences of each non-background color and look for a color that appears exactly once (a singleton). A singleton often acts as an anchor or marker that determines where a larger change will occur.</description>\\n<example>In a grid with three rows, suppose color X appears once and color Y appears many times. That single X is a strong candidate for the special marker: its position is likely used to decide where to apply a global operation, while Y is the color to be propagated.</example>\\n</note2>\\n\\n<note3>\\n<description>Decide the propagation direction by checking alignment: if the singleton sits in a column where the other color appears repeatedly in that column, the natural operation is a vertical fill (fill that column). If the singleton sits in a row where the other color appears repeatedly across that row, the natural operation is a horizontal fill (fill that row).</description>\\n<example>For example, if the singleton is in column 4 and you see the other color in column 4 at several different rows, try filling column 4 with the other color. Conversely, if the singleton is in row 2 and the other color appears in row 2 at many columns, try filling row 2 with that color.</example>\\n</note3>\\n\\n<note4>\\n<description>When applying the fill, propagate the non-singleton color across the entire chosen axis, but do not overwrite the singleton cell itself. The singleton should remain its original color as an anchor; the rest of the axis becomes the other color.</description>\\n<example>If you choose column 4 as the axis and the other color is Z, set every cell in column 4 to Z except the cell that held the singleton (which stays its original color). This preserves the marker while producing the full stripe of the other color.</example>\\n</note4>\\n\\n<note5>\\n<description>Validate your choice by checking consistency: the singleton should be unique and the chosen axis should align with the repeated color in the examples. If multiple singletons exist, prefer the one that lies in an axis already occupied by the other color; if no clear axis exists, consider the alternative axis.</description>\\n<example>Suppose there are two singleton colors but only one sits in a column where the other color already appears repeatedly — pick that one and perform the vertical fill. If both singletons are isolated and neither axis is aligned, re-check which color is the true background and re-evaluate counts and alignments before deciding.</example>\\n</note5>\",\n \"<note1>\\n<description>Separate the dominant background color from the small set of other colors that appear only a few times. Those rare colors are usually the \\\"signals\\\" the task uses to decide where to act. Identifying them first reduces the problem to handling a few special colors rather than the whole grid.</description>\\n<example>Imagine a grid that is mostly gray with a handful of red and blue pixels scattered. Treat gray as background and list red and blue as the candidate signals; you will only need to reason about how red and blue are arranged, not about the gray area.</example>\\n</note1>\\n\\n<note2>\\n<description>Count how many times each rare color appears and check whether that count is the same for two different colors. If two colors both appear the same small number of times, that number is often the key size parameter used by the transformation (for example, it can indicate how many rows or columns to affect).</description>\\n<example>For instance, if red appears exactly three times and blue also appears exactly three times, that \\\"3\\\" is a strong candidate for the size to use when creating horizontal or vertical bands.</example>\\n</note2>\\n\\n<note3>\\n<description>Decide which of the two equal-frequency colors is used to paint stripes: one color will be the stripe color and the other will act as anchors that must remain unchanged. A reliable way to pick the stripe color is to look for the color that appears in multiple rows (or multiple columns) — that color is typically the one extended into full rows or columns.</description>\\n<example>If green occurs in several different rows while orange only appears in a few isolated rows, try using green to fill entire rows and keep orange pixels in place; if the result matches the examples, you have the correct choice.</example>\\n</note3>\\n\\n<note4>\\n<description>When you apply the stripe color, do it row-wise or column-wise depending on the orientation that matches the examples: paint every cell in the selected rows (or columns) with the stripe color, but do not overwrite the anchor color pixels. This produces full horizontal (or vertical) bands that respect existing anchor pixels.</description>\\n<example>On a small grid, if you choose to paint rows, set every cell in each selected row to the stripe color except where an anchor color already sits; the anchors stay visible inside those painted rows.</example>\\n</note4>\\n\\n<note5>\\n<description>Validate your hypothesis by checking counts and preservation: the number of painted rows (or columns) should equal the common count you found, and no anchor pixels should be changed. If counts or preserved pixels don't match the examples, swap which color you treat as stripe vs. anchor and re-check.</description>\\n<example>If your first attempt paints 4 rows but the examples show 3 painted rows, try choosing the other rare color as the stripe or re-evaluate whether the anchors should be preserved; the correct pairing will reproduce the training examples' counts and preserved pixels.</example>\\n</note5>\",\n \"<note1>\\n<description>Look for a single color that appears repeatedly in the same column across many rows — that color is usually the \\\"anchor\\\" or marker. This anchor is distinct from the dominant background and from other sparse colors. Finding that column is the first step because it tells you where to focus.</description>\\n<example>Imagine a grid where a single column contains the color X at several different rows while the rest of the grid is mostly Y. That column is the anchor: mark its column index and treat X as the candidate color to use for the transformation.</example>\\n</note1>\\n\\n<note2>\\n<description>Decide the propagation direction by checking the examples: does the anchor color appear as whole rows (horizontal stripes) or as vertical stripes in the outputs? The examples will show whether you should copy the anchor along rows or along columns. Use that consistent direction when you apply the rule.</description>\\n<example>If the examples show that the anchor color becomes full rows in the output, then you should make entire rows that contain the anchor in the input become that color across all columns; if they show full columns, you would instead fill entire columns.</example>\\n</note2>\\n\\n<note3>\\n<description>Identify the second color that appears as isolated single pixels (not as a column) — this is the \\\"marker\\\" to be removed. The rule usually removes these markers by replacing them with the background color (the most common color in the grid). Treat this color as noise to be erased, not as a new anchor.</description>\\n<example>For instance, if you see a few scattered pixels of color Z while the rest of the grid is color Y, then those Z pixels are markers: convert them to Y so they disappear from the output.</example>\\n</note3>\\n\\n<note4>\\n<description>Apply the propagation step: for every row that contains the anchor color, fill that entire row with the anchor color (in the chosen direction). Do this for all rows that contain the anchor, not just the rows where the anchor is most frequent. This creates the horizontal stripes seen in the examples.</description>\\n<example>If color X appears in rows 2, 5 and 9, then in the output you should set all cells in rows 2, 5 and 9 to X across the grid (except where other rules say to overwrite them).</example>\\n</note4>\\n\\n<note5>\\n<description>After propagation, remove the marker pixels by converting them to the background color. If a marker lies in a row you filled with the anchor, check whether the examples preserve or overwrite such cells — follow that precedence. Also verify that the anchor column itself is preserved in the same column across rows.</description>\\n<example>Suppose a marker Z sits in a row you decided to fill with X; if the examples show that markers are erased regardless of row, then convert that Z to the background color Y. If examples instead keep anchor rows intact, do not overwrite those cells.</example>\\n</note5>\",\n \"<note1>\\n<description>Look for the two non-background colors that appear only a few times. One of them typically appears in many rows (row-aligned) and the other in many columns (column-aligned); the one that is aligned across rows is usually the candidate to be extended.</description>\\n<example>Imagine a mostly gray grid with blue pixels scattered across many rows but always in the same column, and red pixels scattered down many columns but always in the same row. The blue color is row-aligned (it appears in many rows at the same column) and the red color is column-aligned (it appears in many columns at the same row). That alignment tells you which color will be propagated.</example>\\n</note1>\\n\\n<note2>\\n<description>Decide the propagation axis by checking alignment: if the candidate color appears at least once in many different rows at the same column index, treat it as a row-wise feature; if it appears at least once in many different columns at the same row index, treat it as a column-wise feature.</description>\\n<example>For example, if you see green pixels at (row 1,col 4), (row 5,col 4), (row 9,col 4) — green is row-aligned and should be extended horizontally. If you see yellow pixels at (row 3,col 1), (row 3,col 6), (row 3,col 10) — yellow is column-aligned and should be extended vertically.</example>\\n</note2>\\n\\n<note3>\\n<description>Apply the propagation: for a row-aligned color, fill every cell in each of its rows with that color; for a column-aligned color, fill every cell in each of its columns with that color. Do this for all rows/columns where the color appears at least once.</description>\\n<example>If blue is found in rows 2, 7 and 12 (all in column 5), then set every cell in rows 2, 7 and 12 to blue across the full width. If red is found in columns 4 and 9 (both in row 8), then set every cell in columns 4 and 9 to red across the full height.</example>\\n</note3>\\n\\n<note4>\\n<description>Do not overwrite other distinct colors when you propagate. Only replace background cells (or cells that are the same as the propagated color); leave any other special color pixels untouched so they remain visible.</description>\\n<example>Suppose you are filling blue rows but encounter an orange pixel in one of those rows — keep the orange pixel as-is and fill the remaining cells in that row with blue. This preserves the original special pixels while extending the background color.</example>\\n</note4>\\n\\n<note5>\\n<description>Use simple counts and tie-breakers if needed: pick the color that is repeated across many rows (or many columns) as the propagating color, and prefer a color that occurs at least twice to avoid noise. If both colors appear in multiple rows/columns, choose the one that is more consistently aligned (more distinct rows/columns or more occurrences).</description>\\n<example>If both purple and teal appear multiple times but purple appears in 10 different rows while teal appears only in 2 rows, choose purple to propagate. If a color appears only once, treat it as noise and do not propagate it.</example>\\n</note5>\",\n \"<note1>\\n<description>Look for the background color first: it is the color that fills most cells and should be treated as \\\"empty\\\" space. The other colors are the seeds that drive the transformation, so separate them from the background.</description>\\n<example>Imagine a grid mostly filled with color A and only a few B and C pixels scattered around. Treat A as background and list the coordinates of every B and C — those coordinates are the only places where the output differs from the input.</example>\\n</note1>\\n\\n<note2>\\n<description>Count how many times each non-background color appears. A color that appears exactly twice is special: its two occurrences usually indicate a horizontal span to be used (the two columns between them).</description>\\n<example>If color X appears at (r1,c1) and (r2,c2), then the span to consider is columns c1..c2 (inclusive). That span will be the target area for a horizontal operation in the output.</example>\\n</note2>\\n\\n<note3>\\n<description>Once you have a horizontal span (the two columns), extend that color across the entire row at the other special color's row. In other words, paint the full row that contains the other special color using the span's color.</description>\\n<example>Suppose X is at columns 2 and 6 and Y is at row 7. The rule fills row 7 with X across columns 2..6 (overwriting background and any other colors in those cells).</example>\\n</note3>\\n\\n<note4>\\n<description>If a color appears only once, treat it as a vertical seed: extend that color up and down the same column until you hit the grid boundary (or until another non-background pixel blocks you). This creates a continuous vertical stripe of that color.</description>\\n<example>A single Z at (r,c) becomes a vertical line: set every cell (i,c) for i from the top to the bottom (except where a blocking pixel sits) to Z, producing a full column of Z in the output.</example>\\n</note4>\\n\\n<note5>\\n<description>When you apply these operations, preserve the special marker pixels (they are not overwritten) and apply the row- and column-fill rules consistently across the grid. If a fill would pass over a different special pixel, treat that pixel as a blocker (do not overwrite it) — the fill stops at or before that cell.</description>\\n<example>If you are filling a row with color X but encounter a Y at some column, leave Y unchanged and stop the X fill at that column; apply the same rule for every row/column fill you perform.</example>\\n</note5>\",\n \"<note1>\\n<description>Find the background by frequency: the color that fills most cells is usually the background and should be ignored when looking for the rule. Focusing on the other colors reduces noise and reveals the few meaningful pixels that drive the transformation.</description>\\n<example>Imagine a grid where 90% of cells are color A and a handful are colors B and C. Treat A as background; list the coordinates of B and C only. This makes it easy to see whether B or C is being used as a template or a marker.</example>\\n</note1>\\n\\n<note2>\\n<description>Look for a color that appears in many rows but always in the same column(s) — a vertical alignment. That color often acts as a template: its column positions (or the union of those columns) are what the rule copies to other rows.</description>\\n<example>Suppose color X appears in rows 2, 5 and 8 and each time it sits in column 7. X is vertically aligned and likely the template. Record the column(s) where X occurs in each row before deciding how to apply it.</example>\\n</note2>\\n\\n<note3>\\n<description>Find the marker color(s): a color that appears only a few times and is not aligned vertically. These sparse pixels often indicate which rows should receive the template. The marker is typically not the background and is much less frequent than the template.</description>\\n<example>In a grid where color Y appears only three times, and those Ys are scattered across different rows, treat Y as a marker. Each row that contains at least one Y is a candidate row to be changed.</example>\\n</note3>\\n\\n<note4>\\n<description>Apply the template to each marker row by filling the template's column(s) across that entire row with the template color. Do this for every row that contains a marker; leave other rows unchanged unless they also contain a marker.</description>\\n<example>If the template color X occupies column 7 in several rows and row 4 contains a single marker Y, then set every cell in row 4 to X (except where another non-background color must be preserved). Repeat for each marker-containing row.</example>\\n</note4>\\n\\n<note5>\\n<description>When multiple colors could be templates or markers, prefer the one that is consistently aligned (same column across multiple rows) as the template and the one that is rare as the marker. Also be careful not to overwrite other non-background colors that are not part of the marker/template pair.</description>\\n<example>If both X and Z appear but X appears in the same column in many rows while Z is scattered, choose X as the template and the scattered Z as the marker. If a row contains both a marker and another non-background color, preserve that other color and only apply the template to the marker's column(s).</example>\\n</note5>\",\n \"<note1>\\n<description>Look for a color that appears exactly twice and lies in the same column — that pair usually defines a vertical axis (the middle column) that the transformation will use. This axis is the reference for other operations because its column position is consistent across examples.</description>\\n<example>Imagine a grid where the only non-background color appears at (r1,c) and (r2,c). Those two pixels tell you the axis is column c; you should treat that column as special (the “center”) when deciding where to apply changes.</example>\\n</note1>\\n\\n<note2>\\n<description>Count how many times each other non-background color appears and note their alignment: a color that appears multiple times in the same column is a vertical stripe candidate; a color that appears multiple times in the same row is a horizontal stripe candidate. The count and alignment (same column vs same row) determine the orientation of the stripe.</description>\\n<example>If color A appears at (r1,c1), (r2,c1), (r3,c1) then A is a vertical stripe (column c1). If color B appears at (r1,c1), (r1,c2), (r1,c3) then B is a horizontal stripe (row r1).</example>\\n</note2>\\n\\n<note3>\\n<description>Decide which color is used to draw the stripe by comparing counts: the stripe color is the one that occurs more than once and is aligned (either in a column or a row). If two colors each occur multiple times, prefer the one that is aligned and whose occurrences are the most numerous or clearly form a contiguous band.</description>\\n<example>Given two colors, each appearing three times, but one of them all in one column while the other is scattered, choose the column-aligned color as the stripe to be extended across the whole grid.</example>\\n</note3>\\n\\n<note4>\\n<description>Extend the chosen stripe to the grid boundary in its orientation: if it’s a vertical stripe, fill that entire column with the stripe color; if it’s a horizontal stripe, fill that entire row with the stripe color. This turns a small aligned group into a full stripe that spans the grid.</description>\\n<example>If the stripe is column c, set every cell (r,c) to the stripe color for all rows r. If the stripe is row r, set every cell (r,c) to the stripe color for all columns c.</example>\\n</note4>\\n\\n<note5>\\n<description>When you draw the stripe, do not overwrite the two-occurrence axis pixels or any other distinct markers — treat them as anchors that must remain unchanged. Also be careful not to confuse a single isolated pixel with a true stripe: require alignment and multiple occurrences before extending.</description>\\n<example>If the axis color sits at (r0,c0) and (r1,c0), leave those two pixels as they are; only paint the stripe color into cells that are not those anchor pixels. A common pitfall is to extend a single isolated pixel — only extend when the color appears multiple times in the same row or column.</example>\\n</note5>\",\n \"<note1>\\n<description>Look for a color that appears exactly twice; those two pixels are usually the endpoints of a straight line in the output. This is effective because a single pair of identical, non-background pixels is the simplest signal that the task wants you to connect them.</description>\\n<example>Imagine a mostly gray grid with two red pixels at (row 2, col 5) and (row 8, col 5). Those two red pixels are the only reds in the grid, so they are the likely endpoints to act on.</example>\\n</note1>\\n\\n<note2>\\n<description>Check the alignment of the two endpoints: if they share the same row, the connection is horizontal; if they share the same column, the connection is vertical. The line to draw is the straight straight line between those two coordinates.</description>\\n<example>If the two endpoints are at (3,4) and (3,9), they lie on the same row (row 3), so you should consider a horizontal segment from column 4 through column 9 on that row. If they were at (6,2) and (12,2), you would consider a vertical segment from row 6 through row 12 in column 2.</example>\\n</note2>\\n\\n<note3>\\n<description>Fill every cell along that straight line (inclusive of the endpoints) with the endpoint color, overwriting whatever was there. This produces a continuous stripe that spans the gap between the two endpoints.</description>\\n<example>Using the red endpoints in the previous example, change every cell in row 3 from column 4 to 9 to red, replacing background or other colors on that segment so the endpoints become one continuous red line.</example>\\n</note3>\\n\\n<note4>\\n<description>Do not alter cells outside the chosen straight segment. Other colored pixels elsewhere in the grid should remain unchanged; the transformation is local to the straight line connecting the two endpoints.</description>\\n<example>If there is a blue pixel somewhere else in the grid, leave it as is. Only the cells along the horizontal or vertical line between the two red endpoints are converted to red.</example>\\n</note4>\\n\\n<note5>\\n<description>When multiple non-background colors exist, pick the color that appears exactly twice as the one to connect. If more than one color occurs twice, prefer the pair that yields a clean straight-line connection (same row or same column) and then apply the fill rule.</description>\\n<example>Suppose green appears twice in the same column and yellow appears twice in the same row; both are candidates, but you should choose the pair that is aligned and then draw the straight line between them. A common pitfall is to choose a color that appears many times — that usually indicates it is background and not the endpoint pair.</example>\\n</note5>\",\n \"<note1>\\n<description>Find the two minority colors and treat them as the two actors. One color will act as a \\\"marker\\\" (it appears in a regular, repeatable way) and the other as the \\\"fill\\\" (it appears in scattered positions that are candidates for change). Recognizing these roles reduces the task to a simple propagation operation.</description>\\n<example>Imagine a grid with mostly gray cells, a few red pixels scattered, and several blue pixels that all lie on the same rows. If blue appears repeatedly at the same rows and red appears at a few isolated rows, label blue as the marker and red as the candidate to be propagated.</example>\\n</note1>\\n\\n<note2>\\n<description>Check alignment: determine whether the marker pixels share a column or share a row. The axis of alignment (vertical vs horizontal) tells you whether to propagate along rows or along columns. This is the key decision that determines the direction of the fill.</description>\\n<example>If all marker pixels are in the same column, treat them as vertical markers and consider filling across rows; if they all lie in the same row, treat them as horizontal markers and consider filling down columns. For instance, blue pixels in column 4 suggest a vertical pattern and so you should examine rows for changes.</example>\\n</note2>\\n\\n<note3>\\n<description>Propagate the marker color along the orthogonal axis: for each row that contains a marker, paint the entire row with the marker color (or for each column that contains a marker, paint the entire column). This converts a sparse set of markers into full stripes aligned with the grid.</description>\\n<example>Given a vertical marker column, every row that has at least one marker pixel becomes entirely that marker color. Conversely, a horizontal marker row would turn into a full-width stripe of that color.</example>\\n</note3>\\n\\n<note4>\\n<description>When you perform the fill, do not overwrite other non-background colors that are not the marker; those colors act as blockers and remain unchanged. Only background cells are replaced by the marker color when you fill a row or column.</description>\\n<example>If a row contains a marker and also a special green pixel, fill the background cells in that row with the marker color but leave the green pixel intact. The blocker color preserves its original position in the result.</example>\\n</note4>\\n\\n<note5>\\n<description>After filling, verify consistency: the number and alignment of filled rows/columns should match the pattern of the marker pixels in the input (each marker row/column maps to one full stripe). If multiple candidate colors exist, choose the one that forms the consistent alignment (same row or same column) as the marker.</description>\\n<example>If there are three marker rows in the input, you should end up with three full rows of the marker color in the output (unless blocked). If you see a color that appears repeatedly in a single column, that is the marker to use for the orthogonal propagation.</example>\\n</note5>\",\n \"<note1>\\n<description>Look for a color that appears multiple times in the same column. When a color is repeated down one column, that column is the anchor for a transformation: the repeated color is used to paint that entire column in the output. This is effective when one color is clearly aligned vertically in the input.</description>\\n<example>Imagine a grid where color A appears at (row 2, col 4) and (row 7, col 4). Treat column 4 as the anchor column: in the output you would expect column 4 to be filled with color A (every cell in that column becomes A), regardless of other colors elsewhere.</example>\\n</note1>\\n\\n<note2>\\n<description>Use the topmost and bottommost occurrences of the anchor color to define a contiguous row interval. The rows between those two extremes (inclusive) are the rows that receive the anchor color as horizontal stripes. This converts a vertical alignment into a horizontal band.</description>\\n<example>If the anchor color A appears at rows 3 and 9 in the same column, the rows 3 through 9 (inclusive) are the target rows. In the output those rows will be painted with color A across their full width, forming a horizontal band.</example>\\n</note2>\\n\\n<note3>\\n<description>Do not overwrite other non-background pixels when you paint the anchor color. Any cell that already contains a different non-background color in the input should remain that color in the output; only background cells are replaced by the anchor color. This preserves other markers that the rule should not erase.</description>\\n<example>Suppose row 5 falls inside the band but already has a different color B at column 2. When you paint the band with A, leave column 2 as B and only change the background cells to A. The result is a band of A with B preserved at that column.</example>\\n</note3>\\n\\n<note4>\\n<description>Apply the rule independently for each column that contains the anchor color. If the anchor appears in multiple columns, perform the same vertical→horizontal banding for each column separately; bands may overlap and simply coexist (with preserved non-background pixels taking precedence). This handles multiple parallel anchors across the grid.</description>\\n<example>If color A appears at column 1 and column 6, create a band for column 1 using its top/bottom rows and a separate band for column 6 using its top/bottom rows. Where bands cross, background cells become A and any non-background cells remain unchanged.</example>\\n</note4>\\n\\n<note5>\\n<description>Choose the anchor color by looking for a color that is repeated in the same column (not the background). Prefer the color that forms a clear vertical alignment; if more than one color repeats in a column, the one that repeats most clearly (or the one that is not the dominant background) is usually the intended anchor. Avoid treating the most frequent background color as the anchor.</description>\\n<example>Given a grid where color X appears several times in column 3 and color Y appears only once, pick X as the anchor. Compute X's topmost and bottommost occurrences in that column, create the horizontal band for X, and leave Y and background pixels untouched. A common pitfall is to pick the background color or to overwrite non-background markers—preserve them.</example>\\n</note5>\",\n \"<note1>\\n<description>First separate background from signal: find the color that fills most cells and the small set of other colors that appear only a few times. Those rare colors are the likely \\\"seeds\\\" that drive the transformation.</description>\\n<example>Imagine a grid of mostly color A with three isolated pixels of color B. Treat A as background and B as the candidate seed color to track; you will see whether B is copied or extended in the output.</example>\\n</note1>\\n\\n<note2>\\n<description>Count and classify the seed colors by frequency. A color that appears many times (often many times) usually indicates a pattern to propagate, while a color that appears only once (or very few times) often acts as a blocker or anchor.</description>\\n<example>For example, if color X appears 10 times and color Y appears once, expect X to be the thing that gets copied or extended, and Y to be a special pixel that should remain unchanged or mark a boundary.</example>\\n</note2>\\n\\n<note3>\\n<description>Check alignment of the seed pixels: if all occurrences of a color share the same row, that color is being extended horizontally; if they share the same column, expect vertical extension. The orientation tells you whether to paint whole rows or whole columns.</description>\\n<example>If color C appears at (r, c1), (r, c2) and (r, c3), try filling row r with C; if color D appears at (r1, c), (r2, c) and (r3, c), try filling column c with D.</example>\\n</note3>\\n\\n<note4>\\n<description>When you extend a seed, do not overwrite other non-background pixels: treat those as anchors or blockers. The propagation typically fills only background cells and leaves anchor pixels in place.</description>\\n<example>Suppose you want to fill a column with color E but encounter a single pixel of color F in that column; paint the background cells in that column with E but keep F unchanged so it remains a boundary.</example>\\n</note4>\\n\\n<note5>\\n<description>Apply the rule systematically: for each seed color, extend it along its detected axis (row or column) across the grid, skipping over anchor pixels. If multiple seeds exist, repeat for each; conflicts are resolved by preserving anchors and leaving background elsewhere.</description>\\n<example>Given several seed rows and a few anchor pixels, paint each seed row across its full width with that seed color but stop at or around anchor pixels; this reproduces the pattern seen in many ARC tasks where sparse colors are propagated along aligned axes.</example>\\n</note5>\"\n]","isConversational":false},"train":{"kind":"string","value":"[{\"input\": [[9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9], [9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9], [9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 7, 9, 9, 1], [9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9], [9, 9, 9, 9, 9, 9, 9, 7, 9, 9, 9, 9, 9, 1], [9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9], [9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 7, 9, 9], [9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 1], [9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9], [9, 9, 9, 9, 9, 9, 9, 7, 9, 9, 9, 9, 9, 9], [9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 1], [9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9], [9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9], [9, 9, 9, 9, 7, 9, 9, 9, 9, 9, 9, 9, 9, 1], [9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9], [9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9], [9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 1], [9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9], [9, 9, 9, 9, 9, 9, 9, 9, 9, 7, 9, 9, 9, 1], [9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9], [9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9]], \"output\": [[9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9], [1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 9, 9], [9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 7, 1, 1, 1], [1, 1, 1, 1, 1, 1, 1, 1, 1, 9, 9, 9, 9, 9], [9, 9, 9, 9, 9, 9, 9, 7, 1, 1, 1, 1, 1, 1], [9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9], [9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 7, 9, 9], [1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1], [9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9], [9, 9, 9, 9, 9, 9, 9, 7, 9, 9, 9, 9, 9, 9], [1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1], [9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9], [1, 1, 1, 1, 1, 1, 9, 9, 9, 9, 9, 9, 9, 9], [9, 9, 9, 9, 7, 1, 1, 1, 1, 1, 1, 1, 1, 1], [9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9], [9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9], [1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1], [1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 9, 9, 9], [9, 9, 9, 9, 9, 9, 9, 9, 9, 7, 1, 1, 1, 1], [9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9], [9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9]]}, {\"input\": [[8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8], [8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8], [8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8], [8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8], [8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8], [8, 3, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8], [8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8], [8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8], [8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8], [8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8], [8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8], [8, 8, 9, 8, 8, 8, 9, 8, 8, 8, 8, 8, 8, 8]], \"output\": [[8, 8, 9, 8, 8, 8, 9, 8, 8, 8, 8, 8, 8, 8], [8, 8, 9, 8, 8, 8, 9, 8, 8, 8, 8, 8, 8, 8], [8, 8, 9, 8, 8, 8, 9, 8, 8, 8, 8, 8, 8, 8], [8, 8, 9, 8, 8, 8, 9, 8, 8, 8, 8, 8, 8, 8], [8, 8, 9, 8, 8, 8, 9, 8, 8, 8, 8, 8, 8, 8], [8, 3, 9, 8, 8, 8, 9, 8, 8, 8, 8, 8, 8, 8], [8, 8, 9, 8, 8, 8, 9, 8, 8, 8, 8, 8, 8, 8], [8, 8, 9, 8, 8, 8, 9, 8, 8, 8, 8, 8, 8, 8], [8, 8, 9, 8, 8, 8, 9, 8, 8, 8, 8, 8, 8, 8], [8, 8, 9, 8, 8, 8, 9, 8, 8, 8, 8, 8, 8, 8], [8, 8, 9, 8, 8, 8, 9, 8, 8, 8, 8, 8, 8, 8], [8, 8, 9, 8, 8, 8, 9, 8, 8, 8, 8, 8, 8, 8]]}, {\"input\": [[7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7], [7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7], [7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 2], [7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7], [7, 7, 7, 7, 7, 6, 7, 7, 7, 7, 7, 7], [7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7], [7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 2], [7, 7, 7, 6, 7, 7, 7, 7, 7, 7, 7, 7], [7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7], [7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7], [7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7], [7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7], [7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7], [7, 7, 7, 6, 7, 7, 7, 7, 7, 7, 7, 7], [7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7]], \"output\": [[7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7], [7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7], [2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2], [7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7], [7, 7, 7, 7, 7, 6, 7, 7, 7, 7, 7, 7], [7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7], [2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2], [7, 7, 7, 6, 7, 7, 7, 7, 7, 7, 7, 7], [7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7], [7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7], [7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7], [7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7], [7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7], [7, 7, 7, 6, 7, 7, 7, 7, 7, 7, 7, 7], [7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7]]}]"},"test":{"kind":"string","value":"[{\"input\": [[3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3], [3, 3, 3, 3, 3, 3, 3, 6, 3, 3, 3, 3], [3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3], [3, 3, 3, 6, 3, 3, 3, 3, 3, 3, 3, 3], [3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 0], [3, 3, 3, 3, 3, 3, 6, 3, 3, 3, 3, 3], [3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3], [3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3], [3, 6, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3], [3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3], [3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 0], [3, 3, 3, 3, 3, 3, 6, 3, 3, 3, 3, 3], [3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3], [3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3], [3, 3, 3, 3, 3, 3, 6, 3, 3, 3, 3, 3], [3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 0], [3, 6, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3], [3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3], [3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3]], \"output\": [[3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3], [3, 3, 3, 3, 3, 3, 3, 6, 3, 3, 3, 3], [3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3], [3, 3, 3, 6, 3, 3, 3, 3, 3, 3, 3, 3], [0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0], [3, 3, 3, 3, 3, 3, 6, 3, 3, 3, 3, 3], [3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3], [3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3], [3, 6, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3], [3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3], [0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0], [3, 3, 3, 3, 3, 3, 6, 3, 3, 3, 3, 3], [3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3], [3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3], [3, 3, 3, 3, 3, 3, 6, 3, 3, 3, 3, 3], [0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0], [3, 6, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3], [3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3], [3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3]]}]"},"source":{"kind":"string","value":"rearc"},"prompt":{"kind":"string","value":"You will be given some number of paired example inputs and outputs grids. The outputs were produced by applying a transformation rule to the input grids. In addition to the paired example inputs and outputs, there is also one test input without a known output. The inputs and outputs are each “grids”. A grid is a rectangular matrix of integers between 0 and 9 (inclusive). Each number corresponds to a color. 0 is black. Your task is to determine the transformation rule from examples and find out the answer, involving determining the size of the output grid for the test and correctly filling each cell of the grid with the appropriate color or number. The transformation only needs to be unambiguous and applicable to the example inputs and the test input. It doesn't need to work for all possible inputs. Observe the examples carefully, imagine the grid visually, and try to find the pattern. Please output your answer within a code block (```), formatted as a grid of numbers. \n\n# Examples\n## Example 1\nInput:\n```\n9 9 9 9 9 9 9 9 9 9 9 9 9 9\n9 9 9 9 9 9 9 9 9 9 9 9 9 9\n9 9 9 9 9 9 9 9 9 9 7 9 9 1\n9 9 9 9 9 9 9 9 9 9 9 9 9 9\n9 9 9 9 9 9 9 7 9 9 9 9 9 1\n9 9 9 9 9 9 9 9 9 9 9 9 9 9\n9 9 9 9 9 9 9 9 9 9 9 7 9 9\n9 9 9 9 9 9 9 9 9 9 9 9 9 1\n9 9 9 9 9 9 9 9 9 9 9 9 9 9\n9 9 9 9 9 9 9 7 9 9 9 9 9 9\n9 9 9 9 9 9 9 9 9 9 9 9 9 1\n9 9 9 9 9 9 9 9 9 9 9 9 9 9\n9 9 9 9 9 9 9 9 9 9 9 9 9 9\n9 9 9 9 7 9 9 9 9 9 9 9 9 1\n9 9 9 9 9 9 9 9 9 9 9 9 9 9\n9 9 9 9 9 9 9 9 9 9 9 9 9 9\n9 9 9 9 9 9 9 9 9 9 9 9 9 1\n9 9 9 9 9 9 9 9 9 9 9 9 9 9\n9 9 9 9 9 9 9 9 9 7 9 9 9 1\n9 9 9 9 9 9 9 9 9 9 9 9 9 9\n9 9 9 9 9 9 9 9 9 9 9 9 9 9\n```\n\nOutput:\n```\n9 9 9 9 9 9 9 9 9 9 9 9 9 9\n1 1 1 1 1 1 1 1 1 1 1 1 9 9\n9 9 9 9 9 9 9 9 9 9 7 1 1 1\n1 1 1 1 1 1 1 1 1 9 9 9 9 9\n9 9 9 9 9 9 9 7 1 1 1 1 1 1\n9 9 9 9 9 9 9 9 9 9 9 9 9 9\n9 9 9 9 9 9 9 9 9 9 9 7 9 9\n1 1 1 1 1 1 1 1 1 1 1 1 1 1\n9 9 9 9 9 9 9 9 9 9 9 9 9 9\n9 9 9 9 9 9 9 7 9 9 9 9 9 9\n1 1 1 1 1 1 1 1 1 1 1 1 1 1\n9 9 9 9 9 9 9 9 9 9 9 9 9 9\n1 1 1 1 1 1 9 9 9 9 9 9 9 9\n9 9 9 9 7 1 1 1 1 1 1 1 1 1\n9 9 9 9 9 9 9 9 9 9 9 9 9 9\n9 9 9 9 9 9 9 9 9 9 9 9 9 9\n1 1 1 1 1 1 1 1 1 1 1 1 1 1\n1 1 1 1 1 1 1 1 1 1 1 9 9 9\n9 9 9 9 9 9 9 9 9 7 1 1 1 1\n9 9 9 9 9 9 9 9 9 9 9 9 9 9\n9 9 9 9 9 9 9 9 9 9 9 9 9 9\n```\n\n## Example 2\nInput:\n```\n8 8 8 8 8 8 8 8 8 8 8 8 8 8\n8 8 8 8 8 8 8 8 8 8 8 8 8 8\n8 8 8 8 8 8 8 8 8 8 8 8 8 8\n8 8 8 8 8 8 8 8 8 8 8 8 8 8\n8 8 8 8 8 8 8 8 8 8 8 8 8 8\n8 3 8 8 8 8 8 8 8 8 8 8 8 8\n8 8 8 8 8 8 8 8 8 8 8 8 8 8\n8 8 8 8 8 8 8 8 8 8 8 8 8 8\n8 8 8 8 8 8 8 8 8 8 8 8 8 8\n8 8 8 8 8 8 8 8 8 8 8 8 8 8\n8 8 8 8 8 8 8 8 8 8 8 8 8 8\n8 8 9 8 8 8 9 8 8 8 8 8 8 8\n```\n\nOutput:\n```\n8 8 9 8 8 8 9 8 8 8 8 8 8 8\n8 8 9 8 8 8 9 8 8 8 8 8 8 8\n8 8 9 8 8 8 9 8 8 8 8 8 8 8\n8 8 9 8 8 8 9 8 8 8 8 8 8 8\n8 8 9 8 8 8 9 8 8 8 8 8 8 8\n8 3 9 8 8 8 9 8 8 8 8 8 8 8\n8 8 9 8 8 8 9 8 8 8 8 8 8 8\n8 8 9 8 8 8 9 8 8 8 8 8 8 8\n8 8 9 8 8 8 9 8 8 8 8 8 8 8\n8 8 9 8 8 8 9 8 8 8 8 8 8 8\n8 8 9 8 8 8 9 8 8 8 8 8 8 8\n8 8 9 8 8 8 9 8 8 8 8 8 8 8\n```\n\n## Example 3\nInput:\n```\n7 7 7 7 7 7 7 7 7 7 7 7\n7 7 7 7 7 7 7 7 7 7 7 7\n7 7 7 7 7 7 7 7 7 7 7 2\n7 7 7 7 7 7 7 7 7 7 7 7\n7 7 7 7 7 6 7 7 7 7 7 7\n7 7 7 7 7 7 7 7 7 7 7 7\n7 7 7 7 7 7 7 7 7 7 7 2\n7 7 7 6 7 7 7 7 7 7 7 7\n7 7 7 7 7 7 7 7 7 7 7 7\n7 7 7 7 7 7 7 7 7 7 7 7\n7 7 7 7 7 7 7 7 7 7 7 7\n7 7 7 7 7 7 7 7 7 7 7 7\n7 7 7 7 7 7 7 7 7 7 7 7\n7 7 7 6 7 7 7 7 7 7 7 7\n7 7 7 7 7 7 7 7 7 7 7 7\n```\n\nOutput:\n```\n7 7 7 7 7 7 7 7 7 7 7 7\n7 7 7 7 7 7 7 7 7 7 7 7\n2 2 2 2 2 2 2 2 2 2 2 2\n7 7 7 7 7 7 7 7 7 7 7 7\n7 7 7 7 7 6 7 7 7 7 7 7\n7 7 7 7 7 7 7 7 7 7 7 7\n2 2 2 2 2 2 2 2 2 2 2 2\n7 7 7 6 7 7 7 7 7 7 7 7\n7 7 7 7 7 7 7 7 7 7 7 7\n7 7 7 7 7 7 7 7 7 7 7 7\n7 7 7 7 7 7 7 7 7 7 7 7\n7 7 7 7 7 7 7 7 7 7 7 7\n7 7 7 7 7 7 7 7 7 7 7 7\n7 7 7 6 7 7 7 7 7 7 7 7\n7 7 7 7 7 7 7 7 7 7 7 7\n```\n\n# Test Problem:\n```\n3 3 3 3 3 3 3 3 3 3 3 3\n3 3 3 3 3 3 3 6 3 3 3 3\n3 3 3 3 3 3 3 3 3 3 3 3\n3 3 3 6 3 3 3 3 3 3 3 3\n3 3 3 3 3 3 3 3 3 3 3 0\n3 3 3 3 3 3 6 3 3 3 3 3\n3 3 3 3 3 3 3 3 3 3 3 3\n3 3 3 3 3 3 3 3 3 3 3 3\n3 6 3 3 3 3 3 3 3 3 3 3\n3 3 3 3 3 3 3 3 3 3 3 3\n3 3 3 3 3 3 3 3 3 3 3 0\n3 3 3 3 3 3 6 3 3 3 3 3\n3 3 3 3 3 3 3 3 3 3 3 3\n3 3 3 3 3 3 3 3 3 3 3 3\n3 3 3 3 3 3 6 3 3 3 3 3\n3 3 3 3 3 3 3 3 3 3 3 0\n3 6 3 3 3 3 3 3 3 3 3 3\n3 3 3 3 3 3 3 3 3 3 3 3\n3 3 3 3 3 3 3 3 3 3 3 3\n```"},"answer":{"kind":"string","value":"```\n3 3 3 3 3 3 3 3 3 3 3 3\n3 3 3 3 3 3 3 6 3 3 3 3\n3 3 3 3 3 3 3 3 3 3 3 3\n3 3 3 6 3 3 3 3 3 3 3 3\n0 0 0 0 0 0 0 0 0 0 0 0\n3 3 3 3 3 3 6 3 3 3 3 3\n3 3 3 3 3 3 3 3 3 3 3 3\n3 3 3 3 3 3 3 3 3 3 3 3\n3 6 3 3 3 3 3 3 3 3 3 3\n3 3 3 3 3 3 3 3 3 3 3 3\n0 0 0 0 0 0 0 0 0 0 0 0\n3 3 3 3 3 3 6 3 3 3 3 3\n3 3 3 3 3 3 3 3 3 3 3 3\n3 3 3 3 3 3 3 3 3 3 3 3\n3 3 3 3 3 3 6 3 3 3 3 3\n0 0 0 0 0 0 0 0 0 0 0 0\n3 6 3 3 3 3 3 3 3 3 3 3\n3 3 3 3 3 3 3 3 3 3 3 3\n3 3 3 3 3 3 3 3 3 3 3 3\n```"},"num_tokens":{"kind":"number","value":3290,"string":"3,290"}}},{"rowIdx":98,"cells":{"abstraction_prompt":{"kind":"string","value":"<|im_start|>user\n# ARC HINT GENERATOR\n\n## Role & Goal\nYou are an expert ARC (Abstraction and Reasoning Corpus) analyst. Your task is to generate a concise, actionable hint for a user who is struggling with an ARC problem. Analyze the problem and its correct solution to produce a single standalone, targeted hint that helps the user discover the core transformation principle for themselves without revealing the answer.\n\n---\n\n## Hint Generation Strategy\n1. **Compare** the input and output grids for each example. Identify the shared transformation pattern that allows the input grid to be converted into the output grid.\n2. **Identify the Core Principle**: Review the problem description and ground-truth solution to fully discern the key transformation rule. Break it down into its essential operations (e.g., object completion, pattern repetition, symmetry, gravity), paying close attention to properties such as object count, shapes, colors, sizes, symmetry, repetition, relative positioning, and broader grid-level patterns.\n3. **Craft a Targeted Hint**: Generate a hint that guides the user toward the core insight needed to solve the problem. The hint should assist the user during their attempt without revealing the solution.\n4. Structure each note using the template below:\n - **Description** (up to 3 sentences): Explain the concept, when and why it applies, and why it is effective. Include any relevant general formula or principle in its most general form.\n - **Example** (up to 6 sentences): Present a worked example covering all aspects of the description, using a simplified yet representative scenario (not necessarily from the current problem).\n - Optionally, include **Heuristics** or **Pitfalls** in the note where relevant.\n - Focus on methodologies and core principles over specific calculations or problem details.\n - Ensure each hint applies broadly—at least 80% of analogous problems.\n\nAfter generating a hint, verify that no specifics of the solution are revealed, and that the hint remains at the level of guiding the approach.\n\n### Design Guidelines\n- Clarity: Use precise language and correct sentence structure.\n- Atomicity: Each note addresses one recognizable sub-problem.\n- Self-containment: All information needed to understand the idea and its application is within the note.\n- Generalizability: Avoid problem-specific details or variables.\n- Transferability: Notes should apply across a class of problems.\n- Distinctness: Each note addresses a distinct principle.\n\n---\n\n## Guidelines\n- **Guide, Don't Solve**: Illuminate the approach, not the answer. Emphasize what to observe or consider.\n- **Specific yet Abstract**: Use concrete grid details (e.g., \"note the relationship between the blue and red pixels\") to ground abstract patterns (e.g., \"think about one color containing another\").\n\nValidate your generated hint: confirm it is self-contained, actionable, and nondirective. If any aspect is too revealing, revise before finalizing.\n\n---\n\n## Inputs\n### Problem Description\nA full ARC problem, including input/output pairs for training and testing.\n\n## Example 1\nInput:\n```\n0 0 0 0 0 0 0 0 0 0 0 0 0\n0 0 0 0 4 4 0 0 0 0 0 0 0\n0 0 0 0 4 4 0 0 0 0 0 0 0\n0 0 0 0 0 0 0 0 0 0 0 0 0\n0 0 4 4 0 0 0 0 0 0 0 0 0\n0 0 4 4 0 0 0 4 4 0 0 0 0\n0 0 0 0 0 0 0 4 4 0 0 0 0\n0 0 0 0 0 0 0 4 4 0 0 0 0\n2 2 0 0 0 0 0 0 0 0 0 2 2\n2 2 0 0 0 0 0 2 2 2 0 2 0\n2 2 0 0 0 0 0 2 2 2 0 0 0\n0 0 0 0 0 0 0 2 0 2 0 0 0\n0 0 0 0 0 0 0 0 0 0 0 0 0\n```\n\nOutput:\n```\n0 0 0 0 0 0 0 0 0 0 0 0 0\n0 0 0 0 4 4 0 0 0 0 0 0 0\n0 0 0 0 4 4 0 0 0 0 0 0 0\n0 0 0 0 0 0 0 0 0 0 0 0 0\n0 0 4 4 0 0 0 0 0 0 0 0 0\n0 0 4 4 0 0 0 4 4 0 0 0 0\n0 0 0 0 0 0 0 4 4 0 0 0 0\n0 0 0 0 0 0 0 4 4 0 0 0 0\n3 3 0 0 0 0 0 0 0 0 0 3 3\n3 3 0 0 0 0 0 3 3 3 0 3 0\n3 3 0 0 0 0 0 3 3 3 0 0 0\n0 0 0 0 0 0 0 3 0 3 0 0 0\n0 0 0 0 0 0 0 0 0 0 0 0 0\n```\n\n## Example 2\nInput:\n```\n0 0 0 0 0 0 0 0 0 4 4 0\n0 0 0 2 2 0 0 0 0 4 4 0\n0 0 0 2 2 0 0 0 0 4 4 0\n0 0 0 0 0 0 0 0 0 0 0 0\n0 0 0 4 4 0 0 2 2 2 0 0\n0 0 0 0 4 0 0 2 2 2 0 0\n0 0 0 4 4 0 0 0 0 0 0 0\n0 0 0 0 0 0 0 0 0 0 0 0\n0 0 0 0 0 0 0 0 2 2 0 0\n2 0 0 0 0 0 0 0 2 2 0 0\n2 2 2 0 0 0 0 0 2 2 0 0\n0 0 0 0 0 0 0 0 0 0 0 0\n```\n\nOutput:\n```\n0 0 0 0 0 0 0 0 0 4 4 0\n0 0 0 3 3 0 0 0 0 4 4 0\n0 0 0 3 3 0 0 0 0 4 4 0\n0 0 0 0 0 0 0 0 0 0 0 0\n0 0 0 4 4 0 0 3 3 3 0 0\n0 0 0 0 4 0 0 3 3 3 0 0\n0 0 0 4 4 0 0 0 0 0 0 0\n0 0 0 0 0 0 0 0 0 0 0 0\n0 0 0 0 0 0 0 0 3 3 0 0\n3 0 0 0 0 0 0 0 3 3 0 0\n3 3 3 0 0 0 0 0 3 3 0 0\n0 0 0 0 0 0 0 0 0 0 0 0\n```\n\n## Example 3\nInput:\n```\n2 2 0 0 0 0 0 4 0 0 0 0 0 0\n2 2 0 0 0 0 4 4 4 0 0 0 0 0\n0 0 0 0 0 0 0 4 0 0 0 0 0 0\n0 0 0 0 0 0 0 0 0 0 0 0 0 0\n0 0 0 2 2 0 0 0 0 0 0 0 0 0\n4 4 0 2 2 0 0 0 0 0 0 0 0 0\n4 4 0 2 2 0 0 0 0 0 0 0 0 0\n4 4 0 0 0 0 0 0 0 2 2 2 0 0\n0 0 0 0 0 0 0 0 0 2 2 2 0 0\n0 0 0 2 2 2 0 0 0 0 0 0 0 0\n0 0 0 2 0 2 0 0 0 0 0 0 0 0\n0 0 0 2 2 2 0 0 0 0 0 0 0 0\n```\n\nOutput:\n```\n3 3 0 0 0 0 0 4 0 0 0 0 0 0\n3 3 0 0 0 0 4 4 4 0 0 0 0 0\n0 0 0 0 0 0 0 4 0 0 0 0 0 0\n0 0 0 0 0 0 0 0 0 0 0 0 0 0\n0 0 0 3 3 0 0 0 0 0 0 0 0 0\n4 4 0 3 3 0 0 0 0 0 0 0 0 0\n4 4 0 3 3 0 0 0 0 0 0 0 0 0\n4 4 0 0 0 0 0 0 0 3 3 3 0 0\n0 0 0 0 0 0 0 0 0 3 3 3 0 0\n0 0 0 3 3 3 0 0 0 0 0 0 0 0\n0 0 0 3 0 3 0 0 0 0 0 0 0 0\n0 0 0 3 3 3 0 0 0 0 0 0 0 0\n```\n\n### Test Input\nHere is the input for the test problem.\n\n```\n2 2 0 0 0 0 0 0 0 0 0 0 0 0\n2 2 0 0 4 4 0 0 0 4 4 0 0 0\n2 2 0 0 4 4 0 0 0 4 4 0 0 0\n0 0 0 0 4 4 0 0 0 4 4 0 2 2\n0 0 0 0 0 0 0 0 0 0 0 0 0 2\n0 0 0 2 2 2 0 0 0 0 0 0 2 2\n0 0 0 2 2 2 0 0 0 0 0 0 0 0\n0 0 0 0 0 0 0 0 0 0 0 0 0 0\n0 0 0 0 0 0 0 0 0 0 0 0 2 0\n0 2 2 0 0 0 0 0 0 0 0 2 2 2\n0 2 2 0 0 0 4 4 4 0 0 0 2 0\n0 0 0 0 0 0 4 4 4 0 0 0 0 0\n0 0 2 2 0 0 0 0 0 0 0 0 0 0\n0 0 2 2 0 0 0 0 0 0 0 0 0 0\n```\n\n\n### Output Format\nOnly produce a **sequence of 5** notes in the structure:\n<note1>\n<description>...</description>\n<example>...</example>\n</note1>\n<note2>\n<description>...</description>\n<example>...</example>\n</note2>\n...\n\nDO NOT generate any other text\n\n---\n\n\n# Generated Hint<|im_end|>\n<|im_start|>assistant\n"},"abstraction_prompt_length":{"kind":"number","value":3075,"string":"3,075"},"generated_abstractions":{"kind":"list like","value":["<note1>\n<description>First identify which color(s) differ between input and output examples. Often only one color is changed while the rest of the grid (background and other colors) remains identical; that tells you the transformation is a recoloring of a single color class.</description>\n<example>Imagine a small grid where every cell is 0 except a few blue pixels. If the output shows the same blue pixels in a different color but the 0 background and any red pixels are unchanged, then the operation is \"change all blue pixels to a new color\" rather than moving or reshaping pixels.</example>\n</note1>\n\n<note2>\n<description>Check whether the changed pixels keep their exact coordinates and connectivity. If the set of coordinates occupied by the changed color is identical before and after, the rule is recoloring (not translation, reflection, or resizing).</description>\n<example>Suppose a 2×2 block of color A sits at rows 1–2 and columns 4–5 in the input. If the output has a 2×2 block at those same coordinates but in color B, the transformation preserved shape and position and only altered color.</example>\n</note2>\n\n<note3>\n<description>Verify that every instance of the target color is treated the same way (no partial recoloring). If every pixel of that color is changed in all examples, the rule is a uniform mapping from one color to another.</description>\n<example>Imagine three separate clusters of color X scattered across the grid. If in the output all three clusters are the same new color Y (and no cluster is left as X), then the operation is a global recolor of X to Y.</example>\n</note3>\n\n<note4>\n<description>Confirm that other colors and the background are left untouched. This helps you avoid overcomplicating the rule: if only one color is consistently altered across examples, focus on that single mapping.</description>\n<example>Given a grid with background 0 and two other colors, if only color Z is different between input and output while both other colors and the 0 background are identical, you can safely apply a recoloring rule that targets Z only.</example>\n</note4>\n\n<note5>\n<description>Use simple heuristics to pick the target color: it is often the less frequent or isolated color, or the one whose pixels form small, repeated components. Avoid choosing the background (usually 0) or a color that appears in multiple disconnected ways unless examples show that behavior.</description>\n<example>If one color appears as several identical small blocks while another color appears as large continuous regions, the small repeated color is a good candidate to be the one recolored. A quick count of occurrences or a check of connected components will usually reveal the intended target.</example>\n</note5>","<note1>\n<description>Look for a single color that is consistently different between each input and its output. If one color's pixels are the only ones that change across examples, that color is the candidate for the transformation.</description>\n<example>Imagine a grid with two colors A and B. If in every example the same set of A pixels is different in the output while all B pixels remain identical, then A is the color being transformed. Focus your attention on that color for the rest of the analysis.</example>\n</note1>\n\n<note2>\n<description>Verify that the transformation preserves geometry: the changed pixels keep the same coordinates and connectivity. This indicates a recoloring operation rather than movement, filling, or deletion.</description>\n<example>Suppose a 2×2 square of color X appears in the input and a 2×2 square appears in the exact same cells in the output (only with a different color). That shows the operation recolors those cells in place without shifting or resizing them.</example>\n</note2>\n\n<note3>\n<description>Check for consistency across all instances: every disconnected island or component of the candidate color should be treated the same way. The rule is typically applied globally to that color, not selectively to some occurrences.</description>\n<example>If there are three separate X islands in the input and all three appear as the same new color in the output, then the rule is “recolor every X to Y.” If only some islands change, look for an extra selection criterion instead.</example>\n</note3>\n\n<note4>\n<description>Determine whether the replacement is a simple one-to-one color substitution. Often the new color is chosen so it does not collide with existing colors in the input, making the change unambiguous.</description>\n<example>In a simple case, if the input uses colors {A,B} and the output shows {A,C}, it suggests A→C. If the output shows a color that never existed in the input, that color was likely introduced solely as the replacement.</example>\n</note4>\n\n<note5>\n<description>Use a minimal-change hypothesis and validate it on the test input: apply the suspected recolor to every occurrence of the candidate color and leave all other pixels unchanged. If this reproduces the pattern seen in the training examples, you have the correct rule.</description>\n<example>Take the test grid, recolor every pixel of the candidate color to the proposed replacement, and compare the result to the examples' behavior. If shapes, positions, and counts match the examples' behavior (only the candidate color differs), the recolor hypothesis is confirmed; otherwise re-evaluate which color or condition is driving the change.</example>\n</note5>","<note1>\n<description>Look for a single color that is consistently altered across the training pairs while other colors remain unchanged. When one color’s pixels are always the ones that differ, the transformation is likely a global recoloring rather than a geometric change.</description>\n<example>Imagine several grids where a blue shape appears in different places and the output always shows that same blue shape in a different color, while the red shapes remain red. That pattern points to “change every blue pixel to a new color” as the core rule.</example>\n</note1>\n\n<note2>\n<description>Use pixel-wise comparison to identify the target color: compare corresponding cells in each input/output pair and mark colors that change. The target will be the color whose coordinates are different in every example.</description>\n<example>Take a pair where a 2×2 block of color A in the input appears as color B in the output at the exact same coordinates. If you see that same A→B mapping in every example, you can confidently select A as the color to transform.</example>\n</note2>\n\n<note3>\n<description>Verify that the transformation is a recolor, not a move or reshape: check whether the pattern’s geometry (shape, size, and positions) is preserved. If geometry is unchanged, you should only change colors, not coordinates or orientation.</description>\n<example>If a T-shaped cluster of color X in the input appears as an identical T in the output but with a different color, that confirms the rule is “recolor X in place” rather than “move or rotate the T.”</example>\n</note3>\n\n<note4>\n<description>Choose a replacement color that does not appear in the input so the recolored pixels are unambiguous. The replacement should be applied uniformly to every instance of the target color across the grid.</description>\n<example>If the input uses colors {0,1,2} and you decide to recolor color 2, pick a color not in {0,1,2} (for example 3) and change every 2 to that chosen color; this makes the change visible and consistent.</example>\n</note4>\n\n<note5>\n<description>Apply the recoloring to every disconnected occurrence of the target color and leave all other colors unchanged. After recoloring, validate by counting: the number of recolored pixels should equal the original count of the target color.</description>\n<example>If the input contains three separate 2×2 blocks of color A and one isolated A pixel, recolor all four A pixels to the chosen new color. Then check that no other colors were altered and that the counts match expectations.</example>\n</note5>","<note1>\n<description>Scan the input/output pairs and ask: which color(s) differ between input and output while all other colors remain identical? If one color's pixels are the only ones that change, that color is the transformation target. This is effective because recoloring tasks usually leave geometry and other colors intact.</description>\n<example>Imagine a grid with blue and green shapes. In the output the blue shapes appear in the same cells but in a different color, while every green cell is unchanged. That pattern tells you the rule acts on the blue color only.</example>\n</note1>\n\n<note2>\n<description>Check geometry preservation: verify whether the changed pixels keep the same coordinates, shapes, and counts as before. If they do, the operation is a recoloring (a color mapping) rather than a move, rotation, or fill. Distinguishing these avoids confusing recolor with other transformations.</description>\n<example>For example, a 2×2 red square that remains a 2×2 square at the same location in the output indicates a color change only. If the square had shifted or been resized, you would suspect a spatial transformation instead.</example>\n</note2>\n\n<note3>\n<description>Look for consistency across all occurrences: the same input color should be replaced by the same output color in every example. A single consistent mapping across multiple disconnected components is strong evidence of a global recolor rule. If some instances change differently, the rule is more complex.</description>\n<example>Suppose three separate red blobs in different parts of the grid all become yellow in the outputs; that repeated mapping suggests “red → yellow” is the intended rule. If one blob stayed red while others changed, you would need to look for a conditional rule.</example>\n</note3>\n\n<note4>\n<description>Identify the replacement color by inspecting outputs: it will be a color present in the outputs but not used (or used only as the changed color) in the inputs. The replacement is typically a single new color applied uniformly to the target pixels. This tells you which color to use when applying the rule.</description>\n<example>If inputs use only blue and green, and outputs show blue plus a new purple, and all blue pixels become purple, then purple is the replacement color. The replacement color need not appear in the inputs originally.</example>\n</note4>\n\n<note5>\n<description>Apply the discovered mapping to the test input by replacing every pixel of the identified input color with the replacement color, leaving all other pixels unchanged. After applying it, verify that shapes, counts, and positions of non-target colors match the examples. This final check prevents accidental partial or conditional recoloring.</description>\n<example>Given a test grid where the target color appears in several disconnected regions, recolor every pixel of that color to the replacement color and confirm that the number and arrangement of other colors are identical to the input. If everything matches, the transformation is consistent.</example>\n</note5>","<note1>\n<description>Find the color that is consistently changed across the training examples: it is the color whose pixels are altered in the outputs while other colors remain identical. This indicates a global recoloring rule rather than a local edit or geometric transformation. Recognizing which color is the target focuses the rest of the work.</description>\n<example>Imagine three training pairs where a blue cluster in each input appears as a different color in the corresponding output, while red clusters stay red and black stays black. That repeated change points to “blue” as the color being transformed in every example.</example>\n</note1>\n\n<note2>\n<description>Check that the transformation preserves shapes and positions: the changed pixels occupy the same cells in input and output, only their color value changes. If geometry is preserved, the rule is a recoloring operation, not a move, resize, or reflection. This helps you avoid trying geometric operations.</description>\n<example>For example, a 2×2 square of color A at (row 2–3, col 5–6) in the input remains a 2×2 square at the same coordinates in the output but with a different color; this shows the rule alters color only, keeping the shape and location intact.</example>\n</note2>\n\n<note3>\n<description>Observe that the recoloring is uniform: every pixel of the targeted color becomes the same single new color across all instances and across all training examples. The mapping is one-to-one and global for that color. This consistency is the core of the transformation rule.</description>\n<example>If in two training examples every instance of color X becomes color Y (no exceptions), then the rule is “change all X to Y.” You do not need to treat each X instance differently — they all get the same replacement.</example>\n</note3>\n\n<note4>\n<description>Confirm that no other colors are altered and that the background remains unchanged. The transformation should only touch the identified color and leave all other colors and empty cells as they were. This prevents accidental modification of unrelated objects.</description>\n<example>Suppose inputs contain red, green, and black, and only green pixels differ between inputs and outputs; then green is the target and red and black should be left exactly as they are in the output.</example>\n</note4>\n\n<note5>\n<description>To solve the test case, locate every pixel of the identified target color in the test input and recolor each of those pixels to the single replacement color you inferred from training, keeping all positions and shapes unchanged. After recoloring, verify that no other colors were altered and that the recoloring is consistent everywhere.</description>\n<example>Given a new grid with several scattered pixels of the target color, change each of those pixels to the replacement color you found in the examples, leaving all other cells untouched. If the result matches the pattern of the training outputs (only that color changed, shapes preserved), you have applied the rule correctly.</example>\n</note5>","<note1>\n<description>Look for a color that is present in the input but absent in the output; such a disappearance usually means that color was replaced by another. This is a common, simple transformation: one color is globally substituted for a single other color. Formally, if every pixel of color X in the input becomes color Y in the output, then X→Y is the core operation.</description>\n<example>Imagine a small grid where every red pixel in the input appears as blue in the output and no red pixels remain. That tells you the rule is \"replace red with blue\" and you can apply that substitution everywhere in the grid.</example>\n</note1>\n\n<note2>\n<description>Verify the substitution is global and consistent: every occurrence of the candidate color should change to the same new color. If some occurrences remain unchanged or change differently, the rule is not a single global recolor. Consistency across all examples is the key test.</description>\n<example>For instance, if three separate red patches in the input all become blue in the output (and no other colors change), you have a global red→blue substitution. If one red patch stayed red, the rule would need to be more complex.</example>\n</note2>\n\n<note3>\n<description>Use shape and position invariants to confirm the operation: a recoloring preserves the exact locations and shapes of the affected pixels. If shapes are identical between input and output except for color, the transformation is color-only. This helps distinguish recoloring from operations like translation, rotation, or filling.</description>\n<example>If a 2×2 square at a particular location is red in the input and the same 2×2 square is blue in the output, the shape and location are preserved and only the color changed. That supports a recolor rule rather than a geometric change.</example>\n</note3>\n\n<note4>\n<description>Check that all other colors and the background remain unchanged; the transformation should affect only the identified color. If other colors stay identical in both input and output, you can focus on recoloring just that color. This narrows the problem to a single substitution rather than a multi-step edit.</description>\n<example>Suppose green and black pixels are identical between input and output while only red pixels differ; then the rule is limited to red→something and you can ignore green/black when constructing the output.</example>\n</note4>\n\n<note5>\n<description>Once you have identified the color-to-color mapping from the examples, apply it to the test input by replacing every occurrence of the source color with the target color, leaving all other pixels untouched. Finally, verify that the counts and shapes of the affected regions match the pattern seen in the training outputs. This yields a consistent, unambiguous output.</description>\n<example>If your analysis shows red→blue from the examples, then in the test grid change every red pixel to blue and keep all other pixels the same. After this substitution, the blue regions should occupy exactly the same positions and have the same shapes as the red regions did in the input.</example>\n</note5>","<note1>\n<description>Look for a one-to-one color substitution: if one color in the input always becomes a single other color in the output while all other colors remain identical, the rule is a global recoloring. This is effective when shapes and positions are preserved but only the color labels change.</description>\n<example>Imagine several 2×2 blue squares and a few red dots. In the output you see the same squares and dots in the same places, but every blue square is now green while red dots are unchanged. That pattern indicates a single blue→green recoloring rather than any spatial transformation.</example>\n</note1>\n\n<note2>\n<description>Check spatial invariance: verify whether the pixels of the candidate color occupy the exact same coordinates before and after the transformation. If they do, the operation is a recolor; if they move, rotate, or resize, a different rule is in play.</description>\n<example>Take a small L-shaped cluster of pixels. If the output shows an L in the same coordinates but with a different color, the rule did not move the shape — only its color changed. That distinction rules out translations, rotations, or reflections.</example>\n</note2>\n\n<note3>\n<description>Confirm consistency across all instances: the same input color should be recolored in every separate object and every occurrence. Consistent treatment of all instances indicates a uniform global mapping rather than a context-dependent change.</description>\n<example>If three separate blobs of the same color appear in different corners and each blob is the same new color in the output, that supports a global recoloring rule. If one blob changes differently, the rule is not a simple global substitution.</example>\n</note3>\n\n<note4>\n<description>Use counts and bounding boxes to validate the mapping: compare the number of pixels and the bounding box of the input color to the number and bounding box of the output color. Matching counts and identical bounding boxes strengthen the recolor hypothesis.</description>\n<example>Count 12 pixels of color A and find a 12-pixel region of color B in the same bounding box in the output; this suggests A→B recoloring. If counts or bounding boxes differ, the transformation is not a simple recolor.</example>\n</note4>\n\n<note5>\n<description>Apply the inferred mapping to the test grid by replacing every pixel of the identified input color with the mapped color and leaving all other pixels unchanged. Finally, re-check that shapes and counts still match the pattern seen in the training examples.</description>\n<example>After concluding that color X should become color Y, scan the test grid and change every X to Y while keeping other colors as they are. Then verify that each object's shape and pixel count still correspond to the original objects, ensuring the rule was applied correctly.</example>\n</note5>","<note1>\n<description>Look for a color that is identical in every input example and that is the only color that differs in the corresponding outputs. This points to a global recoloring rule: one input color is consistently replaced by a single other color everywhere.</description>\n<example>Imagine three training pairs where the input always has a red shape and the output always shows that same shape in a different color, while other colors remain unchanged. That repeated difference (red → new color) across examples indicates a simple global recolor operation rather than a shape change or movement.</example>\n</note1>\n\n<note2>\n<description>Confirm that the transformation preserves geometry: the shapes, sizes, and coordinates of the affected pixels should be unchanged between input and output. If geometry is preserved, the rule is purely a color substitution, not a translation/rotation/resize.</description>\n<example>For instance, if a 2×2 square at (r,c) in the input appears as a 2×2 square at the same (r,c) in the output but with a different color, then the operation is a recolor. Counting pixels and comparing bounding boxes helps verify that nothing moved or grew.</example>\n</note2>\n\n<note3>\n<description>Use multiple examples to disambiguate which color is being changed: the target color will be the one that appears in inputs but is absent (or different) in outputs in every training pair. Consistency across all examples is the key test.</description>\n<example>Suppose in each example a blue region is present in the input and the same region is a different color in the output, while other colors never change. That repeated presence/absence pattern identifies blue as the color to recolor.</example>\n</note3>\n\n<note4>\n<description>When applying the rule to the test input, recolor every pixel of the identified target color to the replacement color, leaving all other colors and the background untouched. Treat each pixel individually so isolated occurrences are handled correctly.</description>\n<example>If the target is color A and the replacement is color B, then for every cell with color A in the test grid set it to B; do not alter cells that are already B or any other color. This preserves the original shapes and only changes color values.</example>\n</note4>\n\n<note5>\n<description>Watch for common pitfalls: don’t confuse recoloring with other operations like filling holes, merging shapes, or shifting positions. Verify by checking counts and bounding boxes of the affected color before and after recoloring.</description>\n<example>After you recolor, count the pixels of the replacement color and compare with the original count of the target color; also compare bounding boxes. If counts and bounding boxes match (but color changed), the recolor hypothesis is supported; if not, reconsider whether a different rule applies.</example>\n</note5>","<note1>\n<description>Scan the training pairs for which color's pixels differ between input and output. If one color's positions are identical but its numeric label changes while other colors stay the same, the transformation is a color substitution rather than a geometric change.</description>\n<example>Imagine two training grids where every blue pixel in the input appears in the exact same coordinates in the output but is labeled green instead, while red and black pixels are unchanged. That pattern indicates the rule is “replace blue with green” rather than “move or reshape” blue pixels.</example>\n</note1>\n\n<note2>\n<description>Check that the replacement is applied uniformly across all occurrences: every pixel of the source color should be changed in every example. Uniformity across multiple disconnected objects is a strong sign of a global recoloring rule.</description>\n<example>For instance, if a color appears as several separate blocks in the input and in the output each of those blocks is the same new color (no block is left or partially changed), then the rule is consistently replacing that source color everywhere.</example>\n</note2>\n\n<note3>\n<description>Distinguish recoloring from movement or shape change by comparing shapes and counts. If shapes, adjacency, and counts of colored regions remain identical between input and output, the operation is only changing color labels, not geometry.</description>\n<example>Suppose a 2×2 square at a given location is blue in the input and the same 2×2 square is green in the output with the same neighbors; that shows a color swap. If the square were shifted or resized, you would suspect a geometric transformation instead.</example>\n</note3>\n\n<note4>\n<description>Use the training outputs to identify the target color used after substitution: the replacement color will be present in outputs and may be absent or different in the corresponding inputs. The target color is consistent across examples and is the one you should use when recoloring the source in the test case.</description>\n<example>If every training output shows the former source-color pixels turned into the same new color (and that new color appears in outputs but not in inputs), then that new color is the target. Verify consistency across all training pairs before applying it to the test grid.</example>\n</note4>\n\n<note5>\n<description>Apply the inferred mapping to the test input by replacing every pixel of the source color with the target color, leaving all other colors and the background unchanged. After recoloring, confirm that each recolored region matches the shape and count of its original counterpart.</description>\n<example>Take the test grid, find every pixel of the source color and change its label to the target color you identified from training. Then check that the pattern of recolored pixels corresponds to the original colored shapes in the test grid and that no other pixels were altered.</example>\n</note5>","<note1>\n<description>Scan the grid for contiguous regions of the same non-background color and treat each as an object. Record each object's bounding box, pixel count, and whether it is a filled rectangle or an irregular cluster.</description>\n<example>Imagine a grid with three separated blobs: a 2×2 square, a 1×3 horizontal bar, and a 2×2 square. Label them as three objects, compute their bounding boxes (2×2, 1×3, 2×2) and counts (4,3,4). These object summaries let you compare shapes and positions without looking at every pixel.</example>\n</note1>\n\n<note2>\n<description>Group objects by identical shape (same bounding-box dimensions and same pattern of filled vs empty cells) regardless of their color. Two objects that share the same footprint and pixel pattern belong to the same shape-class.</description>\n<example>If you find two 2×2 filled squares in different places and two L-shaped clusters elsewhere, you have two shape-classes: the 2×2 square class and the L-class. Even if one 2×2 is red and the other is blue, treat them as the same class because their patterns match exactly.</example>\n</note2>\n\n<note3>\n<description>Within each shape-class, check the colors that occupy those shapes across the grid. Often one color appears in every instance of that class and another color appears in only some instances — that “shared” color is the invariant you should preserve.</description>\n<example>Suppose every 2×2 square you found is either red or blue, but every L-shape is either green or yellow. The 2×2 squares share the same color in every instance (say blue), so blue is the invariant color for that shape-class. The other color(s) in that class are the ones to change.</example>\n</note3>\n\n<note4>\n<description>Apply the recoloring rule: for each shape-class, leave the invariant color’s pixels unchanged and change every pixel of the other color(s) in that class to a single new color (one color per class). Do not alter the shape geometry or move pixels — only recolor.</description>\n<example>For the 2×2 squares class, keep all blue squares as blue and change every red square to a single new color (call it X). For the L-shapes, keep the green Ls green and change the yellow Ls to another single color (call it Y). The objects remain in the same positions and keep their original shapes; only their colors are unified.</example>\n</note4>\n\n<note5>\n<description>Be careful about edge cases: use exact shape matching (not just bounding-box size), treat rotated or reflected copies as distinct unless they are identical, and choose new colors that do not conflict with existing colors. After recoloring, verify that each shape-class now has exactly one color and that the shapes are unchanged.</description>\n<example>If you see a 2×2 square rotated 90°, it is a different footprint and should not be merged with the 2×2 squares class. If two classes share a color, that color may still be the invariant for one class; always confirm by checking every instance of each class. Finally, pick replacement colors that won’t collide with the preserved colors so the result is unambiguous.</example>\n</note5>","<note1>\n<description>Look for a uniform recoloring: many ARC tasks simply change the color of one object while leaving its shape and position intact. If a single input color becomes a single other color in the output, the rule is likely \"replace color A with color B\".</description>\n<example>Imagine a grid with several small 2×2 blue squares and one large green shape. In the output the blue squares are still in the same cells but now all appear as orange, while the green shape is unchanged. This indicates a global recoloring of blue→orange rather than any movement or resizing.</example>\n</note1>\n\n<note2>\n<description>Identify the target color by comparing color sets: the target is the non-background color that is missing from the output and whose positions match those in the input. Use the training pairs to see which color disappears or is consistently replaced.</description>\n<example>Suppose inputs contain colors {0, A, B} and outputs contain {0, B, C}. If the positions of A in the input exactly match the positions of C in the output, then A is being recolored to C. The background (0) should remain unchanged.</example>\n</note2>\n\n<note3>\n<description>Confirm the rule is global and shape-preserving: the transformation should recolor every pixel of the target color across the grid, not just some instances or only connected components. Check multiple occurrences to be sure.</description>\n<example>If there are three isolated A pixels in different places and the output shows three corresponding pixels of color C (same coordinates), that confirms a global recolor. If only one instance changed, you would suspect a different rule instead.</example>\n</note3>\n\n<note4>\n<description>Use counts and connectivity as a sanity check: the number of target-color pixels should equal the number of new-color pixels in the output, and their connected-component structure should match. This helps distinguish recoloring from copying, filling, or deletion.</description>\n<example>If A appears 12 times in the input and C appears 12 times in the output at the same coordinates, that supports A→C. If counts differ, consider whether other operations (e.g., adding or removing pixels) are involved.</example>\n</note4>\n\n<note5>\n<description>Apply the discovered mapping to the test input and verify invariants: recolor every pixel of the target color to the replacement color, leave all other colors and background intact, and then re-check counts and shapes to ensure consistency.</description>\n<example>After deciding A→C from the training examples, scan the test grid and change every A to C while keeping B and 0 unchanged. Finally, confirm that the number of C pixels equals the number of A pixels originally and that the shapes remain in the same places.</example>\n</note5>","<note1>\n<description>Look for a single color that is consistently altered in every example while other colors remain identical. This points to a global recoloring rule rather than a shape-by-shape transformation.</description>\n<example>Imagine three training pairs where the blue pixels appear in the same relative places in each input but the outputs show those exact cells as green instead; the unchanged red and black pixels stay the same. That pattern suggests the transformation is \"replace color A with color B\" applied everywhere.</example>\n</note1>\n\n<note2>\n<description>Verify that the operation preserves geometry and coordinates: the set of cells occupied by the target color should match between input and output. If shapes and positions are unchanged, you can treat the rule as a color substitution, not a move or reshape.</description>\n<example>For example, if a 2×2 square of color X sits at rows 2–3, cols 5–6 in the input and the output shows a 2×2 square at the same coordinates but in color Y, that indicates a pure recoloring of those cells.</example>\n</note2>\n\n<note3>\n<description>Check that the recoloring is applied uniformly to all disconnected occurrences of the same color. The rule should not depend on object size, location, or orientation—every instance of the target color should be treated the same.</description>\n<example>If there are three separate blobs of color A in different places, and each blob becomes color B in the outputs, then the correct approach is to recolor every A pixel regardless of which blob it belongs to.</example>\n</note3>\n\n<note4>\n<description>Use counts and exclusivity to confirm your hypothesis: the number of pixels of the target color in the input should equal the number of pixels of the replacement color in the output, and no other color should change. This helps avoid mistaking a partial or conditional rule for a global one.</description>\n<example>If the input has 12 pixels of color A and the output shows exactly 12 pixels of color B in the same positions while all other colors keep their counts, that strongly supports a global A→B recoloring rule.</example>\n</note4>\n\n<note5>\n<description>Apply the inferred mapping to the test grid by replacing every instance of the identified target color with the replacement color, leaving all other pixels unchanged. After applying it, re-check that counts and positions of other colors are preserved to ensure consistency.</description>\n<example>Given a test grid with several A-colored shapes scattered around, change every A pixel to B and leave black and other colors alone; then confirm that the number of B pixels equals the original number of A pixels and that no other colors were altered.</example>\n</note5>","<note1>\n<description>Look for a color whose pixels occupy the exact same coordinates in input and output but with a different color value. A one-to-one correspondence of positions (same shape, same orientation) is a strong sign of a recoloring operation rather than a movement or reshaping.</description>\n<example>Imagine a small 2×2 block of color A in the input and an identical 2×2 block in the same location in the output, but colored B. That pattern indicates the transformation simply changed A→B for that object while leaving its geometry unchanged.</example>\n</note1>\n\n<note2>\n<description>Confirm the mapping is global: every instance of the candidate color should be treated the same way. If some occurrences are left unchanged, the rule is more complex; if all are changed, you can treat the recoloring as a uniform operation.</description>\n<example>Suppose three separate 2×2 squares of color A appear in different corners of the input and in the output all three are color B. Because every A was changed consistently, you can apply A→B everywhere rather than handling each object individually.</example>\n</note2>\n\n<note3>\n<description>Check that other colors and background remain identical between input and output. If other colors are unchanged, the rule likely targets only the identified color and preserves the rest of the scene.</description>\n<example>If color C and the black background appear in the same positions before and after, and only color A differs, then the transformation is selective—A is being recolored while C and background are left intact.</example>\n</note3>\n\n<note4>\n<description>Use simple counts and connectivity to validate your hypothesis: the number of changed pixels should match the number of pixels of the candidate color in the input, and their connected components should align. This helps distinguish recoloring from duplication, deletion, or relocation.</description>\n<example>Count how many A pixels exist in the input (e.g., 10). If the output has exactly 10 pixels of color B occupying those same coordinates and no extra B pixels appear elsewhere, the evidence supports A→B recoloring.</example>\n</note4>\n\n<note5>\n<description>When you apply the rule to the test grid, change every pixel of the identified color to the new color and leave all other pixels unchanged. Finally, re-check that shapes, counts, and positions match the invariants you observed in the examples.</description>\n<example>Given a test grid with several scattered A-colored objects, replace each A with B in-place. Then verify that all A→B changes are consistent with the examples (same shapes, same counts, same locations) and that no other colors were altered.</example>\n</note5>","<note1>\n<description>Look first for a single color that consistently changes across every example while other colors remain identical. If one color’s pixels are the only ones that differ between input and output, that color is the transformation target.</description>\n<example>Imagine three small grids where blue shapes appear in the input and, in the corresponding outputs, those same blue pixels are all a different color while red and black pixels are unchanged. That consistent replacement points you to the color you should focus on.</example>\n</note1>\n\n<note2>\n<description>Check whether the transformation is a pure recoloring: the pixels that change keep the same coordinates and shapes, only their color value changes. This distinguishes recoloring from operations that move, resize, or create shapes.</description>\n<example>For instance, if a 2×2 square at the top-right corner is color A in the input and the output shows a 2×2 square at the exact same coordinates but in color B, the operation is a recolor rather than a relocation or reshaping.</example>\n</note2>\n\n<note3>\n<description>Confirm that the recoloring is global and uniform: every pixel of the targeted color is changed the same way, even if there are multiple disconnected patches. The rule should not depend on patch size, orientation, or position.</description>\n<example>Suppose there are three separate patches of color A in different parts of the grid; if all three become color B in the outputs, you have a uniform global recolor rule rather than a patch-specific rule.</example>\n</note3>\n\n<note4>\n<description>Use counts and connectivity to validate your hypothesis: compare the number of pixels of the candidate color in input and output and check that those exact coordinates are occupied by the new color. Matching counts and exact coordinate overlap strengthen the recolor interpretation.</description>\n<example>If the input has N pixels of color A and the output has N pixels of color B occupying the same cells, that numerical and positional match is strong evidence the rule is “replace A with B”.</example>\n</note4>\n\n<note5>\n<description>Before applying the rule to the test case, ensure it is consistent across all training examples and not conditional on location or shape. If it is consistent, apply the same recoloring to every pixel of the identified color in the test grid.</description>\n<example>When every training example shows the same color always changing to the same new color regardless of where it appears, you can confidently recolor every occurrence of that color in the test input to produce the output.</example>\n</note5>","<note1>\n<description>Look for a consistent color substitution: one color in the inputs may be replaced by a single different color in the outputs while all other colors and the background stay the same. This indicates a global recoloring rule rather than a geometric change. </description>\n<example>Imagine several examples where every red pixel in the inputs becomes blue in the outputs, and every green and black pixel remains identical. That pattern suggests the transformation is \"replace red with blue\" rather than moving or reshaping objects.</example>\n</note1>\n\n<note2>\n<description>Use counts and positions to confirm the mapping: the number of pixels of the candidate input color should match the number of pixels of the candidate output color, and their coordinates should align. Matching counts and coordinates are strong evidence of a pure recolor. </description>\n<example>If an input has 12 cyan pixels at particular coordinates and the corresponding output has 12 magenta pixels at those same coordinates, and no other pixels changed, the simplest explanation is a one-to-one recolor from cyan→magenta.</example>\n</note2>\n\n<note3>\n<description>Check that shapes and connectivity are preserved: if the colored regions keep the same footprint and adjacency but only their color changes, the rule is recoloring. If shapes move, grow, shrink, or split, a different rule is at work. </description>\n<example>Suppose a 2×3 block of orange pixels in the input appears as a 2×3 block in the output but in purple; that indicates recoloring. If the block instead becomes a 3×3 or shifts position, you must consider geometric operations instead.</example>\n</note3>\n\n<note4>\n<description>Distinguish global recoloring from selective edits: verify that every instance of the candidate color is changed across all examples, not just some occurrences. A global rule will affect every connected component of that color. </description>\n<example>If one example shows a single isolated yellow pixel and another shows a large yellow cluster, and in both outputs those yellow pixels are the same new color, that supports a global \"replace yellow\" rule. If only some yellow pixels change, the rule is more selective.</example>\n</note4>\n\n<note5>\n<description>Apply the inferred mapping to the test input and then validate: recolor every pixel of the chosen input color to the chosen output color, leave all other colors unchanged, and check that counts, shapes, and background match the pattern from examples. This final check prevents accidental overfitting to a single example. </description>\n<example>After deducing that one color consistently becomes another across training pairs, perform that substitution on the test grid and confirm that the resulting colored regions and their positions are consistent with the behavior seen in the examples.</example>\n</note5>","<note1>\n<description>Start by isolating the difference: find the color(s) that are present in the input but not in the output, and the color(s) that appear in the output but not in the input. This often reveals a one-to-one recoloring rather than a geometric change. Focusing on which color was replaced reduces the search space.</description>\n<example>Imagine a small grid where blue pixels form several identical squares and green pixels form other shapes. In the output you see the green shapes still in the same positions but now all yellow, while the blue squares are unchanged. Noticing that exactly one input color has been replaced by one new color points you toward a recoloring rule.</example>\n</note1>\n\n<note2>\n<description>Check shape and position invariance: if the pixels that change keep the same coordinates and the same pattern, the transformation is likely a recolor rather than a move or rotation. This distinguishes color-only rules from spatial transformations. Use this to ignore spatial hypotheses when appropriate.</description>\n<example>Take a 2×2 red block at a fixed location; if in the output that same 2×2 block is green but at the same coordinates, then the operation was a color swap for that block. If instead the block moved or rotated, you would need a spatial rule.</example>\n</note2>\n\n<note3>\n<description>Verify consistency across all examples: a true rule will apply the same recoloring to every occurrence of the target color in every training pair. If the same source color is always changed to the same target color, that consistency is the key. If you find exceptions, the rule may depend on context (shape, adjacency, or position).</description>\n<example>If in three training examples every blue pixel becomes yellow while red pixels remain red, that repeated pattern strongly indicates a global blue→yellow recolor. If some blue pixels stayed blue in one example, look for additional conditions that explain the exception.</example>\n</note3>\n\n<note4>\n<description>Look for a single new color introduced in outputs that did not appear in the inputs; often the rule is “replace color A with a new color B.” This is a common pattern when one color is removed and a fresh color is used to mark it. Identifying which color is new helps you infer the mapping direction (which color is being replaced).</description>\n<example>Suppose an input uses colors {0,1,2} and the outputs use {0,1,3}. The presence of 3 in outputs but not in inputs suggests that one of the existing colors was mapped to 3. Checking which input color disappears in outputs tells you which color was replaced.</example>\n</note4>\n\n<note5>\n<description>Apply the inferred mapping to the test grid: recolor every pixel of the identified source color to the inferred target color and leave all other pixels unchanged. After recoloring, verify that the shapes, counts, and positions of recolored pixels match the pattern you observed in the training examples. This final check ensures you haven’t missed a contextual exception.</description>\n<example>Once you deduce “color X → color Y” from the examples, go through the test grid and change every X to Y while keeping all other colors as they are. Then confirm that the recolored pixels occupy the same locations as before and that no other pixels were altered.</example>\n</note5>"],"string":"[\n \"<note1>\\n<description>First identify which color(s) differ between input and output examples. Often only one color is changed while the rest of the grid (background and other colors) remains identical; that tells you the transformation is a recoloring of a single color class.</description>\\n<example>Imagine a small grid where every cell is 0 except a few blue pixels. If the output shows the same blue pixels in a different color but the 0 background and any red pixels are unchanged, then the operation is \\\"change all blue pixels to a new color\\\" rather than moving or reshaping pixels.</example>\\n</note1>\\n\\n<note2>\\n<description>Check whether the changed pixels keep their exact coordinates and connectivity. If the set of coordinates occupied by the changed color is identical before and after, the rule is recoloring (not translation, reflection, or resizing).</description>\\n<example>Suppose a 2×2 block of color A sits at rows 1–2 and columns 4–5 in the input. If the output has a 2×2 block at those same coordinates but in color B, the transformation preserved shape and position and only altered color.</example>\\n</note2>\\n\\n<note3>\\n<description>Verify that every instance of the target color is treated the same way (no partial recoloring). If every pixel of that color is changed in all examples, the rule is a uniform mapping from one color to another.</description>\\n<example>Imagine three separate clusters of color X scattered across the grid. If in the output all three clusters are the same new color Y (and no cluster is left as X), then the operation is a global recolor of X to Y.</example>\\n</note3>\\n\\n<note4>\\n<description>Confirm that other colors and the background are left untouched. This helps you avoid overcomplicating the rule: if only one color is consistently altered across examples, focus on that single mapping.</description>\\n<example>Given a grid with background 0 and two other colors, if only color Z is different between input and output while both other colors and the 0 background are identical, you can safely apply a recoloring rule that targets Z only.</example>\\n</note4>\\n\\n<note5>\\n<description>Use simple heuristics to pick the target color: it is often the less frequent or isolated color, or the one whose pixels form small, repeated components. Avoid choosing the background (usually 0) or a color that appears in multiple disconnected ways unless examples show that behavior.</description>\\n<example>If one color appears as several identical small blocks while another color appears as large continuous regions, the small repeated color is a good candidate to be the one recolored. A quick count of occurrences or a check of connected components will usually reveal the intended target.</example>\\n</note5>\",\n \"<note1>\\n<description>Look for a single color that is consistently different between each input and its output. If one color's pixels are the only ones that change across examples, that color is the candidate for the transformation.</description>\\n<example>Imagine a grid with two colors A and B. If in every example the same set of A pixels is different in the output while all B pixels remain identical, then A is the color being transformed. Focus your attention on that color for the rest of the analysis.</example>\\n</note1>\\n\\n<note2>\\n<description>Verify that the transformation preserves geometry: the changed pixels keep the same coordinates and connectivity. This indicates a recoloring operation rather than movement, filling, or deletion.</description>\\n<example>Suppose a 2×2 square of color X appears in the input and a 2×2 square appears in the exact same cells in the output (only with a different color). That shows the operation recolors those cells in place without shifting or resizing them.</example>\\n</note2>\\n\\n<note3>\\n<description>Check for consistency across all instances: every disconnected island or component of the candidate color should be treated the same way. The rule is typically applied globally to that color, not selectively to some occurrences.</description>\\n<example>If there are three separate X islands in the input and all three appear as the same new color in the output, then the rule is “recolor every X to Y.” If only some islands change, look for an extra selection criterion instead.</example>\\n</note3>\\n\\n<note4>\\n<description>Determine whether the replacement is a simple one-to-one color substitution. Often the new color is chosen so it does not collide with existing colors in the input, making the change unambiguous.</description>\\n<example>In a simple case, if the input uses colors {A,B} and the output shows {A,C}, it suggests A→C. If the output shows a color that never existed in the input, that color was likely introduced solely as the replacement.</example>\\n</note4>\\n\\n<note5>\\n<description>Use a minimal-change hypothesis and validate it on the test input: apply the suspected recolor to every occurrence of the candidate color and leave all other pixels unchanged. If this reproduces the pattern seen in the training examples, you have the correct rule.</description>\\n<example>Take the test grid, recolor every pixel of the candidate color to the proposed replacement, and compare the result to the examples' behavior. If shapes, positions, and counts match the examples' behavior (only the candidate color differs), the recolor hypothesis is confirmed; otherwise re-evaluate which color or condition is driving the change.</example>\\n</note5>\",\n \"<note1>\\n<description>Look for a single color that is consistently altered across the training pairs while other colors remain unchanged. When one color’s pixels are always the ones that differ, the transformation is likely a global recoloring rather than a geometric change.</description>\\n<example>Imagine several grids where a blue shape appears in different places and the output always shows that same blue shape in a different color, while the red shapes remain red. That pattern points to “change every blue pixel to a new color” as the core rule.</example>\\n</note1>\\n\\n<note2>\\n<description>Use pixel-wise comparison to identify the target color: compare corresponding cells in each input/output pair and mark colors that change. The target will be the color whose coordinates are different in every example.</description>\\n<example>Take a pair where a 2×2 block of color A in the input appears as color B in the output at the exact same coordinates. If you see that same A→B mapping in every example, you can confidently select A as the color to transform.</example>\\n</note2>\\n\\n<note3>\\n<description>Verify that the transformation is a recolor, not a move or reshape: check whether the pattern’s geometry (shape, size, and positions) is preserved. If geometry is unchanged, you should only change colors, not coordinates or orientation.</description>\\n<example>If a T-shaped cluster of color X in the input appears as an identical T in the output but with a different color, that confirms the rule is “recolor X in place” rather than “move or rotate the T.”</example>\\n</note3>\\n\\n<note4>\\n<description>Choose a replacement color that does not appear in the input so the recolored pixels are unambiguous. The replacement should be applied uniformly to every instance of the target color across the grid.</description>\\n<example>If the input uses colors {0,1,2} and you decide to recolor color 2, pick a color not in {0,1,2} (for example 3) and change every 2 to that chosen color; this makes the change visible and consistent.</example>\\n</note4>\\n\\n<note5>\\n<description>Apply the recoloring to every disconnected occurrence of the target color and leave all other colors unchanged. After recoloring, validate by counting: the number of recolored pixels should equal the original count of the target color.</description>\\n<example>If the input contains three separate 2×2 blocks of color A and one isolated A pixel, recolor all four A pixels to the chosen new color. Then check that no other colors were altered and that the counts match expectations.</example>\\n</note5>\",\n \"<note1>\\n<description>Scan the input/output pairs and ask: which color(s) differ between input and output while all other colors remain identical? If one color's pixels are the only ones that change, that color is the transformation target. This is effective because recoloring tasks usually leave geometry and other colors intact.</description>\\n<example>Imagine a grid with blue and green shapes. In the output the blue shapes appear in the same cells but in a different color, while every green cell is unchanged. That pattern tells you the rule acts on the blue color only.</example>\\n</note1>\\n\\n<note2>\\n<description>Check geometry preservation: verify whether the changed pixels keep the same coordinates, shapes, and counts as before. If they do, the operation is a recoloring (a color mapping) rather than a move, rotation, or fill. Distinguishing these avoids confusing recolor with other transformations.</description>\\n<example>For example, a 2×2 red square that remains a 2×2 square at the same location in the output indicates a color change only. If the square had shifted or been resized, you would suspect a spatial transformation instead.</example>\\n</note2>\\n\\n<note3>\\n<description>Look for consistency across all occurrences: the same input color should be replaced by the same output color in every example. A single consistent mapping across multiple disconnected components is strong evidence of a global recolor rule. If some instances change differently, the rule is more complex.</description>\\n<example>Suppose three separate red blobs in different parts of the grid all become yellow in the outputs; that repeated mapping suggests “red → yellow” is the intended rule. If one blob stayed red while others changed, you would need to look for a conditional rule.</example>\\n</note3>\\n\\n<note4>\\n<description>Identify the replacement color by inspecting outputs: it will be a color present in the outputs but not used (or used only as the changed color) in the inputs. The replacement is typically a single new color applied uniformly to the target pixels. This tells you which color to use when applying the rule.</description>\\n<example>If inputs use only blue and green, and outputs show blue plus a new purple, and all blue pixels become purple, then purple is the replacement color. The replacement color need not appear in the inputs originally.</example>\\n</note4>\\n\\n<note5>\\n<description>Apply the discovered mapping to the test input by replacing every pixel of the identified input color with the replacement color, leaving all other pixels unchanged. After applying it, verify that shapes, counts, and positions of non-target colors match the examples. This final check prevents accidental partial or conditional recoloring.</description>\\n<example>Given a test grid where the target color appears in several disconnected regions, recolor every pixel of that color to the replacement color and confirm that the number and arrangement of other colors are identical to the input. If everything matches, the transformation is consistent.</example>\\n</note5>\",\n \"<note1>\\n<description>Find the color that is consistently changed across the training examples: it is the color whose pixels are altered in the outputs while other colors remain identical. This indicates a global recoloring rule rather than a local edit or geometric transformation. Recognizing which color is the target focuses the rest of the work.</description>\\n<example>Imagine three training pairs where a blue cluster in each input appears as a different color in the corresponding output, while red clusters stay red and black stays black. That repeated change points to “blue” as the color being transformed in every example.</example>\\n</note1>\\n\\n<note2>\\n<description>Check that the transformation preserves shapes and positions: the changed pixels occupy the same cells in input and output, only their color value changes. If geometry is preserved, the rule is a recoloring operation, not a move, resize, or reflection. This helps you avoid trying geometric operations.</description>\\n<example>For example, a 2×2 square of color A at (row 2–3, col 5–6) in the input remains a 2×2 square at the same coordinates in the output but with a different color; this shows the rule alters color only, keeping the shape and location intact.</example>\\n</note2>\\n\\n<note3>\\n<description>Observe that the recoloring is uniform: every pixel of the targeted color becomes the same single new color across all instances and across all training examples. The mapping is one-to-one and global for that color. This consistency is the core of the transformation rule.</description>\\n<example>If in two training examples every instance of color X becomes color Y (no exceptions), then the rule is “change all X to Y.” You do not need to treat each X instance differently — they all get the same replacement.</example>\\n</note3>\\n\\n<note4>\\n<description>Confirm that no other colors are altered and that the background remains unchanged. The transformation should only touch the identified color and leave all other colors and empty cells as they were. This prevents accidental modification of unrelated objects.</description>\\n<example>Suppose inputs contain red, green, and black, and only green pixels differ between inputs and outputs; then green is the target and red and black should be left exactly as they are in the output.</example>\\n</note4>\\n\\n<note5>\\n<description>To solve the test case, locate every pixel of the identified target color in the test input and recolor each of those pixels to the single replacement color you inferred from training, keeping all positions and shapes unchanged. After recoloring, verify that no other colors were altered and that the recoloring is consistent everywhere.</description>\\n<example>Given a new grid with several scattered pixels of the target color, change each of those pixels to the replacement color you found in the examples, leaving all other cells untouched. If the result matches the pattern of the training outputs (only that color changed, shapes preserved), you have applied the rule correctly.</example>\\n</note5>\",\n \"<note1>\\n<description>Look for a color that is present in the input but absent in the output; such a disappearance usually means that color was replaced by another. This is a common, simple transformation: one color is globally substituted for a single other color. Formally, if every pixel of color X in the input becomes color Y in the output, then X→Y is the core operation.</description>\\n<example>Imagine a small grid where every red pixel in the input appears as blue in the output and no red pixels remain. That tells you the rule is \\\"replace red with blue\\\" and you can apply that substitution everywhere in the grid.</example>\\n</note1>\\n\\n<note2>\\n<description>Verify the substitution is global and consistent: every occurrence of the candidate color should change to the same new color. If some occurrences remain unchanged or change differently, the rule is not a single global recolor. Consistency across all examples is the key test.</description>\\n<example>For instance, if three separate red patches in the input all become blue in the output (and no other colors change), you have a global red→blue substitution. If one red patch stayed red, the rule would need to be more complex.</example>\\n</note2>\\n\\n<note3>\\n<description>Use shape and position invariants to confirm the operation: a recoloring preserves the exact locations and shapes of the affected pixels. If shapes are identical between input and output except for color, the transformation is color-only. This helps distinguish recoloring from operations like translation, rotation, or filling.</description>\\n<example>If a 2×2 square at a particular location is red in the input and the same 2×2 square is blue in the output, the shape and location are preserved and only the color changed. That supports a recolor rule rather than a geometric change.</example>\\n</note3>\\n\\n<note4>\\n<description>Check that all other colors and the background remain unchanged; the transformation should affect only the identified color. If other colors stay identical in both input and output, you can focus on recoloring just that color. This narrows the problem to a single substitution rather than a multi-step edit.</description>\\n<example>Suppose green and black pixels are identical between input and output while only red pixels differ; then the rule is limited to red→something and you can ignore green/black when constructing the output.</example>\\n</note4>\\n\\n<note5>\\n<description>Once you have identified the color-to-color mapping from the examples, apply it to the test input by replacing every occurrence of the source color with the target color, leaving all other pixels untouched. Finally, verify that the counts and shapes of the affected regions match the pattern seen in the training outputs. This yields a consistent, unambiguous output.</description>\\n<example>If your analysis shows red→blue from the examples, then in the test grid change every red pixel to blue and keep all other pixels the same. After this substitution, the blue regions should occupy exactly the same positions and have the same shapes as the red regions did in the input.</example>\\n</note5>\",\n \"<note1>\\n<description>Look for a one-to-one color substitution: if one color in the input always becomes a single other color in the output while all other colors remain identical, the rule is a global recoloring. This is effective when shapes and positions are preserved but only the color labels change.</description>\\n<example>Imagine several 2×2 blue squares and a few red dots. In the output you see the same squares and dots in the same places, but every blue square is now green while red dots are unchanged. That pattern indicates a single blue→green recoloring rather than any spatial transformation.</example>\\n</note1>\\n\\n<note2>\\n<description>Check spatial invariance: verify whether the pixels of the candidate color occupy the exact same coordinates before and after the transformation. If they do, the operation is a recolor; if they move, rotate, or resize, a different rule is in play.</description>\\n<example>Take a small L-shaped cluster of pixels. If the output shows an L in the same coordinates but with a different color, the rule did not move the shape — only its color changed. That distinction rules out translations, rotations, or reflections.</example>\\n</note2>\\n\\n<note3>\\n<description>Confirm consistency across all instances: the same input color should be recolored in every separate object and every occurrence. Consistent treatment of all instances indicates a uniform global mapping rather than a context-dependent change.</description>\\n<example>If three separate blobs of the same color appear in different corners and each blob is the same new color in the output, that supports a global recoloring rule. If one blob changes differently, the rule is not a simple global substitution.</example>\\n</note3>\\n\\n<note4>\\n<description>Use counts and bounding boxes to validate the mapping: compare the number of pixels and the bounding box of the input color to the number and bounding box of the output color. Matching counts and identical bounding boxes strengthen the recolor hypothesis.</description>\\n<example>Count 12 pixels of color A and find a 12-pixel region of color B in the same bounding box in the output; this suggests A→B recoloring. If counts or bounding boxes differ, the transformation is not a simple recolor.</example>\\n</note4>\\n\\n<note5>\\n<description>Apply the inferred mapping to the test grid by replacing every pixel of the identified input color with the mapped color and leaving all other pixels unchanged. Finally, re-check that shapes and counts still match the pattern seen in the training examples.</description>\\n<example>After concluding that color X should become color Y, scan the test grid and change every X to Y while keeping other colors as they are. Then verify that each object's shape and pixel count still correspond to the original objects, ensuring the rule was applied correctly.</example>\\n</note5>\",\n \"<note1>\\n<description>Look for a color that is identical in every input example and that is the only color that differs in the corresponding outputs. This points to a global recoloring rule: one input color is consistently replaced by a single other color everywhere.</description>\\n<example>Imagine three training pairs where the input always has a red shape and the output always shows that same shape in a different color, while other colors remain unchanged. That repeated difference (red → new color) across examples indicates a simple global recolor operation rather than a shape change or movement.</example>\\n</note1>\\n\\n<note2>\\n<description>Confirm that the transformation preserves geometry: the shapes, sizes, and coordinates of the affected pixels should be unchanged between input and output. If geometry is preserved, the rule is purely a color substitution, not a translation/rotation/resize.</description>\\n<example>For instance, if a 2×2 square at (r,c) in the input appears as a 2×2 square at the same (r,c) in the output but with a different color, then the operation is a recolor. Counting pixels and comparing bounding boxes helps verify that nothing moved or grew.</example>\\n</note2>\\n\\n<note3>\\n<description>Use multiple examples to disambiguate which color is being changed: the target color will be the one that appears in inputs but is absent (or different) in outputs in every training pair. Consistency across all examples is the key test.</description>\\n<example>Suppose in each example a blue region is present in the input and the same region is a different color in the output, while other colors never change. That repeated presence/absence pattern identifies blue as the color to recolor.</example>\\n</note3>\\n\\n<note4>\\n<description>When applying the rule to the test input, recolor every pixel of the identified target color to the replacement color, leaving all other colors and the background untouched. Treat each pixel individually so isolated occurrences are handled correctly.</description>\\n<example>If the target is color A and the replacement is color B, then for every cell with color A in the test grid set it to B; do not alter cells that are already B or any other color. This preserves the original shapes and only changes color values.</example>\\n</note4>\\n\\n<note5>\\n<description>Watch for common pitfalls: don’t confuse recoloring with other operations like filling holes, merging shapes, or shifting positions. Verify by checking counts and bounding boxes of the affected color before and after recoloring.</description>\\n<example>After you recolor, count the pixels of the replacement color and compare with the original count of the target color; also compare bounding boxes. If counts and bounding boxes match (but color changed), the recolor hypothesis is supported; if not, reconsider whether a different rule applies.</example>\\n</note5>\",\n \"<note1>\\n<description>Scan the training pairs for which color's pixels differ between input and output. If one color's positions are identical but its numeric label changes while other colors stay the same, the transformation is a color substitution rather than a geometric change.</description>\\n<example>Imagine two training grids where every blue pixel in the input appears in the exact same coordinates in the output but is labeled green instead, while red and black pixels are unchanged. That pattern indicates the rule is “replace blue with green” rather than “move or reshape” blue pixels.</example>\\n</note1>\\n\\n<note2>\\n<description>Check that the replacement is applied uniformly across all occurrences: every pixel of the source color should be changed in every example. Uniformity across multiple disconnected objects is a strong sign of a global recoloring rule.</description>\\n<example>For instance, if a color appears as several separate blocks in the input and in the output each of those blocks is the same new color (no block is left or partially changed), then the rule is consistently replacing that source color everywhere.</example>\\n</note2>\\n\\n<note3>\\n<description>Distinguish recoloring from movement or shape change by comparing shapes and counts. If shapes, adjacency, and counts of colored regions remain identical between input and output, the operation is only changing color labels, not geometry.</description>\\n<example>Suppose a 2×2 square at a given location is blue in the input and the same 2×2 square is green in the output with the same neighbors; that shows a color swap. If the square were shifted or resized, you would suspect a geometric transformation instead.</example>\\n</note3>\\n\\n<note4>\\n<description>Use the training outputs to identify the target color used after substitution: the replacement color will be present in outputs and may be absent or different in the corresponding inputs. The target color is consistent across examples and is the one you should use when recoloring the source in the test case.</description>\\n<example>If every training output shows the former source-color pixels turned into the same new color (and that new color appears in outputs but not in inputs), then that new color is the target. Verify consistency across all training pairs before applying it to the test grid.</example>\\n</note4>\\n\\n<note5>\\n<description>Apply the inferred mapping to the test input by replacing every pixel of the source color with the target color, leaving all other colors and the background unchanged. After recoloring, confirm that each recolored region matches the shape and count of its original counterpart.</description>\\n<example>Take the test grid, find every pixel of the source color and change its label to the target color you identified from training. Then check that the pattern of recolored pixels corresponds to the original colored shapes in the test grid and that no other pixels were altered.</example>\\n</note5>\",\n \"<note1>\\n<description>Scan the grid for contiguous regions of the same non-background color and treat each as an object. Record each object's bounding box, pixel count, and whether it is a filled rectangle or an irregular cluster.</description>\\n<example>Imagine a grid with three separated blobs: a 2×2 square, a 1×3 horizontal bar, and a 2×2 square. Label them as three objects, compute their bounding boxes (2×2, 1×3, 2×2) and counts (4,3,4). These object summaries let you compare shapes and positions without looking at every pixel.</example>\\n</note1>\\n\\n<note2>\\n<description>Group objects by identical shape (same bounding-box dimensions and same pattern of filled vs empty cells) regardless of their color. Two objects that share the same footprint and pixel pattern belong to the same shape-class.</description>\\n<example>If you find two 2×2 filled squares in different places and two L-shaped clusters elsewhere, you have two shape-classes: the 2×2 square class and the L-class. Even if one 2×2 is red and the other is blue, treat them as the same class because their patterns match exactly.</example>\\n</note2>\\n\\n<note3>\\n<description>Within each shape-class, check the colors that occupy those shapes across the grid. Often one color appears in every instance of that class and another color appears in only some instances — that “shared” color is the invariant you should preserve.</description>\\n<example>Suppose every 2×2 square you found is either red or blue, but every L-shape is either green or yellow. The 2×2 squares share the same color in every instance (say blue), so blue is the invariant color for that shape-class. The other color(s) in that class are the ones to change.</example>\\n</note3>\\n\\n<note4>\\n<description>Apply the recoloring rule: for each shape-class, leave the invariant color’s pixels unchanged and change every pixel of the other color(s) in that class to a single new color (one color per class). Do not alter the shape geometry or move pixels — only recolor.</description>\\n<example>For the 2×2 squares class, keep all blue squares as blue and change every red square to a single new color (call it X). For the L-shapes, keep the green Ls green and change the yellow Ls to another single color (call it Y). The objects remain in the same positions and keep their original shapes; only their colors are unified.</example>\\n</note4>\\n\\n<note5>\\n<description>Be careful about edge cases: use exact shape matching (not just bounding-box size), treat rotated or reflected copies as distinct unless they are identical, and choose new colors that do not conflict with existing colors. After recoloring, verify that each shape-class now has exactly one color and that the shapes are unchanged.</description>\\n<example>If you see a 2×2 square rotated 90°, it is a different footprint and should not be merged with the 2×2 squares class. If two classes share a color, that color may still be the invariant for one class; always confirm by checking every instance of each class. Finally, pick replacement colors that won’t collide with the preserved colors so the result is unambiguous.</example>\\n</note5>\",\n \"<note1>\\n<description>Look for a uniform recoloring: many ARC tasks simply change the color of one object while leaving its shape and position intact. If a single input color becomes a single other color in the output, the rule is likely \\\"replace color A with color B\\\".</description>\\n<example>Imagine a grid with several small 2×2 blue squares and one large green shape. In the output the blue squares are still in the same cells but now all appear as orange, while the green shape is unchanged. This indicates a global recoloring of blue→orange rather than any movement or resizing.</example>\\n</note1>\\n\\n<note2>\\n<description>Identify the target color by comparing color sets: the target is the non-background color that is missing from the output and whose positions match those in the input. Use the training pairs to see which color disappears or is consistently replaced.</description>\\n<example>Suppose inputs contain colors {0, A, B} and outputs contain {0, B, C}. If the positions of A in the input exactly match the positions of C in the output, then A is being recolored to C. The background (0) should remain unchanged.</example>\\n</note2>\\n\\n<note3>\\n<description>Confirm the rule is global and shape-preserving: the transformation should recolor every pixel of the target color across the grid, not just some instances or only connected components. Check multiple occurrences to be sure.</description>\\n<example>If there are three isolated A pixels in different places and the output shows three corresponding pixels of color C (same coordinates), that confirms a global recolor. If only one instance changed, you would suspect a different rule instead.</example>\\n</note3>\\n\\n<note4>\\n<description>Use counts and connectivity as a sanity check: the number of target-color pixels should equal the number of new-color pixels in the output, and their connected-component structure should match. This helps distinguish recoloring from copying, filling, or deletion.</description>\\n<example>If A appears 12 times in the input and C appears 12 times in the output at the same coordinates, that supports A→C. If counts differ, consider whether other operations (e.g., adding or removing pixels) are involved.</example>\\n</note4>\\n\\n<note5>\\n<description>Apply the discovered mapping to the test input and verify invariants: recolor every pixel of the target color to the replacement color, leave all other colors and background intact, and then re-check counts and shapes to ensure consistency.</description>\\n<example>After deciding A→C from the training examples, scan the test grid and change every A to C while keeping B and 0 unchanged. Finally, confirm that the number of C pixels equals the number of A pixels originally and that the shapes remain in the same places.</example>\\n</note5>\",\n \"<note1>\\n<description>Look for a single color that is consistently altered in every example while other colors remain identical. This points to a global recoloring rule rather than a shape-by-shape transformation.</description>\\n<example>Imagine three training pairs where the blue pixels appear in the same relative places in each input but the outputs show those exact cells as green instead; the unchanged red and black pixels stay the same. That pattern suggests the transformation is \\\"replace color A with color B\\\" applied everywhere.</example>\\n</note1>\\n\\n<note2>\\n<description>Verify that the operation preserves geometry and coordinates: the set of cells occupied by the target color should match between input and output. If shapes and positions are unchanged, you can treat the rule as a color substitution, not a move or reshape.</description>\\n<example>For example, if a 2×2 square of color X sits at rows 2–3, cols 5–6 in the input and the output shows a 2×2 square at the same coordinates but in color Y, that indicates a pure recoloring of those cells.</example>\\n</note2>\\n\\n<note3>\\n<description>Check that the recoloring is applied uniformly to all disconnected occurrences of the same color. The rule should not depend on object size, location, or orientation—every instance of the target color should be treated the same.</description>\\n<example>If there are three separate blobs of color A in different places, and each blob becomes color B in the outputs, then the correct approach is to recolor every A pixel regardless of which blob it belongs to.</example>\\n</note3>\\n\\n<note4>\\n<description>Use counts and exclusivity to confirm your hypothesis: the number of pixels of the target color in the input should equal the number of pixels of the replacement color in the output, and no other color should change. This helps avoid mistaking a partial or conditional rule for a global one.</description>\\n<example>If the input has 12 pixels of color A and the output shows exactly 12 pixels of color B in the same positions while all other colors keep their counts, that strongly supports a global A→B recoloring rule.</example>\\n</note4>\\n\\n<note5>\\n<description>Apply the inferred mapping to the test grid by replacing every instance of the identified target color with the replacement color, leaving all other pixels unchanged. After applying it, re-check that counts and positions of other colors are preserved to ensure consistency.</description>\\n<example>Given a test grid with several A-colored shapes scattered around, change every A pixel to B and leave black and other colors alone; then confirm that the number of B pixels equals the original number of A pixels and that no other colors were altered.</example>\\n</note5>\",\n \"<note1>\\n<description>Look for a color whose pixels occupy the exact same coordinates in input and output but with a different color value. A one-to-one correspondence of positions (same shape, same orientation) is a strong sign of a recoloring operation rather than a movement or reshaping.</description>\\n<example>Imagine a small 2×2 block of color A in the input and an identical 2×2 block in the same location in the output, but colored B. That pattern indicates the transformation simply changed A→B for that object while leaving its geometry unchanged.</example>\\n</note1>\\n\\n<note2>\\n<description>Confirm the mapping is global: every instance of the candidate color should be treated the same way. If some occurrences are left unchanged, the rule is more complex; if all are changed, you can treat the recoloring as a uniform operation.</description>\\n<example>Suppose three separate 2×2 squares of color A appear in different corners of the input and in the output all three are color B. Because every A was changed consistently, you can apply A→B everywhere rather than handling each object individually.</example>\\n</note2>\\n\\n<note3>\\n<description>Check that other colors and background remain identical between input and output. If other colors are unchanged, the rule likely targets only the identified color and preserves the rest of the scene.</description>\\n<example>If color C and the black background appear in the same positions before and after, and only color A differs, then the transformation is selective—A is being recolored while C and background are left intact.</example>\\n</note3>\\n\\n<note4>\\n<description>Use simple counts and connectivity to validate your hypothesis: the number of changed pixels should match the number of pixels of the candidate color in the input, and their connected components should align. This helps distinguish recoloring from duplication, deletion, or relocation.</description>\\n<example>Count how many A pixels exist in the input (e.g., 10). If the output has exactly 10 pixels of color B occupying those same coordinates and no extra B pixels appear elsewhere, the evidence supports A→B recoloring.</example>\\n</note4>\\n\\n<note5>\\n<description>When you apply the rule to the test grid, change every pixel of the identified color to the new color and leave all other pixels unchanged. Finally, re-check that shapes, counts, and positions match the invariants you observed in the examples.</description>\\n<example>Given a test grid with several scattered A-colored objects, replace each A with B in-place. Then verify that all A→B changes are consistent with the examples (same shapes, same counts, same locations) and that no other colors were altered.</example>\\n</note5>\",\n \"<note1>\\n<description>Look first for a single color that consistently changes across every example while other colors remain identical. If one color’s pixels are the only ones that differ between input and output, that color is the transformation target.</description>\\n<example>Imagine three small grids where blue shapes appear in the input and, in the corresponding outputs, those same blue pixels are all a different color while red and black pixels are unchanged. That consistent replacement points you to the color you should focus on.</example>\\n</note1>\\n\\n<note2>\\n<description>Check whether the transformation is a pure recoloring: the pixels that change keep the same coordinates and shapes, only their color value changes. This distinguishes recoloring from operations that move, resize, or create shapes.</description>\\n<example>For instance, if a 2×2 square at the top-right corner is color A in the input and the output shows a 2×2 square at the exact same coordinates but in color B, the operation is a recolor rather than a relocation or reshaping.</example>\\n</note2>\\n\\n<note3>\\n<description>Confirm that the recoloring is global and uniform: every pixel of the targeted color is changed the same way, even if there are multiple disconnected patches. The rule should not depend on patch size, orientation, or position.</description>\\n<example>Suppose there are three separate patches of color A in different parts of the grid; if all three become color B in the outputs, you have a uniform global recolor rule rather than a patch-specific rule.</example>\\n</note3>\\n\\n<note4>\\n<description>Use counts and connectivity to validate your hypothesis: compare the number of pixels of the candidate color in input and output and check that those exact coordinates are occupied by the new color. Matching counts and exact coordinate overlap strengthen the recolor interpretation.</description>\\n<example>If the input has N pixels of color A and the output has N pixels of color B occupying the same cells, that numerical and positional match is strong evidence the rule is “replace A with B”.</example>\\n</note4>\\n\\n<note5>\\n<description>Before applying the rule to the test case, ensure it is consistent across all training examples and not conditional on location or shape. If it is consistent, apply the same recoloring to every pixel of the identified color in the test grid.</description>\\n<example>When every training example shows the same color always changing to the same new color regardless of where it appears, you can confidently recolor every occurrence of that color in the test input to produce the output.</example>\\n</note5>\",\n \"<note1>\\n<description>Look for a consistent color substitution: one color in the inputs may be replaced by a single different color in the outputs while all other colors and the background stay the same. This indicates a global recoloring rule rather than a geometric change. </description>\\n<example>Imagine several examples where every red pixel in the inputs becomes blue in the outputs, and every green and black pixel remains identical. That pattern suggests the transformation is \\\"replace red with blue\\\" rather than moving or reshaping objects.</example>\\n</note1>\\n\\n<note2>\\n<description>Use counts and positions to confirm the mapping: the number of pixels of the candidate input color should match the number of pixels of the candidate output color, and their coordinates should align. Matching counts and coordinates are strong evidence of a pure recolor. </description>\\n<example>If an input has 12 cyan pixels at particular coordinates and the corresponding output has 12 magenta pixels at those same coordinates, and no other pixels changed, the simplest explanation is a one-to-one recolor from cyan→magenta.</example>\\n</note2>\\n\\n<note3>\\n<description>Check that shapes and connectivity are preserved: if the colored regions keep the same footprint and adjacency but only their color changes, the rule is recoloring. If shapes move, grow, shrink, or split, a different rule is at work. </description>\\n<example>Suppose a 2×3 block of orange pixels in the input appears as a 2×3 block in the output but in purple; that indicates recoloring. If the block instead becomes a 3×3 or shifts position, you must consider geometric operations instead.</example>\\n</note3>\\n\\n<note4>\\n<description>Distinguish global recoloring from selective edits: verify that every instance of the candidate color is changed across all examples, not just some occurrences. A global rule will affect every connected component of that color. </description>\\n<example>If one example shows a single isolated yellow pixel and another shows a large yellow cluster, and in both outputs those yellow pixels are the same new color, that supports a global \\\"replace yellow\\\" rule. If only some yellow pixels change, the rule is more selective.</example>\\n</note4>\\n\\n<note5>\\n<description>Apply the inferred mapping to the test input and then validate: recolor every pixel of the chosen input color to the chosen output color, leave all other colors unchanged, and check that counts, shapes, and background match the pattern from examples. This final check prevents accidental overfitting to a single example. </description>\\n<example>After deducing that one color consistently becomes another across training pairs, perform that substitution on the test grid and confirm that the resulting colored regions and their positions are consistent with the behavior seen in the examples.</example>\\n</note5>\",\n \"<note1>\\n<description>Start by isolating the difference: find the color(s) that are present in the input but not in the output, and the color(s) that appear in the output but not in the input. This often reveals a one-to-one recoloring rather than a geometric change. Focusing on which color was replaced reduces the search space.</description>\\n<example>Imagine a small grid where blue pixels form several identical squares and green pixels form other shapes. In the output you see the green shapes still in the same positions but now all yellow, while the blue squares are unchanged. Noticing that exactly one input color has been replaced by one new color points you toward a recoloring rule.</example>\\n</note1>\\n\\n<note2>\\n<description>Check shape and position invariance: if the pixels that change keep the same coordinates and the same pattern, the transformation is likely a recolor rather than a move or rotation. This distinguishes color-only rules from spatial transformations. Use this to ignore spatial hypotheses when appropriate.</description>\\n<example>Take a 2×2 red block at a fixed location; if in the output that same 2×2 block is green but at the same coordinates, then the operation was a color swap for that block. If instead the block moved or rotated, you would need a spatial rule.</example>\\n</note2>\\n\\n<note3>\\n<description>Verify consistency across all examples: a true rule will apply the same recoloring to every occurrence of the target color in every training pair. If the same source color is always changed to the same target color, that consistency is the key. If you find exceptions, the rule may depend on context (shape, adjacency, or position).</description>\\n<example>If in three training examples every blue pixel becomes yellow while red pixels remain red, that repeated pattern strongly indicates a global blue→yellow recolor. If some blue pixels stayed blue in one example, look for additional conditions that explain the exception.</example>\\n</note3>\\n\\n<note4>\\n<description>Look for a single new color introduced in outputs that did not appear in the inputs; often the rule is “replace color A with a new color B.” This is a common pattern when one color is removed and a fresh color is used to mark it. Identifying which color is new helps you infer the mapping direction (which color is being replaced).</description>\\n<example>Suppose an input uses colors {0,1,2} and the outputs use {0,1,3}. The presence of 3 in outputs but not in inputs suggests that one of the existing colors was mapped to 3. Checking which input color disappears in outputs tells you which color was replaced.</example>\\n</note4>\\n\\n<note5>\\n<description>Apply the inferred mapping to the test grid: recolor every pixel of the identified source color to the inferred target color and leave all other pixels unchanged. After recoloring, verify that the shapes, counts, and positions of recolored pixels match the pattern you observed in the training examples. This final check ensures you haven’t missed a contextual exception.</description>\\n<example>Once you deduce “color X → color Y” from the examples, go through the test grid and change every X to Y while keeping all other colors as they are. Then confirm that the recolored pixels occupy the same locations as before and that no other pixels were altered.</example>\\n</note5>\"\n]","isConversational":false},"train":{"kind":"string","value":"[{\"input\": [[0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0], [0, 0, 0, 0, 4, 4, 0, 0, 0, 0, 0, 0, 0], [0, 0, 0, 0, 4, 4, 0, 0, 0, 0, 0, 0, 0], [0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0], [0, 0, 4, 4, 0, 0, 0, 0, 0, 0, 0, 0, 0], [0, 0, 4, 4, 0, 0, 0, 4, 4, 0, 0, 0, 0], [0, 0, 0, 0, 0, 0, 0, 4, 4, 0, 0, 0, 0], [0, 0, 0, 0, 0, 0, 0, 4, 4, 0, 0, 0, 0], [2, 2, 0, 0, 0, 0, 0, 0, 0, 0, 0, 2, 2], [2, 2, 0, 0, 0, 0, 0, 2, 2, 2, 0, 2, 0], [2, 2, 0, 0, 0, 0, 0, 2, 2, 2, 0, 0, 0], [0, 0, 0, 0, 0, 0, 0, 2, 0, 2, 0, 0, 0], [0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0]], \"output\": [[0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0], [0, 0, 0, 0, 4, 4, 0, 0, 0, 0, 0, 0, 0], [0, 0, 0, 0, 4, 4, 0, 0, 0, 0, 0, 0, 0], [0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0], [0, 0, 4, 4, 0, 0, 0, 0, 0, 0, 0, 0, 0], [0, 0, 4, 4, 0, 0, 0, 4, 4, 0, 0, 0, 0], [0, 0, 0, 0, 0, 0, 0, 4, 4, 0, 0, 0, 0], [0, 0, 0, 0, 0, 0, 0, 4, 4, 0, 0, 0, 0], [3, 3, 0, 0, 0, 0, 0, 0, 0, 0, 0, 3, 3], [3, 3, 0, 0, 0, 0, 0, 3, 3, 3, 0, 3, 0], [3, 3, 0, 0, 0, 0, 0, 3, 3, 3, 0, 0, 0], [0, 0, 0, 0, 0, 0, 0, 3, 0, 3, 0, 0, 0], [0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0]]}, {\"input\": [[0, 0, 0, 0, 0, 0, 0, 0, 0, 4, 4, 0], [0, 0, 0, 2, 2, 0, 0, 0, 0, 4, 4, 0], [0, 0, 0, 2, 2, 0, 0, 0, 0, 4, 4, 0], [0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0], [0, 0, 0, 4, 4, 0, 0, 2, 2, 2, 0, 0], [0, 0, 0, 0, 4, 0, 0, 2, 2, 2, 0, 0], [0, 0, 0, 4, 4, 0, 0, 0, 0, 0, 0, 0], [0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0], [0, 0, 0, 0, 0, 0, 0, 0, 2, 2, 0, 0], [2, 0, 0, 0, 0, 0, 0, 0, 2, 2, 0, 0], [2, 2, 2, 0, 0, 0, 0, 0, 2, 2, 0, 0], [0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0]], \"output\": [[0, 0, 0, 0, 0, 0, 0, 0, 0, 4, 4, 0], [0, 0, 0, 3, 3, 0, 0, 0, 0, 4, 4, 0], [0, 0, 0, 3, 3, 0, 0, 0, 0, 4, 4, 0], [0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0], [0, 0, 0, 4, 4, 0, 0, 3, 3, 3, 0, 0], [0, 0, 0, 0, 4, 0, 0, 3, 3, 3, 0, 0], [0, 0, 0, 4, 4, 0, 0, 0, 0, 0, 0, 0], [0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0], [0, 0, 0, 0, 0, 0, 0, 0, 3, 3, 0, 0], [3, 0, 0, 0, 0, 0, 0, 0, 3, 3, 0, 0], [3, 3, 3, 0, 0, 0, 0, 0, 3, 3, 0, 0], [0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0]]}, {\"input\": [[2, 2, 0, 0, 0, 0, 0, 4, 0, 0, 0, 0, 0, 0], [2, 2, 0, 0, 0, 0, 4, 4, 4, 0, 0, 0, 0, 0], [0, 0, 0, 0, 0, 0, 0, 4, 0, 0, 0, 0, 0, 0], [0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0], [0, 0, 0, 2, 2, 0, 0, 0, 0, 0, 0, 0, 0, 0], [4, 4, 0, 2, 2, 0, 0, 0, 0, 0, 0, 0, 0, 0], [4, 4, 0, 2, 2, 0, 0, 0, 0, 0, 0, 0, 0, 0], [4, 4, 0, 0, 0, 0, 0, 0, 0, 2, 2, 2, 0, 0], [0, 0, 0, 0, 0, 0, 0, 0, 0, 2, 2, 2, 0, 0], [0, 0, 0, 2, 2, 2, 0, 0, 0, 0, 0, 0, 0, 0], [0, 0, 0, 2, 0, 2, 0, 0, 0, 0, 0, 0, 0, 0], [0, 0, 0, 2, 2, 2, 0, 0, 0, 0, 0, 0, 0, 0]], \"output\": [[3, 3, 0, 0, 0, 0, 0, 4, 0, 0, 0, 0, 0, 0], [3, 3, 0, 0, 0, 0, 4, 4, 4, 0, 0, 0, 0, 0], [0, 0, 0, 0, 0, 0, 0, 4, 0, 0, 0, 0, 0, 0], [0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0], [0, 0, 0, 3, 3, 0, 0, 0, 0, 0, 0, 0, 0, 0], [4, 4, 0, 3, 3, 0, 0, 0, 0, 0, 0, 0, 0, 0], [4, 4, 0, 3, 3, 0, 0, 0, 0, 0, 0, 0, 0, 0], [4, 4, 0, 0, 0, 0, 0, 0, 0, 3, 3, 3, 0, 0], [0, 0, 0, 0, 0, 0, 0, 0, 0, 3, 3, 3, 0, 0], [0, 0, 0, 3, 3, 3, 0, 0, 0, 0, 0, 0, 0, 0], [0, 0, 0, 3, 0, 3, 0, 0, 0, 0, 0, 0, 0, 0], [0, 0, 0, 3, 3, 3, 0, 0, 0, 0, 0, 0, 0, 0]]}]"},"test":{"kind":"string","value":"[{\"input\": [[2, 2, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0], [2, 2, 0, 0, 4, 4, 0, 0, 0, 4, 4, 0, 0, 0], [2, 2, 0, 0, 4, 4, 0, 0, 0, 4, 4, 0, 0, 0], [0, 0, 0, 0, 4, 4, 0, 0, 0, 4, 4, 0, 2, 2], [0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 2], [0, 0, 0, 2, 2, 2, 0, 0, 0, 0, 0, 0, 2, 2], [0, 0, 0, 2, 2, 2, 0, 0, 0, 0, 0, 0, 0, 0], [0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0], [0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 2, 0], [0, 2, 2, 0, 0, 0, 0, 0, 0, 0, 0, 2, 2, 2], [0, 2, 2, 0, 0, 0, 4, 4, 4, 0, 0, 0, 2, 0], [0, 0, 0, 0, 0, 0, 4, 4, 4, 0, 0, 0, 0, 0], [0, 0, 2, 2, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0], [0, 0, 2, 2, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0]], \"output\": [[3, 3, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0], [3, 3, 0, 0, 4, 4, 0, 0, 0, 4, 4, 0, 0, 0], [3, 3, 0, 0, 4, 4, 0, 0, 0, 4, 4, 0, 0, 0], [0, 0, 0, 0, 4, 4, 0, 0, 0, 4, 4, 0, 3, 3], [0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 3], [0, 0, 0, 3, 3, 3, 0, 0, 0, 0, 0, 0, 3, 3], [0, 0, 0, 3, 3, 3, 0, 0, 0, 0, 0, 0, 0, 0], [0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0], [0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 3, 0], [0, 3, 3, 0, 0, 0, 0, 0, 0, 0, 0, 3, 3, 3], [0, 3, 3, 0, 0, 0, 4, 4, 4, 0, 0, 0, 3, 0], [0, 0, 0, 0, 0, 0, 4, 4, 4, 0, 0, 0, 0, 0], [0, 0, 3, 3, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0], [0, 0, 3, 3, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0]]}]"},"source":{"kind":"string","value":"barc_heavy"},"prompt":{"kind":"string","value":"You will be given some number of paired example inputs and outputs grids. The outputs were produced by applying a transformation rule to the input grids. In addition to the paired example inputs and outputs, there is also one test input without a known output. The inputs and outputs are each “grids”. A grid is a rectangular matrix of integers between 0 and 9 (inclusive). Each number corresponds to a color. 0 is black. Your task is to determine the transformation rule from examples and find out the answer, involving determining the size of the output grid for the test and correctly filling each cell of the grid with the appropriate color or number. The transformation only needs to be unambiguous and applicable to the example inputs and the test input. It doesn't need to work for all possible inputs. Observe the examples carefully, imagine the grid visually, and try to find the pattern. Please output your answer within a code block (```), formatted as a grid of numbers. \n\n# Examples\n## Example 1\nInput:\n```\n0 0 0 0 0 0 0 0 0 0 0 0 0\n0 0 0 0 4 4 0 0 0 0 0 0 0\n0 0 0 0 4 4 0 0 0 0 0 0 0\n0 0 0 0 0 0 0 0 0 0 0 0 0\n0 0 4 4 0 0 0 0 0 0 0 0 0\n0 0 4 4 0 0 0 4 4 0 0 0 0\n0 0 0 0 0 0 0 4 4 0 0 0 0\n0 0 0 0 0 0 0 4 4 0 0 0 0\n2 2 0 0 0 0 0 0 0 0 0 2 2\n2 2 0 0 0 0 0 2 2 2 0 2 0\n2 2 0 0 0 0 0 2 2 2 0 0 0\n0 0 0 0 0 0 0 2 0 2 0 0 0\n0 0 0 0 0 0 0 0 0 0 0 0 0\n```\n\nOutput:\n```\n0 0 0 0 0 0 0 0 0 0 0 0 0\n0 0 0 0 4 4 0 0 0 0 0 0 0\n0 0 0 0 4 4 0 0 0 0 0 0 0\n0 0 0 0 0 0 0 0 0 0 0 0 0\n0 0 4 4 0 0 0 0 0 0 0 0 0\n0 0 4 4 0 0 0 4 4 0 0 0 0\n0 0 0 0 0 0 0 4 4 0 0 0 0\n0 0 0 0 0 0 0 4 4 0 0 0 0\n3 3 0 0 0 0 0 0 0 0 0 3 3\n3 3 0 0 0 0 0 3 3 3 0 3 0\n3 3 0 0 0 0 0 3 3 3 0 0 0\n0 0 0 0 0 0 0 3 0 3 0 0 0\n0 0 0 0 0 0 0 0 0 0 0 0 0\n```\n\n## Example 2\nInput:\n```\n0 0 0 0 0 0 0 0 0 4 4 0\n0 0 0 2 2 0 0 0 0 4 4 0\n0 0 0 2 2 0 0 0 0 4 4 0\n0 0 0 0 0 0 0 0 0 0 0 0\n0 0 0 4 4 0 0 2 2 2 0 0\n0 0 0 0 4 0 0 2 2 2 0 0\n0 0 0 4 4 0 0 0 0 0 0 0\n0 0 0 0 0 0 0 0 0 0 0 0\n0 0 0 0 0 0 0 0 2 2 0 0\n2 0 0 0 0 0 0 0 2 2 0 0\n2 2 2 0 0 0 0 0 2 2 0 0\n0 0 0 0 0 0 0 0 0 0 0 0\n```\n\nOutput:\n```\n0 0 0 0 0 0 0 0 0 4 4 0\n0 0 0 3 3 0 0 0 0 4 4 0\n0 0 0 3 3 0 0 0 0 4 4 0\n0 0 0 0 0 0 0 0 0 0 0 0\n0 0 0 4 4 0 0 3 3 3 0 0\n0 0 0 0 4 0 0 3 3 3 0 0\n0 0 0 4 4 0 0 0 0 0 0 0\n0 0 0 0 0 0 0 0 0 0 0 0\n0 0 0 0 0 0 0 0 3 3 0 0\n3 0 0 0 0 0 0 0 3 3 0 0\n3 3 3 0 0 0 0 0 3 3 0 0\n0 0 0 0 0 0 0 0 0 0 0 0\n```\n\n## Example 3\nInput:\n```\n2 2 0 0 0 0 0 4 0 0 0 0 0 0\n2 2 0 0 0 0 4 4 4 0 0 0 0 0\n0 0 0 0 0 0 0 4 0 0 0 0 0 0\n0 0 0 0 0 0 0 0 0 0 0 0 0 0\n0 0 0 2 2 0 0 0 0 0 0 0 0 0\n4 4 0 2 2 0 0 0 0 0 0 0 0 0\n4 4 0 2 2 0 0 0 0 0 0 0 0 0\n4 4 0 0 0 0 0 0 0 2 2 2 0 0\n0 0 0 0 0 0 0 0 0 2 2 2 0 0\n0 0 0 2 2 2 0 0 0 0 0 0 0 0\n0 0 0 2 0 2 0 0 0 0 0 0 0 0\n0 0 0 2 2 2 0 0 0 0 0 0 0 0\n```\n\nOutput:\n```\n3 3 0 0 0 0 0 4 0 0 0 0 0 0\n3 3 0 0 0 0 4 4 4 0 0 0 0 0\n0 0 0 0 0 0 0 4 0 0 0 0 0 0\n0 0 0 0 0 0 0 0 0 0 0 0 0 0\n0 0 0 3 3 0 0 0 0 0 0 0 0 0\n4 4 0 3 3 0 0 0 0 0 0 0 0 0\n4 4 0 3 3 0 0 0 0 0 0 0 0 0\n4 4 0 0 0 0 0 0 0 3 3 3 0 0\n0 0 0 0 0 0 0 0 0 3 3 3 0 0\n0 0 0 3 3 3 0 0 0 0 0 0 0 0\n0 0 0 3 0 3 0 0 0 0 0 0 0 0\n0 0 0 3 3 3 0 0 0 0 0 0 0 0\n```\n\n# Test Problem:\n```\n2 2 0 0 0 0 0 0 0 0 0 0 0 0\n2 2 0 0 4 4 0 0 0 4 4 0 0 0\n2 2 0 0 4 4 0 0 0 4 4 0 0 0\n0 0 0 0 4 4 0 0 0 4 4 0 2 2\n0 0 0 0 0 0 0 0 0 0 0 0 0 2\n0 0 0 2 2 2 0 0 0 0 0 0 2 2\n0 0 0 2 2 2 0 0 0 0 0 0 0 0\n0 0 0 0 0 0 0 0 0 0 0 0 0 0\n0 0 0 0 0 0 0 0 0 0 0 0 2 0\n0 2 2 0 0 0 0 0 0 0 0 2 2 2\n0 2 2 0 0 0 4 4 4 0 0 0 2 0\n0 0 0 0 0 0 4 4 4 0 0 0 0 0\n0 0 2 2 0 0 0 0 0 0 0 0 0 0\n0 0 2 2 0 0 0 0 0 0 0 0 0 0\n```"},"answer":{"kind":"string","value":"```\n3 3 0 0 0 0 0 0 0 0 0 0 0 0\n3 3 0 0 4 4 0 0 0 4 4 0 0 0\n3 3 0 0 4 4 0 0 0 4 4 0 0 0\n0 0 0 0 4 4 0 0 0 4 4 0 3 3\n0 0 0 0 0 0 0 0 0 0 0 0 0 3\n0 0 0 3 3 3 0 0 0 0 0 0 3 3\n0 0 0 3 3 3 0 0 0 0 0 0 0 0\n0 0 0 0 0 0 0 0 0 0 0 0 0 0\n0 0 0 0 0 0 0 0 0 0 0 0 3 0\n0 3 3 0 0 0 0 0 0 0 0 3 3 3\n0 3 3 0 0 0 4 4 4 0 0 0 3 0\n0 0 0 0 0 0 4 4 4 0 0 0 0 0\n0 0 3 3 0 0 0 0 0 0 0 0 0 0\n0 0 3 3 0 0 0 0 0 0 0 0 0 0\n```"},"num_tokens":{"kind":"number","value":2582,"string":"2,582"}}},{"rowIdx":99,"cells":{"abstraction_prompt":{"kind":"string","value":"<|im_start|>user\n# ARC HINT GENERATOR\n\n## Role & Goal\nYou are an expert ARC (Abstraction and Reasoning Corpus) analyst. Your task is to generate a concise, actionable hint for a user who is struggling with an ARC problem. Analyze the problem and its correct solution to produce a single standalone, targeted hint that helps the user discover the core transformation principle for themselves without revealing the answer.\n\n---\n\n## Hint Generation Strategy\n1. **Compare** the input and output grids for each example. Identify the shared transformation pattern that allows the input grid to be converted into the output grid.\n2. **Identify the Core Principle**: Review the problem description and ground-truth solution to fully discern the key transformation rule. Break it down into its essential operations (e.g., object completion, pattern repetition, symmetry, gravity), paying close attention to properties such as object count, shapes, colors, sizes, symmetry, repetition, relative positioning, and broader grid-level patterns.\n3. **Craft a Targeted Hint**: Generate a hint that guides the user toward the core insight needed to solve the problem. The hint should assist the user during their attempt without revealing the solution.\n4. Structure each note using the template below:\n - **Description** (up to 3 sentences): Explain the concept, when and why it applies, and why it is effective. Include any relevant general formula or principle in its most general form.\n - **Example** (up to 6 sentences): Present a worked example covering all aspects of the description, using a simplified yet representative scenario (not necessarily from the current problem).\n - Optionally, include **Heuristics** or **Pitfalls** in the note where relevant.\n - Focus on methodologies and core principles over specific calculations or problem details.\n - Ensure each hint applies broadly—at least 80% of analogous problems.\n\nAfter generating a hint, verify that no specifics of the solution are revealed, and that the hint remains at the level of guiding the approach.\n\n### Design Guidelines\n- Clarity: Use precise language and correct sentence structure.\n- Atomicity: Each note addresses one recognizable sub-problem.\n- Self-containment: All information needed to understand the idea and its application is within the note.\n- Generalizability: Avoid problem-specific details or variables.\n- Transferability: Notes should apply across a class of problems.\n- Distinctness: Each note addresses a distinct principle.\n\n---\n\n## Guidelines\n- **Guide, Don't Solve**: Illuminate the approach, not the answer. Emphasize what to observe or consider.\n- **Specific yet Abstract**: Use concrete grid details (e.g., \"note the relationship between the blue and red pixels\") to ground abstract patterns (e.g., \"think about one color containing another\").\n\nValidate your generated hint: confirm it is self-contained, actionable, and nondirective. If any aspect is too revealing, revise before finalizing.\n\n---\n\n## Inputs\n### Problem Description\nA full ARC problem, including input/output pairs for training and testing.\n\n## Example 1\nInput:\n```\n0 0 0 0 0 0 0 0 0 0 0 0 0 0 0\n0 0 0 0 0 0 0 0 0 0 0 0 0 0 0\n0 0 0 0 0 0 0 0 0 0 0 0 0 0 0\n0 0 0 0 0 0 0 0 0 0 0 0 0 0 0\n0 0 0 0 0 0 0 0 0 0 0 0 0 0 0\n0 0 0 0 0 0 0 0 0 0 0 0 0 0 0\n0 0 0 0 0 0 0 0 0 0 0 0 0 0 0\n0 0 0 0 0 0 0 0 0 0 0 0 0 0 0\n0 0 0 0 0 0 0 0 0 0 0 0 0 0 0\n0 0 0 0 0 0 0 0 0 0 0 0 0 0 0\n0 0 0 4 5 5 0 0 0 0 0 0 0 0 0\n0 0 0 1 3 2 0 0 0 0 0 0 0 0 0\n0 0 0 5 6 9 0 0 0 0 0 0 0 0 0\n0 0 0 0 0 0 0 0 0 0 0 0 0 0 0\n0 0 0 0 0 0 0 0 0 0 0 0 0 0 0\n0 0 0 0 0 0 0 0 0 0 0 0 0 0 0\n0 0 0 0 0 0 0 0 0 0 0 0 0 0 0\n0 0 0 0 0 0 0 0 0 0 0 0 0 0 0\n0 0 0 0 0 0 0 0 0 0 0 0 0 0 0\n```\n\nOutput:\n```\n0 0 0 0 0 0 0 0 0 0 0 0 0 0 0\n0 0 0 0 0 0 0 0 0 0 0 0 0 0 0\n0 0 0 0 0 0 0 0 0 0 0 0 0 0 0\n0 0 0 0 0 0 0 0 0 0 0 0 0 0 0\n0 0 0 0 0 0 0 0 0 0 0 0 0 0 0\n0 0 0 0 0 0 0 0 0 0 0 0 0 0 0\n0 0 0 0 0 0 0 0 0 0 0 0 0 0 0\n0 0 0 0 0 0 0 0 0 0 0 0 0 0 0\n0 0 0 0 0 0 0 0 0 0 0 0 0 0 0\n0 0 0 0 0 0 0 0 0 0 0 0 0 0 0\n0 0 0 4 4 4 0 0 0 0 0 0 0 0 0\n0 0 0 4 0 4 0 0 0 0 0 0 0 0 0\n0 0 0 4 4 4 0 0 0 0 0 0 0 0 0\n0 0 0 0 0 0 0 0 0 0 0 0 0 0 0\n0 0 0 0 0 0 0 0 0 0 0 0 0 0 0\n0 0 0 0 0 0 0 0 0 0 0 0 0 0 0\n0 0 0 0 0 0 0 0 0 0 0 0 0 0 0\n0 0 0 0 0 0 0 0 0 0 0 0 0 0 0\n0 0 0 0 0 0 0 0 0 0 0 0 0 0 0\n```\n\n## Example 2\nInput:\n```\n0 0 0 0 0 0 0 0 0 0 0\n0 0 0 0 0 0 0 0 0 0 0\n3 1 4 5 0 0 0 0 0 0 0\n8 2 5 9 0 0 0 0 0 0 0\n7 9 5 9 0 0 0 0 0 0 0\n0 0 0 0 0 0 0 0 0 0 0\n0 0 0 0 0 0 0 0 0 0 0\n0 0 0 0 0 6 2 2 7 0 0\n0 0 0 0 0 1 8 6 3 0 0\n0 0 0 0 0 3 9 7 4 0 0\n0 0 0 0 0 4 9 4 3 0 0\n0 0 0 0 0 1 3 1 7 0 0\n0 0 0 0 0 0 0 0 0 0 0\n0 0 0 0 0 0 0 0 0 0 0\n```\n\nOutput:\n```\n0 0 0 0 0 0 0 0 0 0 0\n0 0 0 0 0 0 0 0 0 0 0\n4 4 4 4 0 0 0 0 0 0 0\n4 0 0 4 0 0 0 0 0 0 0\n4 4 4 4 0 0 0 0 0 0 0\n0 0 0 0 0 0 0 0 0 0 0\n0 0 0 0 0 0 0 0 0 0 0\n0 0 0 0 0 4 4 4 4 0 0\n0 0 0 0 0 4 0 0 4 0 0\n0 0 0 0 0 4 0 0 4 0 0\n0 0 0 0 0 4 0 0 4 0 0\n0 0 0 0 0 4 4 4 4 0 0\n0 0 0 0 0 0 0 0 0 0 0\n0 0 0 0 0 0 0 0 0 0 0\n```\n\n## Example 3\nInput:\n```\n0 0 0 0 0 0 0 0 0 0 0\n0 0 0 0 0 0 0 0 0 0 0\n0 0 0 0 0 0 0 0 0 0 0\n0 0 0 0 0 0 0 0 0 0 0\n0 0 0 0 0 0 0 0 0 0 0\n0 0 0 0 0 0 0 0 0 0 0\n0 0 0 0 0 0 0 0 0 0 0\n0 0 0 0 0 0 2 3 0 0 0\n0 0 0 0 0 0 6 3 0 0 0\n0 0 0 0 0 0 4 7 0 0 0\n0 0 0 0 0 0 7 6 0 0 0\n0 0 0 0 0 0 8 3 0 0 0\n0 0 0 0 0 0 0 0 0 0 0\n0 0 0 0 0 0 0 0 0 0 0\n0 0 8 2 0 0 0 0 0 0 0\n0 0 2 8 0 0 0 0 0 0 5\n0 0 8 8 0 0 0 0 0 0 5\n0 0 0 0 0 0 0 0 0 0 4\n0 0 0 0 0 0 0 0 0 0 8\n```\n\nOutput:\n```\n0 0 0 0 0 0 0 0 0 0 0\n0 0 0 0 0 0 0 0 0 0 0\n0 0 0 0 0 0 0 0 0 0 0\n0 0 0 0 0 0 0 0 0 0 0\n0 0 0 0 0 0 0 0 0 0 0\n0 0 0 0 0 0 0 0 0 0 0\n0 0 0 0 0 0 0 0 0 0 0\n0 0 0 0 0 0 4 4 0 0 0\n0 0 0 0 0 0 4 4 0 0 0\n0 0 0 0 0 0 4 4 0 0 0\n0 0 0 0 0 0 4 4 0 0 0\n0 0 0 0 0 0 4 4 0 0 0\n0 0 0 0 0 0 0 0 0 0 0\n0 0 0 0 0 0 0 0 0 0 0\n0 0 4 4 0 0 0 0 0 0 0\n0 0 4 4 0 0 0 0 0 0 4\n0 0 4 4 0 0 0 0 0 0 4\n0 0 0 0 0 0 0 0 0 0 4\n0 0 0 0 0 0 0 0 0 0 4\n```\n\n### Test Input\nHere is the input for the test problem.\n\n```\n0 0 0 0 0 0 0 0 0 0 0\n0 0 0 0 0 0 0 0 0 0 0\n0 0 0 0 0 0 0 0 0 0 0\n0 0 0 0 0 0 0 0 0 0 0\n0 0 0 0 0 0 0 0 0 0 0\n0 0 0 0 0 0 0 0 0 0 0\n0 0 0 0 0 0 0 0 0 0 0\n0 0 0 0 0 0 0 0 0 0 0\n0 0 0 0 0 0 0 0 0 0 0\n0 0 0 0 0 0 0 0 0 0 0\n0 0 0 0 0 0 0 0 0 0 0\n0 0 0 0 0 0 0 0 0 0 0\n0 0 0 0 0 0 0 0 0 0 0\n0 0 0 0 0 0 0 0 0 0 0\n0 0 0 0 0 0 0 0 0 0 0\n0 0 0 0 0 0 0 0 0 0 0\n0 0 0 0 0 0 0 0 0 4 6\n```\n\n\n### Output Format\nOnly produce a **sequence of 5** notes in the structure:\n<note1>\n<description>...</description>\n<example>...</example>\n</note1>\n<note2>\n<description>...</description>\n<example>...</example>\n</note2>\n...\n\nDO NOT generate any other text\n\n---\n\n\n# Generated Hint<|im_end|>\n<|im_start|>assistant\n"},"abstraction_prompt_length":{"kind":"number","value":3725,"string":"3,725"},"generated_abstractions":{"kind":"list like","value":["<note1>\n<description>Separate the scene into objects by finding contiguous non-zero pixels; each contiguous group is treated independently. This isolates the units the transformation acts on and prevents mixing information from different regions.</description>\n<example>Imagine a grid with two disconnected colored blobs: one on the left and one on the right. You would analyze the left blob by itself and then the right blob by itself, computing sizes and positions for each separately.</example>\n</note1>\n\n<note2>\n<description>For each object compute its minimal bounding rectangle (min row, max row, min col, max col). The rectangle size (height × width) is the key numeric property used to decide the shape of the replacement.</description>\n<example>If a blob occupies rows 5–7 and columns 2–4, its bounding rectangle is 3 rows by 3 columns. Record these dimensions before you change any pixels.</example>\n</note2>\n\n<note3>\n<description>Replace the object by drawing a one-pixel-thick border (a frame) around that bounding rectangle using a single color. The frame occupies the rectangle's perimeter; the interior cells inside the perimeter become the background color.</description>\n<example>A 4×4 bounding box becomes a 4×4 frame: the outer ring is the new color and the inner 2×2 area is cleared to background. A 2×3 box becomes a 2×3 frame: the outer cells are colored and the interior (if any) is cleared.</example>\n</note3>\n\n<note4>\n<description>Use one consistent replacement color for every frame. The examples use a single non-background color to draw all borders; pick that same color for every object's perimeter so the result is uniform.</description>\n<example>If the training outputs show frames in color X, then every object you frame should use color X as well. Do not mix colors between different objects.</example>\n</note4>\n\n<note5>\n<description>Handle edge cases: a bounding rectangle that is already 1×1 (a single pixel) remains a 1×1 frame (no interior to clear), and when frames touch or overlap, they simply share the border color. Apply the same rule to each object independently.</description>\n<example>A single colored pixel stays a single pixel (it is its own 1×1 frame). If two nearby blobs produce frames that meet, the meeting cells are still the chosen frame color and you do not merge interiors or alter background elsewhere.</example>\n</note5>","<note1>\n<description>Look for connected non-zero pixels: treat any non-background cells that touch (including diagonally) as one object. The transformation operates on these objects rather than on individual isolated pixels. This tells you where to focus your changes.</description>\n<example>Imagine a grid with a 2×3 block of colored pixels and a single colored pixel elsewhere; the block and the single pixel are two separate objects. You should process each object independently rather than merging them or changing the background zeros.</example>\n</note1>\n\n<note2>\n<description>Compute the minimal bounding rectangle for each object: find the smallest row and column indices that contain the object, and the largest ones. That rectangle is the natural region to modify for that object. Use these four extremes (minRow, maxRow, minCol, maxCol) as the target region.</description>\n<example>If an object has pixels at rows 4..6 and columns 7..9, its bounding rectangle is rows 4–6 by columns 7–9. You will operate only inside that rectangle for that object.</example>\n</note2>\n\n<note3>\n<description>Replace every cell inside the bounding rectangle with one uniform color. The examples show the rectangle is filled completely, not just the object's original pixels. The rectangle size is determined by the object's extents, so it can be 1×1, 1×N, N×1, or N×M.</description>\n<example>A 1×3 horizontal object becomes a filled 1×3 horizontal stripe of a single color; a 3×2 object becomes a filled 3×2 block of that color. The original internal pattern is not preserved — it is overwritten.</example>\n</note3>\n\n<note4>\n<description>Choose the fill color by inspecting the training outputs: the same non-background color is used consistently to fill all rectangles. That color is a fixed marker in the examples, not something computed from each object's internal colors. Use that same marker for every object in the test grid.</description>\n<example>If every training output shows filled rectangles in the same color, adopt that color for all bounding rectangles in the test input rather than picking a color based on each object's own palette.</example>\n</note4>\n\n<note5>\n<description>Be careful about edge cases: single-pixel objects, narrow rectangles, or objects that touch the grid border. The rectangle can be degenerate (1×1, 1×N, or N×1) but still gets filled. Do not change any zeros outside the rectangles and do not alter the grid size.</description>\n<example>A lone colored pixel becomes a filled 1×1 square of the chosen color; a vertical line of two pixels becomes a filled 2×1 column. Always verify you only modify cells inside each object's bounding rectangle and leave the rest as background.</example>\n</note5>","<note1>\n<description>Look for contiguous non-zero pixels that form compact rectangular blocks; these blocks are the objects being transformed. Treat each such block as a single unit by computing its minimal bounding rectangle (min row, max row, min col, max col).</description>\n<example>Imagine a 6×6 grid with a 2×3 patch of colored pixels at rows 2–3 and cols 4–6; the object's bounding box is rows 2..3 and cols 4..6. Work with that box as the region to change rather than individual pixels scattered around.</example>\n</note1>\n\n<note2>\n<description>Within each bounding box, identify the color that will be used to repaint the object's border. In these tasks that border color is taken from a fixed relative position inside the original box (a corner or edge position), not from the majority color.</description>\n<example>If a 3×3 box has values [[1,2,3],[4,5,6],[7,8,9]] and the top-left corner is 1, the border color chosen is 1. The interior values (2,3,4,5,6,7,8,9) are irrelevant to that choice.</example>\n</note2>\n\n<note3>\n<description>Construct a one-pixel-thick hollow rectangle (a frame) along the bounding box perimeter using the chosen border color, leaving the interior cells as background (zeros). The frame occupies the top and bottom rows and the left and right columns of the bounding box.</description>\n<example>For a 4×2 bounding box, set the two cells on the top row, the two on the bottom row, and the two cells on the left and right columns to the border color; the two interior cells remain background zeros. The result is a hollow rectangle of the same size as the original block.</example>\n</note3>\n\n<note4>\n<description>Apply the same frame operation independently to every separate colored block in the grid; do not merge blocks or change their positions. After processing, the grid should show one framed rectangle per original colored region, all in the same border color.</description>\n<example>If two distinct 2×2 colored squares appear in different parts of the grid, each becomes a hollow 2×2 frame (top and bottom rows and left and right columns painted), while the original interior pixels are cleared to background.</example>\n</note4>\n\n<note5>\n<description>Watch edge cases: if a bounding box is only one cell wide or one cell tall, the frame will cover the whole box (no interior to clear). Also, when multiple boxes are present, each uses the same rule — pick the border color from the same relative position in each box so all frames use the same color.</description>\n<example>A 1×4 colored strip becomes a 1×4 frame (all four cells painted) because there is no interior to clear. If two boxes both have their top-left corner equal to color X, both frames will be color X even if the boxes are different sizes.</example>\n</note5>","<note1>\n<description>Look for contiguous groups of non-zero cells: each such group is an independent object to transform. Treat each object by its minimal bounding rectangle so you can reason about its size and shape without interference from other objects.</description>\n<example>Imagine a 2×3 block of colored pixels surrounded by zeros. The minimal bounding rectangle is exactly that 2×3 area; you should consider that whole rectangle as the object to be transformed rather than individual pixels scattered around it.</example>\n</note1>\n\n<note2>\n<description>Observe the output pattern: every object is replaced by a single-color outline (a one-pixel-thick perimeter) drawn in a single consistent color across the grid. The interior of the original bounding rectangle is cleared back to the background.</description>\n<example>For a 3×4 bounding box, the output will show a 1-pixel-wide frame along the box's four edges and the inner cells set to background. The frame is continuous and exactly follows the rectangle's edges.</example>\n</note2>\n\n<note3>\n<description>The color used for the outline is not taken from the object's original internal colors but is a fixed, global color chosen for all objects in the task. Identify that color by looking at the outputs of the training examples and then reuse it for every object in the test.</description>\n<example>If every example output shows the same single color used for the perimeters, pick that color as the frame color. Do not try to copy each object's internal color—use the consistent frame color instead.</example>\n</note3>\n\n<note4>\n<description>Compute the frame precisely: for a bounding rectangle with top row r0, left column c0, height h and width w, the perimeter cells are those with row in {r0, r0+h-1} or column in {c0, c0+w-1}. Leave all other cells inside the rectangle as background.</description>\n<example>For a 4×5 rectangle (h=4,w=5) the perimeter is the top and bottom rows of the rectangle and the leftmost and rightmost columns; the remaining 2×3 interior stays background. This gives a one-pixel-thick outline exactly matching the original rectangle edges.</example>\n</note4>\n\n<note5>\n<description>Apply the same rectangle-to-outline operation independently to every object and do not change the grid size or move objects. Be careful with thin objects: if a bounding rectangle is only one pixel tall or one pixel wide, the perimeter covers the entire rectangle and there is no interior to clear.</description>\n<example>A 1×2 vertical object becomes a 1×2 frame (two pixels of the frame color), and a 1×1 object becomes a single pixel of the frame color. Treat each object separately and place its frame at the same coordinates as its original bounding rectangle.</example>\n</note5>","<note1>\n<description>Look for contiguous non‑zero pixels: treat each group of adjacent non‑black cells as an object to be transformed. This isolates independent shapes so you can reason about each one separately.</description>\n<example>Imagine a grid with two separated clusters of colored pixels (one in the top‑left, one in the bottom‑right). Each cluster is handled on its own: you do not merge them or move them relative to each other. Work object‑by‑object rather than trying to transform the whole grid at once.</example>\n</note1>\n\n<note2>\n<description>Compute the minimal axis‑aligned bounding rectangle for each object: record the minimum and maximum row and column that contain the object. That rectangle is the region you will later modify.</description>\n<example>If an object occupies cells at (r=2,c=3), (r=4,c=5) and (r=3,c=4), the bounding rectangle spans rows 2..4 and columns 3..5. Use those min/max coordinates as the box edges for the transformation.</example>\n</note2>\n\n<note3>\n<description>Replace the interior of each bounding rectangle with a single uniform color, but leave the rectangle's interior zeros (holes) unchanged. In other words, fill only the non‑zero positions inside the box with one color.</description>\n<example>Take a 3×4 bounding box that contains some zeros and some colored pixels. After the operation, every non‑zero cell inside that 3×4 area becomes the same fill color, while any zero cells inside remain zero (holes are preserved).</example>\n</note3>\n\n<note4>\n<description>Choose one consistent fill color for all objects and use it across the whole grid. The training examples use a single color to mark the filled rectangles, so pick the same one for every bounding box.</description>\n<example>If you decide to use color X, then every filled rectangle produced for each object will be entirely color X. This makes the output visually consistent and distinguishes the transformed boxes from the original varied colors.</example>\n</note4>\n\n<note5>\n<description>Keep the original grid size and positions: do not shift, resize, or merge objects. Only recolor the interior of each object's bounding rectangle and leave all other cells (background and holes) as they were.</description>\n<example>For a single object that originally occupied a small rectangle, the result is that same rectangle location filled uniformly (with holes preserved). For multiple objects, apply the same rule independently to each rectangle so their relative positions remain unchanged.</example>\n</note5>","<note1>\n<description>Look for contiguous non-background regions and treat each as an independent object. These objects are the units being transformed; the background (zeros) stays unchanged and is not part of the transformation.</description>\n<example>Imagine a grid with two separated colored blobs on a black background. Instead of trying to transform the whole grid, first isolate each blob by its non-zero pixels and consider them separately — the same rule will be applied to each blob.</example>\n</note1>\n\n<note2>\n<description>Compute the minimal axis-aligned bounding rectangle for each object: take the minimum and maximum row and column that contain non-background pixels. That rectangle captures the object's outer extent and is the region you will modify.</description>\n<example>For an object whose colored pixels lie between rows 4–7 and columns 2–5, the bounding box is rows 4..7 by cols 2..5. Even if the object has holes or irregular edges, the bounding box still spans from the topmost to bottommost and leftmost to rightmost colored pixels.</example>\n</note2>\n\n<note3>\n<description>Convert each object's interior into a hollow frame: fill only the outermost cells of the bounding rectangle (the perimeter) with a single color, and set every strictly interior cell of that rectangle to background (0). This yields a one-pixel-thick border around the object.</description>\n<example>If a bounding box is 4×5, color every cell on the top and bottom rows of the box and every cell on the leftmost and rightmost columns; then set the 2×3 interior cells to 0. The result is a rectangular frame of one-pixel width.</example>\n</note3>\n\n<note4>\n<description>Use one consistent color for all frames. In the examples the frame color is taken from a single, easily identifiable pixel of the original object (for instance the top-leftmost non-background pixel of that object). Using the same selection rule for every object keeps the transformation uniform.</description>\n<example>Suppose an object's top-leftmost colored pixel is blue; then every perimeter cell of its bounding box should be painted blue, and the interior cleared to black. Do this for each object so all frames share the same color.</example>\n</note4>\n\n<note5>\n<description>Watch edge cases: if a bounding box is only one row or one column wide, there is no interior to clear and the frame is just a single line; if two bounding boxes touch or overlap, apply the frame rule independently and do not fill interior cells (they should remain background). Also, do not alter pixels outside any bounding box.</description>\n<example>A 1×4 stripe becomes a 1×4 line of the chosen color (no interior to clear). If two frames meet, each perimeter is drawn according to its own bounding box, and any cell that is not on a perimeter stays 0.</example>\n</note5>","<note1>\n<description>Look for contiguous regions made of non-background pixels and treat each as a separate object. The transformation acts on these objects independently, so isolating them first simplifies the task.</description>\n<example>Imagine a grid with two separated colored blobs: a 2×3 rectangle in the upper-left and a 1×4 line in the lower-right. You should consider these two shapes separately rather than trying to merge them or change the background around them.</example>\n</note1>\n\n<note2>\n<description>For each object, determine its minimal bounding rectangle (the smallest axis-aligned box that contains all its pixels). The bounding box gives the exact area that the output will modify for that object.</description>\n<example>If an object occupies cells at rows 5–8 and columns 2–4, its bounding box is the rectangle spanning those rows and columns (a 4×3 box). That rectangle is the region you will operate on for that object.</example>\n</note2>\n\n<note3>\n<description>The object's internal pattern is discarded: the output replaces every cell inside the bounding box with a single, uniform color. The shape of the box (not the original pixel arrangement) determines the area to fill.</description>\n<example>A 2×2 patch with mixed colors becomes a 2×2 block where every cell is the same chosen color, regardless of the original values inside the patch.</example>\n</note3>\n\n<note4>\n<description>Choose one consistent fill color for all objects. A reliable choice is the color that appears most often in the entire input (excluding the background); use that same color for every bounding box. This keeps the output consistent and ties the fill to the input palette.</description>\n<example>If color 4 appears more frequently than any other non-background color in the input, then every bounding box you fill should be painted with color 4 so all objects share the same fill color.</example>\n</note4>\n\n<note5>\n<description>After filling, verify that only the bounding boxes changed and the background remains untouched. The output should show solid rectangular blocks at the same coordinates as the original objects, with no extra pixels added or removed.</description>\n<example>Given several isolated objects, the final grid will show each as a solid rectangle at its original location; any cell outside those rectangles should match the original background value.</example>\n</note5>","<note1>\n<description>Focus first on finding the objects: contiguous groups of non-background pixels. Treat each such group as an independent object to be transformed, and ignore isolated background pixels.</description>\n<example>Imagine a grid with two separated colored blobs. Draw the smallest rectangle that contains each blob; that rectangle is the region you will work on. Do not merge objects that are separated by background cells.</example>\n</note1>\n\n<note2>\n<description>Compute the minimal bounding rectangle for each object and use its dimensions to determine the shape to draw. The rectangle’s width and height tell you whether you will produce a filled rectangle or a hollow frame (border).</description>\n<example>If an object’s bounding box is 2×2, its width equals its height and the natural framed shape is a 3×3 border (a hollow square). If the box is 3×5, the natural framed shape is a 4×6 border (a hollow rectangle).</example>\n</note2>\n\n<note3>\n<description>Replace each object by a one-pixel-thick border around its bounding rectangle, leaving the rectangle’s interior as background. The border is placed immediately outside the bounding box on all four sides.</description>\n<example>For a 2×2 object, create a 3×3 hollow square: fill the top and bottom rows and the leftmost and rightmost columns of that 3×3 area with the chosen color, and leave the center cell as background. For a 4×6 object, draw a 5×7 hollow rectangle in the same way.</example>\n</note3>\n\n<note4>\n<description>Choose the fill color for all borders by inspecting the training outputs: the same non-background color is used for every object’s border. Use that consistent color when you draw each border in the test case.</description>\n<example>Look at the example outputs and note which color appears as the thin outline around each object; that color is the one to use for every object’s border in the test input. Do not invent a new color — reuse the one shown in the examples.</example>\n</note4>\n\n<note5>\n<description>Keep the transformed object in the same location and orientation as the original; do not shift, rotate, or resize it. If a border would extend beyond the grid edge, simply clip the border to the grid (only draw the visible portion).</description>\n<example>If an object sits at the grid edge, the border will be truncated where it would go off-grid; you still place the border relative to the original bounding box and only draw the cells that fit inside the grid. This preserves object positions while allowing for partial borders at edges.</example>\n</note5>","<note1>\n<description>Look for contiguous groups of non-background pixels and treat each as a separate object. These objects are the units that get transformed, so identifying their extents is the first step.</description>\n<example>Imagine a grid with two separated patches of colored pixels. Each patch is an independent object even if they share the same color values; handle each patch separately rather than merging them into one region.</example>\n</note1>\n\n<note2>\n<description>For each object compute its minimal bounding rectangle: the smallest axis-aligned box that contains every pixel of that object. This box defines the region that will be standardized in the output.</description>\n<example>If an object occupies rows 2–5 and columns 3–6, its bounding box is those rows and columns. Even if some interior cells are background, the box still spans from the topmost to bottommost and leftmost to rightmost non-background pixels.</example>\n</note2>\n\n<note3>\n<description>Replace the interior of each bounding box by a one-pixel-thick frame of a single color, leaving the interior cells as background. The frame occupies the outermost cells of the box and has thickness one on all sides.</description>\n<example>A 3×3 bounding box becomes a hollow 3×3 square: the outer eight cells are the frame color and the center cell becomes background. A 2×4 box becomes a 2×4 frame: the outermost rows and columns are filled and the inner cells are cleared.</example>\n</note3>\n\n<note4>\n<description>Use the same frame color for every object — the examples use one consistent non-background color for all frames. Do not try to preserve the original colors or patterns inside the objects; they are overwritten by the single frame color.</description>\n<example>Two different input objects, even if they started with different colors, both become frames in the same frame color. This makes the transformation uniform across all objects.</example>\n</note4>\n\n<note5>\n<description>Apply the frame operation independently to each object and do not alter pixels outside any object's bounding box. If boxes touch or overlap, apply the rule to each box so each object ends up with its own frame.</description>\n<example>Two nearby objects will each get their own one-pixel border; if they are close enough the borders may meet or overlap, but the rule remains: draw the frame for each bounding box and leave other cells unchanged.</example>\n</note5>","<note1>\n<description>Look for contiguous non-background pixels and treat each connected cluster as an object to transform. This isolates the parts of the grid that matter and separates them from the unchanged background.</description>\n<example>Imagine a grid with two separated patches of colored pixels. Mark each patch as an independent object (don’t merge them just because they share the same color). You will transform each object separately rather than the whole grid at once.</example>\n</note1>\n\n<note2>\n<description>Compute the minimal bounding rectangle for each object by taking the minimum and maximum row and column indices that contain the object's pixels. That rectangle defines the area you will modify.</description>\n<example>If an object has pixels at rows 2..4 and columns 5..7, its bounding box is rows 2..4 by cols 5..7. Use those four indices (minRow, maxRow, minCol, maxCol) to describe the region to be painted.</example>\n</note2>\n\n<note3>\n<description>Replace every cell inside each bounding rectangle with a single, uniform color while leaving the background (zeros) untouched. The interior can be filled completely or only the border, depending on the examples.</description>\n<example>Given a 2×3 bounding box, paint all six cells inside it with the chosen color; if the examples show a hollow frame, only paint the outer ring of that box and leave the interior cells as background.</example>\n</note3>\n\n<note4>\n<description>Choose one consistent fill color for all objects rather than deriving a new color per object. The examples use the same color for every transformed rectangle, so pick a single non-background color and apply it to every bounding box.</description>\n<example>If the training outputs always use the same color for the filled rectangles, use that same color for every object's bounding box in your solution. Avoid using a color that would be confused with the background or the original object colors.</example>\n</note4>\n\n<note5>\n<description>Be careful with thin shapes and nested objects: if a bounding box is only one cell wide or tall, the border and the interior coincide, so the object becomes a single filled line; if an object is completely filled in the input, its bounding box will be filled in the output as well.</description>\n<example>A 1×4 horizontal stripe has a bounding box of height 1, so the border is the whole stripe and it remains filled. A 3×3 solid square has a one-cell interior; if the examples show hollow frames, that interior should remain background while the border is painted.</example>\n</note5>","<note1>\n<description>Look for contiguous non-background pixels and treat each such cluster as an object. Objects in these tasks are usually axis-aligned and rectangular, so their bounding box (min/max row and column) is a reliable descriptor of the object.</description>\n<example>Imagine a 3×4 patch of non-zero pixels in a corner. The smallest rectangle that contains all those pixels (its bounding box) is the object you should focus on; everything outside that rectangle is background and can be ignored for the transformation.</example>\n</note1>\n\n<note2>\n<description>Compare input and output shapes: the transformation turns each object's interior into a hollow rectangle (a frame) while preserving the object's outer dimensions. In other words, the object's bounding box is used as the outer boundary and the interior is cleared to background.</description>\n<example>If an object occupies a 5×4 rectangle in the input, the output will show a 5×4 frame: the outermost row and column cells of that bounding box become the frame color, and the cells strictly inside become background (zeros).</example>\n</note2>\n\n<note3>\n<description>Notice how the frame color is chosen: it is the same single color used for every object in the output. That color is taken from one consistent pixel in the input (a specific location relative to each object), not computed from the object's internal colors.</description>\n<example>For each object, look at the pixel at the same relative corner (for example, the object's top-left corner) and use that pixel's color to paint the object's frame. Do this for every object so all frames share the same color.</example>\n</note3>\n\n<note4>\n<description>Apply the rule independently to each object: do not merge objects or move them. The transformation preserves each object's position and size and only changes its interior/background pattern.</description>\n<example>If there are two separate colored patches in the input, you should produce two separate frames in the output at the same coordinates; the background between them remains unchanged.</example>\n</note4>\n\n<note5>\n<description>Handle thin or edge-touching objects carefully: a frame's width equals the object's width and height (so a 1×N or N×1 object will produce a 1×N or N×1 border). Also, if an object touches the grid edge, its frame simply uses the available cells (no wrapping).</description>\n<example>A 1×3 horizontal object becomes a 1×3 border (three border cells in a row) with no interior cells to clear. A 3×1 vertical object becomes a 3×1 border (three border cells in a column). If an object touches the grid boundary, the border still occupies the cells that exist.</example>\n</note5>","<note1>\n<description>Look for contiguous non-zero pixels and treat each such patch as an independent object. The transformation is applied to whole patches, not to isolated individual pixels.</description>\n<example>Imagine a grid with two separated 3×2 colored blocks in different places; you should detect two separate objects and plan the same operation for each one rather than trying to connect them or change the background.</example>\n</note1>\n\n<note2>\n<description>For each object compute its minimal bounding rectangle (the smallest axis-aligned box that contains all its non-zero pixels). This box defines the exact area that will be transformed.</description>\n<example>If an object occupies rows 5–7 and columns 2–4, its bounding box is the 3×3 rectangle from (row 5, col 2) to (row 7, col 4); that rectangle is the region you will use for the next step.</example>\n</note2>\n\n<note3>\n<description>Replace every cell inside the bounding rectangle with a single uniform color (the same color for all objects). The output does not preserve the original internal color pattern inside each box.</description>\n<example>A 2×3 rectangle that originally contains many different colors becomes a solid 2×3 block of one color in the output; you only need to decide which color to use, not which original pixel maps to which new pixel.</example>\n</note3>\n\n<note4>\n<description>Choose the fill color by inspecting the input for a non-background color that already appears as an isolated marker or small marker pixel; use that same marker color for every filled rectangle. Do not invent a new color or use the background color (0).</description>\n<example>If you see a single pixel of color X sitting alone somewhere in the input (a tiny isolated marker), use color X to fill every bounding box you found; if no such marker exists, pick a consistent non-zero color and apply it to all boxes.</example>\n</note4>\n\n<note5>\n<description>After filling, clear the original internal pattern inside each bounding box (set those cells to background) and leave all other cells unchanged. The final grid should show only the new uniform rectangles in their original positions.</description>\n<example>Given two objects, you will end up with two solid rectangles in the same places; everything outside those rectangles remains the original background color, and the original mixed pixels inside each rectangle are no longer visible.</example>\n</note5>","<note1>\n<description>Look for connected clusters of non-background pixels and treat each cluster as a single object. The transformation operates on whole objects, not on isolated pixels, so finding those connected components is the first step.</description>\n<example>Imagine a grid with two separate patches of non-zero pixels; each patch is an object. You should process each patch independently (compute its bounding box and ignore its internal colors) rather than trying to change every colored pixel individually.</example>\n</note1>\n\n<note2>\n<description>For each object compute its minimal bounding rectangle (the smallest axis-aligned box that contains every pixel of the object). That rectangle determines the size and placement of the new shape you will draw.</description>\n<example>If an object occupies cells whose rows run from r1 to r2 and columns from c1 to c2, the bounding box is exactly rows r1..r2 by columns c1..c2. Use that box as the template for the replacement shape.</example>\n</note2>\n\n<note3>\n<description>Replace the irregular interior of the bounding box with a one-pixel-thick border: fill the top and bottom rows of the box and the leftmost and rightmost columns of the box with the chosen border color. Do not fill the interior cells (they remain background).</description>\n<example>A 3×4 bounding box becomes a frame: the first and last rows of the box are filled, and the first and last columns of the box are filled; the central cells inside the box stay background. The result is a hollow rectangular outline that exactly matches the original box dimensions.</example>\n</note3>\n\n<note4>\n<description>Use the same single border color for every object so the output is consistent across all shapes. Choose a color that is not the background and apply it uniformly to all outlines.</description>\n<example>If you pick color X, every object's border should be color X. This makes the transformation uniform and easy to verify: all outlines share the same color while interiors remain background.</example>\n</note4>\n\n<note5>\n<description>Be careful with thin or narrow bounding boxes: when width or height is 1 the border covers the whole box, so it will appear filled. Also ensure the outline remains exactly one pixel thick and that you only modify cells inside the original bounding box.</description>\n<example>A 1×4 box becomes a filled 1×4 strip because the border covers every cell. A 2×2 box becomes a 2×2 filled square (border covers all four cells). In every case the border is one pixel wide and confined to the bounding rectangle.</example>\n</note5>","<note1>\n<description>Look for separate objects by finding contiguous non-background pixels; each contiguous cluster is a candidate for the same transformation. This isolates the problem into smaller, repeatable subproblems.</description>\n<example>Imagine a grid with two separated colored blobs on a black background. Treat each blob independently: compute its extent and handle it the same way rather than trying to transform the whole grid at once.</example>\n</note1>\n\n<note2>\n<description>Compute the minimal bounding rectangle for each object: the smallest axis-aligned box that contains all its pixels. The rectangle gives a clear size and position for the shape you will draw.</description>\n<example>If an object occupies rows 3–6 and columns 5–8, its bounding rectangle is 4 rows by 4 columns. Use those min/max row and column indices to define the rectangle to work with.</example>\n</note2>\n\n<note3>\n<description>Replace the irregular object by a one-pixel-thick outline (a hollow rectangle) that follows the bounding rectangle's perimeter. The interior of that rectangle should remain background.</description>\n<example>A 3×4 bounding box becomes a hollow frame: the top and bottom rows and the left and right columns of the box are filled, while the 1×2 interior remains empty. This turns any arbitrary shape inside the box into a simple perimeter-only shape.</example>\n</note3>\n\n<note4>\n<description>Use a single, consistent color for all outlines — pick the color that appears most frequently among the original non-background pixels (ignore zeros). This keeps the outputs uniform and tied to the input distribution.</description>\n<example>If the original colored pixels contain many occurrences of color X and fewer of other colors, choose X to paint every outline. If two colors tie, prefer the one that appears in the largest connected component.</example>\n</note4>\n\n<note5>\n<description>Do not move or resize objects: place each outline exactly where the bounding rectangle was and leave all other cells unchanged. If outlines touch or overlap, treat them as separate outlines and apply the same color rule consistently.</description>\n<example>Two nearby objects produce two outlines placed at their respective bounding boxes; if they meet, you still draw both outlines in the chosen color. Always preserve the original grid size and background pixels outside the rectangles.</example>\n</note5>","<note1>\n<description>Look for the minimal axis-aligned rectangle that contains every non-background cell. This bounding box (top, bottom, left, right) is the region that the transformation acts upon.</description>\n<example>Imagine a 6×6 grid where colored pixels appear only at rows 2–4 and columns 3–5. The bounding box is the rectangle rows 2..4 × cols 3..5. Treat that rectangle as the single object to transform rather than handling each colored pixel individually.</example>\n</note1>\n\n<note2>\n<description>Inside that bounding box, replace every non-background cell with a single uniform color (the examples use color 4). The interior pattern of different colors is discarded; only the presence of a non-background cell matters.</description>\n<example>Take a 3×4 box that contains several different colors and zeros. After the operation, every cell that was non-zero in that box becomes the same color (e.g., all become 4), so the box appears uniformly colored.</example>\n</note2>\n\n<note3>\n<description>After making the interior uniform, clear the interior zeros to background (0). The result is a solid rectangular outline: the box is filled except that its interior cells (if any) become background.</description>\n<example>For a 4×4 box that originally had some zeros inside, set all non-background cells to the chosen color and then set the remaining interior cells (the zeros) to 0. The box will show a filled border or a filled area with a cleared center depending on size.</example>\n</note3>\n\n<note4>\n<description>Apply the same procedure independently to each separate colored cluster. Each cluster yields its own bounding box; the operation does not merge or shift clusters relative to the grid.</description>\n<example>If the grid has two distinct colored patches in different places, compute two bounding boxes and perform the same “fill then clear interior” step on each. You will get two separate uniform rectangles in their original positions.</example>\n</note4>\n\n<note5>\n<description>Be careful about edge cases: a bounding box that is one row or one column wide has no interior to clear, so it stays uniformly filled. Also, use the same fill color consistently across all boxes (the examples use a single color).</description>\n<example>A 1×3 vertical bar has no interior zeros, so after filling it remains a single-color bar. A 3×3 box, however, will become a filled 3×3 area with the center cell set to background (0).</example>\n</note5>","<note1>\n<description>Look for contiguous regions of non-zero pixels and treat each as a single object. The transformation operates on these whole objects, not on individual scattered pixels.</description>\n<example>Imagine a grid with two separated colored blobs: one in the top-left and one in the bottom-right. Each blob is an independent object to be transformed, so you should analyze and transform each blob separately rather than trying to merge them.</example>\n</note1>\n\n<note2>\n<description>For each object, compute its minimal bounding rectangle: the smallest axis-aligned rectangle that contains all its non-background pixels. This rectangle determines the outer shape you will draw around the object.</description>\n<example>If a blob occupies rows 2..5 and columns 3..6, its bounding box is that 4×4 rectangle. Even if some cells inside that rectangle are background, they still belong to the bounding box and will be considered when drawing the frame.</example>\n</note2>\n\n<note3>\n<description>Replace the interior of the bounding box by filling it with a single uniform color (the same color for every object). The interior can be a filled block or a hollow ring depending on the box size.</description>\n<example>A 3×3 bounding box becomes a filled 3×3 block of one color; a 4×4 bounding box becomes a filled 4×4 block of the same color. The exact original colors inside the box are ignored — they are all overwritten by the uniform fill.</example>\n</note3>\n\n<note4>\n<description>Draw a one-pixel-thick border (a hollow frame) around the filled interior: the border cells are the perimeter of the bounding box and should be set to the same uniform color, while interior cells remain the filled color. If the box is too small to have an interior (width≤2 or height≤2), the frame coincides with the filled area.</description>\n<example>For a 4×4 bounding box, the outermost row and column form the border and the central 2×2 is the interior; the border is drawn in the same color as the interior. For a 2×2 bounding box there is no interior, so the result is simply a 2×2 filled block.</example>\n</note4>\n\n<note5>\n<description>Use a single consistent color for every object's frame/interior (the same across the whole grid) and do not alter background pixels. Apply the same bounding-box-to-frame rule to every separate object.</description>\n<example>Two distant blobs become two identical framed rectangles (same border thickness and same fill color). A useful check: after transformation, each object should be a uniformly colored rectangle whose border is one pixel thick and whose interior is filled.</example>\n</note5>"],"string":"[\n \"<note1>\\n<description>Separate the scene into objects by finding contiguous non-zero pixels; each contiguous group is treated independently. This isolates the units the transformation acts on and prevents mixing information from different regions.</description>\\n<example>Imagine a grid with two disconnected colored blobs: one on the left and one on the right. You would analyze the left blob by itself and then the right blob by itself, computing sizes and positions for each separately.</example>\\n</note1>\\n\\n<note2>\\n<description>For each object compute its minimal bounding rectangle (min row, max row, min col, max col). The rectangle size (height × width) is the key numeric property used to decide the shape of the replacement.</description>\\n<example>If a blob occupies rows 5–7 and columns 2–4, its bounding rectangle is 3 rows by 3 columns. Record these dimensions before you change any pixels.</example>\\n</note2>\\n\\n<note3>\\n<description>Replace the object by drawing a one-pixel-thick border (a frame) around that bounding rectangle using a single color. The frame occupies the rectangle's perimeter; the interior cells inside the perimeter become the background color.</description>\\n<example>A 4×4 bounding box becomes a 4×4 frame: the outer ring is the new color and the inner 2×2 area is cleared to background. A 2×3 box becomes a 2×3 frame: the outer cells are colored and the interior (if any) is cleared.</example>\\n</note3>\\n\\n<note4>\\n<description>Use one consistent replacement color for every frame. The examples use a single non-background color to draw all borders; pick that same color for every object's perimeter so the result is uniform.</description>\\n<example>If the training outputs show frames in color X, then every object you frame should use color X as well. Do not mix colors between different objects.</example>\\n</note4>\\n\\n<note5>\\n<description>Handle edge cases: a bounding rectangle that is already 1×1 (a single pixel) remains a 1×1 frame (no interior to clear), and when frames touch or overlap, they simply share the border color. Apply the same rule to each object independently.</description>\\n<example>A single colored pixel stays a single pixel (it is its own 1×1 frame). If two nearby blobs produce frames that meet, the meeting cells are still the chosen frame color and you do not merge interiors or alter background elsewhere.</example>\\n</note5>\",\n \"<note1>\\n<description>Look for connected non-zero pixels: treat any non-background cells that touch (including diagonally) as one object. The transformation operates on these objects rather than on individual isolated pixels. This tells you where to focus your changes.</description>\\n<example>Imagine a grid with a 2×3 block of colored pixels and a single colored pixel elsewhere; the block and the single pixel are two separate objects. You should process each object independently rather than merging them or changing the background zeros.</example>\\n</note1>\\n\\n<note2>\\n<description>Compute the minimal bounding rectangle for each object: find the smallest row and column indices that contain the object, and the largest ones. That rectangle is the natural region to modify for that object. Use these four extremes (minRow, maxRow, minCol, maxCol) as the target region.</description>\\n<example>If an object has pixels at rows 4..6 and columns 7..9, its bounding rectangle is rows 4–6 by columns 7–9. You will operate only inside that rectangle for that object.</example>\\n</note2>\\n\\n<note3>\\n<description>Replace every cell inside the bounding rectangle with one uniform color. The examples show the rectangle is filled completely, not just the object's original pixels. The rectangle size is determined by the object's extents, so it can be 1×1, 1×N, N×1, or N×M.</description>\\n<example>A 1×3 horizontal object becomes a filled 1×3 horizontal stripe of a single color; a 3×2 object becomes a filled 3×2 block of that color. The original internal pattern is not preserved — it is overwritten.</example>\\n</note3>\\n\\n<note4>\\n<description>Choose the fill color by inspecting the training outputs: the same non-background color is used consistently to fill all rectangles. That color is a fixed marker in the examples, not something computed from each object's internal colors. Use that same marker for every object in the test grid.</description>\\n<example>If every training output shows filled rectangles in the same color, adopt that color for all bounding rectangles in the test input rather than picking a color based on each object's own palette.</example>\\n</note4>\\n\\n<note5>\\n<description>Be careful about edge cases: single-pixel objects, narrow rectangles, or objects that touch the grid border. The rectangle can be degenerate (1×1, 1×N, or N×1) but still gets filled. Do not change any zeros outside the rectangles and do not alter the grid size.</description>\\n<example>A lone colored pixel becomes a filled 1×1 square of the chosen color; a vertical line of two pixels becomes a filled 2×1 column. Always verify you only modify cells inside each object's bounding rectangle and leave the rest as background.</example>\\n</note5>\",\n \"<note1>\\n<description>Look for contiguous non-zero pixels that form compact rectangular blocks; these blocks are the objects being transformed. Treat each such block as a single unit by computing its minimal bounding rectangle (min row, max row, min col, max col).</description>\\n<example>Imagine a 6×6 grid with a 2×3 patch of colored pixels at rows 2–3 and cols 4–6; the object's bounding box is rows 2..3 and cols 4..6. Work with that box as the region to change rather than individual pixels scattered around.</example>\\n</note1>\\n\\n<note2>\\n<description>Within each bounding box, identify the color that will be used to repaint the object's border. In these tasks that border color is taken from a fixed relative position inside the original box (a corner or edge position), not from the majority color.</description>\\n<example>If a 3×3 box has values [[1,2,3],[4,5,6],[7,8,9]] and the top-left corner is 1, the border color chosen is 1. The interior values (2,3,4,5,6,7,8,9) are irrelevant to that choice.</example>\\n</note2>\\n\\n<note3>\\n<description>Construct a one-pixel-thick hollow rectangle (a frame) along the bounding box perimeter using the chosen border color, leaving the interior cells as background (zeros). The frame occupies the top and bottom rows and the left and right columns of the bounding box.</description>\\n<example>For a 4×2 bounding box, set the two cells on the top row, the two on the bottom row, and the two cells on the left and right columns to the border color; the two interior cells remain background zeros. The result is a hollow rectangle of the same size as the original block.</example>\\n</note3>\\n\\n<note4>\\n<description>Apply the same frame operation independently to every separate colored block in the grid; do not merge blocks or change their positions. After processing, the grid should show one framed rectangle per original colored region, all in the same border color.</description>\\n<example>If two distinct 2×2 colored squares appear in different parts of the grid, each becomes a hollow 2×2 frame (top and bottom rows and left and right columns painted), while the original interior pixels are cleared to background.</example>\\n</note4>\\n\\n<note5>\\n<description>Watch edge cases: if a bounding box is only one cell wide or one cell tall, the frame will cover the whole box (no interior to clear). Also, when multiple boxes are present, each uses the same rule — pick the border color from the same relative position in each box so all frames use the same color.</description>\\n<example>A 1×4 colored strip becomes a 1×4 frame (all four cells painted) because there is no interior to clear. If two boxes both have their top-left corner equal to color X, both frames will be color X even if the boxes are different sizes.</example>\\n</note5>\",\n \"<note1>\\n<description>Look for contiguous groups of non-zero cells: each such group is an independent object to transform. Treat each object by its minimal bounding rectangle so you can reason about its size and shape without interference from other objects.</description>\\n<example>Imagine a 2×3 block of colored pixels surrounded by zeros. The minimal bounding rectangle is exactly that 2×3 area; you should consider that whole rectangle as the object to be transformed rather than individual pixels scattered around it.</example>\\n</note1>\\n\\n<note2>\\n<description>Observe the output pattern: every object is replaced by a single-color outline (a one-pixel-thick perimeter) drawn in a single consistent color across the grid. The interior of the original bounding rectangle is cleared back to the background.</description>\\n<example>For a 3×4 bounding box, the output will show a 1-pixel-wide frame along the box's four edges and the inner cells set to background. The frame is continuous and exactly follows the rectangle's edges.</example>\\n</note2>\\n\\n<note3>\\n<description>The color used for the outline is not taken from the object's original internal colors but is a fixed, global color chosen for all objects in the task. Identify that color by looking at the outputs of the training examples and then reuse it for every object in the test.</description>\\n<example>If every example output shows the same single color used for the perimeters, pick that color as the frame color. Do not try to copy each object's internal color—use the consistent frame color instead.</example>\\n</note3>\\n\\n<note4>\\n<description>Compute the frame precisely: for a bounding rectangle with top row r0, left column c0, height h and width w, the perimeter cells are those with row in {r0, r0+h-1} or column in {c0, c0+w-1}. Leave all other cells inside the rectangle as background.</description>\\n<example>For a 4×5 rectangle (h=4,w=5) the perimeter is the top and bottom rows of the rectangle and the leftmost and rightmost columns; the remaining 2×3 interior stays background. This gives a one-pixel-thick outline exactly matching the original rectangle edges.</example>\\n</note4>\\n\\n<note5>\\n<description>Apply the same rectangle-to-outline operation independently to every object and do not change the grid size or move objects. Be careful with thin objects: if a bounding rectangle is only one pixel tall or one pixel wide, the perimeter covers the entire rectangle and there is no interior to clear.</description>\\n<example>A 1×2 vertical object becomes a 1×2 frame (two pixels of the frame color), and a 1×1 object becomes a single pixel of the frame color. Treat each object separately and place its frame at the same coordinates as its original bounding rectangle.</example>\\n</note5>\",\n \"<note1>\\n<description>Look for contiguous non‑zero pixels: treat each group of adjacent non‑black cells as an object to be transformed. This isolates independent shapes so you can reason about each one separately.</description>\\n<example>Imagine a grid with two separated clusters of colored pixels (one in the top‑left, one in the bottom‑right). Each cluster is handled on its own: you do not merge them or move them relative to each other. Work object‑by‑object rather than trying to transform the whole grid at once.</example>\\n</note1>\\n\\n<note2>\\n<description>Compute the minimal axis‑aligned bounding rectangle for each object: record the minimum and maximum row and column that contain the object. That rectangle is the region you will later modify.</description>\\n<example>If an object occupies cells at (r=2,c=3), (r=4,c=5) and (r=3,c=4), the bounding rectangle spans rows 2..4 and columns 3..5. Use those min/max coordinates as the box edges for the transformation.</example>\\n</note2>\\n\\n<note3>\\n<description>Replace the interior of each bounding rectangle with a single uniform color, but leave the rectangle's interior zeros (holes) unchanged. In other words, fill only the non‑zero positions inside the box with one color.</description>\\n<example>Take a 3×4 bounding box that contains some zeros and some colored pixels. After the operation, every non‑zero cell inside that 3×4 area becomes the same fill color, while any zero cells inside remain zero (holes are preserved).</example>\\n</note3>\\n\\n<note4>\\n<description>Choose one consistent fill color for all objects and use it across the whole grid. The training examples use a single color to mark the filled rectangles, so pick the same one for every bounding box.</description>\\n<example>If you decide to use color X, then every filled rectangle produced for each object will be entirely color X. This makes the output visually consistent and distinguishes the transformed boxes from the original varied colors.</example>\\n</note4>\\n\\n<note5>\\n<description>Keep the original grid size and positions: do not shift, resize, or merge objects. Only recolor the interior of each object's bounding rectangle and leave all other cells (background and holes) as they were.</description>\\n<example>For a single object that originally occupied a small rectangle, the result is that same rectangle location filled uniformly (with holes preserved). For multiple objects, apply the same rule independently to each rectangle so their relative positions remain unchanged.</example>\\n</note5>\",\n \"<note1>\\n<description>Look for contiguous non-background regions and treat each as an independent object. These objects are the units being transformed; the background (zeros) stays unchanged and is not part of the transformation.</description>\\n<example>Imagine a grid with two separated colored blobs on a black background. Instead of trying to transform the whole grid, first isolate each blob by its non-zero pixels and consider them separately — the same rule will be applied to each blob.</example>\\n</note1>\\n\\n<note2>\\n<description>Compute the minimal axis-aligned bounding rectangle for each object: take the minimum and maximum row and column that contain non-background pixels. That rectangle captures the object's outer extent and is the region you will modify.</description>\\n<example>For an object whose colored pixels lie between rows 4–7 and columns 2–5, the bounding box is rows 4..7 by cols 2..5. Even if the object has holes or irregular edges, the bounding box still spans from the topmost to bottommost and leftmost to rightmost colored pixels.</example>\\n</note2>\\n\\n<note3>\\n<description>Convert each object's interior into a hollow frame: fill only the outermost cells of the bounding rectangle (the perimeter) with a single color, and set every strictly interior cell of that rectangle to background (0). This yields a one-pixel-thick border around the object.</description>\\n<example>If a bounding box is 4×5, color every cell on the top and bottom rows of the box and every cell on the leftmost and rightmost columns; then set the 2×3 interior cells to 0. The result is a rectangular frame of one-pixel width.</example>\\n</note3>\\n\\n<note4>\\n<description>Use one consistent color for all frames. In the examples the frame color is taken from a single, easily identifiable pixel of the original object (for instance the top-leftmost non-background pixel of that object). Using the same selection rule for every object keeps the transformation uniform.</description>\\n<example>Suppose an object's top-leftmost colored pixel is blue; then every perimeter cell of its bounding box should be painted blue, and the interior cleared to black. Do this for each object so all frames share the same color.</example>\\n</note4>\\n\\n<note5>\\n<description>Watch edge cases: if a bounding box is only one row or one column wide, there is no interior to clear and the frame is just a single line; if two bounding boxes touch or overlap, apply the frame rule independently and do not fill interior cells (they should remain background). Also, do not alter pixels outside any bounding box.</description>\\n<example>A 1×4 stripe becomes a 1×4 line of the chosen color (no interior to clear). If two frames meet, each perimeter is drawn according to its own bounding box, and any cell that is not on a perimeter stays 0.</example>\\n</note5>\",\n \"<note1>\\n<description>Look for contiguous regions made of non-background pixels and treat each as a separate object. The transformation acts on these objects independently, so isolating them first simplifies the task.</description>\\n<example>Imagine a grid with two separated colored blobs: a 2×3 rectangle in the upper-left and a 1×4 line in the lower-right. You should consider these two shapes separately rather than trying to merge them or change the background around them.</example>\\n</note1>\\n\\n<note2>\\n<description>For each object, determine its minimal bounding rectangle (the smallest axis-aligned box that contains all its pixels). The bounding box gives the exact area that the output will modify for that object.</description>\\n<example>If an object occupies cells at rows 5–8 and columns 2–4, its bounding box is the rectangle spanning those rows and columns (a 4×3 box). That rectangle is the region you will operate on for that object.</example>\\n</note2>\\n\\n<note3>\\n<description>The object's internal pattern is discarded: the output replaces every cell inside the bounding box with a single, uniform color. The shape of the box (not the original pixel arrangement) determines the area to fill.</description>\\n<example>A 2×2 patch with mixed colors becomes a 2×2 block where every cell is the same chosen color, regardless of the original values inside the patch.</example>\\n</note3>\\n\\n<note4>\\n<description>Choose one consistent fill color for all objects. A reliable choice is the color that appears most often in the entire input (excluding the background); use that same color for every bounding box. This keeps the output consistent and ties the fill to the input palette.</description>\\n<example>If color 4 appears more frequently than any other non-background color in the input, then every bounding box you fill should be painted with color 4 so all objects share the same fill color.</example>\\n</note4>\\n\\n<note5>\\n<description>After filling, verify that only the bounding boxes changed and the background remains untouched. The output should show solid rectangular blocks at the same coordinates as the original objects, with no extra pixels added or removed.</description>\\n<example>Given several isolated objects, the final grid will show each as a solid rectangle at its original location; any cell outside those rectangles should match the original background value.</example>\\n</note5>\",\n \"<note1>\\n<description>Focus first on finding the objects: contiguous groups of non-background pixels. Treat each such group as an independent object to be transformed, and ignore isolated background pixels.</description>\\n<example>Imagine a grid with two separated colored blobs. Draw the smallest rectangle that contains each blob; that rectangle is the region you will work on. Do not merge objects that are separated by background cells.</example>\\n</note1>\\n\\n<note2>\\n<description>Compute the minimal bounding rectangle for each object and use its dimensions to determine the shape to draw. The rectangle’s width and height tell you whether you will produce a filled rectangle or a hollow frame (border).</description>\\n<example>If an object’s bounding box is 2×2, its width equals its height and the natural framed shape is a 3×3 border (a hollow square). If the box is 3×5, the natural framed shape is a 4×6 border (a hollow rectangle).</example>\\n</note2>\\n\\n<note3>\\n<description>Replace each object by a one-pixel-thick border around its bounding rectangle, leaving the rectangle’s interior as background. The border is placed immediately outside the bounding box on all four sides.</description>\\n<example>For a 2×2 object, create a 3×3 hollow square: fill the top and bottom rows and the leftmost and rightmost columns of that 3×3 area with the chosen color, and leave the center cell as background. For a 4×6 object, draw a 5×7 hollow rectangle in the same way.</example>\\n</note3>\\n\\n<note4>\\n<description>Choose the fill color for all borders by inspecting the training outputs: the same non-background color is used for every object’s border. Use that consistent color when you draw each border in the test case.</description>\\n<example>Look at the example outputs and note which color appears as the thin outline around each object; that color is the one to use for every object’s border in the test input. Do not invent a new color — reuse the one shown in the examples.</example>\\n</note4>\\n\\n<note5>\\n<description>Keep the transformed object in the same location and orientation as the original; do not shift, rotate, or resize it. If a border would extend beyond the grid edge, simply clip the border to the grid (only draw the visible portion).</description>\\n<example>If an object sits at the grid edge, the border will be truncated where it would go off-grid; you still place the border relative to the original bounding box and only draw the cells that fit inside the grid. This preserves object positions while allowing for partial borders at edges.</example>\\n</note5>\",\n \"<note1>\\n<description>Look for contiguous groups of non-background pixels and treat each as a separate object. These objects are the units that get transformed, so identifying their extents is the first step.</description>\\n<example>Imagine a grid with two separated patches of colored pixels. Each patch is an independent object even if they share the same color values; handle each patch separately rather than merging them into one region.</example>\\n</note1>\\n\\n<note2>\\n<description>For each object compute its minimal bounding rectangle: the smallest axis-aligned box that contains every pixel of that object. This box defines the region that will be standardized in the output.</description>\\n<example>If an object occupies rows 2–5 and columns 3–6, its bounding box is those rows and columns. Even if some interior cells are background, the box still spans from the topmost to bottommost and leftmost to rightmost non-background pixels.</example>\\n</note2>\\n\\n<note3>\\n<description>Replace the interior of each bounding box by a one-pixel-thick frame of a single color, leaving the interior cells as background. The frame occupies the outermost cells of the box and has thickness one on all sides.</description>\\n<example>A 3×3 bounding box becomes a hollow 3×3 square: the outer eight cells are the frame color and the center cell becomes background. A 2×4 box becomes a 2×4 frame: the outermost rows and columns are filled and the inner cells are cleared.</example>\\n</note3>\\n\\n<note4>\\n<description>Use the same frame color for every object — the examples use one consistent non-background color for all frames. Do not try to preserve the original colors or patterns inside the objects; they are overwritten by the single frame color.</description>\\n<example>Two different input objects, even if they started with different colors, both become frames in the same frame color. This makes the transformation uniform across all objects.</example>\\n</note4>\\n\\n<note5>\\n<description>Apply the frame operation independently to each object and do not alter pixels outside any object's bounding box. If boxes touch or overlap, apply the rule to each box so each object ends up with its own frame.</description>\\n<example>Two nearby objects will each get their own one-pixel border; if they are close enough the borders may meet or overlap, but the rule remains: draw the frame for each bounding box and leave other cells unchanged.</example>\\n</note5>\",\n \"<note1>\\n<description>Look for contiguous non-background pixels and treat each connected cluster as an object to transform. This isolates the parts of the grid that matter and separates them from the unchanged background.</description>\\n<example>Imagine a grid with two separated patches of colored pixels. Mark each patch as an independent object (don’t merge them just because they share the same color). You will transform each object separately rather than the whole grid at once.</example>\\n</note1>\\n\\n<note2>\\n<description>Compute the minimal bounding rectangle for each object by taking the minimum and maximum row and column indices that contain the object's pixels. That rectangle defines the area you will modify.</description>\\n<example>If an object has pixels at rows 2..4 and columns 5..7, its bounding box is rows 2..4 by cols 5..7. Use those four indices (minRow, maxRow, minCol, maxCol) to describe the region to be painted.</example>\\n</note2>\\n\\n<note3>\\n<description>Replace every cell inside each bounding rectangle with a single, uniform color while leaving the background (zeros) untouched. The interior can be filled completely or only the border, depending on the examples.</description>\\n<example>Given a 2×3 bounding box, paint all six cells inside it with the chosen color; if the examples show a hollow frame, only paint the outer ring of that box and leave the interior cells as background.</example>\\n</note3>\\n\\n<note4>\\n<description>Choose one consistent fill color for all objects rather than deriving a new color per object. The examples use the same color for every transformed rectangle, so pick a single non-background color and apply it to every bounding box.</description>\\n<example>If the training outputs always use the same color for the filled rectangles, use that same color for every object's bounding box in your solution. Avoid using a color that would be confused with the background or the original object colors.</example>\\n</note4>\\n\\n<note5>\\n<description>Be careful with thin shapes and nested objects: if a bounding box is only one cell wide or tall, the border and the interior coincide, so the object becomes a single filled line; if an object is completely filled in the input, its bounding box will be filled in the output as well.</description>\\n<example>A 1×4 horizontal stripe has a bounding box of height 1, so the border is the whole stripe and it remains filled. A 3×3 solid square has a one-cell interior; if the examples show hollow frames, that interior should remain background while the border is painted.</example>\\n</note5>\",\n \"<note1>\\n<description>Look for contiguous non-background pixels and treat each such cluster as an object. Objects in these tasks are usually axis-aligned and rectangular, so their bounding box (min/max row and column) is a reliable descriptor of the object.</description>\\n<example>Imagine a 3×4 patch of non-zero pixels in a corner. The smallest rectangle that contains all those pixels (its bounding box) is the object you should focus on; everything outside that rectangle is background and can be ignored for the transformation.</example>\\n</note1>\\n\\n<note2>\\n<description>Compare input and output shapes: the transformation turns each object's interior into a hollow rectangle (a frame) while preserving the object's outer dimensions. In other words, the object's bounding box is used as the outer boundary and the interior is cleared to background.</description>\\n<example>If an object occupies a 5×4 rectangle in the input, the output will show a 5×4 frame: the outermost row and column cells of that bounding box become the frame color, and the cells strictly inside become background (zeros).</example>\\n</note2>\\n\\n<note3>\\n<description>Notice how the frame color is chosen: it is the same single color used for every object in the output. That color is taken from one consistent pixel in the input (a specific location relative to each object), not computed from the object's internal colors.</description>\\n<example>For each object, look at the pixel at the same relative corner (for example, the object's top-left corner) and use that pixel's color to paint the object's frame. Do this for every object so all frames share the same color.</example>\\n</note3>\\n\\n<note4>\\n<description>Apply the rule independently to each object: do not merge objects or move them. The transformation preserves each object's position and size and only changes its interior/background pattern.</description>\\n<example>If there are two separate colored patches in the input, you should produce two separate frames in the output at the same coordinates; the background between them remains unchanged.</example>\\n</note4>\\n\\n<note5>\\n<description>Handle thin or edge-touching objects carefully: a frame's width equals the object's width and height (so a 1×N or N×1 object will produce a 1×N or N×1 border). Also, if an object touches the grid edge, its frame simply uses the available cells (no wrapping).</description>\\n<example>A 1×3 horizontal object becomes a 1×3 border (three border cells in a row) with no interior cells to clear. A 3×1 vertical object becomes a 3×1 border (three border cells in a column). If an object touches the grid boundary, the border still occupies the cells that exist.</example>\\n</note5>\",\n \"<note1>\\n<description>Look for contiguous non-zero pixels and treat each such patch as an independent object. The transformation is applied to whole patches, not to isolated individual pixels.</description>\\n<example>Imagine a grid with two separated 3×2 colored blocks in different places; you should detect two separate objects and plan the same operation for each one rather than trying to connect them or change the background.</example>\\n</note1>\\n\\n<note2>\\n<description>For each object compute its minimal bounding rectangle (the smallest axis-aligned box that contains all its non-zero pixels). This box defines the exact area that will be transformed.</description>\\n<example>If an object occupies rows 5–7 and columns 2–4, its bounding box is the 3×3 rectangle from (row 5, col 2) to (row 7, col 4); that rectangle is the region you will use for the next step.</example>\\n</note2>\\n\\n<note3>\\n<description>Replace every cell inside the bounding rectangle with a single uniform color (the same color for all objects). The output does not preserve the original internal color pattern inside each box.</description>\\n<example>A 2×3 rectangle that originally contains many different colors becomes a solid 2×3 block of one color in the output; you only need to decide which color to use, not which original pixel maps to which new pixel.</example>\\n</note3>\\n\\n<note4>\\n<description>Choose the fill color by inspecting the input for a non-background color that already appears as an isolated marker or small marker pixel; use that same marker color for every filled rectangle. Do not invent a new color or use the background color (0).</description>\\n<example>If you see a single pixel of color X sitting alone somewhere in the input (a tiny isolated marker), use color X to fill every bounding box you found; if no such marker exists, pick a consistent non-zero color and apply it to all boxes.</example>\\n</note4>\\n\\n<note5>\\n<description>After filling, clear the original internal pattern inside each bounding box (set those cells to background) and leave all other cells unchanged. The final grid should show only the new uniform rectangles in their original positions.</description>\\n<example>Given two objects, you will end up with two solid rectangles in the same places; everything outside those rectangles remains the original background color, and the original mixed pixels inside each rectangle are no longer visible.</example>\\n</note5>\",\n \"<note1>\\n<description>Look for connected clusters of non-background pixels and treat each cluster as a single object. The transformation operates on whole objects, not on isolated pixels, so finding those connected components is the first step.</description>\\n<example>Imagine a grid with two separate patches of non-zero pixels; each patch is an object. You should process each patch independently (compute its bounding box and ignore its internal colors) rather than trying to change every colored pixel individually.</example>\\n</note1>\\n\\n<note2>\\n<description>For each object compute its minimal bounding rectangle (the smallest axis-aligned box that contains every pixel of the object). That rectangle determines the size and placement of the new shape you will draw.</description>\\n<example>If an object occupies cells whose rows run from r1 to r2 and columns from c1 to c2, the bounding box is exactly rows r1..r2 by columns c1..c2. Use that box as the template for the replacement shape.</example>\\n</note2>\\n\\n<note3>\\n<description>Replace the irregular interior of the bounding box with a one-pixel-thick border: fill the top and bottom rows of the box and the leftmost and rightmost columns of the box with the chosen border color. Do not fill the interior cells (they remain background).</description>\\n<example>A 3×4 bounding box becomes a frame: the first and last rows of the box are filled, and the first and last columns of the box are filled; the central cells inside the box stay background. The result is a hollow rectangular outline that exactly matches the original box dimensions.</example>\\n</note3>\\n\\n<note4>\\n<description>Use the same single border color for every object so the output is consistent across all shapes. Choose a color that is not the background and apply it uniformly to all outlines.</description>\\n<example>If you pick color X, every object's border should be color X. This makes the transformation uniform and easy to verify: all outlines share the same color while interiors remain background.</example>\\n</note4>\\n\\n<note5>\\n<description>Be careful with thin or narrow bounding boxes: when width or height is 1 the border covers the whole box, so it will appear filled. Also ensure the outline remains exactly one pixel thick and that you only modify cells inside the original bounding box.</description>\\n<example>A 1×4 box becomes a filled 1×4 strip because the border covers every cell. A 2×2 box becomes a 2×2 filled square (border covers all four cells). In every case the border is one pixel wide and confined to the bounding rectangle.</example>\\n</note5>\",\n \"<note1>\\n<description>Look for separate objects by finding contiguous non-background pixels; each contiguous cluster is a candidate for the same transformation. This isolates the problem into smaller, repeatable subproblems.</description>\\n<example>Imagine a grid with two separated colored blobs on a black background. Treat each blob independently: compute its extent and handle it the same way rather than trying to transform the whole grid at once.</example>\\n</note1>\\n\\n<note2>\\n<description>Compute the minimal bounding rectangle for each object: the smallest axis-aligned box that contains all its pixels. The rectangle gives a clear size and position for the shape you will draw.</description>\\n<example>If an object occupies rows 3–6 and columns 5–8, its bounding rectangle is 4 rows by 4 columns. Use those min/max row and column indices to define the rectangle to work with.</example>\\n</note2>\\n\\n<note3>\\n<description>Replace the irregular object by a one-pixel-thick outline (a hollow rectangle) that follows the bounding rectangle's perimeter. The interior of that rectangle should remain background.</description>\\n<example>A 3×4 bounding box becomes a hollow frame: the top and bottom rows and the left and right columns of the box are filled, while the 1×2 interior remains empty. This turns any arbitrary shape inside the box into a simple perimeter-only shape.</example>\\n</note3>\\n\\n<note4>\\n<description>Use a single, consistent color for all outlines — pick the color that appears most frequently among the original non-background pixels (ignore zeros). This keeps the outputs uniform and tied to the input distribution.</description>\\n<example>If the original colored pixels contain many occurrences of color X and fewer of other colors, choose X to paint every outline. If two colors tie, prefer the one that appears in the largest connected component.</example>\\n</note4>\\n\\n<note5>\\n<description>Do not move or resize objects: place each outline exactly where the bounding rectangle was and leave all other cells unchanged. If outlines touch or overlap, treat them as separate outlines and apply the same color rule consistently.</description>\\n<example>Two nearby objects produce two outlines placed at their respective bounding boxes; if they meet, you still draw both outlines in the chosen color. Always preserve the original grid size and background pixels outside the rectangles.</example>\\n</note5>\",\n \"<note1>\\n<description>Look for the minimal axis-aligned rectangle that contains every non-background cell. This bounding box (top, bottom, left, right) is the region that the transformation acts upon.</description>\\n<example>Imagine a 6×6 grid where colored pixels appear only at rows 2–4 and columns 3–5. The bounding box is the rectangle rows 2..4 × cols 3..5. Treat that rectangle as the single object to transform rather than handling each colored pixel individually.</example>\\n</note1>\\n\\n<note2>\\n<description>Inside that bounding box, replace every non-background cell with a single uniform color (the examples use color 4). The interior pattern of different colors is discarded; only the presence of a non-background cell matters.</description>\\n<example>Take a 3×4 box that contains several different colors and zeros. After the operation, every cell that was non-zero in that box becomes the same color (e.g., all become 4), so the box appears uniformly colored.</example>\\n</note2>\\n\\n<note3>\\n<description>After making the interior uniform, clear the interior zeros to background (0). The result is a solid rectangular outline: the box is filled except that its interior cells (if any) become background.</description>\\n<example>For a 4×4 box that originally had some zeros inside, set all non-background cells to the chosen color and then set the remaining interior cells (the zeros) to 0. The box will show a filled border or a filled area with a cleared center depending on size.</example>\\n</note3>\\n\\n<note4>\\n<description>Apply the same procedure independently to each separate colored cluster. Each cluster yields its own bounding box; the operation does not merge or shift clusters relative to the grid.</description>\\n<example>If the grid has two distinct colored patches in different places, compute two bounding boxes and perform the same “fill then clear interior” step on each. You will get two separate uniform rectangles in their original positions.</example>\\n</note4>\\n\\n<note5>\\n<description>Be careful about edge cases: a bounding box that is one row or one column wide has no interior to clear, so it stays uniformly filled. Also, use the same fill color consistently across all boxes (the examples use a single color).</description>\\n<example>A 1×3 vertical bar has no interior zeros, so after filling it remains a single-color bar. A 3×3 box, however, will become a filled 3×3 area with the center cell set to background (0).</example>\\n</note5>\",\n \"<note1>\\n<description>Look for contiguous regions of non-zero pixels and treat each as a single object. The transformation operates on these whole objects, not on individual scattered pixels.</description>\\n<example>Imagine a grid with two separated colored blobs: one in the top-left and one in the bottom-right. Each blob is an independent object to be transformed, so you should analyze and transform each blob separately rather than trying to merge them.</example>\\n</note1>\\n\\n<note2>\\n<description>For each object, compute its minimal bounding rectangle: the smallest axis-aligned rectangle that contains all its non-background pixels. This rectangle determines the outer shape you will draw around the object.</description>\\n<example>If a blob occupies rows 2..5 and columns 3..6, its bounding box is that 4×4 rectangle. Even if some cells inside that rectangle are background, they still belong to the bounding box and will be considered when drawing the frame.</example>\\n</note2>\\n\\n<note3>\\n<description>Replace the interior of the bounding box by filling it with a single uniform color (the same color for every object). The interior can be a filled block or a hollow ring depending on the box size.</description>\\n<example>A 3×3 bounding box becomes a filled 3×3 block of one color; a 4×4 bounding box becomes a filled 4×4 block of the same color. The exact original colors inside the box are ignored — they are all overwritten by the uniform fill.</example>\\n</note3>\\n\\n<note4>\\n<description>Draw a one-pixel-thick border (a hollow frame) around the filled interior: the border cells are the perimeter of the bounding box and should be set to the same uniform color, while interior cells remain the filled color. If the box is too small to have an interior (width≤2 or height≤2), the frame coincides with the filled area.</description>\\n<example>For a 4×4 bounding box, the outermost row and column form the border and the central 2×2 is the interior; the border is drawn in the same color as the interior. For a 2×2 bounding box there is no interior, so the result is simply a 2×2 filled block.</example>\\n</note4>\\n\\n<note5>\\n<description>Use a single consistent color for every object's frame/interior (the same across the whole grid) and do not alter background pixels. Apply the same bounding-box-to-frame rule to every separate object.</description>\\n<example>Two distant blobs become two identical framed rectangles (same border thickness and same fill color). A useful check: after transformation, each object should be a uniformly colored rectangle whose border is one pixel thick and whose interior is filled.</example>\\n</note5>\"\n]","isConversational":false},"train":{"kind":"string","value":"[{\"input\": [[0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0], [0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0], [0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0], [0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0], [0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0], [0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0], [0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0], [0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0], [0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0], [0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0], [0, 0, 0, 4, 5, 5, 0, 0, 0, 0, 0, 0, 0, 0, 0], [0, 0, 0, 1, 3, 2, 0, 0, 0, 0, 0, 0, 0, 0, 0], [0, 0, 0, 5, 6, 9, 0, 0, 0, 0, 0, 0, 0, 0, 0], [0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0], [0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0], [0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0], [0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0], [0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0], [0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0]], \"output\": [[0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0], [0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0], [0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0], [0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0], [0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0], [0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0], [0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0], [0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0], [0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0], [0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0], [0, 0, 0, 4, 4, 4, 0, 0, 0, 0, 0, 0, 0, 0, 0], [0, 0, 0, 4, 0, 4, 0, 0, 0, 0, 0, 0, 0, 0, 0], [0, 0, 0, 4, 4, 4, 0, 0, 0, 0, 0, 0, 0, 0, 0], [0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0], [0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0], [0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0], [0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0], [0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0], [0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0]]}, {\"input\": [[0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0], [0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0], [3, 1, 4, 5, 0, 0, 0, 0, 0, 0, 0], [8, 2, 5, 9, 0, 0, 0, 0, 0, 0, 0], [7, 9, 5, 9, 0, 0, 0, 0, 0, 0, 0], [0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0], [0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0], [0, 0, 0, 0, 0, 6, 2, 2, 7, 0, 0], [0, 0, 0, 0, 0, 1, 8, 6, 3, 0, 0], [0, 0, 0, 0, 0, 3, 9, 7, 4, 0, 0], [0, 0, 0, 0, 0, 4, 9, 4, 3, 0, 0], [0, 0, 0, 0, 0, 1, 3, 1, 7, 0, 0], [0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0], [0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0]], \"output\": [[0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0], [0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0], [4, 4, 4, 4, 0, 0, 0, 0, 0, 0, 0], [4, 0, 0, 4, 0, 0, 0, 0, 0, 0, 0], [4, 4, 4, 4, 0, 0, 0, 0, 0, 0, 0], [0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0], [0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0], [0, 0, 0, 0, 0, 4, 4, 4, 4, 0, 0], [0, 0, 0, 0, 0, 4, 0, 0, 4, 0, 0], [0, 0, 0, 0, 0, 4, 0, 0, 4, 0, 0], [0, 0, 0, 0, 0, 4, 0, 0, 4, 0, 0], [0, 0, 0, 0, 0, 4, 4, 4, 4, 0, 0], [0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0], [0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0]]}, {\"input\": [[0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0], [0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0], [0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0], [0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0], [0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0], [0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0], [0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0], [0, 0, 0, 0, 0, 0, 2, 3, 0, 0, 0], [0, 0, 0, 0, 0, 0, 6, 3, 0, 0, 0], [0, 0, 0, 0, 0, 0, 4, 7, 0, 0, 0], [0, 0, 0, 0, 0, 0, 7, 6, 0, 0, 0], [0, 0, 0, 0, 0, 0, 8, 3, 0, 0, 0], [0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0], [0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0], [0, 0, 8, 2, 0, 0, 0, 0, 0, 0, 0], [0, 0, 2, 8, 0, 0, 0, 0, 0, 0, 5], [0, 0, 8, 8, 0, 0, 0, 0, 0, 0, 5], [0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 4], [0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 8]], \"output\": [[0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0], [0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0], [0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0], [0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0], [0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0], [0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0], [0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0], [0, 0, 0, 0, 0, 0, 4, 4, 0, 0, 0], [0, 0, 0, 0, 0, 0, 4, 4, 0, 0, 0], [0, 0, 0, 0, 0, 0, 4, 4, 0, 0, 0], [0, 0, 0, 0, 0, 0, 4, 4, 0, 0, 0], [0, 0, 0, 0, 0, 0, 4, 4, 0, 0, 0], [0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0], [0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0], [0, 0, 4, 4, 0, 0, 0, 0, 0, 0, 0], [0, 0, 4, 4, 0, 0, 0, 0, 0, 0, 4], [0, 0, 4, 4, 0, 0, 0, 0, 0, 0, 4], [0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 4], [0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 4]]}]"},"test":{"kind":"string","value":"[{\"input\": [[0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0], [0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0], [0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0], [0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0], [0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0], [0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0], [0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0], [0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0], [0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0], [0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0], [0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0], [0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0], [0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0], [0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0], [0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0], [0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0], [0, 0, 0, 0, 0, 0, 0, 0, 0, 4, 6]], \"output\": [[0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0], [0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0], [0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0], [0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0], [0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0], [0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0], [0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0], [0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0], [0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0], [0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0], [0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0], [0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0], [0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0], [0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0], [0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0], [0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0], [0, 0, 0, 0, 0, 0, 0, 0, 0, 4, 4]]}]"},"source":{"kind":"string","value":"barc_heavy"},"prompt":{"kind":"string","value":"You will be given some number of paired example inputs and outputs grids. The outputs were produced by applying a transformation rule to the input grids. In addition to the paired example inputs and outputs, there is also one test input without a known output. The inputs and outputs are each “grids”. A grid is a rectangular matrix of integers between 0 and 9 (inclusive). Each number corresponds to a color. 0 is black. Your task is to determine the transformation rule from examples and find out the answer, involving determining the size of the output grid for the test and correctly filling each cell of the grid with the appropriate color or number. The transformation only needs to be unambiguous and applicable to the example inputs and the test input. It doesn't need to work for all possible inputs. Observe the examples carefully, imagine the grid visually, and try to find the pattern. Please output your answer within a code block (```), formatted as a grid of numbers. \n\n# Examples\n## Example 1\nInput:\n```\n0 0 0 0 0 0 0 0 0 0 0 0 0 0 0\n0 0 0 0 0 0 0 0 0 0 0 0 0 0 0\n0 0 0 0 0 0 0 0 0 0 0 0 0 0 0\n0 0 0 0 0 0 0 0 0 0 0 0 0 0 0\n0 0 0 0 0 0 0 0 0 0 0 0 0 0 0\n0 0 0 0 0 0 0 0 0 0 0 0 0 0 0\n0 0 0 0 0 0 0 0 0 0 0 0 0 0 0\n0 0 0 0 0 0 0 0 0 0 0 0 0 0 0\n0 0 0 0 0 0 0 0 0 0 0 0 0 0 0\n0 0 0 0 0 0 0 0 0 0 0 0 0 0 0\n0 0 0 4 5 5 0 0 0 0 0 0 0 0 0\n0 0 0 1 3 2 0 0 0 0 0 0 0 0 0\n0 0 0 5 6 9 0 0 0 0 0 0 0 0 0\n0 0 0 0 0 0 0 0 0 0 0 0 0 0 0\n0 0 0 0 0 0 0 0 0 0 0 0 0 0 0\n0 0 0 0 0 0 0 0 0 0 0 0 0 0 0\n0 0 0 0 0 0 0 0 0 0 0 0 0 0 0\n0 0 0 0 0 0 0 0 0 0 0 0 0 0 0\n0 0 0 0 0 0 0 0 0 0 0 0 0 0 0\n```\n\nOutput:\n```\n0 0 0 0 0 0 0 0 0 0 0 0 0 0 0\n0 0 0 0 0 0 0 0 0 0 0 0 0 0 0\n0 0 0 0 0 0 0 0 0 0 0 0 0 0 0\n0 0 0 0 0 0 0 0 0 0 0 0 0 0 0\n0 0 0 0 0 0 0 0 0 0 0 0 0 0 0\n0 0 0 0 0 0 0 0 0 0 0 0 0 0 0\n0 0 0 0 0 0 0 0 0 0 0 0 0 0 0\n0 0 0 0 0 0 0 0 0 0 0 0 0 0 0\n0 0 0 0 0 0 0 0 0 0 0 0 0 0 0\n0 0 0 0 0 0 0 0 0 0 0 0 0 0 0\n0 0 0 4 4 4 0 0 0 0 0 0 0 0 0\n0 0 0 4 0 4 0 0 0 0 0 0 0 0 0\n0 0 0 4 4 4 0 0 0 0 0 0 0 0 0\n0 0 0 0 0 0 0 0 0 0 0 0 0 0 0\n0 0 0 0 0 0 0 0 0 0 0 0 0 0 0\n0 0 0 0 0 0 0 0 0 0 0 0 0 0 0\n0 0 0 0 0 0 0 0 0 0 0 0 0 0 0\n0 0 0 0 0 0 0 0 0 0 0 0 0 0 0\n0 0 0 0 0 0 0 0 0 0 0 0 0 0 0\n```\n\n## Example 2\nInput:\n```\n0 0 0 0 0 0 0 0 0 0 0\n0 0 0 0 0 0 0 0 0 0 0\n3 1 4 5 0 0 0 0 0 0 0\n8 2 5 9 0 0 0 0 0 0 0\n7 9 5 9 0 0 0 0 0 0 0\n0 0 0 0 0 0 0 0 0 0 0\n0 0 0 0 0 0 0 0 0 0 0\n0 0 0 0 0 6 2 2 7 0 0\n0 0 0 0 0 1 8 6 3 0 0\n0 0 0 0 0 3 9 7 4 0 0\n0 0 0 0 0 4 9 4 3 0 0\n0 0 0 0 0 1 3 1 7 0 0\n0 0 0 0 0 0 0 0 0 0 0\n0 0 0 0 0 0 0 0 0 0 0\n```\n\nOutput:\n```\n0 0 0 0 0 0 0 0 0 0 0\n0 0 0 0 0 0 0 0 0 0 0\n4 4 4 4 0 0 0 0 0 0 0\n4 0 0 4 0 0 0 0 0 0 0\n4 4 4 4 0 0 0 0 0 0 0\n0 0 0 0 0 0 0 0 0 0 0\n0 0 0 0 0 0 0 0 0 0 0\n0 0 0 0 0 4 4 4 4 0 0\n0 0 0 0 0 4 0 0 4 0 0\n0 0 0 0 0 4 0 0 4 0 0\n0 0 0 0 0 4 0 0 4 0 0\n0 0 0 0 0 4 4 4 4 0 0\n0 0 0 0 0 0 0 0 0 0 0\n0 0 0 0 0 0 0 0 0 0 0\n```\n\n## Example 3\nInput:\n```\n0 0 0 0 0 0 0 0 0 0 0\n0 0 0 0 0 0 0 0 0 0 0\n0 0 0 0 0 0 0 0 0 0 0\n0 0 0 0 0 0 0 0 0 0 0\n0 0 0 0 0 0 0 0 0 0 0\n0 0 0 0 0 0 0 0 0 0 0\n0 0 0 0 0 0 0 0 0 0 0\n0 0 0 0 0 0 2 3 0 0 0\n0 0 0 0 0 0 6 3 0 0 0\n0 0 0 0 0 0 4 7 0 0 0\n0 0 0 0 0 0 7 6 0 0 0\n0 0 0 0 0 0 8 3 0 0 0\n0 0 0 0 0 0 0 0 0 0 0\n0 0 0 0 0 0 0 0 0 0 0\n0 0 8 2 0 0 0 0 0 0 0\n0 0 2 8 0 0 0 0 0 0 5\n0 0 8 8 0 0 0 0 0 0 5\n0 0 0 0 0 0 0 0 0 0 4\n0 0 0 0 0 0 0 0 0 0 8\n```\n\nOutput:\n```\n0 0 0 0 0 0 0 0 0 0 0\n0 0 0 0 0 0 0 0 0 0 0\n0 0 0 0 0 0 0 0 0 0 0\n0 0 0 0 0 0 0 0 0 0 0\n0 0 0 0 0 0 0 0 0 0 0\n0 0 0 0 0 0 0 0 0 0 0\n0 0 0 0 0 0 0 0 0 0 0\n0 0 0 0 0 0 4 4 0 0 0\n0 0 0 0 0 0 4 4 0 0 0\n0 0 0 0 0 0 4 4 0 0 0\n0 0 0 0 0 0 4 4 0 0 0\n0 0 0 0 0 0 4 4 0 0 0\n0 0 0 0 0 0 0 0 0 0 0\n0 0 0 0 0 0 0 0 0 0 0\n0 0 4 4 0 0 0 0 0 0 0\n0 0 4 4 0 0 0 0 0 0 4\n0 0 4 4 0 0 0 0 0 0 4\n0 0 0 0 0 0 0 0 0 0 4\n0 0 0 0 0 0 0 0 0 0 4\n```\n\n# Test Problem:\n```\n0 0 0 0 0 0 0 0 0 0 0\n0 0 0 0 0 0 0 0 0 0 0\n0 0 0 0 0 0 0 0 0 0 0\n0 0 0 0 0 0 0 0 0 0 0\n0 0 0 0 0 0 0 0 0 0 0\n0 0 0 0 0 0 0 0 0 0 0\n0 0 0 0 0 0 0 0 0 0 0\n0 0 0 0 0 0 0 0 0 0 0\n0 0 0 0 0 0 0 0 0 0 0\n0 0 0 0 0 0 0 0 0 0 0\n0 0 0 0 0 0 0 0 0 0 0\n0 0 0 0 0 0 0 0 0 0 0\n0 0 0 0 0 0 0 0 0 0 0\n0 0 0 0 0 0 0 0 0 0 0\n0 0 0 0 0 0 0 0 0 0 0\n0 0 0 0 0 0 0 0 0 0 0\n0 0 0 0 0 0 0 0 0 4 6\n```"},"answer":{"kind":"string","value":"```\n0 0 0 0 0 0 0 0 0 0 0\n0 0 0 0 0 0 0 0 0 0 0\n0 0 0 0 0 0 0 0 0 0 0\n0 0 0 0 0 0 0 0 0 0 0\n0 0 0 0 0 0 0 0 0 0 0\n0 0 0 0 0 0 0 0 0 0 0\n0 0 0 0 0 0 0 0 0 0 0\n0 0 0 0 0 0 0 0 0 0 0\n0 0 0 0 0 0 0 0 0 0 0\n0 0 0 0 0 0 0 0 0 0 0\n0 0 0 0 0 0 0 0 0 0 0\n0 0 0 0 0 0 0 0 0 0 0\n0 0 0 0 0 0 0 0 0 0 0\n0 0 0 0 0 0 0 0 0 0 0\n0 0 0 0 0 0 0 0 0 0 0\n0 0 0 0 0 0 0 0 0 0 0\n0 0 0 0 0 0 0 0 0 4 4\n```"},"num_tokens":{"kind":"number","value":3232,"string":"3,232"}}}],"truncated":false,"partial":false},"paginationData":{"pageIndex":0,"numItemsPerPage":100,"numTotalItems":11169,"offset":0,"length":100}},"jwt":"eyJhbGciOiJFZERTQSJ9.eyJyZWFkIjp0cnVlLCJwZXJtaXNzaW9ucyI6eyJyZXBvLmNvbnRlbnQucmVhZCI6dHJ1ZX0sImlhdCI6MTc4MDc2NjIxMywic3ViIjoiL2RhdGFzZXRzL2FzaW5naDE1L2FyYy1iYXJjLXByb2Nlc3NlZC1kaXJlY3QtbWF4NGstc2Z0YWJzZnVsbHByb2JzIiwiZXhwIjoxNzgwNzY5ODEzLCJpc3MiOiJodHRwczovL2h1Z2dpbmdmYWNlLmNvIn0.W7mwnugXRNNn_GC3Urda0N8KXE1rKWMkGMpznjWhNUX8AzjNzaTFeUTXZxyXleKmTSHshUWqOoIGi1Lrz8t7Ag","displayUrls":true,"splitSizeSummaries":[{"config":"default","split":"train","numRows":11169,"numBytesParquet":241172264},{"config":"default","split":"test","numRows":120,"numBytesParquet":2707426}]},"discussionsStats":{"closed":0,"open":0,"total":0},"fullWidth":true,"hasGatedAccess":true,"hasFullAccess":true,"isEmbedded":false,"savedQueries":{"community":[],"user":[]}}">
abstraction_prompt stringlengths 3.62k 7.46k | abstraction_prompt_length int64 792 4.59k | generated_abstractions listlengths 16 16 | train stringlengths 150 5.95k | test stringlengths 46 6.03k | source stringclasses 4
values | prompt stringlengths 1.16k 5k | answer stringlengths 9 1.81k | num_tokens int64 299 4.1k |
|---|---|---|---|---|---|---|---|---|
<|im_start|>user
# ARC HINT GENERATOR
## Role & Goal
You are an expert ARC (Abstraction and Reasoning Corpus) analyst. Your task is to generate a concise, actionable hint for a user who is struggling with an ARC problem. Analyze the problem and its correct solution to produce a single standalone, targeted hint that he... | 2,939 | [
"<note1>\n<description>Look first for rows or columns that are entirely one color and span the grid; these act as divider lines that partition the whole grid into rectangular tiles. Treat those full lines as fixed boundaries and do not change them when you transform the grid.</description>\n<example>Imagine a grid ... | [{"input": [[7, 7, 7, 7, 7, 7, 8, 7, 7, 7, 7, 7, 7], [7, 7, 7, 7, 9, 7, 8, 7, 7, 7, 7, 7, 7], [7, 7, 7, 9, 9, 7, 8, 7, 7, 7, 9, 9, 7], [7, 7, 7, 7, 7, 7, 8, 7, 7, 7, 7, 7, 7], [8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8], [7, 7, 7, 7, 7, 7, 8, 7, 7, 7, 7, 7, 7], [7, 7, 7, 7, 7, 7, 8, 7, 7, 7, 7, 9, 7], [7, 7, 7, 7, 7, 7, 8,... | [{"input": [[1, 1, 1, 1, 3, 1, 1, 1, 1, 3, 1, 1, 1, 1], [1, 1, 1, 1, 3, 1, 1, 1, 1, 3, 1, 1, 6, 1], [1, 1, 1, 1, 3, 1, 6, 6, 1, 3, 1, 6, 6, 1], [1, 1, 1, 1, 3, 1, 6, 1, 1, 3, 1, 1, 6, 1], [1, 6, 1, 1, 3, 1, 6, 1, 1, 3, 1, 6, 1, 1], [1, 1, 1, 1, 3, 1, 1, 1, 1, 3, 1, 1, 1, 1], [3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3], ... | rearc | You will be given some number of paired example inputs and outputs grids. The outputs were produced by applying a transformation rule to the input grids. In addition to the paired example inputs and outputs, there is also one test input without a known output. The inputs and outputs are each “grids”. A grid is a rectan... | ```
1 1 1 1 3 1 1 1 1 3 1 1 1 1
1 3 3 1 3 1 3 3 1 3 1 3 6 1
1 3 3 1 3 1 6 6 1 3 1 6 6 1
1 3 3 1 3 1 6 3 1 3 1 3 6 1
1 6 1 1 3 1 6 1 1 3 1 6 1 1
1 1 1 1 3 1 1 1 1 3 1 1 1 1
3 3 3 3 3 3 3 3 3 3 3 3 3 3
1 1 1 1 3 1 1 1 1 3 1 1 1 1
1 3 3 1 3 1 3 6 1 3 1 6 6 1
1 3 3 1 3 1 6 6 1 3 1 6 3 1
1 3 3 1 3 1 3 3 1 3 1 6 6 1
1 3 1 1 ... | 2,446 |
<|im_start|>user
# ARC HINT GENERATOR
## Role & Goal
You are an expert ARC (Abstraction and Reasoning Corpus) analyst. Your task is to generate a concise, actionable hint for a user who is struggling with an ARC problem. Analyze the problem and its correct solution to produce a single standalone, targeted hint that he... | 3,523 | [
"<note1>\n<description>Look for connected non-zero regions and treat each as an object: find its minimal bounding rectangle and record the pattern of colored cells inside it. This isolates the shapes you must move without changing their internal arrangement. Using bounding boxes makes it easy to compare and transla... | [{"input": [[0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0], [0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0], [0, 9, 9, 9, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0], [0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 6, 6, 0, 0], [0, 0, 2, 2, 0, 0, 0, 0, 0, 0, 0, 0, 0, 6, 6, 0, 0], [0, 0, 2, 2, 0, 0, 0, 0, 0, 0, 0, 0, 0, 6, ... | [{"input": [[0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0], [0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0], [0, 9, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0], [0, 4, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0], [0, 4, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0], [0, 4, 0, 0, 6, 6, 0, 0, 0, 0, 0, 0, 0, 0], [0, 0, 0, 0, 0, 0, 0, 0, 0, 7, 7, 0, 0, 0], ... | barc_heavy | You will be given some number of paired example inputs and outputs grids. The outputs were produced by applying a transformation rule to the input grids. In addition to the paired example inputs and outputs, there is also one test input without a known output. The inputs and outputs are each “grids”. A grid is a rectan... | ```
0 0 0 0 0 0 0 0 0 0 0 0 0 0
9 0 0 0 0 0 0 0 0 0 0 0 0 0
4 0 0 0 0 0 0 0 0 0 0 0 0 0
4 0 0 0 0 0 0 0 0 0 0 0 0 0
4 6 6 0 0 0 0 0 0 0 0 0 0 0
0 0 0 0 0 0 0 0 0 0 0 0 0 0
0 0 0 0 0 0 0 0 0 0 0 0 0 0
0 0 0 0 0 0 0 0 0 0 0 0 0 0
0 0 0 0 0 0 0 0 0 0 0 0 0 0
0 0 0 7 7 0 0 0 0 0 0 0 0 0
0 0 0 7 7 0 0 0 0 0 0 0 0 0
0 0 0 7 ... | 3,030 |
<|im_start|>user
# ARC HINT GENERATOR
## Role & Goal
You are an expert ARC (Abstraction and Reasoning Corpus) analyst. Your task is to generate a concise, actionable hint for a user who is struggling with an ARC problem. Analyze the problem and its correct solution to produce a single standalone, targeted hint that he... | 3,471 | [
"<note1>\n<description>Look for the anchor color that forms two straight, long runs (an L‑shaped pair). Those two runs act as the opposite corners of an implicit rectangle; the corner where they meet is the anchor cell and determines the rectangle's orientation.</description>\n<example>Imagine one long vertical lin... | [{"input": [[0, 0, 0, 0, 0, 0, 0, 0], [2, 0, 0, 0, 0, 0, 0, 0], [2, 0, 0, 0, 0, 0, 0, 0], [2, 0, 0, 0, 8, 0, 0, 0], [2, 0, 0, 0, 0, 0, 0, 0], [0, 0, 0, 0, 0, 0, 0, 0], [0, 0, 0, 0, 0, 0, 0, 0], [0, 0, 0, 0, 0, 0, 0, 0], [0, 0, 0, 0, 0, 0, 0, 0], [0, 0, 0, 0, 0, 0, 0, 0], [0, 0, 0, 0, 0, 0, 0, 0], [0, 0, 0, 0, 0, 0, 0, ... | [{"input": [[0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0], [2, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0], [2, 0, 0, 0, 0, 0, 0, 0, 8, 0, 0, 0], [2, 0, 0, 0, 0, 0, 0, 8, 0, 0, 0, 0], [2, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0], [2, 0, 0, 0, 8, 0, 0, 0, 0, 0, 0, 0], [2, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0], [0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0], [0, ... | arc 1 | You will be given some number of paired example inputs and outputs grids. The outputs were produced by applying a transformation rule to the input grids. In addition to the paired example inputs and outputs, there is also one test input without a known output. The inputs and outputs are each “grids”. A grid is a rectan... | ```
0 0 0 0 0 0 0 0 0 0 0 0
2 0 0 0 0 0 0 0 0 0 0 0
2 8 8 8 8 8 8 8 4 0 0 0
2 8 8 8 8 8 8 4 0 0 0 0
2 0 0 0 0 0 0 0 0 0 0 0
2 8 8 8 4 0 0 0 0 0 0 0
2 0 0 0 0 0 0 0 0 0 0 0
0 0 0 0 0 0 0 0 0 0 0 0
0 0 0 0 0 0 0 0 0 0 0 0
0 0 0 0 0 0 0 0 0 0 0 0
0 0 0 0 0 0 0 0 0 0 0 0
0 0 0 0 0 0 0 0 0 0 0 0
0 0 0 0 0 0 0 0 0 0 0 0
0 0 ... | 2,978 |
<|im_start|>user
# ARC HINT GENERATOR
## Role & Goal
You are an expert ARC (Abstraction and Reasoning Corpus) analyst. Your task is to generate a concise, actionable hint for a user who is struggling with an ARC problem. Analyze the problem and its correct solution to produce a single standalone, targeted hint that he... | 1,109 | [
"<note1>\n<description>Look first for a global geometric operation: many ARC tasks apply the same rigid transform to the whole grid (rotation or reflection). If the output looks like the input moved as a block, try rotating or flipping the input and compare positions rather than individual colors.</description>\n<e... | [{"input": [[7, 5, 8, 9, 9], [5, 1, 1, 3, 3], [1, 1, 9, 4, 1], [1, 5, 1, 7, 2], [1, 5, 1, 1, 9]], "output": [[5, 5, 5, 0, 8], [0, 0, 5, 5, 0], [5, 5, 9, 5, 6], [5, 8, 2, 1, 9], [9, 3, 5, 1, 9]]}, {"input": [[2, 9, 9, 5, 4], [5, 7, 9, 5, 4], [5, 4, 3, 3, 3], [8, 9, 1, 6, 4], [7, 8, 1, 6, 6]], "output": [[8, 6, 0, 0, 3],... | [{"input": [[2, 2, 3, 1, 8], [2, 6, 3, 8, 8], [2, 7, 6, 1, 1], [7, 2, 6, 6, 1], [7, 2, 2, 6, 2]], "output": [[8, 8, 3, 3, 3], [3, 3, 8, 5, 3], [3, 5, 5, 1, 1], [5, 5, 5, 6, 5], [3, 5, 5, 6, 6]]}] | barc_heavy | You will be given some number of paired example inputs and outputs grids. The outputs were produced by applying a transformation rule to the input grids. In addition to the paired example inputs and outputs, there is also one test input without a known output. The inputs and outputs are each “grids”. A grid is a rectan... | ```
8 8 3 3 3
3 3 8 5 3
3 5 5 1 1
5 5 5 6 5
3 5 5 6 6
``` | 616 |
<|im_start|>user
# ARC HINT GENERATOR
## Role & Goal
You are an expert ARC (Abstraction and Reasoning Corpus) analyst. Your task is to generate a concise, actionable hint for a user who is struggling with an ARC problem. Analyze the problem and its correct solution to produce a single standalone, targeted hint that he... | 2,453 | [
"<note1>\n<description>Look for a single pivot (an anchor) that is common to every example: a color that appears once in the input and is used as the reference for all changes. That pivot is the center of the transformation and is not moved; other pixels are placed relative to it. Finding this anchor reduces the pr... | [{"input": [[0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0], [0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0], [0, 0, 0, 0, 0, 0, 1, 0, 0, 0, 0], [0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0], [0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0], [0, 0, 0, 0, 0, 3, 0, 0, 0, 0, 1], [0, 0, 0, 0, 0, 2, 0, 0, 1, 0, 0], [0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0], [0, 0, 0, 0, 0, 0, 0, 0, 0, ... | [{"input": [[0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0], [0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0], [0, 0, 0, 0, 0, 1, 0, 0, 0, 0, 0], [0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0], [0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0], [0, 0, 0, 0, 2, 3, 0, 2, 0, 1, 0], [0, 0, 0, 0, 0, 2, 0, 0, 0, 0, 0], [0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0], [0, 0, 0, 0, 2, 0, 0, 0, 2, ... | barc_heavy | You will be given some number of paired example inputs and outputs grids. The outputs were produced by applying a transformation rule to the input grids. In addition to the paired example inputs and outputs, there is also one test input without a known output. The inputs and outputs are each “grids”. A grid is a rectan... | ```
0 0 9 0 0 0 0 0 0 0 0
0 0 0 0 0 0 0 0 0 0 0
0 0 9 0 0 1 9 0 0 0 0
0 0 0 0 0 0 0 0 0 0 0
0 0 0 0 0 9 0 0 0 0 0
0 3 0 9 2 3 9 2 0 1 0
0 0 0 0 0 2 0 0 0 0 0
0 0 0 0 0 0 0 0 0 0 0
0 0 0 0 2 3 0 0 2 0 0
0 0 0 0 0 0 0 0 0 0 0
0 0 0 0 0 0 0 0 2 0 0
``` | 1,960 |
<|im_start|>user
# ARC HINT GENERATOR
## Role & Goal
You are an expert ARC (Abstraction and Reasoning Corpus) analyst. Your task is to generate a concise, actionable hint for a user who is struggling with an ARC problem. Analyze the problem and its correct solution to produce a single standalone, targeted hint that he... | 3,523 | [
"<note1>\n<description>Many ARC tasks turn isolated single-pixel \"seeds\" into small filled squares in the output. If you see the same color repeated in compact 2×2 blocks in the output, it is a strong hint that each such block corresponds to one input pixel.</description>\n<example>Imagine an input with a single ... | [{"input": [[4, 6, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 7], [1, 0, 4, 0, 0, 0, 7, 0, 0, 8, 0, 0, 0, 0, 0, 0, 4], [0, 7, 0, 0, 0, 0, 0, 8, 0, 0, 0, 0, 0, 6, 0, 0, 0], [0, 0, 0, 0, 0, 0, 9, 2, 0, 8, 0, 0, 0, 0, 0, 0, 0], [0, 0, 0, 0, 0, 4, 0, 0, 0, 8, 0, 0, 0, 0, 0, 0, 0], [0, 0, 0, 0, 7, 0, 9, 0, 0, 0, 0, 0, 0, 0, ... | [{"input": [[5, 0, 0, 0, 0, 5, 5, 0, 0, 7, 0, 8, 0, 0], [0, 0, 0, 0, 0, 0, 0, 0, 8, 0, 0, 3, 0, 3], [0, 0, 8, 0, 0, 0, 0, 9, 0, 0, 0, 0, 0, 4], [0, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0], [0, 0, 0, 0, 0, 0, 1, 7, 0, 0, 0, 0, 0, 0], [0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0], [0, 0, 5, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0], ... | barc_heavy | You will be given some number of paired example inputs and outputs grids. The outputs were produced by applying a transformation rule to the input grids. In addition to the paired example inputs and outputs, there is also one test input without a known output. The inputs and outputs are each “grids”. A grid is a rectan... | ```
5 5 0 0 0 5 5 8 8 7 3 3 3 3
5 8 8 0 0 0 9 9 8 7 3 3 4 4
0 1 1 0 0 0 9 9 0 0 0 0 4 4
0 1 1 0 0 1 7 7 0 0 0 0 0 0
0 0 0 0 0 1 7 7 0 0 0 0 0 0
0 5 5 0 0 0 0 0 0 0 0 0 0 0
2 2 5 0 5 5 6 6 0 0 3 3 0 0
2 2 0 0 5 4 4 8 8 0 3 8 8 0
8 8 0 0 0 4 4 8 8 7 7 8 8 0
8 8 0 0 0 0 0 0 0 7 7 0 0 0
2 2 0 0 0 0 0 0 0 0 5 5 0 0
2 2 0 0 ... | 3,030 |
<|im_start|>user
# ARC HINT GENERATOR
## Role & Goal
You are an expert ARC (Abstraction and Reasoning Corpus) analyst. Your task is to generate a concise, actionable hint for a user who is struggling with an ARC problem. Analyze the problem and its correct solution to produce a single standalone, targeted hint that he... | 2,379 | [
"<note1>\n<description>Look first for a consistent dimension change: the examples always halve one axis. This tells you which direction to pair cells (rows or columns) and that the output size is the input size along the unchanged axis and half along the halved axis.</description>\n<example>If an input is 11×21 and... | [{"input": [[7, 7, 7, 4, 7, 5, 7, 7], [7, 7, 7, 7, 7, 7, 7, 5], [7, 4, 7, 7, 5, 5, 7, 7], [7, 4, 7, 4, 7, 7, 7, 7], [7, 7, 4, 7, 7, 5, 7, 5], [7, 7, 7, 7, 7, 7, 7, 7], [7, 4, 7, 7, 7, 7, 7, 7]], "output": [[7, 6, 7, 6], [7, 7, 7, 6], [6, 6, 7, 7], [7, 6, 7, 6], [7, 6, 6, 6], [7, 7, 7, 7], [7, 6, 7, 7]]}, {"input": [[2,... | [{"input": [[2, 2, 2, 2, 2, 1], [2, 2, 2, 2, 2, 2], [2, 2, 2, 2, 2, 5], [2, 2, 2, 2, 2, 2]], "output": [[2, 2, 2, 2, 2, 6], [2, 2, 2, 2, 2, 2]]}] | rearc | You will be given some number of paired example inputs and outputs grids. The outputs were produced by applying a transformation rule to the input grids. In addition to the paired example inputs and outputs, there is also one test input without a known output. The inputs and outputs are each “grids”. A grid is a rectan... | ```
2 2 2 2 2 6
2 2 2 2 2 2
``` | 1,886 |
<|im_start|>user
# ARC HINT GENERATOR
## Role & Goal
You are an expert ARC (Abstraction and Reasoning Corpus) analyst. Your task is to generate a concise, actionable hint for a user who is struggling with an ARC problem. Analyze the problem and its correct solution to produce a single standalone, targeted hint that he... | 1,971 | [
"<note1>\n<description>Look for a color that appears in exactly two rows. When one color occurs only on two distinct rows, those rows often mark the top and bottom of the region you must extract. This is a reliable cue because a color confined to two rows usually defines a vertical boundary pair.</description>\n<ex... | [{"input": [[4, 4, 4, 4, 4, 4, 4, 4, 4, 4], [4, 4, 0, 8, 8, 8, 8, 0, 4, 4], [4, 4, 4, 4, 4, 4, 4, 4, 4, 4], [4, 4, 4, 4, 4, 4, 4, 4, 4, 4], [4, 4, 4, 4, 4, 0, 4, 0, 4, 4], [4, 4, 4, 0, 4, 4, 4, 4, 4, 4], [4, 4, 4, 4, 4, 4, 4, 4, 4, 4], [4, 4, 0, 8, 8, 8, 8, 0, 4, 4], [4, 4, 0, 4, 4, 0, 4, 0, 0, 4], [4, 4, 4, 4, 0, 4, 4... | [{"input": [[2, 2, 2, 2, 4, 2, 2, 4, 2, 2, 4], [2, 2, 2, 4, 8, 2, 2, 2, 2, 2, 8], [2, 2, 2, 2, 8, 2, 4, 2, 2, 2, 8], [2, 2, 2, 2, 4, 2, 2, 2, 4, 2, 4], [2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2]], "output": [[4, 2, 2, 4, 2, 2, 4], [8, 2, 2, 2, 2, 2, 8], [8, 2, 4, 2, 2, 2, 8], [4, 2, 2, 2, 4, 2, 4]]}] | rearc | You will be given some number of paired example inputs and outputs grids. The outputs were produced by applying a transformation rule to the input grids. In addition to the paired example inputs and outputs, there is also one test input without a known output. The inputs and outputs are each “grids”. A grid is a rectan... | ```
4 2 2 4 2 2 4
8 2 2 2 2 2 8
8 2 4 2 2 2 8
4 2 2 2 4 2 4
``` | 1,478 |
<|im_start|>user
# ARC HINT GENERATOR
## Role & Goal
You are an expert ARC (Abstraction and Reasoning Corpus) analyst. Your task is to generate a concise, actionable hint for a user who is struggling with an ARC problem. Analyze the problem and its correct solution to produce a single standalone, targeted hint that he... | 2,182 | [
"<note1>\n<description>Look for a single color that repeatedly appears as solid, filled patches across the grid; these patches are the likely targets of the transformation. Treat each contiguous filled region (connected component) of that color as an independent object to consider.</description>\n<example>Imagine a... | [{"input": [[0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0], [1, 0, 5, 5, 0, 0, 0, 0, 0, 0, 0, 0], [2, 0, 5, 5, 0, 0, 0, 0, 0, 0, 0, 0], [1, 0, 5, 5, 0, 0, 0, 0, 0, 0, 0, 0], [1, 0, 5, 5, 0, 0, 0, 0, 0, 0, 0, 0], [1, 0, 5, 5, 0, 0, 0, 0, 5, 5, 0, 0], [2, 0, 5, 5, 0, 0, 0, 0, 5, 5, 0, 0], [2, 0, 5, 5, 0, 0, 0, 0, 5, 5, 0, 0], [1, ... | [{"input": [[1, 0, 5, 5, 5, 5, 5, 5, 0, 0, 0, 0], [8, 0, 5, 5, 5, 5, 5, 5, 0, 0, 0, 0], [1, 0, 5, 5, 5, 5, 5, 5, 0, 0, 0, 0], [1, 0, 5, 5, 5, 5, 5, 5, 0, 5, 5, 5], [7, 0, 5, 5, 5, 5, 5, 5, 0, 5, 5, 5], [7, 0, 5, 5, 5, 5, 5, 5, 0, 5, 5, 5], [7, 0, 0, 0, 0, 0, 5, 5, 5, 5, 5, 5], [7, 0, 0, 0, 0, 0, 5, 5, 5, 0, 0, 0], [8, ... | arc 1 | You will be given some number of paired example inputs and outputs grids. The outputs were produced by applying a transformation rule to the input grids. In addition to the paired example inputs and outputs, there is also one test input without a known output. The inputs and outputs are each “grids”. A grid is a rectan... | ```
1 0 1 1 1 1 1 1 0 0 0 0
8 0 8 8 8 8 8 8 0 0 0 0
1 0 1 1 1 1 1 1 0 0 0 0
1 0 1 1 1 1 1 1 0 1 1 1
7 0 7 7 7 7 7 7 0 7 7 7
7 0 7 7 7 7 7 7 0 7 7 7
7 0 0 0 0 0 7 7 7 7 7 7
7 0 0 0 0 0 7 7 7 0 0 0
8 0 0 0 0 0 8 8 8 0 0 0
8 0 8 8 8 0 8 8 8 0 0 0
8 0 8 8 8 0 8 8 8 0 0 0
8 0 8 8 8 0 8 8 8 0 0 0
``` | 1,689 |
<|im_start|>user
# ARC HINT GENERATOR
## Role & Goal
You are an expert ARC (Abstraction and Reasoning Corpus) analyst. Your task is to generate a concise, actionable hint for a user who is struggling with an ARC problem. Analyze the problem and its correct solution to produce a single standalone, targeted hint that he... | 2,159 | [
"<note1>\n<description>Look first for an invariant full row or column: when a whole row/column is the same color in the input, that line usually acts as a fixed separator and is not changed by the transformation. Treat that line as a boundary that splits the grid into independent regions you should analyze separate... | [{"input": [[0, 0, 0, 0, 0, 0, 6, 0, 0, 0], [0, 4, 0, 0, 0, 0, 0, 0, 0, 0], [0, 0, 0, 0, 0, 0, 0, 0, 0, 0], [0, 0, 0, 0, 0, 0, 0, 0, 2, 3], [0, 5, 0, 0, 0, 4, 0, 0, 0, 0], [0, 0, 0, 0, 0, 0, 0, 0, 0, 0], [0, 0, 0, 0, 0, 3, 0, 0, 0, 0], [0, 0, 1, 0, 0, 0, 5, 0, 0, 2], [0, 0, 0, 0, 0, 0, 0, 6, 5, 3], [5, 5, 5, 5, 5, 5, 5... | [{"input": [[0, 0, 0, 0, 0, 0, 0, 0, 3, 4], [0, 9, 9, 0, 0, 0, 0, 0, 0, 0], [0, 0, 0, 0, 0, 0, 0, 0, 0, 0], [9, 0, 0, 0, 0, 0, 0, 0, 0, 0], [0, 0, 0, 0, 0, 0, 0, 0, 1, 0], [7, 0, 0, 0, 0, 0, 0, 0, 0, 0], [0, 0, 0, 9, 0, 0, 0, 3, 0, 0], [7, 0, 0, 4, 0, 0, 7, 0, 0, 8], [0, 0, 0, 0, 0, 0, 0, 0, 2, 0], [5, 5, 5, 5, 5, 5, 5... | barc_heavy | You will be given some number of paired example inputs and outputs grids. The outputs were produced by applying a transformation rule to the input grids. In addition to the paired example inputs and outputs, there is also one test input without a known output. The inputs and outputs are each “grids”. A grid is a rectan... | ```
9 9 9 9 0 0 7 3 3 4
0 0 0 0 0 0 0 0 1 8
0 0 0 0 0 0 0 0 0 0
0 0 0 0 0 0 0 0 0 0
7 0 0 0 0 0 0 0 0 0
0 0 0 0 0 0 0 0 2 0
7 0 0 0 0 0 0 0 0 0
0 0 0 4 0 0 0 0 0 0
0 0 0 0 0 0 0 0 0 0
5 5 5 5 5 5 5 5 5 5
``` | 1,666 |
<|im_start|>user
# ARC HINT GENERATOR
## Role & Goal
You are an expert ARC (Abstraction and Reasoning Corpus) analyst. Your task is to generate a concise, actionable hint for a user who is struggling with an ARC problem. Analyze the problem and its correct solution to produce a single standalone, targeted hint that he... | 3,705 | [
"<note1>\n<description>Many ARC tasks split the grid into two large contiguous bands (either horizontal or vertical) separated by a straight boundary of a single color. Detecting that split reduces the problem to working with two smaller, aligned subgrids.</description>\n<example>Imagine a grid whose top rows are a... | [{"input": [[8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8], [8, 7, 7, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8], [7, 8, 8, 7, 8, 8, 8, 8, 8, 3, 8, 8, 8], [8, 7, 7, 8, 8, 8, 3, 8, 3, 3, 8, 8, 8], [8, 8, 8, 8, 8, 3, 8, 8, 3, 3, 8, 8, 8], [8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8], [8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8], [8, 8, 8, 8, 8, 8, 8,... | [{"input": [[6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6], [6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6], [6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6], [6, 6, 6, 6, 6, 0, 4, 4, 4, 4, 4, 6], [6, 6, 6, 6, 6, 4, 4, 0, 4, 0, 4, 6], [6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6], [4, 3, 4, 6, 6, 6, 6, 6, 6, 6, 6, 6], [4, 4, 3, 6, 6, 6, 6, 4, 4, 1, 4, 6], [4, ... | rearc | You will be given some number of paired example inputs and outputs grids. The outputs were produced by applying a transformation rule to the input grids. In addition to the paired example inputs and outputs, there is also one test input without a known output. The inputs and outputs are each “grids”. A grid is a rectan... | ```
7 7 7 7 7 7 7 7 7 7 7 7
7 4 3 4 7 7 7 7 7 7 7 7
7 4 4 3 7 7 7 7 7 7 7 7
7 4 4 4 7 7 7 7 7 7 7 7
7 4 4 4 7 7 7 7 7 7 7 7
7 4 4 4 7 7 7 7 7 7 7 7
7 7 7 7 7 7 7 7 7 7 7 7
7 7 7 7 4 4 7 7 7 7 7 7
7 7 7 7 4 9 7 7 7 7 7 7
7 7 7 7 7 7 7 7 7 7 7 7
7 7 7 7 7 7 7 7 7 7 7 7
7 7 7 0 4 4 4 4 4 7 7 7
7 7 7 4 4 0 4 0 4 7 7 7
``` | 3,212 |
<|im_start|>user
# ARC HINT GENERATOR
## Role & Goal
You are an expert ARC (Abstraction and Reasoning Corpus) analyst. Your task is to generate a concise, actionable hint for a user who is struggling with an ARC problem. Analyze the problem and its correct solution to produce a single standalone, targeted hint that he... | 2,155 | [
"<note1>\n<description>Look first for a uniform downsampling: many ARC tasks compress the grid by grouping adjacent cells into small blocks (commonly 2×2) and producing one output cell per block. If the output dimensions are about half the input dimensions (rounded up), a 2×2 block is a strong candidate.</descripti... | [{"input": [[6, 5, 6, 6, 9, 9], [6, 6, 6, 9, 9, 9], [6, 5, 5, 9, 9, 9], [6, 6, 5, 6, 9, 9], [6, 6, 6, 9, 6, 9], [6, 6, 5, 9, 6, 9], [6, 6, 6, 6, 6, 0], [6, 6, 6, 6, 6, 6], [6, 6, 8, 6, 6, 6], [6, 6, 6, 6, 6, 0], [6, 6, 6, 0, 0, 6], [6, 6, 6, 6, 0, 6]], "output": [[6, 9, 9], [9, 9, 9], [9, 9, 9], [6, 9, 9], [9, 0, 9], [... | [{"input": [[5, 5, 5, 7, 7, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 4, 5, 5, 4, 5, 5, 5], [7, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 4, 4, 4, 5, 4, 5, 4], [5, 5, 5, 5, 7, 5, 5, 5, 5, 5, 5, 5, 5, 4, 5, 5, 4, 4, 4, 5, 4, 5], [5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 4, 5, 4, 4, 5, 5, 5, 5], [5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5,... | rearc | You will be given some number of paired example inputs and outputs grids. The outputs were produced by applying a transformation rule to the input grids. In addition to the paired example inputs and outputs, there is also one test input without a known output. The inputs and outputs are each “grids”. A grid is a rectan... | ```
6 5 3 3 4 5 5 4 6 5 6
6 3 5 3 4 4 4 6 4 3 4
6 3 4 3 7 4 4 4 5 4 6
6 6 3 4 3 4 4 6 6 3 6
5 5 3 5 4 6 6 6 4 4 4
4 6 4 3 5 6 6 4 6 4 3
4 5 6 4 6 4 4 4 6 5 4
``` | 1,662 |
<|im_start|>user
# ARC HINT GENERATOR
## Role & Goal
You are an expert ARC (Abstraction and Reasoning Corpus) analyst. Your task is to generate a concise, actionable hint for a user who is struggling with an ARC problem. Analyze the problem and its correct solution to produce a single standalone, targeted hint that he... | 2,903 | [
"<note1>\n<description>First find the \"odd\" color: the one that appears only a few times against a uniform background. This sparse color is usually the object you must operate on. Counting occurrences and noting whether they are isolated or clustered quickly narrows the target.</description>\n<example>Imagine a 7... | [{"input": [[5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5], [5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5], [5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5], [5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5], [5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5], [5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5], [5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5], [5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5], [5, ... | [{"input": [[6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6], [6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6], [6, 6, 9, 6, 6, 6, 6, 6, 6, 6, 6, 6], [6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6], [6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6], [6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6], [6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6], [6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6], [6, ... | rearc | You will be given some number of paired example inputs and outputs grids. The outputs were produced by applying a transformation rule to the input grids. In addition to the paired example inputs and outputs, there is also one test input without a known output. The inputs and outputs are each “grids”. A grid is a rectan... | ```
6 6 6 6 6 6 6 6 6 6 6 6
6 6 6 6 6 6 6 6 6 6 6 6
6 6 9 9 9 9 9 9 9 9 9 6
6 6 9 6 6 6 6 6 6 6 9 6
6 6 9 6 6 6 6 6 6 6 9 6
6 6 9 6 6 6 6 6 6 6 9 6
6 6 9 6 6 6 6 6 6 6 9 6
6 6 9 6 6 6 6 6 6 6 9 6
6 6 9 6 6 6 6 6 6 6 9 6
6 6 9 6 6 6 6 6 6 6 9 6
6 6 9 6 6 6 6 6 6 6 9 6
6 6 9 6 6 6 6 6 6 6 9 6
6 6 9 6 6 6 9 6 6 6 9 6
6 6 ... | 2,410 |
<|im_start|>user
# ARC HINT GENERATOR
## Role & Goal
You are an expert ARC (Abstraction and Reasoning Corpus) analyst. Your task is to generate a concise, actionable hint for a user who is struggling with an ARC problem. Analyze the problem and its correct solution to produce a single standalone, targeted hint that he... | 2,612 | [
"<note1>\n<description>Look for a small rectangular motif that is repeated across the grid: many ARC tasks are built by tiling the same subgrid. If the same arrangement of colors appears at regular intervals, the grid is a tiling of one smaller block.</description>\n<example>Imagine a 6×6 grid made by repeating a 3... | [{"input": [[1, 4, 1, 1, 1, 1, 1, 1, 1, 4, 1], [4, 4, 1, 1, 1, 1, 1, 1, 1, 4, 4], [1, 1, 1, 1, 1, 1, 1, 8, 8, 1, 1], [1, 1, 3, 1, 1, 1, 1, 1, 8, 1, 1], [1, 1, 3, 1, 1, 1, 1, 1, 8, 1, 1], [1, 1, 1, 1, 1, 1, 1, 8, 8, 1, 1], [4, 4, 1, 1, 1, 1, 1, 1, 1, 4, 4], [1, 4, 1, 1, 1, 1, 1, 1, 1, 4, 1], [1, 4, 1, 1, 1, 1, 1, 1, 1, ... | [{"input": [[2, 2, 8, 2, 2, 2, 2, 8, 2, 2, 2, 2, 8, 2, 2, 2, 2, 8, 2, 2, 2, 2, 8, 2, 2], [2, 1, 6, 1, 2, 2, 4, 6, 4, 2, 2, 1, 6, 1, 2, 2, 4, 6, 4, 2, 2, 8, 8, 8, 2], [8, 8, 8, 8, 8, 8, 4, 4, 4, 8, 8, 1, 1, 1, 8, 8, 4, 4, 4, 8, 8, 8, 8, 8, 8], [8, 8, 8, 8, 8, 8, 4, 6, 4, 8, 8, 1, 6, 1, 8, 8, 4, 6, 4, 8, 8, 8, 8, 8, 8], ... | arc 2 | You will be given some number of paired example inputs and outputs grids. The outputs were produced by applying a transformation rule to the input grids. In addition to the paired example inputs and outputs, there is also one test input without a known output. The inputs and outputs are each “grids”. A grid is a rectan... | ```
2 2 8 2 2
2 1 6 1 2
8 1 1 1 8
8 1 6 1 8
2 1 1 1 2
2 1 6 1 2
2 1 1 1 2
8 1 6 1 8
8 1 1 1 8
2 1 6 1 2
2 2 8 2 2
``` | 2,119 |
<|im_start|>user
# ARC HINT GENERATOR
## Role & Goal
You are an expert ARC (Abstraction and Reasoning Corpus) analyst. Your task is to generate a concise, actionable hint for a user who is struggling with an ARC problem. Analyze the problem and its correct solution to produce a single standalone, targeted hint that he... | 1,759 | [
"<note1>\n<description>Look for objects by grouping same-colored pixels that touch orthogonally (up/down/left/right). Treat each such connected group as a single object to be moved; do not merge objects that are separated by at least one empty cell.</description>\n<example>Imagine a grid with a 2×2 red square and a... | [{"input": [[0, 2, 2, 0, 0, 0, 0, 0, 0, 0], [0, 2, 2, 0, 0, 0, 0, 1, 1, 0], [0, 0, 0, 0, 4, 4, 0, 1, 1, 0], [0, 0, 0, 0, 4, 4, 0, 0, 0, 0], [0, 0, 0, 0, 0, 0, 0, 0, 0, 0]], "output": [[0, 0, 0, 0, 0, 0, 0, 0, 0, 0], [0, 2, 2, 0, 4, 4, 0, 1, 1, 0], [0, 2, 2, 0, 4, 4, 0, 1, 1, 0], [0, 0, 0, 0, 0, 0, 0, 0, 0, 0], [0, 0, 0... | [{"input": [[0, 0, 0, 0, 0, 0, 0, 0, 2, 2], [0, 0, 0, 0, 0, 0, 0, 0, 2, 2], [0, 1, 1, 0, 0, 0, 0, 2, 0, 0], [0, 1, 1, 0, 0, 0, 0, 0, 0, 0], [1, 0, 0, 0, 0, 0, 0, 0, 0, 0], [0, 0, 0, 0, 4, 4, 0, 0, 0, 0], [0, 0, 0, 0, 4, 4, 0, 0, 0, 0], [0, 0, 0, 4, 0, 0, 0, 0, 0, 0], [0, 0, 0, 0, 0, 0, 0, 0, 0, 0], [0, 0, 0, 0, 0, 0, 0... | arc 1 | You will be given some number of paired example inputs and outputs grids. The outputs were produced by applying a transformation rule to the input grids. In addition to the paired example inputs and outputs, there is also one test input without a known output. The inputs and outputs are each “grids”. A grid is a rectan... | ```
0 0 0 0 0 0 0 0 0 0
0 0 0 0 0 0 0 0 0 0
0 1 1 0 4 4 0 0 2 2
0 1 1 0 4 4 0 0 2 2
1 0 0 4 0 0 0 2 0 0
0 0 0 0 0 0 0 0 0 0
0 0 0 0 0 0 0 0 0 0
0 0 0 0 0 0 0 0 0 0
0 0 0 0 0 0 0 0 0 0
0 0 0 0 0 0 0 0 0 0
``` | 1,266 |
<|im_start|>user
# ARC HINT GENERATOR
## Role & Goal
You are an expert ARC (Abstraction and Reasoning Corpus) analyst. Your task is to generate a concise, actionable hint for a user who is struggling with an ARC problem. Analyze the problem and its correct solution to produce a single standalone, targeted hint that he... | 2,757 | [
"<note1>\n<description>Look for a single non-background color that consistently appears in the inputs and is the only color used in the outputs. When one color is the only one that changes from input to output, it is likely the key feature the transformation uses.</description>\n<example>Imagine a grid filled mostl... | [{"input": [[0, 0, 4, 4], [0, 0, 0, 4], [0, 0, 4, 4], [0, 4, 0, 0], [0, 0, 0, 0], [0, 0, 4, 0], [0, 0, 0, 0], [0, 0, 0, 0], [0, 0, 0, 0], [0, 0, 4, 0], [0, 0, 4, 0], [0, 0, 0, 0], [0, 4, 0, 0], [4, 0, 0, 0], [0, 4, 0, 0], [0, 0, 0, 4], [0, 0, 4, 4], [0, 0, 0, 4], [0, 0, 0, 0], [0, 0, 4, 0], [0, 0, 0, 0], [0, 0, 0, 0], ... | [{"input": [[0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0], [0, 0, 0, 8, 0, 8, 0, 0, 0, 0, 0, 0, 0, 0], [0, 8, 8, 0, 0, 0, 0, 0, 0, 0, 0, 8, 0, 0], [0, 0, 0, 0, 8, 0, 0, 0, 0, 0, 0, 0, 0, 0], [0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0], [0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0], [0, 0, 0, 0, 0, 8, 0, 0, 8, 0, 0, 0, 0, 0], ... | rearc | You will be given some number of paired example inputs and outputs grids. The outputs were produced by applying a transformation rule to the input grids. In addition to the paired example inputs and outputs, there is also one test input without a known output. The inputs and outputs are each “grids”. A grid is a rectan... | ```
8 8 8 8 8 8 8 8 8 8 8 8 8 8 8 8 8 8 8 8 8 8 8 8 8 8 8 8
``` | 2,264 |
<|im_start|>user
# ARC HINT GENERATOR
## Role & Goal
You are an expert ARC (Abstraction and Reasoning Corpus) analyst. Your task is to generate a concise, actionable hint for a user who is struggling with an ARC problem. Analyze the problem and its correct solution to produce a single standalone, targeted hint that he... | 4,319 | [
"<note1>\n<description>Look for the smallest rectangular region that contains every cell different from the dominant background color. That rectangle is the likely \"seed\" or tile that the transformation uses. This is effective because many ARC tasks hide a compact pattern inside a sea of a single color.</descript... | [{"input": [[1, 1, 1, 1, 1, 1, 3, 8, 8, 3, 8, 8], [1, 1, 1, 1, 1, 1, 9, 0, 8, 9, 0, 8], [1, 1, 1, 1, 1, 1, 1, 9, 8, 1, 9, 8], [1, 1, 1, 1, 1, 1, 1, 0, 9, 1, 0, 9], [1, 1, 1, 1, 1, 1, 1, 9, 1, 1, 9, 1], [1, 1, 1, 1, 1, 1, 1, 9, 1, 1, 9, 1], [1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1]], "output": [[3, 8, 8, 3, 8, 8, 3, 8, 8, 3,... | [{"input": [[6, 1, 8, 6, 1, 8, 4, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7], [4, 1, 1, 6, 6, 1, 4, 4, 4, 1, 4, 1, 6, 1, 7, 7, 7], [6, 1, 8, 6, 1, 8, 4, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7], [4, 1, 1, 6, 6, 1, 4, 4, 4, 1, 4, 1, 6, 1, 7, 7, 7], [7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7], [7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, ... | rearc | You will be given some number of paired example inputs and outputs grids. The outputs were produced by applying a transformation rule to the input grids. In addition to the paired example inputs and outputs, there is also one test input without a known output. The inputs and outputs are each “grids”. A grid is a rectan... | ```
6 1 8 6 1 8 4 7 7 7 7 7 7 7 7 7 7
4 1 1 6 6 1 4 4 4 1 4 1 6 1 7 7 7
6 1 8 6 1 8 4 7 7 7 7 7 7 7 7 7 7
4 1 1 6 6 1 4 4 4 1 4 1 6 1 7 7 7
6 1 8 6 1 8 4 7 7 7 7 7 7 7 7 7 7
4 1 1 6 6 1 4 4 4 1 4 1 6 1 7 7 7
6 1 8 6 1 8 4 7 7 7 7 7 7 7 7 7 7
4 1 1 6 6 1 4 4 4 1 4 1 6 1 7 7 7
6 1 8 6 1 8 4 7 7 7 7 7 7 7 7 7 7
4 1 1 6 6 ... | 3,826 |
<|im_start|>user
# ARC HINT GENERATOR
## Role & Goal
You are an expert ARC (Abstraction and Reasoning Corpus) analyst. Your task is to generate a concise, actionable hint for a user who is struggling with an ARC problem. Analyze the problem and its correct solution to produce a single standalone, targeted hint that he... | 2,431 | [
"<note1>\n<description>Look for a single non‑zero color that is consistently preserved across the examples while all other colors are removed. When an output contains only one color, that color is the transformation's focus. Identifying this target color is the first step before any spatial reasoning.</description>... | [{"input": [[8, 0, 6, 0, 0, 5, 0, 7, 9, 0, 8, 0, 2], [9, 8, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 3], [0, 0, 8, 3, 1, 0, 0, 5, 0, 0, 9, 8, 0], [8, 0, 0, 0, 0, 8, 0, 0, 0, 4, 0, 0, 2], [0, 0, 0, 0, 3, 8, 0, 2, 6, 9, 9, 7, 0], [0, 0, 7, 0, 0, 0, 0, 0, 6, 0, 0, 0, 6], [1, 9, 0, 0, 0, 9, 0, 5, 0, 0, 7, 0, 0], [0, 0, 1, 3, 5, 0, 7,... | [{"input": [[0, 0, 8, 0, 3, 9], [0, 0, 0, 0, 0, 5], [0, 2, 0, 3, 7, 0], [4, 0, 0, 7, 0, 0], [5, 0, 0, 0, 0, 6], [0, 7, 0, 0, 1, 0], [0, 8, 9, 5, 0, 0], [0, 4, 2, 0, 9, 0], [0, 1, 0, 0, 9, 3], [8, 5, 0, 0, 0, 0], [7, 0, 0, 0, 0, 0]], "output": [[0, 0, 0, 0, 3, 0], [0, 0, 0, 0, 0, 0], [0, 0, 0, 0, 0, 0], [0, 0, 0, 0, 0, ... | barc_heavy | You will be given some number of paired example inputs and outputs grids. The outputs were produced by applying a transformation rule to the input grids. In addition to the paired example inputs and outputs, there is also one test input without a known output. The inputs and outputs are each “grids”. A grid is a rectan... | ```
0 0 0 0 3 0
0 0 0 0 0 0
0 0 0 0 0 0
0 0 0 0 0 0
0 0 0 0 0 0
0 0 0 0 0 0
0 0 0 0 0 0
0 0 0 0 0 0
0 0 0 0 0 0
0 0 0 0 0 0
0 0 0 0 0 0
``` | 1,938 |
<|im_start|>user
# ARC HINT GENERATOR
## Role & Goal
You are an expert ARC (Abstraction and Reasoning Corpus) analyst. Your task is to generate a concise, actionable hint for a user who is struggling with an ARC problem. Analyze the problem and its correct solution to produce a single standalone, targeted hint that he... | 3,523 | [
"<note1>\n<description>Look for a single non-background color that is preserved in the output while other colors disappear. This color is not chosen arbitrarily but is determined by a simple geometric property of its connected component (for example, its bounding-box aspect ratio).</description>\n<example>Imagine a... | [{"input": [[0, 0, 6, 0, 0, 0, 0, 0, 9, 9, 0, 0, 0, 0, 0, 0, 0], [0, 0, 6, 6, 6, 0, 0, 0, 9, 9, 9, 9, 0, 0, 0, 0, 0], [0, 6, 6, 6, 0, 0, 0, 0, 9, 9, 0, 0, 0, 0, 0, 0, 0], [0, 0, 0, 6, 0, 0, 0, 0, 9, 9, 0, 0, 0, 0, 0, 0, 0], [0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 6, 6, 6, 6], [0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 6, 6, ... | [{"input": [[0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0], [0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0], [0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 2, 2, 2, 0], [0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 2, 2, 2, 0], [0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 2, 0, 0], [0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0], [0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0], ... | barc_heavy | You will be given some number of paired example inputs and outputs grids. The outputs were produced by applying a transformation rule to the input grids. In addition to the paired example inputs and outputs, there is also one test input without a known output. The inputs and outputs are each “grids”. A grid is a rectan... | ```
8 8 8 0 0 0 0 0 0 0 0 0 0 0
8 8 8 0 0 0 0 0 0 0 0 0 0 0
0 8 0 0 0 0 0 0 0 0 0 0 0 0
0 0 0 0 0 0 0 0 0 0 0 0 0 0
0 0 0 0 0 0 0 0 0 0 0 0 0 0
0 0 0 0 0 0 0 0 0 0 0 0 0 0
0 0 0 0 0 0 0 0 0 0 0 0 0 0
0 0 0 0 0 0 0 0 0 0 0 0 0 0
0 0 0 0 0 0 0 0 0 0 0 0 0 0
0 8 8 0 0 0 0 0 0 0 0 0 0 0
8 8 8 8 0 0 0 0 0 0 0 0 0 0
8 8 8 8 ... | 3,030 |
<|im_start|>user
# ARC HINT GENERATOR
## Role & Goal
You are an expert ARC (Abstraction and Reasoning Corpus) analyst. Your task is to generate a concise, actionable hint for a user who is struggling with an ARC problem. Analyze the problem and its correct solution to produce a single standalone, targeted hint that he... | 2,949 | [
"<note1>\n<description>Look for a color that appears as a continuous closed loop (a rectangular frame) rather than as isolated pixels. Such a frame is typically one pixel thick and forms the four sides of a rectangle; it is distinct from the uniform background because it encloses other colors.</description>\n<examp... | [{"input": [[6, 5, 2, 9, 2, 9, 2, 2, 2, 2, 2, 3, 2, 6, 3, 5, 6, 2, 2, 2, 6, 2, 2], [6, 5, 2, 9, 2, 9, 2, 2, 2, 2, 2, 3, 2, 6, 3, 5, 6, 2, 2, 2, 6, 2, 2], [6, 5, 0, 9, 0, 8, 8, 8, 8, 8, 8, 8, 0, 6, 3, 5, 6, 0, 0, 0, 6, 0, 0], [0, 0, 0, 0, 0, 8, 0, 0, 0, 0, 0, 8, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0], [6, 5, 2, 9, 2, 8, 2, 2,... | [{"input": [[9, 5, 9, 9, 1, 9, 8, 9, 5], [9, 5, 9, 9, 1, 9, 8, 9, 5], [2, 5, 2, 2, 1, 2, 8, 2, 5], [9, 5, 9, 9, 1, 9, 8, 9, 5], [9, 5, 9, 9, 1, 9, 8, 9, 5], [9, 5, 9, 9, 1, 9, 8, 9, 5], [9, 5, 9, 9, 1, 9, 8, 9, 5], [9, 5, 9, 9, 1, 9, 8, 9, 5], [9, 5, 9, 9, 4, 4, 4, 9, 5], [6, 6, 6, 6, 4, 6, 4, 6, 6], [9, 5, 9, 9, 4, 9,... | rearc | You will be given some number of paired example inputs and outputs grids. The outputs were produced by applying a transformation rule to the input grids. In addition to the paired example inputs and outputs, there is also one test input without a known output. The inputs and outputs are each “grids”. A grid is a rectan... | ```
4 4 4
4 6 4
4 9 4
4 4 4
``` | 2,456 |
<|im_start|>user
# ARC HINT GENERATOR
## Role & Goal
You are an expert ARC (Abstraction and Reasoning Corpus) analyst. Your task is to generate a concise, actionable hint for a user who is struggling with an ARC problem. Analyze the problem and its correct solution to produce a single standalone, targeted hint that he... | 2,159 | [
"<note1>\n<description>Look for a single-color rectangular outline (a continuous border) that encloses an interior. That border defines a fixed reference: the interior is the area strictly inside the border, and the border itself is not part of the objects to be moved.</description>\n<example>Imagine a 6×6 ring of ... | [{"input": [[0, 0, 0, 0, 0, 0, 0, 0, 0, 0], [0, 0, 0, 0, 0, 0, 0, 0, 0, 0], [0, 0, 7, 7, 7, 7, 7, 7, 0, 0], [0, 0, 7, 2, 0, 0, 8, 7, 0, 0], [0, 0, 7, 0, 0, 0, 0, 7, 0, 0], [0, 0, 7, 0, 0, 0, 0, 7, 0, 0], [0, 0, 7, 9, 0, 0, 3, 7, 0, 0], [0, 0, 7, 7, 7, 7, 7, 7, 0, 0], [0, 0, 0, 0, 0, 0, 0, 0, 0, 0], [0, 0, 0, 0, 0, 0, 0... | [{"input": [[0, 0, 0, 0, 0, 0, 0, 0, 0, 0], [0, 0, 0, 0, 0, 0, 0, 0, 0, 0], [0, 0, 0, 0, 0, 0, 0, 0, 0, 0], [0, 0, 3, 3, 3, 3, 3, 3, 0, 0], [0, 0, 3, 6, 0, 0, 4, 3, 0, 0], [0, 0, 3, 0, 0, 0, 0, 3, 0, 0], [0, 0, 3, 8, 0, 0, 2, 3, 0, 0], [0, 0, 3, 3, 3, 3, 3, 3, 0, 0], [0, 0, 0, 0, 0, 0, 0, 0, 0, 0], [0, 0, 0, 0, 0, 0, 0... | arc 2 | You will be given some number of paired example inputs and outputs grids. The outputs were produced by applying a transformation rule to the input grids. In addition to the paired example inputs and outputs, there is also one test input without a known output. The inputs and outputs are each “grids”. A grid is a rectan... | ```
0 0 0 0 0 0 0 0 0 0
0 0 0 0 0 0 0 0 0 0
0 2 0 0 0 0 0 0 8 0
0 0 3 3 3 3 3 3 0 0
0 0 3 0 0 0 0 3 0 0
0 0 3 0 0 0 0 3 0 0
0 0 3 0 0 0 0 3 0 0
0 0 3 3 3 3 3 3 0 0
0 4 0 0 0 0 0 0 6 0
0 0 0 0 0 0 0 0 0 0
``` | 1,666 |
<|im_start|>user
# ARC HINT GENERATOR
## Role & Goal
You are an expert ARC (Abstraction and Reasoning Corpus) analyst. Your task is to generate a concise, actionable hint for a user who is struggling with an ARC problem. Analyze the problem and its correct solution to produce a single standalone, targeted hint that he... | 3,165 | [
"<note1>\n<description>Find the dominant background color and treat every other color as the foreground object(s). Isolating the foreground reduces the problem to tracking a small set of pixels or a small shape that moves between rows. This makes it easier to see the rule that governs how those pixels reappear in n... | [{"input": [[1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 9, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1], [1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 9, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1], [1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 9, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1]], "output": [[1, 1, 1, 1, 1, 1, 1, 1, 1, 1... | [{"input": [[2, 2, 2, 2, 2, 2, 2, 2, 2, 8], [2, 2, 2, 2, 2, 2, 2, 2, 8, 2], [2, 2, 2, 2, 2, 2, 2, 8, 2, 2]], "output": [[2, 2, 2, 2, 2, 2, 2, 2, 2, 8], [2, 2, 2, 2, 2, 2, 2, 2, 8, 2], [2, 2, 2, 2, 2, 2, 2, 8, 2, 2], [2, 2, 2, 2, 2, 2, 8, 2, 2, 2], [2, 2, 2, 2, 2, 8, 2, 2, 2, 2], [2, 2, 2, 2, 8, 2, 2, 2, 2, 2], [2, 2, 2... | rearc | You will be given some number of paired example inputs and outputs grids. The outputs were produced by applying a transformation rule to the input grids. In addition to the paired example inputs and outputs, there is also one test input without a known output. The inputs and outputs are each “grids”. A grid is a rectan... | ```
2 2 2 2 2 2 2 2 2 8
2 2 2 2 2 2 2 2 8 2
2 2 2 2 2 2 2 8 2 2
2 2 2 2 2 2 8 2 2 2
2 2 2 2 2 8 2 2 2 2
2 2 2 2 8 2 2 2 2 2
2 2 2 8 2 2 2 2 2 2
2 2 8 2 2 2 2 2 2 2
2 8 2 2 2 2 2 2 2 2
8 2 2 2 2 2 2 2 2 2
``` | 2,672 |
<|im_start|>user
# ARC HINT GENERATOR
## Role & Goal
You are an expert ARC (Abstraction and Reasoning Corpus) analyst. Your task is to generate a concise, actionable hint for a user who is struggling with an ARC problem. Analyze the problem and its correct solution to produce a single standalone, targeted hint that he... | 1,623 | [
"<note1>\n<description>Look for a full row and a full column made of one color; they act as separators that partition the 9×9 into four quadrants. Treat those separator lines as boundaries and ignore them when you inspect the shapes inside each quadrant.</description>\n<example>Imagine a grid where row r and column... | [{"input": [[0, 0, 5, 0, 0, 0, 1, 1, 1], [0, 0, 5, 0, 0, 0, 1, 1, 1], [0, 0, 5, 0, 1, 1, 1, 1, 1], [0, 0, 5, 0, 1, 1, 1, 0, 0], [0, 0, 5, 1, 1, 1, 1, 0, 0], [0, 0, 5, 0, 1, 0, 0, 0, 0], [5, 5, 5, 5, 5, 5, 5, 5, 5], [4, 8, 5, 0, 0, 0, 0, 0, 0], [9, 6, 5, 0, 0, 0, 0, 0, 0]], "output": [[0, 0, 0, 8, 8, 8], [0, 0, 0, 8, 8,... | [{"input": [[3, 7, 5, 0, 0, 0, 0, 0, 0], [6, 8, 5, 0, 0, 0, 0, 0, 0], [5, 5, 5, 5, 5, 5, 5, 5, 5], [0, 0, 5, 0, 1, 1, 0, 0, 0], [0, 0, 5, 0, 0, 1, 0, 0, 1], [0, 0, 5, 0, 0, 1, 1, 1, 1], [0, 0, 5, 1, 1, 1, 1, 0, 0], [0, 0, 5, 1, 0, 0, 1, 0, 0], [0, 0, 5, 0, 0, 0, 1, 1, 0]], "output": [[0, 3, 3, 0, 0, 0], [0, 0, 3, 0, 0,... | barc_heavy | You will be given some number of paired example inputs and outputs grids. The outputs were produced by applying a transformation rule to the input grids. In addition to the paired example inputs and outputs, there is also one test input without a known output. The inputs and outputs are each “grids”. A grid is a rectan... | ```
0 3 3 0 0 0
0 0 3 0 0 7
0 0 3 7 7 7
6 6 6 8 0 0
6 0 0 8 0 0
0 0 0 8 8 0
``` | 1,130 |
<|im_start|>user
# ARC HINT GENERATOR
## Role & Goal
You are an expert ARC (Abstraction and Reasoning Corpus) analyst. Your task is to generate a concise, actionable hint for a user who is struggling with an ARC problem. Analyze the problem and its correct solution to produce a single standalone, targeted hint that he... | 2,159 | [
"<note1>\n<description>Look for the single color that is being transformed across examples while other colors remain unchanged. This usually means one non-background color is being split into two new colors in the outputs. Identifying that target color narrows the problem to operations on its connected pieces.</des... | [{"input": [[0, 0, 0, 0, 0, 0, 0, 0, 0, 0], [0, 0, 0, 0, 0, 2, 0, 0, 2, 0], [0, 0, 0, 1, 1, 2, 1, 1, 2, 0], [0, 0, 1, 1, 1, 2, 2, 2, 2, 0], [0, 0, 1, 1, 1, 0, 0, 0, 0, 0], [0, 0, 0, 1, 1, 0, 1, 2, 1, 0], [0, 0, 0, 0, 0, 0, 2, 2, 2, 0], [0, 0, 0, 0, 0, 0, 2, 2, 2, 0], [0, 0, 0, 0, 0, 0, 1, 2, 1, 0], [0, 0, 0, 0, 0, 0, 0... | [{"input": [[0, 0, 0, 0, 0, 0, 0, 0, 0, 0], [0, 0, 0, 2, 0, 0, 0, 0, 0, 0], [0, 1, 1, 1, 1, 0, 0, 0, 0, 0], [0, 1, 0, 2, 0, 0, 0, 0, 0, 0], [0, 1, 1, 0, 0, 0, 0, 0, 0, 0], [0, 0, 0, 0, 0, 0, 0, 0, 0, 0], [0, 0, 0, 1, 1, 1, 0, 0, 0, 0], [0, 0, 0, 1, 1, 1, 0, 0, 0, 0], [0, 0, 0, 0, 0, 0, 0, 0, 0, 0], [0, 0, 0, 0, 0, 0, 0... | barc_heavy | You will be given some number of paired example inputs and outputs grids. The outputs were produced by applying a transformation rule to the input grids. In addition to the paired example inputs and outputs, there is also one test input without a known output. The inputs and outputs are each “grids”. A grid is a rectan... | ```
0 0 0 0 0 0 0 0 0 0
0 0 0 2 0 0 0 0 0 0
0 3 3 3 3 0 0 0 0 0
0 3 0 2 0 0 0 0 0 0
0 3 3 0 0 0 0 0 0 0
0 0 0 0 0 0 0 0 0 0
0 0 0 3 3 3 0 0 0 0
0 0 0 3 3 3 0 0 0 0
0 0 0 0 0 0 0 0 0 0
0 0 0 0 0 0 0 0 0 0
``` | 1,666 |
<|im_start|>user
# ARC HINT GENERATOR
## Role & Goal
You are an expert ARC (Abstraction and Reasoning Corpus) analyst. Your task is to generate a concise, actionable hint for a user who is struggling with an ARC problem. Analyze the problem and its correct solution to produce a single standalone, targeted hint that he... | 4,267 | [
"<note1>\n<description>Start by identifying the two main colors in the input: one color will form a continuous background/field and the other will appear as compact islands. The transformation usually targets those compact islands rather than the background.</description>\n<example>Imagine a grid with mostly blue c... | [{"input": [[9, 6, 9, 9, 9, 9, 9, 9, 9, 9, 6, 6, 9, 6, 9, 6, 6, 6, 6, 6, 6, 9, 6, 6, 9, 9, 6, 6, 6, 6], [6, 9, 6, 6, 9, 6, 6, 6, 9, 6, 9, 6, 6, 9, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 9, 6, 9], [6, 6, 6, 6, 9, 6, 6, 6, 9, 6, 9, 6, 9, 9, 9, 9, 9, 6, 9, 9, 9, 6, 6, 6, 6, 6, 9, 6, 9, 6], [6, 6, 6, 6, 6, 9, 9, 9, 9, 6, 6... | [{"input": [[7, 7, 7, 3, 3, 3, 3, 3, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7], [7, 7, 7, 3, 7, 7, 7, 7, 3, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7], [3, 7, 7, 3, 7, 7, 7, 7, 3, 7, 7, 7, 7, 3, 3, 3, 3, 3, 3, 3, 3, 7], [7, 3, 3, 3, 7, 7, 3, 7, 3, 3, 3, 3, 3, 3, 7, 3, 3, 3, 3, 3, 3, 7], [3, 7, 3, 3, 7, 7, 7, 7, 3, 3, 7, 7,... | rearc | You will be given some number of paired example inputs and outputs grids. The outputs were produced by applying a transformation rule to the input grids. In addition to the paired example inputs and outputs, there is also one test input without a known output. The inputs and outputs are each “grids”. A grid is a rectan... | ```
7 7 7 3 3 3 3 3 7 7 7 7 7 7 7 7 7 7 7 7 7 7
7 7 7 3 4 4 4 4 3 7 7 7 7 7 7 7 7 7 7 7 7 7
3 7 7 3 4 4 4 4 3 7 7 7 7 3 3 3 3 3 3 3 3 7
7 3 3 3 4 4 3 4 3 3 3 3 3 3 4 3 3 3 3 3 3 7
3 4 3 3 4 4 4 4 3 3 4 4 3 3 4 3 4 4 4 3 3 7
3 4 3 7 3 3 3 3 3 3 3 3 3 3 4 3 3 3 3 3 3 7
3 4 3 7 7 7 3 3 3 3 3 4 4 3 4 4 4 4 4 4 3 7
3 4 3 7 ... | 3,774 |
<|im_start|>user
# ARC HINT GENERATOR
## Role & Goal
You are an expert ARC (Abstraction and Reasoning Corpus) analyst. Your task is to generate a concise, actionable hint for a user who is struggling with an ARC problem. Analyze the problem and its correct solution to produce a single standalone, targeted hint that he... | 1,773 | [
"<note1>\n<description>Start by identifying the single non-background color that forms the shape you must transform. That color is the \"object\" and every other cell (zeros) is background; the transformation only changes those object cells.</description>\n<example>Imagine a 5×5 grid with zeros everywhere except a ... | [{"input": [[0, 0, 0, 0, 0, 8, 0, 0], [8, 0, 8, 8, 0, 0, 0, 8], [0, 8, 8, 0, 8, 0, 8, 8], [0, 8, 0, 8, 8, 0, 0, 8], [8, 0, 8, 0, 8, 8, 0, 0], [8, 0, 8, 0, 8, 0, 8, 8], [8, 0, 0, 0, 8, 8, 8, 8], [8, 8, 8, 8, 0, 0, 8, 0], [0, 0, 0, 0, 0, 8, 0, 0], [8, 0, 8, 0, 8, 8, 8, 8]], "output": [[0, 0, 0, 0, 0, 4, 0, 0], [4, 2, 4, ... | [{"input": [[0, 6, 0, 6, 6, 6, 0, 0, 0], [0, 0, 0, 6, 0, 6, 0, 6, 6], [0, 6, 6, 0, 6, 6, 6, 6, 6], [6, 0, 0, 0, 0, 0, 6, 0, 0], [0, 0, 6, 0, 6, 6, 6, 0, 6], [0, 6, 0, 0, 6, 6, 0, 0, 6], [6, 6, 0, 6, 6, 6, 6, 0, 0], [6, 0, 6, 0, 0, 0, 6, 6, 6], [0, 0, 6, 6, 0, 0, 6, 0, 6]], "output": [[0, 5, 0, 5, 5, 5, 2, 2, 2], [0, 0,... | barc_heavy | You will be given some number of paired example inputs and outputs grids. The outputs were produced by applying a transformation rule to the input grids. In addition to the paired example inputs and outputs, there is also one test input without a known output. The inputs and outputs are each “grids”. A grid is a rectan... | ```
0 5 0 5 5 5 2 2 2
0 0 0 5 2 5 2 5 5
0 5 6 2 5 5 5 5 5
5 2 0 2 2 2 5 2 2
0 0 5 2 5 5 5 2 6
2 5 2 2 5 5 2 2 5
5 5 2 6 6 6 6 0 0
6 0 5 2 0 0 6 6 6
0 0 5 5 0 0 6 0 6
``` | 1,280 |
<|im_start|>user
# ARC HINT GENERATOR
## Role & Goal
You are an expert ARC (Abstraction and Reasoning Corpus) analyst. Your task is to generate a concise, actionable hint for a user who is struggling with an ARC problem. Analyze the problem and its correct solution to produce a single standalone, targeted hint that he... | 3,781 | [
"<note1>\n<description>Look first for a single color that appears exactly four times and sits on the four corners of an axis-aligned rectangle. That color is usually the marker that defines the region of interest. Finding it reduces the problem to a smaller subgrid bounded by those four pixels.</description>\n<exam... | [{"input": [[3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 8, 3, 3, 8], [3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 7, 7, 3, 3, 3, 3, 3, 3, 3], [3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 6, 3, 3, 3, 3, 3, 3, 3], [3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 7, 7, 3, 3, 3, 3, 3, 3, 3], [3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 0, 4, 3, 3,... | [{"input": [[5, 5, 5, 5, 0, 5, 5, 5, 0, 5, 5, 5, 5, 5, 5], [5, 5, 5, 5, 5, 5, 4, 6, 4, 5, 5, 5, 5, 5, 5], [5, 5, 5, 5, 5, 5, 4, 6, 4, 5, 5, 5, 5, 5, 5], [5, 5, 5, 5, 5, 5, 6, 5, 5, 5, 5, 5, 5, 5, 5], [5, 5, 5, 5, 5, 5, 6, 6, 6, 5, 5, 5, 5, 5, 5], [5, 5, 5, 5, 5, 5, 6, 4, 6, 5, 5, 5, 5, 5, 5], [5, 5, 5, 5, 5, 5, 4, 6, 6... | rearc | You will be given some number of paired example inputs and outputs grids. The outputs were produced by applying a transformation rule to the input grids. In addition to the paired example inputs and outputs, there is also one test input without a known output. The inputs and outputs are each “grids”. A grid is a rectan... | ```
5 5 5 5 0 5 5 5 0 5 5 5 5 5 5
5 5 5 5 5 4 6 4 5 5 5 5 5 5 5
5 5 5 5 5 4 6 4 5 5 5 5 5 5 5
5 5 5 5 5 6 5 5 5 5 5 5 5 5 5
5 5 5 5 5 6 6 6 5 5 5 5 5 5 5
5 5 5 5 5 6 4 6 5 5 5 5 5 5 5
5 5 5 5 5 4 6 6 5 5 5 5 5 5 5
5 5 5 5 5 6 4 4 5 5 5 5 5 5 5
5 5 5 5 5 6 4 6 5 5 5 5 5 5 5
5 5 5 5 5 5 4 6 5 5 5 5 5 5 5
5 5 5 5 5 5 4 6 ... | 3,288 |
<|im_start|>user
# ARC HINT GENERATOR
## Role & Goal
You are an expert ARC (Abstraction and Reasoning Corpus) analyst. Your task is to generate a concise, actionable hint for a user who is struggling with an ARC problem. Analyze the problem and its correct solution to produce a single standalone, targeted hint that he... | 2,867 | [
"<note1>\n<description>Look for a full row or full column made of one color that spans the entire grid; this is the divider that cleanly separates the image into two blocks. It is effective because a uniform stripe is visually distinct and usually not part of the patterned halves. Use the stripe orientation (horizo... | [{"input": [[8, 2, 2, 8, 2, 0, 8, 8, 8, 8, 4], [8, 8, 2, 2, 2, 0, 4, 8, 8, 4, 4], [2, 2, 2, 2, 2, 0, 4, 4, 8, 8, 4], [8, 8, 8, 8, 8, 0, 8, 8, 8, 8, 8], [2, 2, 8, 8, 2, 0, 8, 8, 8, 8, 4], [2, 2, 8, 8, 8, 0, 8, 8, 8, 8, 8], [2, 2, 8, 2, 8, 0, 8, 4, 4, 8, 4], [2, 2, 8, 2, 2, 0, 8, 4, 8, 8, 8], [8, 8, 2, 2, 8, 0, 8, 8, 4, ... | [{"input": [[7, 5], [5, 5], [5, 5], [5, 5], [5, 7], [7, 5], [5, 5], [5, 5], [5, 5], [0, 0], [6, 6], [5, 6], [5, 5], [6, 6], [6, 6], [6, 6], [6, 5], [5, 6], [6, 5]], "output": [[3, 3], [5, 3], [5, 5], [3, 3], [3, 3], [3, 3], [3, 5], [5, 3], [3, 5]]}] | rearc | You will be given some number of paired example inputs and outputs grids. The outputs were produced by applying a transformation rule to the input grids. In addition to the paired example inputs and outputs, there is also one test input without a known output. The inputs and outputs are each “grids”. A grid is a rectan... | ```
3 3
5 3
5 5
3 3
3 3
3 3
3 5
5 3
3 5
``` | 2,374 |
<|im_start|>user
# ARC HINT GENERATOR
## Role & Goal
You are an expert ARC (Abstraction and Reasoning Corpus) analyst. Your task is to generate a concise, actionable hint for a user who is struggling with an ARC problem. Analyze the problem and its correct solution to produce a single standalone, targeted hint that he... | 3,379 | [
"<note1>\n<description>Look for a vertical, periodic pattern: the outputs show the same columns changed in every row. When changes recur at the same column positions across many rows, treat that as a column-wise rule rather than an object-by-object rule.</description>\n<example>Imagine several rows where only colum... | [{"input": [[5, 5, 0, 0, 8, 5, 8, 8, 8, 0, 0, 5, 9, 0, 0, 0, 9], [0, 8, 0, 5, 9, 7, 0, 0, 9, 7, 8, 0, 0, 0, 0, 0, 0], [8, 5, 9, 7, 0, 8, 8, 0, 0, 5, 0, 0, 0, 7, 0, 0, 0], [9, 0, 7, 0, 0, 0, 7, 0, 0, 0, 8, 8, 0, 5, 7, 0, 0], [5, 0, 7, 0, 5, 7, 9, 9, 7, 0, 7, 8, 0, 0, 9, 9, 0], [7, 5, 0, 8, 0, 7, 9, 8, 7, 5, 7, 8, 0, 9, ... | [{"input": [[0, 2, 0, 1, 1, 2, 2, 0, 9, 0], [0, 0, 1, 0, 0, 0, 9, 0, 0, 9], [2, 0, 0, 0, 2, 1, 0, 2, 9, 1], [0, 9, 0, 0, 9, 0, 9, 0, 0, 0], [0, 9, 2, 1, 0, 0, 2, 0, 0, 1]], "output": [[0, 2, 0, 6, 1, 2, 6, 0, 9, 0], [0, 0, 1, 0, 0, 0, 6, 0, 0, 6], [6, 0, 0, 0, 2, 1, 0, 2, 9, 6], [0, 9, 0, 0, 9, 0, 6, 0, 0, 0], [0, 9, 2... | rearc | You will be given some number of paired example inputs and outputs grids. The outputs were produced by applying a transformation rule to the input grids. In addition to the paired example inputs and outputs, there is also one test input without a known output. The inputs and outputs are each “grids”. A grid is a rectan... | ```
0 2 0 6 1 2 6 0 9 0
0 0 1 0 0 0 6 0 0 6
6 0 0 0 2 1 0 2 9 6
0 9 0 0 9 0 6 0 0 0
0 9 2 6 0 0 6 0 0 6
``` | 2,886 |
<|im_start|>user
# ARC HINT GENERATOR
## Role & Goal
You are an expert ARC (Abstraction and Reasoning Corpus) analyst. Your task is to generate a concise, actionable hint for a user who is struggling with an ARC problem. Analyze the problem and its correct solution to produce a single standalone, targeted hint that he... | 3,523 | [
"<note1>\n<description>Treat each contiguous non-zero color region as an independent object and compute its minimal bounding box (min/max row and column). This reduces the problem to comparing a few small rectangles instead of many scattered pixels.</description>\n<example>Imagine a grid with three colored blobs: a... | [{"input": [[0, 0, 6, 0, 0, 6, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0], [0, 0, 6, 6, 6, 6, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0], [0, 0, 6, 6, 6, 6, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0], [0, 0, 6, 0, 0, 6, 0, 0, 6, 6, 0, 0, 0, 0, 0, 0, 0], [0, 0, 0, 0, 0, 0, 0, 0, 6, 6, 6, 0, 0, 0, 0, 0, 0], [0, 0, 0, 0, 0, 8, 8, 0, 6, 6, 0, 0, 0, 0, ... | [{"input": [[0, 0, 9, 9, 9, 0, 0, 0, 0, 0, 0, 0, 0, 0], [0, 0, 9, 9, 9, 0, 0, 0, 0, 0, 0, 0, 0, 0], [0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0], [0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0], [0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0], [0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0], [0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0], ... | barc_heavy | You will be given some number of paired example inputs and outputs grids. The outputs were produced by applying a transformation rule to the input grids. In addition to the paired example inputs and outputs, there is also one test input without a known output. The inputs and outputs are each “grids”. A grid is a rectan... | ```
0 0 0 0 0 0 0 0 0 0 0 0 0 0
0 0 0 0 0 0 0 0 0 0 0 0 0 0
0 0 0 0 0 0 0 0 0 0 0 0 0 0
0 0 0 0 0 0 0 0 0 0 0 0 0 0
0 0 0 0 0 0 0 0 0 0 0 0 0 0
0 0 0 0 0 0 0 0 0 0 0 0 0 0
0 0 0 0 0 0 0 0 0 0 0 0 0 0
0 0 0 0 0 0 0 0 0 0 0 0 5 5
0 0 0 0 0 0 0 0 0 0 0 5 5 0
0 0 0 0 0 0 0 0 0 0 0 5 5 0
0 0 0 0 0 0 0 0 0 6 6 6 5 5
0 0 0 0 ... | 3,030 |
<|im_start|>user
# ARC HINT GENERATOR
## Role & Goal
You are an expert ARC (Abstraction and Reasoning Corpus) analyst. Your task is to generate a concise, actionable hint for a user who is struggling with an ARC problem. Analyze the problem and its correct solution to produce a single standalone, targeted hint that he... | 1,445 | [
"<note1>\n<description>Look for a solitary colored pixel that sits exactly on a grid edge or corner — such a pixel often serves as a marker. When a color appears only once and is at an edge, treat it as a candidate for movement rather than part of the main object.</description>\n<example>Imagine a grid where every ... | [{"input": [[0, 0, 0, 0, 0, 0, 8], [0, 4, 4, 4, 0, 0, 0], [0, 4, 4, 4, 4, 0, 0], [0, 4, 4, 4, 4, 4, 0], [0, 0, 4, 4, 4, 4, 0], [0, 0, 0, 4, 4, 4, 0], [0, 0, 0, 0, 0, 0, 0]], "output": [[0, 0, 0, 0, 0, 0, 0], [0, 4, 4, 4, 0, 0, 0], [0, 4, 4, 4, 4, 0, 0], [0, 4, 4, 4, 4, 4, 0], [0, 0, 4, 4, 4, 4, 0], [0, 0, 0, 4, 4, 4, 0... | [{"input": [[0, 0, 0, 0, 0, 0, 5], [0, 0, 6, 6, 0, 0, 0], [0, 0, 6, 6, 6, 6, 0], [0, 6, 6, 6, 6, 6, 0], [0, 6, 6, 6, 6, 0, 0], [0, 0, 0, 6, 6, 0, 0], [0, 0, 0, 0, 0, 0, 0]], "output": [[0, 0, 0, 0, 0, 0, 0], [0, 0, 6, 6, 0, 0, 0], [0, 0, 6, 6, 6, 6, 0], [0, 6, 6, 6, 6, 6, 0], [0, 6, 6, 6, 6, 0, 0], [0, 0, 0, 6, 6, 0, 0... | barc_heavy | You will be given some number of paired example inputs and outputs grids. The outputs were produced by applying a transformation rule to the input grids. In addition to the paired example inputs and outputs, there is also one test input without a known output. The inputs and outputs are each “grids”. A grid is a rectan... | ```
0 0 0 0 0 0 0
0 0 6 6 0 0 0
0 0 6 6 6 6 0
0 6 6 6 6 6 0
0 6 6 6 6 0 0
0 0 0 6 6 0 0
0 0 0 0 0 0 5
``` | 952 |
<|im_start|>user
# ARC HINT GENERATOR
## Role & Goal
You are an expert ARC (Abstraction and Reasoning Corpus) analyst. Your task is to generate a concise, actionable hint for a user who is struggling with an ARC problem. Analyze the problem and its correct solution to produce a single standalone, targeted hint that he... | 1,717 | [
"<note1>\n<description>Separate the grid into background and objects by color and treat each connected colored region as an object. This isolates the meaningful shapes you must compare instead of treating every pixel individually.</description>\n<example>Imagine a grid where most cells are 0 and there are two verti... | [{"input": [[7, 7, 7, 7, 7, 7, 7], [7, 8, 7, 7, 7, 7, 7], [7, 8, 7, 2, 7, 7, 7], [7, 8, 7, 2, 7, 7, 7], [7, 8, 7, 2, 7, 7, 7], [7, 8, 7, 2, 7, 7, 7]], "output": [[7, 7, 7, 7, 7, 7, 7], [7, 8, 7, 7, 7, 7, 7], [7, 8, 7, 2, 7, 7, 7], [7, 8, 7, 2, 7, 7, 7], [7, 8, 7, 2, 7, 7, 7], [7, 8, 7, 2, 7, 5, 7]]}, {"input": [[7, 7, ... | [{"input": [[7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7], [7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 2, 7, 7, 7], [7, 8, 7, 7, 7, 7, 7, 7, 7, 7, 7, 2, 7, 7, 7], [7, 8, 7, 7, 7, 7, 7, 7, 7, 7, 7, 2, 7, 7, 7], [7, 8, 7, 7, 7, 7, 7, 8, 7, 7, 7, 2, 7, 7, 7], [7, 8, 7, 7, 7, 7, 7, 8, 7, 7, 7, 2, 7, 7, 7], [7, 8, 7, 2, 7, 7, 7, 8, 7... | arc 2 | You will be given some number of paired example inputs and outputs grids. The outputs were produced by applying a transformation rule to the input grids. In addition to the paired example inputs and outputs, there is also one test input without a known output. The inputs and outputs are each “grids”. A grid is a rectan... | ```
7 7 7 7 7 7 7 7 7 7 7 7 7 7 7
7 7 7 7 7 7 7 7 7 7 7 2 7 7 7
7 8 7 7 7 7 7 7 7 7 7 2 7 7 7
7 8 7 7 7 7 7 7 7 7 7 2 7 7 7
7 8 7 7 7 7 7 8 7 7 7 2 7 7 7
7 8 7 7 7 7 7 8 7 7 7 2 7 7 7
7 8 7 2 7 7 7 8 7 7 7 2 7 7 7
7 8 7 2 7 8 7 8 7 7 7 2 7 5 7
7 8 7 2 7 8 7 8 7 2 7 2 7 5 7
``` | 1,224 |
<|im_start|>user
# ARC HINT GENERATOR
## Role & Goal
You are an expert ARC (Abstraction and Reasoning Corpus) analyst. Your task is to generate a concise, actionable hint for a user who is struggling with an ARC problem. Analyze the problem and its correct solution to produce a single standalone, targeted hint that he... | 2,725 | [
"<note1>\n<description>Find the target color(s) and treat each contiguous cluster as an object. Many ARC tasks operate on one dominant color; isolating that color lets you reason about shape and position instead of every pixel.</description>\n<example>Imagine a grid with a single blue cluster on a black background.... | [{"input": [[0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0], [0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0], [0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0], [0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0], [0, 0, 0, 0, 0, 0, 8, 8, 8, 8, 0, 0, 0], [0, 0, 0, 0, 0, 8, 8, 8, 8, 8, 0, 0, 0], [0, 0, 0, 0, 0, 0, 8, 8, 8, 8, 0, 0, 0], [0, 0, 0, 0, 0, 8, 8,... | [{"input": [[0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0], [0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0], [0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0], [0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0], [0, 0, 0, 8, 8, 8, 8, 0, 0, 0, 0, 0, 0, 0, 0], [0, 0, 0, 0, 8, 8, 8, 0, 0, 0, 0, 0, 0, 0, 0], [0, 0, 0, 0, 8, 8, 8, 0, 0... | barc_heavy | You will be given some number of paired example inputs and outputs grids. The outputs were produced by applying a transformation rule to the input grids. In addition to the paired example inputs and outputs, there is also one test input without a known output. The inputs and outputs are each “grids”. A grid is a rectan... | ```
0 0 0 0 0 0 0 8 8 8 8 8 8 8 8
0 0 0 0 0 0 0 8 8 8 8 8 8 8 8
0 0 0 0 0 0 0 8 8 8 8 8 8 8 8
0 0 0 0 0 0 0 8 8 8 8 8 8 8 8
0 0 0 8 8 8 8 8 8 8 8 8 8 8 8
0 0 0 0 8 8 8 8 8 8 8 8 8 8 8
0 0 0 0 8 8 8 8 8 8 8 8 8 8 8
0 0 0 8 0 8 8 8 8 8 8 8 8 8 8
0 0 0 0 0 0 0 8 8 8 8 8 8 8 8
``` | 2,232 |
<|im_start|>user
# ARC HINT GENERATOR
## Role & Goal
You are an expert ARC (Abstraction and Reasoning Corpus) analyst. Your task is to generate a concise, actionable hint for a user who is struggling with an ARC problem. Analyze the problem and its correct solution to produce a single standalone, targeted hint that he... | 2,279 | [
"<note1>\n<description>Look for a single non-background pixel in each input: when there is exactly one colored cell, the transformation usually acts only on that cell and leaves the rest of the grid unchanged. This reduces the problem to a coordinate mapping from one cell to another.</description>\n<example>Imagine... | [{"input": [[0, 0, 0, 0, 0, 0, 0, 0, 0, 0], [0, 0, 0, 0, 0, 0, 0, 0, 0, 0], [0, 0, 0, 8, 0, 0, 0, 0, 0, 0], [0, 0, 0, 0, 0, 0, 0, 0, 0, 0], [0, 0, 0, 0, 0, 0, 0, 0, 0, 0], [0, 0, 0, 0, 0, 0, 0, 0, 0, 0], [0, 0, 0, 0, 0, 0, 0, 0, 0, 0]], "output": [[0, 0, 0, 0, 0, 0, 0, 0, 0, 0], [0, 0, 0, 0, 0, 0, 0, 0, 0, 0], [0, 0, 0... | [{"input": [[0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0], [0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0], [0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0], [0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0], [0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 9, 0, 0, 0], [0, 0, 0, 0, ... | barc_heavy | You will be given some number of paired example inputs and outputs grids. The outputs were produced by applying a transformation rule to the input grids. In addition to the paired example inputs and outputs, there is also one test input without a known output. The inputs and outputs are each “grids”. A grid is a rectan... | ```
0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0
0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0
0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0
0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0
0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0
0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0
0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0
0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0
0 0 0 0 0 0 ... | 1,786 |
<|im_start|>user
# ARC HINT GENERATOR
## Role & Goal
You are an expert ARC (Abstraction and Reasoning Corpus) analyst. Your task is to generate a concise, actionable hint for a user who is struggling with an ARC problem. Analyze the problem and its correct solution to produce a single standalone, targeted hint that he... | 4,145 | [
"<note1>\n<description>Look for the background color by frequency: the color that occupies most cells is usually the canvas. Treat every other color as a candidate object to inspect. This helps separate the large uniform field from smaller, meaningful shapes.</description>\n<example>Imagine a grid where 80% of cell... | [{"input": [[4, 5, 5, 5, 4, 4, 4, 4, 4, 4, 4, 4, 8, 4, 4, 4, 4, 4], [5, 5, 5, 5, 4, 4, 4, 4, 4, 4, 8, 4, 4, 8, 4, 8, 4, 4], [4, 5, 4, 4, 4, 4, 8, 4, 4, 4, 8, 4, 4, 4, 8, 4, 4, 4], [4, 5, 4, 4, 4, 4, 8, 8, 4, 8, 4, 4, 4, 4, 8, 4, 4, 4], [4, 4, 4, 4, 4, 4, 4, 4, 8, 4, 4, 4, 4, 8, 4, 4, 4, 4], [4, 1, 1, 4, 1, 4, 4, 4, 4, ... | [{"input": [[2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2], [2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 7, 7], [2, 2, 2, 8, 2, 2, 2, 2, 7, 7, 7, 7, 7], [2, 2, 2, 2, 8, 8, 2, 2, 2, 2, 2, 2, 2], [2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 6, 2], [9, 9, 2, 2, 2, 2, 2, 2, 2, 2, 6, 2, 2], [2, 9, 2, 2, 2, 2, 2, 2, 2, 6, 2, 2, 2], [2, 2, 2, 2, 2, 2, 3,... | rearc | You will be given some number of paired example inputs and outputs grids. The outputs were produced by applying a transformation rule to the input grids. In addition to the paired example inputs and outputs, there is also one test input without a known output. The inputs and outputs are each “grids”. A grid is a rectan... | ```
5 5
``` | 3,652 |
<|im_start|>user
# ARC HINT GENERATOR
## Role & Goal
You are an expert ARC (Abstraction and Reasoning Corpus) analyst. Your task is to generate a concise, actionable hint for a user who is struggling with an ARC problem. Analyze the problem and its correct solution to produce a single standalone, targeted hint that he... | 3,399 | [
"<note1>\n<description>Look for a color that fills an entire side of the grid (top, bottom, left or right). Such a uniform border color usually acts as an anchor: it is preserved and is the reference used to recolor interior pixels. Identifying this anchor is the first step because it determines the two possible ta... | [{"input": [[8, 3, 3, 3, 3, 3, 3, 1], [8, 3, 3, 3, 0, 3, 3, 1], [8, 3, 3, 3, 3, 3, 3, 1], [8, 3, 3, 3, 3, 0, 3, 1], [8, 3, 3, 0, 3, 3, 3, 1]], "output": [[8, 3, 3, 3, 3, 3, 3, 1], [8, 3, 3, 3, 1, 3, 3, 1], [8, 3, 3, 3, 3, 3, 3, 1], [8, 3, 3, 3, 3, 1, 3, 1], [8, 3, 3, 8, 3, 3, 3, 1]]}, {"input": [[0, 0, 0, 0, 0, 0, 0, 0... | [{"input": [[8, 0, 0, 0, 0, 0, 0, 7], [8, 0, 0, 0, 0, 0, 0, 7], [8, 0, 0, 0, 0, 0, 0, 7], [8, 0, 0, 0, 0, 0, 0, 7], [8, 0, 4, 0, 0, 0, 0, 7], [8, 0, 0, 0, 0, 0, 0, 7], [8, 4, 0, 0, 0, 0, 0, 7], [8, 0, 0, 0, 0, 0, 0, 7], [8, 0, 0, 4, 0, 0, 0, 7], [8, 0, 0, 0, 0, 0, 0, 7], [8, 0, 0, 0, 0, 0, 0, 7], [8, 0, 0, 0, 0, 0, 0, ... | rearc | You will be given some number of paired example inputs and outputs grids. The outputs were produced by applying a transformation rule to the input grids. In addition to the paired example inputs and outputs, there is also one test input without a known output. The inputs and outputs are each “grids”. A grid is a rectan... | ```
8 0 0 0 0 0 0 7
8 0 0 0 0 0 0 7
8 0 0 0 0 0 0 7
8 0 0 0 0 0 0 7
8 0 8 0 0 0 0 7
8 0 0 0 0 0 0 7
8 8 0 0 0 0 0 7
8 0 0 0 0 0 0 7
8 0 0 8 0 0 0 7
8 0 0 0 0 0 0 7
8 0 0 0 0 0 0 7
8 0 0 0 0 0 0 7
8 0 0 0 0 0 7 7
8 0 0 0 0 0 0 7
8 0 0 0 0 0 0 7
8 0 0 0 0 7 0 7
8 0 0 8 0 0 7 7
8 0 0 0 0 0 0 7
8 0 0 0 0 0 0 7
8 0 0 0 0 0 ... | 2,906 |
<|im_start|>user
# ARC HINT GENERATOR
## Role & Goal
You are an expert ARC (Abstraction and Reasoning Corpus) analyst. Your task is to generate a concise, actionable hint for a user who is struggling with an ARC problem. Analyze the problem and its correct solution to produce a single standalone, targeted hint that he... | 4,417 | [
"<note1>\n<description>Look for a single new color that appears in the outputs but not in the inputs; this color is the mask that separates preserved cells from overwritten cells. Once you identify that color, you can treat the problem as “which input cells are preserved?” rather than “what new pixels appear?”.</de... | [{"input": [[9, 1, 2, 7, 6, 2, 2, 2, 4, 8, 9, 0, 8, 0, 1], [9, 2, 6, 0, 6, 2, 4, 9, 6, 6, 9, 0, 1, 4, 0], [4, 8, 1, 6, 6, 0, 6, 4, 2, 1, 8, 0, 0, 2, 1], [2, 6, 9, 4, 1, 4, 4, 9, 0, 0, 7, 6, 1, 6, 6], [8, 0, 4, 1, 9, 4, 7, 8, 8, 0, 6, 1, 7, 1, 9], [1, 6, 0, 0, 1, 4, 2, 2, 4, 2, 6, 7, 6, 7, 6], [1, 8, 7, 8, 1, 7, 4, 1, 8... | [{"input": [[6, 9, 7, 4, 9, 6, 4, 6, 5, 9, 7, 2, 7, 6, 4], [7, 4, 7, 5, 2, 5, 7, 9, 7, 4, 6, 7, 5, 4, 4], [9, 4, 5, 5, 9, 9, 2, 5, 4, 2, 6, 6, 4, 4, 4], [4, 2, 7, 5, 9, 6, 5, 4, 5, 5, 6, 5, 5, 6, 5], [7, 5, 7, 7, 2, 5, 5, 9, 2, 4, 6, 2, 2, 4, 5], [5, 7, 9, 4, 5, 7, 7, 7, 5, 4, 9, 5, 6, 7, 5], [9, 5, 6, 9, 6, 4, 9, 6, 2... | rearc | You will be given some number of paired example inputs and outputs grids. The outputs were produced by applying a transformation rule to the input grids. In addition to the paired example inputs and outputs, there is also one test input without a known output. The inputs and outputs are each “grids”. A grid is a rectan... | ```
3 3 3 3 3 3 3 3 3 3 3 3 3 3 3
7 4 7 5 2 5 7 9 7 4 6 7 5 4 3
3 3 3 3 3 3 3 3 3 3 3 3 3 4 3
3 2 7 5 9 6 5 4 5 5 6 5 3 6 3
3 5 3 3 3 3 3 3 3 3 3 2 3 4 3
3 7 3 4 5 7 7 7 5 4 3 5 3 7 3
3 5 3 9 3 3 3 3 3 4 3 2 3 5 3
3 4 3 4 3 7 7 2 9 9 3 4 3 9 3
3 2 3 9 3 3 3 3 3 3 3 2 3 5 3
3 2 3 4 6 7 2 6 5 2 7 7 3 7 3
3 7 3 3 3 3 3 3 ... | 3,924 |
<|im_start|>user
# ARC HINT GENERATOR
## Role & Goal
You are an expert ARC (Abstraction and Reasoning Corpus) analyst. Your task is to generate a concise, actionable hint for a user who is struggling with an ARC problem. Analyze the problem and its correct solution to produce a single standalone, targeted hint that he... | 1,603 | [
"<note1>\n<description>Look for a small horizontal motif that repeats across the row. When a 3-row grid shows the same three-column pattern repeated, it helps to treat each 3-column block as a unit for comparison between input and output.</description>\n<example>Imagine a 3×9 grid where columns 1–3, 4–6 and 7–9 loo... | [{"input": [[4, 0, 4, 0, 4, 0, 4, 0, 4, 0, 4, 0, 4], [4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4], [0, 4, 0, 4, 0, 4, 0, 4, 0, 4, 0, 4, 0]], "output": [[6, 0, 4, 0, 4, 0, 6, 0, 4, 0, 4, 0, 6], [6, 4, 4, 6, 4, 4, 6, 4, 4, 6, 4, 4, 6], [0, 4, 0, 6, 0, 4, 0, 4, 0, 6, 0, 4, 0]]}, {"input": [[0, 4, 0, 4, 0, 4, 0, 4, 0, 4, 0], [4... | [{"input": [[0, 4, 0, 4, 0, 4, 0, 4, 0, 4, 0, 4, 0, 4, 0, 4, 0], [4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4], [4, 0, 4, 0, 4, 0, 4, 0, 4, 0, 4, 0, 4, 0, 4, 0, 4]], "output": [[0, 4, 0, 6, 0, 4, 0, 4, 0, 6, 0, 4, 0, 4, 0, 6, 0], [6, 4, 4, 6, 4, 4, 6, 4, 4, 6, 4, 4, 6, 4, 4, 6, 4], [6, 0, 4, 0, 4, 0, 6, 0, 4, 0, ... | arc 2 | You will be given some number of paired example inputs and outputs grids. The outputs were produced by applying a transformation rule to the input grids. In addition to the paired example inputs and outputs, there is also one test input without a known output. The inputs and outputs are each “grids”. A grid is a rectan... | ```
0 4 0 6 0 4 0 4 0 6 0 4 0 4 0 6 0
6 4 4 6 4 4 6 4 4 6 4 4 6 4 4 6 4
6 0 4 0 4 0 6 0 4 0 4 0 6 0 4 0 4
``` | 1,110 |
<|im_start|>user
# ARC HINT GENERATOR
## Role & Goal
You are an expert ARC (Abstraction and Reasoning Corpus) analyst. Your task is to generate a concise, actionable hint for a user who is struggling with an ARC problem. Analyze the problem and its correct solution to produce a single standalone, targeted hint that he... | 3,479 | [
"<note1>\n<description>Look for the dominant background color by frequency: the color that fills most cells is usually the backdrop and should be ignored when searching for the transformation. This reduces the problem to a few foreground colors to analyze.</description>\n<example>Imagine a 10×10 grid where 85 cells... | [{"input": [[5, 5, 5, 5, 5, 5, 5], [5, 5, 5, 5, 5, 5, 5], [5, 5, 5, 5, 5, 5, 5], [5, 5, 5, 5, 5, 5, 5], [5, 5, 5, 5, 5, 5, 1], [5, 5, 4, 5, 5, 5, 5], [5, 5, 4, 5, 5, 5, 5], [5, 4, 4, 4, 5, 5, 5], [5, 4, 5, 5, 5, 5, 5], [5, 4, 4, 5, 4, 4, 5], [5, 4, 4, 5, 4, 5, 5], [5, 5, 4, 4, 4, 5, 5], [5, 4, 4, 4, 4, 4, 5], [5, 4, 4,... | [{"input": [[2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2], [2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 8, 2, 2], [2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 8, 2, 2], [2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 8, 8, 2], [2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 8, 8, 2], [2, 2, 2, 2, 2, 2, 2, 2, 8, 8, 2, 8, 8, 2], [2, 2, 2, 2, 2, 8, 8, 2, 2, 8, 8, 8, 8, 2], ... | rearc | You will be given some number of paired example inputs and outputs grids. The outputs were produced by applying a transformation rule to the input grids. In addition to the paired example inputs and outputs, there is also one test input without a known output. The inputs and outputs are each “grids”. A grid is a rectan... | ```
2 2 2 2 2 2 2 2 2 2 2 2 2 2
2 2 2 2 2 2 2 2 2 2 2 5 2 2
2 2 2 2 2 2 2 2 2 2 2 5 2 2
2 2 2 2 2 2 2 2 2 2 2 5 5 2
2 2 2 2 2 2 2 2 2 2 2 5 5 2
2 2 2 2 2 2 2 2 5 5 2 5 5 2
2 2 2 2 2 5 5 2 2 5 5 5 5 2
2 2 2 2 2 2 5 2 5 5 5 5 5 2
2 2 2 2 2 2 5 2 2 2 2 2 5 2
2 2 2 5 5 5 5 5 2 2 5 5 5 2
2 2 2 5 5 5 5 2 2 5 5 5 5 2
2 2 2 5 ... | 2,986 |
<|im_start|>user
# ARC HINT GENERATOR
## Role & Goal
You are an expert ARC (Abstraction and Reasoning Corpus) analyst. Your task is to generate a concise, actionable hint for a user who is struggling with an ARC problem. Analyze the problem and its correct solution to produce a single standalone, targeted hint that he... | 2,159 | [
"<note1>\n<description>Look for the dominant object by color and compute its minimal bounding rectangle. The bounding box gives you the object's top, bottom, left and right edges and isolates the region where symmetry or repetition is meaningful.</description>\n<example>Imagine a 3×4 block of 1s near the center of ... | [{"input": [[0, 0, 0, 0, 0, 0, 0, 0, 0, 0], [0, 0, 0, 1, 1, 1, 1, 1, 0, 0], [0, 0, 0, 1, 1, 1, 1, 1, 0, 0], [0, 0, 0, 0, 0, 1, 0, 0, 1, 1], [0, 0, 0, 0, 0, 1, 0, 0, 1, 1], [0, 0, 0, 0, 0, 1, 1, 1, 1, 1], [0, 0, 0, 0, 0, 1, 0, 0, 1, 1], [0, 0, 0, 0, 0, 1, 0, 0, 1, 1], [0, 0, 0, 1, 1, 1, 1, 1, 0, 0], [0, 0, 0, 1, 1, 1, 1... | [{"input": [[0, 0, 0, 0, 1, 0, 0, 0, 0, 0], [0, 0, 1, 1, 1, 1, 1, 0, 0, 0], [0, 0, 0, 0, 1, 1, 0, 0, 1, 0], [0, 0, 0, 0, 1, 0, 0, 0, 1, 0], [0, 0, 0, 0, 1, 1, 1, 1, 1, 1], [0, 0, 0, 0, 1, 1, 0, 1, 1, 0], [0, 0, 0, 0, 0, 1, 0, 0, 1, 0], [0, 0, 0, 0, 1, 1, 0, 0, 0, 0], [0, 0, 0, 1, 1, 1, 1, 1, 0, 0], [0, 0, 0, 0, 0, 1, 0... | arc 2 | You will be given some number of paired example inputs and outputs grids. The outputs were produced by applying a transformation rule to the input grids. In addition to the paired example inputs and outputs, there is also one test input without a known output. The inputs and outputs are each “grids”. A grid is a rectan... | ```
0 0 0 0 1 0 0 0 0 0
0 0 1 1 1 1 1 0 0 0
0 0 0 0 1 1 0 0 1 0
0 2 0 0 1 0 0 0 1 0
0 2 2 0 1 1 1 1 1 1
2 2 2 2 1 1 0 1 1 0
0 2 0 0 0 1 0 0 1 0
0 2 0 0 1 1 0 0 0 0
0 0 0 1 1 1 1 1 0 0
0 0 0 0 0 1 0 0 0 0
``` | 1,666 |
<|im_start|>user
# ARC HINT GENERATOR
## Role & Goal
You are an expert ARC (Abstraction and Reasoning Corpus) analyst. Your task is to generate a concise, actionable hint for a user who is struggling with an ARC problem. Analyze the problem and its correct solution to produce a single standalone, targeted hint that he... | 1,977 | [
"<note1>\n<description>Look for whole-grid repetition: many ARC tasks create a larger grid by placing an identical copy of the input next to itself. If you see the same colored pattern appearing twice in the output, the simplest explanation is a vertical tiling (stacking) of the input.</description>\n<example>Imagi... | [{"input": [[0, 0, 0, 0, 0, 0, 0, 0], [0, 0, 0, 0, 6, 0, 0, 0], [0, 0, 6, 6, 6, 6, 6, 0], [0, 0, 6, 6, 6, 6, 6, 0], [0, 6, 6, 6, 6, 6, 6, 6], [0, 0, 6, 6, 6, 6, 6, 0], [0, 0, 6, 6, 6, 6, 6, 0], [0, 0, 0, 0, 6, 0, 0, 0]], "output": [[0, 0, 0, 0, 0, 0, 0, 0], [0, 0, 0, 6, 0, 0, 0, 0], [0, 6, 6, 6, 6, 6, 0, 0], [0, 6, 6, ... | [{"input": [[0, 0, 0, 0, 0, 0, 0, 0, 0], [0, 0, 0, 0, 0, 0, 0, 0, 0], [0, 0, 0, 0, 0, 0, 0, 0, 0], [0, 0, 0, 0, 6, 0, 0, 0, 0], [0, 0, 0, 6, 6, 6, 0, 0, 0], [0, 0, 0, 0, 6, 0, 0, 0, 0], [0, 0, 0, 0, 0, 0, 0, 0, 0], [0, 0, 0, 0, 0, 0, 0, 0, 0], [0, 0, 0, 0, 0, 0, 0, 0, 0]], "output": [[0, 0, 0, 0, 0, 0, 0, 0, 0], [0, 0,... | barc_heavy | You will be given some number of paired example inputs and outputs grids. The outputs were produced by applying a transformation rule to the input grids. In addition to the paired example inputs and outputs, there is also one test input without a known output. The inputs and outputs are each “grids”. A grid is a rectan... | ```
0 0 0 0 0 0 0 0 0
0 0 0 0 0 0 0 0 0
0 0 0 0 0 0 0 0 0
0 0 0 0 6 0 0 0 0
0 0 0 6 6 6 0 0 0
0 0 0 0 6 0 0 0 0
0 0 0 0 0 0 0 0 0
0 0 0 0 0 0 0 0 0
0 0 0 0 0 0 0 0 0
0 0 0 0 0 0 0 0 0
0 0 0 0 0 0 0 0 0
0 0 0 0 0 0 0 0 0
0 0 0 0 6 0 0 0 0
0 0 0 6 6 6 0 0 0
0 0 0 0 6 0 0 0 0
0 0 0 0 0 0 0 0 0
0 0 0 0 0 0 0 0 0
0 0 0 0 0 ... | 1,484 |
<|im_start|>user
# ARC HINT GENERATOR
## Role & Goal
You are an expert ARC (Abstraction and Reasoning Corpus) analyst. Your task is to generate a concise, actionable hint for a user who is struggling with an ARC problem. Analyze the problem and its correct solution to produce a single standalone, targeted hint that he... | 3,523 | [
"<note1>\n<description>Start by locating the unique non-background pixel in each input — that pixel is the anchor for the whole transformation. The output always builds a larger motif around that anchor, so identifying its color and exact coordinates is the first step.</description>\n<example>Imagine a mostly-black... | [{"input": [[0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0], [0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0], [0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0], [0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0], [0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0], [0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, ... | [{"input": [[0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0], [0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0], [0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0], [0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0], [0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0], [0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0], [0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0], ... | barc_heavy | You will be given some number of paired example inputs and outputs grids. The outputs were produced by applying a transformation rule to the input grids. In addition to the paired example inputs and outputs, there is also one test input without a known output. The inputs and outputs are each “grids”. A grid is a rectan... | ```
0 0 0 0 0 0 0 0 0 0 0 0 0 0
0 0 0 0 0 0 0 0 0 0 0 0 0 0
0 0 0 0 0 0 0 0 0 0 0 0 0 0
0 0 0 0 0 0 0 0 0 0 0 0 0 0
0 0 0 0 0 0 0 0 0 0 0 0 0 0
0 0 0 0 0 0 0 0 0 0 0 0 0 0
0 0 0 0 0 0 0 0 0 0 0 0 0 0
0 0 0 0 0 0 0 0 0 0 0 0 0 0
0 0 0 0 0 0 0 0 0 0 0 0 0 0
0 0 0 0 0 0 6 0 0 6 0 6 0 6
0 0 0 0 0 6 6 6 0 6 0 6 0 6
0 0 0 0 ... | 3,030 |
<|im_start|>user
# ARC HINT GENERATOR
## Role & Goal
You are an expert ARC (Abstraction and Reasoning Corpus) analyst. Your task is to generate a concise, actionable hint for a user who is struggling with an ARC problem. Analyze the problem and its correct solution to produce a single standalone, targeted hint that he... | 3,615 | [
"<note1>\n<description>Look for contiguous regions of a single color that form perfect, axis-aligned rectangles. These are the objects being transformed; treat each such region as a candidate for the same interior operation.</description>\n<example>Imagine a 6×4 block of green pixels sitting on a uniform background... | [{"input": [[4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4], [4, 6, 6, 6, 6, 6, 6, 4, 4, 4, 4], [4, 6, 6, 6, 6, 6, 6, 4, 4, 4, 4], [4, 6, 6, 6, 6, 6, 6, 4, 4, 4, 4], [4, 6, 6, 6, 6, 6, 6, 4, 4, 4, 4], [4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4], [4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4], [4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4], [4, 4, 4, 4, 4, 4, 4, 4, 4, ... | [{"input": [[7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7], [7, 7, 7, 2, 2, 2, 2, 7, 7, 7, 7, 7, 7, 7, 7], [7, 7, 7, 2, 2, 2, 2, 7, 7, 7, 7, 7, 7, 7, 7], [7, 7, 7, 2, 2, 2, 2, 7, 7, 7, 7, 7, 7, 7, 7], [7, 7, 7, 2, 2, 2, 2, 7, 7, 7, 7, 7, 7, 7, 7], [7, 7, 7, 2, 2, 2, 2, 7, 7, 1, 1, 1, 1, 7, 7], [7, 7, 7, 2, 2, 2, 2, 7, 7... | rearc | You will be given some number of paired example inputs and outputs grids. The outputs were produced by applying a transformation rule to the input grids. In addition to the paired example inputs and outputs, there is also one test input without a known output. The inputs and outputs are each “grids”. A grid is a rectan... | ```
7 7 7 7 7 7 7 7 7 7 7 7 7 7 7
7 7 7 2 2 2 2 7 7 7 7 7 7 7 7
7 7 7 2 8 8 2 7 7 7 7 7 7 7 7
7 7 7 2 8 8 2 7 7 7 7 7 7 7 7
7 7 7 2 8 8 2 7 7 7 7 7 7 7 7
7 7 7 2 8 8 2 7 7 1 1 1 1 7 7
7 7 7 2 8 8 2 7 7 1 8 8 1 7 7
7 7 7 2 2 2 2 7 7 1 8 8 1 7 7
7 7 7 7 7 7 7 7 7 1 8 8 1 7 7
7 7 7 7 7 7 7 7 7 1 1 1 1 7 7
7 7 7 7 7 7 7 7 ... | 3,122 |
<|im_start|>user
# ARC HINT GENERATOR
## Role & Goal
You are an expert ARC (Abstraction and Reasoning Corpus) analyst. Your task is to generate a concise, actionable hint for a user who is struggling with an ARC problem. Analyze the problem and its correct solution to produce a single standalone, targeted hint that he... | 2,159 | [
"<note1>\n<description>Look for a unique pivot: a single pixel of one color that does not belong to the repeated marker color. This pivot often serves as the center of the transformation and is the reference for where other pixels should be changed. Finding that unique pixel first narrows the search to a local neig... | [{"input": [[0, 0, 0, 0, 0, 0, 0, 0, 0, 0], [0, 0, 0, 0, 0, 0, 0, 0, 0, 0], [0, 0, 4, 0, 0, 0, 0, 0, 0, 0], [0, 0, 0, 0, 0, 4, 0, 1, 0, 0], [0, 0, 0, 0, 0, 0, 0, 0, 0, 0], [4, 0, 0, 0, 4, 0, 0, 0, 0, 4], [0, 0, 0, 0, 0, 0, 4, 0, 4, 0], [0, 0, 0, 0, 0, 0, 0, 0, 0, 0], [0, 0, 0, 0, 0, 0, 4, 0, 0, 0], [0, 0, 0, 0, 4, 0, 4... | [{"input": [[0, 0, 0, 0, 0, 0, 0, 0, 4, 0], [0, 0, 0, 0, 0, 0, 0, 0, 0, 0], [0, 0, 0, 0, 0, 0, 0, 0, 0, 0], [0, 0, 0, 0, 0, 0, 0, 0, 0, 0], [0, 0, 0, 0, 1, 4, 0, 0, 4, 4], [0, 0, 4, 0, 0, 4, 0, 0, 0, 0], [0, 0, 0, 0, 0, 0, 0, 0, 4, 0], [0, 0, 0, 0, 0, 4, 0, 0, 0, 0], [0, 0, 0, 0, 0, 4, 0, 0, 0, 0], [0, 0, 0, 0, 0, 0, 0... | barc_heavy | You will be given some number of paired example inputs and outputs grids. The outputs were produced by applying a transformation rule to the input grids. In addition to the paired example inputs and outputs, there is also one test input without a known output. The inputs and outputs are each “grids”. A grid is a rectan... | ```
0 0 0 0 0 0 0 0 4 0
0 0 0 0 0 0 0 0 0 0
0 0 0 0 0 0 0 0 0 0
0 0 0 0 0 0 0 0 0 0
4 0 0 4 1 4 0 0 4 4
0 0 4 0 0 4 0 0 0 0
0 0 0 0 0 0 0 0 4 0
0 0 0 0 0 4 0 0 0 0
0 0 0 0 0 4 0 0 0 0
0 0 0 0 0 0 0 0 0 0
``` | 1,666 |
<|im_start|>user
# ARC HINT GENERATOR
## Role & Goal
You are an expert ARC (Abstraction and Reasoning Corpus) analyst. Your task is to generate a concise, actionable hint for a user who is struggling with an ARC problem. Analyze the problem and its correct solution to produce a single standalone, targeted hint that he... | 1,167 | [
"<note1>\n<description>Look first for an axis swap: does the output have as many rows as the input had columns (and vice versa)? If so, the transformation is a transpose-like operation that reorients the grid rather than changing colors or pixel counts.</description>\n<example>Imagine a 2×3 input (two rows, three c... | [{"input": [[0, 0, 6, 0, 0], [0, 0, 0, 0, 0], [6, 6, 6, 6, 6], [0, 6, 0, 0, 0]], "output": [[0, 0, 6, 0, 0, 0, 0, 0], [0, 0, 0, 0, 0, 0, 0, 0], [6, 6, 6, 6, 6, 0, 0, 0], [0, 6, 0, 0, 0, 0, 0, 0], [0, 0, 6, 0, 0, 0, 0, 0]]}, {"input": [[0, 0, 7, 7], [7, 0, 7, 0], [0, 0, 0, 0], [7, 0, 0, 0], [0, 0, 0, 7]], "output": [[0,... | [{"input": [[6, 6, 0], [6, 6, 6], [6, 0, 0]], "output": [[6, 6, 0, 0, 0, 0], [6, 6, 6, 0, 0, 0], [6, 0, 0, 0, 0, 0]]}] | barc_heavy | You will be given some number of paired example inputs and outputs grids. The outputs were produced by applying a transformation rule to the input grids. In addition to the paired example inputs and outputs, there is also one test input without a known output. The inputs and outputs are each “grids”. A grid is a rectan... | ```
6 6 0 0 0 0
6 6 6 0 0 0
6 0 0 0 0 0
``` | 674 |
<|im_start|>user
# ARC HINT GENERATOR
## Role & Goal
You are an expert ARC (Abstraction and Reasoning Corpus) analyst. Your task is to generate a concise, actionable hint for a user who is struggling with an ARC problem. Analyze the problem and its correct solution to produce a single standalone, targeted hint that he... | 3,971 | [
"<note1>\n<description>First isolate the meaningful pixels by finding the background color (the color that fills most of the grid) and computing the minimal bounding rectangle that contains every non-background cell. This reduces the problem to a smaller region that actually carries information. Use that rectangle ... | [{"input": [[3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3], [3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3], [3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3], [3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3], [3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3], [3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3], [3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3], [3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3], [3, ... | [{"input": [[1, 1, 1, 4, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1], [1, 7, 1, 1, 7, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1], [4, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1], [1, 1, 1, 1, 1, 4, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1... | rearc | You will be given some number of paired example inputs and outputs grids. The outputs were produced by applying a transformation rule to the input grids. In addition to the paired example inputs and outputs, there is also one test input without a known output. The inputs and outputs are each “grids”. A grid is a rectan... | ```
1 1 1
1 7 1
4 1 1
``` | 3,478 |
<|im_start|>user
# ARC HINT GENERATOR
## Role & Goal
You are an expert ARC (Abstraction and Reasoning Corpus) analyst. Your task is to generate a concise, actionable hint for a user who is struggling with an ARC problem. Analyze the problem and its correct solution to produce a single standalone, targeted hint that he... | 1,619 | [
"<note1>\n<description>Focus on the set of non-background colors in the input and the output: the output uses only those colors (plus zeros). This suggests the transformation is a frequency-based encoding of the input palette rather than a geometric reconstruction.</description>\n<example>Imagine an input with red,... | [{"input": [[0, 0, 0, 0, 0, 0, 0, 0, 0, 0], [0, 0, 0, 0, 0, 0, 0, 0, 0, 0], [0, 0, 1, 0, 0, 0, 0, 0, 0, 0], [0, 0, 0, 0, 0, 0, 0, 0, 0, 0], [0, 0, 0, 0, 0, 0, 0, 0, 0, 0], [0, 0, 0, 0, 2, 0, 7, 0, 0, 0], [1, 0, 0, 2, 2, 0, 4, 1, 0, 4], [0, 3, 0, 1, 0, 0, 3, 0, 0, 0], [0, 0, 0, 0, 0, 0, 0, 7, 0, 1], [0, 0, 3, 0, 0, 3, 0... | [{"input": [[0, 0, 0, 0, 0, 0, 0, 0, 0, 0], [0, 0, 0, 0, 0, 0, 0, 0, 0, 0], [0, 0, 0, 0, 0, 7, 0, 0, 0, 0], [2, 0, 0, 0, 0, 0, 0, 0, 0, 0], [4, 0, 0, 0, 0, 0, 0, 0, 2, 0], [0, 0, 0, 0, 2, 0, 0, 0, 7, 4], [0, 0, 0, 0, 0, 0, 0, 0, 0, 0], [0, 0, 0, 0, 0, 0, 0, 0, 0, 0], [0, 0, 0, 0, 0, 0, 3, 0, 0, 0], [0, 0, 0, 0, 0, 0, 0... | barc_heavy | You will be given some number of paired example inputs and outputs grids. The outputs were produced by applying a transformation rule to the input grids. In addition to the paired example inputs and outputs, there is also one test input without a known output. The inputs and outputs are each “grids”. A grid is a rectan... | ```
2 4 0 3 7
0 0 0 0 0
``` | 1,126 |
<|im_start|>user
# ARC HINT GENERATOR
## Role & Goal
You are an expert ARC (Abstraction and Reasoning Corpus) analyst. Your task is to generate a concise, actionable hint for a user who is struggling with an ARC problem. Analyze the problem and its correct solution to produce a single standalone, targeted hint that he... | 4,367 | [
"<note1>\n<description>Find the anchor color: one color usually forms a long, continuous run (a stripe) that acts as the reference for the transformation. This anchor is the color you will compare to the minority color and is the one that gets used as the replacement.</description>\n<example>Imagine a grid where th... | [{"input": [[4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4], [0, 4, 0, 4, 0, 4, 0, 0, 0, 4, 0, 0, 4, 0, 0, 4, 0, 4, 0, 0, 0, 4, 0, 4, 0, 4], [0, 4, 0, 4, 0, 4, 0, 0, 0, 4, 0, 0, 4, 0, 0, 4, 0, 4, 0, 0, 0, 4, 0, 4, 0, 4], [0, 4, 0, 4, 0, 4, 0, 0, 0, 4, 0, 0, 4, 0, 0, 5, 0, 4, 0, 0, 0, 4, 0... | [{"input": [[5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 0], [5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 0], [5, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0], [5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 0], [5, 5, 5, 5, 5, 5, 5, 5, 1, 0, 0, 0, 0, 0], [5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 0], [5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 0], ... | rearc | You will be given some number of paired example inputs and outputs grids. The outputs were produced by applying a transformation rule to the input grids. In addition to the paired example inputs and outputs, there is also one test input without a known output. The inputs and outputs are each “grids”. A grid is a rectan... | ```
5 5 5 5 5 5 5 5 5 5 5 5 5 0
5 5 5 5 5 5 5 5 5 5 5 5 5 0
5 5 0 0 0 0 0 0 0 0 0 0 0 1
5 5 5 5 5 5 5 5 5 5 5 5 5 0
5 5 5 5 5 5 5 5 5 0 0 0 0 1
5 5 5 5 5 5 5 5 5 5 5 5 5 0
5 5 5 5 5 5 5 5 5 5 5 5 5 0
5 5 5 5 5 5 5 5 5 5 5 5 5 0
5 5 5 5 5 5 5 5 5 5 5 5 5 0
5 5 5 5 5 5 5 5 5 5 5 5 5 0
5 5 5 5 5 5 5 5 5 5 5 5 5 0
``` | 3,874 |
<|im_start|>user
# ARC HINT GENERATOR
## Role & Goal
You are an expert ARC (Abstraction and Reasoning Corpus) analyst. Your task is to generate a concise, actionable hint for a user who is struggling with an ARC problem. Analyze the problem and its correct solution to produce a single standalone, targeted hint that he... | 4,467 | [
"<note1>\n<description>Separate the scene into distinct objects: treat each contiguous non‑zero region as an object and record its bounding box and the set of occupied coordinates. This isolates the pieces that are being transformed and avoids confusing background with objects.</description>\n<example>Imagine a gri... | [{"input": [[0, 0, 0, 0, 0, 0, 9, 0, 0, 0, 0, 0, 0], [0, 0, 0, 0, 9, 9, 9, 9, 9, 0, 0, 0, 0], [0, 0, 0, 0, 9, 9, 9, 9, 9, 0, 0, 0, 0], [0, 0, 0, 9, 9, 9, 9, 9, 9, 0, 0, 0, 0], [0, 0, 0, 0, 9, 9, 9, 9, 9, 6, 6, 6, 6], [0, 0, 0, 0, 9, 9, 9, 9, 9, 6, 6, 6, 6], [0, 0, 0, 0, 0, 0, 0, 0, 0, 6, 6, 6, 6], [0, 0, 0, 0, 0, 0, 0,... | [{"input": [[0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0], [0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 8, 0, 0, 0, 0, 0, 0, 0, 0], [0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 8, 8, 8, 8, 8, 0, 0, 0, 0, 0, 0], [0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 8, 8, 8, 8, 8, 0, 0, 0, 0, 0, 0], [0, 0, 0, 0,... | barc_heavy | You will be given some number of paired example inputs and outputs grids. The outputs were produced by applying a transformation rule to the input grids. In addition to the paired example inputs and outputs, there is also one test input without a known output. The inputs and outputs are each “grids”. A grid is a rectan... | ```
0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0
0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 9 0 0 0 0 0 0 0 0
0 0 0 0 0 0 0 0 0 0 0 0 0 9 9 9 9 9 0 0 0 0 0 0
0 0 0 0 0 0 0 0 0 0 0 0 0 9 9 9 9 9 0 0 0 0 0 0
0 0 0 0 0 0 0 0 0 0 0 0 9 9 9 9 9 9 0 0 0 0 0 0
0 0 0 0 0 0 0 0 0 0 0 0 0 9 9 9 9 9 0 0 0 0 0 0
0 0 0 0 0 0 0 0 0 0 0 0 0 9 ... | 3,974 |
<|im_start|>user
# ARC HINT GENERATOR
## Role & Goal
You are an expert ARC (Abstraction and Reasoning Corpus) analyst. Your task is to generate a concise, actionable hint for a user who is struggling with an ARC problem. Analyze the problem and its correct solution to produce a single standalone, targeted hint that he... | 3,997 | [
"<note1>\n<description>Look for solid, uniformly colored blocks that are perfect squares (every cell in the block is the same color). These perfect squares are the objects the transformation treats specially; they are the only shapes that are simplified. The side length of these squares is consistent across the exa... | [{"input": [[0, 0, 0, 0, 0, 0, 0, 0, 0, 7, 7, 7], [0, 0, 0, 0, 0, 0, 0, 0, 0, 7, 7, 7], [0, 0, 0, 0, 0, 0, 3, 3, 3, 0, 0, 0], [3, 3, 3, 0, 0, 0, 3, 3, 3, 0, 0, 0], [3, 3, 3, 0, 0, 0, 3, 3, 3, 0, 0, 0], [3, 3, 3, 0, 0, 0, 3, 3, 3, 0, 3, 3], [3, 3, 3, 0, 0, 0, 0, 0, 0, 0, 3, 3], [0, 0, 0, 0, 0, 8, 8, 8, 0, 0, 3, 3], [0, ... | [{"input": [[0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 2, 2, 2, 2, 0, 0, 0], [0, 0, 2, 2, 0, 0, 0, 0, 0, 0, 0, 0, 2, 2, 2, 2, 0, 0, 0], [0, 0, 2, 2, 0, 0, 3, 3, 3, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0], [0, 0, 0, 0, 0, 0, 3, 3, 3, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0], [0, 0, 0, 0, 0, 0, 3, 3, 3, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0], [0, 0, 0, 0, ... | barc_heavy | You will be given some number of paired example inputs and outputs grids. The outputs were produced by applying a transformation rule to the input grids. In addition to the paired example inputs and outputs, there is also one test input without a known output. The inputs and outputs are each “grids”. A grid is a rectan... | ```
0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0
0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0
0 0 2 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0
0 0 0 0 0 0 3 3 3 0 0 0 0 0 0 0 0 0 0
0 0 0 0 0 0 3 3 3 0 0 0 0 0 0 0 0 0 0
0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0
0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0
0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0
0 0 0 0 0 0 ... | 3,504 |
<|im_start|>user
# ARC HINT GENERATOR
## Role & Goal
You are an expert ARC (Abstraction and Reasoning Corpus) analyst. Your task is to generate a concise, actionable hint for a user who is struggling with an ARC problem. Analyze the problem and its correct solution to produce a single standalone, targeted hint that he... | 1,742 | [
"<note1>\n<description>Isolate the active area by computing the minimal bounding rectangle that contains every non-background cell. Working inside that rectangle simplifies the task because the transformation is applied only to those cells and the rest of the grid stays unchanged.</description>\n<example>Imagine a ... | [{"input": [[8, 8, 8, 8, 8, 8, 8, 8, 8, 8], [8, 8, 8, 8, 8, 8, 8, 8, 8, 8], [8, 8, 8, 8, 8, 8, 8, 8, 8, 8], [8, 8, 8, 8, 8, 8, 8, 8, 8, 8], [8, 8, 4, 8, 8, 8, 8, 8, 8, 8], [8, 8, 7, 1, 6, 5, 6, 1, 8, 8], [8, 8, 8, 8, 8, 8, 8, 2, 8, 8], [8, 8, 8, 8, 8, 8, 8, 8, 8, 8], [8, 8, 8, 8, 8, 8, 8, 8, 8, 8], [8, 8, 8, 8, 8, 8, 8... | [{"input": [[8, 8, 8, 8, 8, 8, 8, 8, 8, 8], [8, 8, 8, 8, 8, 8, 9, 9, 2, 8], [8, 8, 8, 8, 8, 8, 9, 8, 2, 8], [8, 8, 6, 6, 1, 8, 5, 8, 2, 8], [8, 8, 6, 8, 4, 8, 5, 8, 4, 8], [8, 8, 7, 8, 1, 5, 5, 8, 4, 8], [8, 8, 7, 8, 8, 8, 8, 8, 4, 8], [8, 8, 7, 8, 8, 8, 8, 8, 1, 8], [8, 8, 1, 1, 7, 8, 8, 1, 1, 8], [8, 8, 8, 8, 8, 8, 8... | arc 2 | You will be given some number of paired example inputs and outputs grids. The outputs were produced by applying a transformation rule to the input grids. In addition to the paired example inputs and outputs, there is also one test input without a known output. The inputs and outputs are each “grids”. A grid is a rectan... | ```
8 8 8 8 8 8 8 8 8 8
8 8 8 8 8 8 4 1 6 8
8 8 8 8 8 8 1 8 6 8
8 8 2 2 9 8 5 8 6 8
8 8 2 8 9 8 5 8 7 8
8 8 4 8 9 5 5 8 7 8
8 8 4 8 8 8 8 8 7 8
8 8 4 8 8 8 8 8 1 8
8 8 1 1 1 8 8 7 1 8
8 8 8 8 8 8 8 8 8 8
``` | 1,249 |
<|im_start|>user
# ARC HINT GENERATOR
## Role & Goal
You are an expert ARC (Abstraction and Reasoning Corpus) analyst. Your task is to generate a concise, actionable hint for a user who is struggling with an ARC problem. Analyze the problem and its correct solution to produce a single standalone, targeted hint that he... | 4,195 | [
"<note1>\n<description>Find the two dominant non-background objects by color and treat each as a connected component. For each component compute its minimal bounding rectangle (min/max row and column) — that rectangle is the object's canonical representation.</description>\n<example>Imagine a grid with a red cluste... | [{"input": [[0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0], [0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0], [0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0], [0, 0, 0, 0, 0, 0, 0, 2, 2, 2, 2, 2, 2, 2, 0, 0, 0, 0], [0, 0, 0, 0, 0, 0, 0, 2, 2, 2, 2, 2, 2, 2, 0, 0, 0, 0], [0, 4, 4, 4, 0, 0, 0, 2, 2, ... | [{"input": [[0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0], [0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0], [0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0], [0, 3, 3, 3, 3, 3, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0], [0, 3, 3, 3, 3, 3, 7, 7, 7, 7, 7, 7, 7, 7, 7, 0, 0], [0, 3, 3, 3, 3, 3, 0, 0, 0, 0, 0, 7, 7, 7, ... | arc 2 | You will be given some number of paired example inputs and outputs grids. The outputs were produced by applying a transformation rule to the input grids. In addition to the paired example inputs and outputs, there is also one test input without a known output. The inputs and outputs are each “grids”. A grid is a rectan... | ```
0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0
0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0
0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0
0 3 3 3 3 3 0 0 0 0 0 0 0 0 0 0 0
0 3 3 3 3 3 7 7 7 7 0 0 0 0 0 0 0
0 3 3 3 3 3 7 7 7 7 0 0 0 0 0 0 0
0 3 3 3 3 3 7 7 7 7 0 0 0 0 0 0 0
0 3 3 3 3 3 0 0 0 0 0 0 0 0 0 0 0
0 3 3 3 3 3 0 0 0 0 0 0 0 0 0 0 0
0 3 3 3 3 ... | 3,702 |
<|im_start|>user
# ARC HINT GENERATOR
## Role & Goal
You are an expert ARC (Abstraction and Reasoning Corpus) analyst. Your task is to generate a concise, actionable hint for a user who is struggling with an ARC problem. Analyze the problem and its correct solution to produce a single standalone, targeted hint that he... | 2,085 | [
"<note1>\n<description>Look for a small set of colors that are consistently changed between input and output. If only a few colors differ while the background and other colors remain identical, the transformation is likely a recoloring rather than a movement or reshaping operation.</description>\n<example>Imagine a... | [{"input": [[0, 0, 0, 0, 0, 0, 0, 0], [0, 0, 0, 0, 0, 0, 0, 0], [0, 0, 0, 0, 0, 0, 0, 0], [0, 0, 0, 0, 0, 0, 0, 0], [0, 0, 0, 0, 0, 0, 0, 0], [0, 0, 2, 0, 0, 0, 0, 0], [0, 0, 0, 2, 2, 0, 0, 0], [0, 0, 1, 1, 1, 1, 1, 1], [0, 0, 1, 1, 1, 1, 1, 1], [0, 0, 1, 1, 1, 1, 1, 1], [0, 0, 1, 1, 1, 1, 1, 1], [0, 0, 1, 1, 1, 1, 1, ... | [{"input": [[0, 0, 0, 0, 0, 0, 2, 0, 0], [0, 1, 1, 1, 1, 1, 0, 0, 0], [0, 1, 1, 1, 1, 1, 0, 0, 0], [0, 1, 1, 1, 1, 1, 0, 0, 0], [0, 1, 1, 1, 1, 1, 0, 0, 0], [0, 1, 1, 1, 1, 1, 0, 2, 2], [0, 1, 1, 1, 1, 1, 0, 0, 0], [0, 1, 1, 1, 1, 1, 0, 0, 0], [2, 1, 1, 1, 1, 1, 2, 0, 0]], "output": [[0, 0, 0, 0, 0, 0, 4, 0, 0], [0, 3,... | barc_heavy | You will be given some number of paired example inputs and outputs grids. The outputs were produced by applying a transformation rule to the input grids. In addition to the paired example inputs and outputs, there is also one test input without a known output. The inputs and outputs are each “grids”. A grid is a rectan... | ```
0 0 0 0 0 0 4 0 0
0 3 3 3 3 3 0 0 0
0 3 3 3 3 3 0 0 0
0 3 3 3 3 3 0 0 0
0 3 3 3 3 3 0 0 0
0 3 3 3 3 3 0 4 4
0 3 3 3 3 3 0 0 0
0 3 3 3 3 3 0 0 0
4 3 3 3 3 3 4 0 0
``` | 1,592 |
<|im_start|>user
# ARC HINT GENERATOR
## Role & Goal
You are an expert ARC (Abstraction and Reasoning Corpus) analyst. Your task is to generate a concise, actionable hint for a user who is struggling with an ARC problem. Analyze the problem and its correct solution to produce a single standalone, targeted hint that he... | 3,523 | [
"<note1>\n<description>Look for a regular lattice of non-zero pixels: many ARC tasks place meaningful pixels at fixed offsets (for example every other row and column). Recognizing that lattice reduces the problem to a small repeating sub-grid that you can study.</description>\n<example>Imagine a 7×7 grid where colo... | [{"input": [[0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0], [0, 7, 0, 6, 0, 4, 0, 6, 0, 9, 0, 8, 0, 5, 0, 6, 0], [0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0], [0, 7, 0, 9, 0, 3, 0, 3, 0, 7, 0, 7, 0, 9, 0, 7, 0], [0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0], [0, 5, 0, 7, 0, 1, 0, 6, 0, 5, 0, 8, 0, 7, ... | [{"input": [[0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0], [0, 6, 0, 5, 0, 3, 0, 6, 0, 9, 0, 5, 0, 0], [0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0], [0, 9, 0, 1, 0, 6, 0, 5, 0, 6, 0, 5, 0, 0], [0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0], [0, 6, 0, 9, 0, 9, 0, 7, 0, 6, 0, 6, 0, 0], [0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0], ... | barc_heavy | You will be given some number of paired example inputs and outputs grids. The outputs were produced by applying a transformation rule to the input grids. In addition to the paired example inputs and outputs, there is also one test input without a known output. The inputs and outputs are each “grids”. A grid is a rectan... | ```
0 0 0 0 0 0 0 0 0 0 0 0 0 0
0 7 0 8 0 2 0 7 0 8 0 8 0 0
0 0 0 0 0 0 0 0 0 0 0 0 0 0
0 8 0 4 0 7 0 8 0 7 0 8 0 0
0 0 0 0 0 0 0 0 0 0 0 0 0 0
0 7 0 8 0 8 0 6 0 7 0 7 0 0
0 0 0 0 0 0 0 0 0 0 0 0 0 0
0 7 0 9 0 8 0 1 0 4 0 6 0 0
0 0 0 0 0 0 0 0 0 0 0 0 0 0
0 6 0 7 0 8 0 4 0 3 0 7 0 0
0 0 0 0 0 0 0 0 0 0 0 0 0 0
0 8 0 3 ... | 3,030 |
<|im_start|>user
# ARC HINT GENERATOR
## Role & Goal
You are an expert ARC (Abstraction and Reasoning Corpus) analyst. Your task is to generate a concise, actionable hint for a user who is struggling with an ARC problem. Analyze the problem and its correct solution to produce a single standalone, targeted hint that he... | 1,263 | [
"<note1>\n<description>Look for small, perfectly filled 2×2 squares of the same non-background color — these are the atomic objects the task cares about. Ignore isolated single pixels or irregular clusters; only exact 2×2 filled blocks should be counted. This isolates the units you will later represent in the outpu... | [{"input": [[0, 0, 0, 0, 0, 0], [0, 6, 6, 0, 0, 0], [0, 6, 6, 0, 0, 0], [0, 0, 0, 6, 6, 0], [0, 0, 0, 6, 6, 0], [0, 0, 0, 0, 0, 0]], "output": [[3, 0, 0, 0, 0, 0], [3, 0, 0, 0, 0, 0], [0, 0, 0, 0, 0, 0], [0, 0, 0, 0, 0, 0], [0, 0, 0, 0, 0, 0], [0, 0, 0, 0, 0, 0]]}, {"input": [[0, 0, 0, 0, 0, 0], [6, 6, 0, 0, 0, 0], [6,... | [{"input": [[0, 0, 0, 0, 0, 0], [0, 0, 0, 0, 0, 0], [0, 0, 0, 0, 0, 0], [0, 0, 0, 0, 0, 0], [0, 0, 0, 0, 4, 4], [0, 0, 0, 0, 4, 4]], "output": [[7, 0, 0, 0, 0, 0], [0, 0, 0, 0, 0, 0], [0, 0, 0, 0, 0, 0], [0, 0, 0, 0, 0, 0], [0, 0, 0, 0, 0, 0], [0, 0, 0, 0, 0, 0]]}] | barc_heavy | You will be given some number of paired example inputs and outputs grids. The outputs were produced by applying a transformation rule to the input grids. In addition to the paired example inputs and outputs, there is also one test input without a known output. The inputs and outputs are each “grids”. A grid is a rectan... | ```
7 0 0 0 0 0
0 0 0 0 0 0
0 0 0 0 0 0
0 0 0 0 0 0
0 0 0 0 0 0
0 0 0 0 0 0
``` | 770 |
<|im_start|>user
# ARC HINT GENERATOR
## Role & Goal
You are an expert ARC (Abstraction and Reasoning Corpus) analyst. Your task is to generate a concise, actionable hint for a user who is struggling with an ARC problem. Analyze the problem and its correct solution to produce a single standalone, targeted hint that he... | 1,167 | [
"<note1>\n<description>Look for whole-row repetition: sometimes the output is formed by repeating each input row one or more times in the same order. This is effective when the output's width is an integer multiple of the input's width and each repeated segment matches the original row exactly.</description>\n<exam... | [{"input": [[7, 6, 6, 9, 9], [5, 1, 1, 3, 3], [1, 1, 1, 7, 2], [1, 5, 1, 1, 9]], "output": [[7, 6, 6, 9, 9, 7, 6, 6, 9, 9], [5, 1, 1, 3, 3, 5, 1, 1, 3, 3], [1, 1, 1, 7, 2, 1, 1, 1, 7, 2], [1, 5, 1, 1, 9, 1, 5, 1, 1, 9]]}, {"input": [[2, 2, 7, 7], [7, 7, 7, 7], [3, 7, 1, 7], [3, 8, 6, 1], [7, 4, 4, 1]], "output": [[2, 2... | [{"input": [[6, 1, 8], [1, 1, 4], [1, 6, 2]], "output": [[6, 1, 8, 6, 1, 8], [1, 1, 4, 1, 1, 4], [1, 6, 2, 1, 6, 2]]}] | barc_heavy | You will be given some number of paired example inputs and outputs grids. The outputs were produced by applying a transformation rule to the input grids. In addition to the paired example inputs and outputs, there is also one test input without a known output. The inputs and outputs are each “grids”. A grid is a rectan... | ```
6 1 8 6 1 8
1 1 4 1 1 4
1 6 2 1 6 2
``` | 674 |
<|im_start|>user
# ARC HINT GENERATOR
## Role & Goal
You are an expert ARC (Abstraction and Reasoning Corpus) analyst. Your task is to generate a concise, actionable hint for a user who is struggling with an ARC problem. Analyze the problem and its correct solution to produce a single standalone, targeted hint that he... | 3,467 | [
"<note1>\n<description>Look for a single, dominant contiguous region that forms a clear block or rectangle. This region is usually the largest connected component of one color and is visually distinct from the surrounding noisy pattern.</description>\n<example>Imagine a grid where many cells form a neat 4×6 rectang... | [{"input": [[3, 0, 3, 0, 3, 5, 3, 5, 5, 5, 5, 5, 5, 3, 1, 0, 0, 0, 0], [5, 0, 5, 5, 1, 5, 1, 0, 3, 5, 3, 1, 5, 5, 5, 3, 0, 1, 3], [5, 0, 5, 5, 0, 3, 3, 3, 1, 5, 0, 1, 0, 1, 0, 0, 3, 1, 0], [5, 3, 0, 3, 1, 0, 1, 5, 1, 0, 5, 0, 3, 0, 3, 1, 0, 3, 0], [5, 1, 0, 1, 5, 0, 5, 1, 0, 1, 0, 0, 5, 0, 1, 3, 5, 1, 3], [0, 5, 1, 0, ... | [{"input": [[3, 0, 9, 0, 0, 0, 9, 3, 9, 3, 9, 0, 9, 3, 9, 0, 3, 0], [0, 9, 0, 0, 9, 0, 3, 0, 3, 9, 3, 0, 3, 0, 3, 3, 0, 3], [0, 3, 9, 3, 3, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 3], [0, 9, 3, 0, 3, 5, 5, 5, 3, 5, 5, 5, 5, 5, 5, 5, 5, 3], [0, 9, 3, 9, 9, 5, 5, 3, 5, 5, 5, 5, 5, 5, 5, 5, 5, 9], [3, 0, 0, 9, 9, 5, 5, 5, 5, ... | rearc | You will be given some number of paired example inputs and outputs grids. The outputs were produced by applying a transformation rule to the input grids. In addition to the paired example inputs and outputs, there is also one test input without a known output. The inputs and outputs are each “grids”. A grid is a rectan... | ```
5 5 3 3 3 5 5 3 5 5 5 5
3 3 3 3 3 3 3 3 3 3 3 3
3 3 3 3 3 3 3 3 3 3 3 3
3 3 3 3 3 3 3 3 3 3 3 3
3 3 3 3 3 3 3 3 3 3 3 3
5 5 3 3 3 5 5 3 5 5 5 5
``` | 2,974 |
<|im_start|>user
# ARC HINT GENERATOR
## Role & Goal
You are an expert ARC (Abstraction and Reasoning Corpus) analyst. Your task is to generate a concise, actionable hint for a user who is struggling with an ARC problem. Analyze the problem and its correct solution to produce a single standalone, targeted hint that he... | 1,893 | [
"<note1>\n<description>Find the single object by locating all non-background pixels and compute its bounding box: min_row, max_row, min_col, max_col. The bounding box gives height = max_row - min_row + 1 and width = max_col - min_col + 1; these two numbers are the key measurements for the transformation.</descripti... | [{"input": [[0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0], [0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0], [0, 0, 0, 0, 7, 7, 0, 0, 0, 0, 0, 0], [0, 0, 0, 0, 7, 7, 7, 0, 0, 0, 0, 0], [0, 0, 0, 0, 0, 7, 7, 0, 0, 0, 0, 0], [0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0], [0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0], [0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0]], "ou... | [{"input": [[0, 0, 0, 0, 0, 0, 0, 0, 0], [0, 0, 0, 0, 0, 0, 0, 0, 0], [0, 0, 0, 0, 0, 0, 0, 0, 0], [0, 0, 0, 6, 6, 6, 0, 0, 0], [0, 0, 0, 6, 6, 6, 0, 0, 0], [0, 0, 0, 0, 0, 0, 0, 0, 0], [0, 0, 0, 0, 0, 0, 0, 0, 0], [0, 0, 0, 0, 0, 0, 0, 0, 0], [0, 0, 0, 0, 0, 0, 0, 0, 0]], "output": [[0, 0, 0, 0, 0, 0, 0, 0, 0], [0, 0,... | barc_heavy | You will be given some number of paired example inputs and outputs grids. The outputs were produced by applying a transformation rule to the input grids. In addition to the paired example inputs and outputs, there is also one test input without a known output. The inputs and outputs are each “grids”. A grid is a rectan... | ```
0 0 0 0 0 0 0 0 0
0 0 0 0 0 0 0 0 0
0 0 0 0 0 0 0 0 0
0 0 0 0 1 1 0 0 0
0 0 0 0 1 1 0 0 0
0 0 0 0 1 1 0 0 0
0 0 0 0 0 0 0 0 0
0 0 0 0 0 0 0 0 0
0 0 0 0 0 0 0 0 0
``` | 1,400 |
<|im_start|>user
# ARC HINT GENERATOR
## Role & Goal
You are an expert ARC (Abstraction and Reasoning Corpus) analyst. Your task is to generate a concise, actionable hint for a user who is struggling with an ARC problem. Analyze the problem and its correct solution to produce a single standalone, targeted hint that he... | 3,621 | [
"<note1>\n<description>Focus on the color that is being summarized: the examples show one color in the output that corresponds to a single, repeated color in the input. That color is chosen by a simple frequency test (the most common non-background color) and is the only color you need to track.</description>\n<exa... | [{"input": [[0, 0, 3, 4, 3], [0, 3, 4, 3, 3], [3, 4, 4, 3, 0], [4, 0, 9, 0, 0], [3, 4, 0, 3, 4], [9, 0, 4, 9, 4], [0, 3, 3, 0, 4]], "output": [[0, 0, 5], [0, 0, 5], [5, 5, 5]]}, {"input": [[7, 0, 0, 5, 8], [0, 8, 9, 2, 5], [7, 6, 5, 8, 7], [7, 5, 0, 5, 0], [8, 8, 6, 4, 8], [4, 6, 8, 9, 4], [2, 2, 6, 8, 7], [7, 4, 4, 5,... | [{"input": [[6, 6, 9, 9, 9, 3, 6, 9, 9, 9, 9, 9, 9, 9, 6, 6, 9, 9, 6, 6, 3, 6, 9, 6, 3, 9], [9, 9, 6, 9, 9, 6, 9, 6, 9, 9, 3, 3, 9, 9, 6, 6, 6, 6, 3, 9, 9, 9, 9, 6, 3, 3], [9, 3, 6, 9, 9, 6, 6, 9, 6, 9, 6, 9, 9, 6, 9, 9, 6, 9, 9, 3, 9, 6, 6, 6, 6, 6], [9, 6, 9, 6, 9, 6, 9, 6, 9, 6, 3, 3, 6, 6, 9, 6, 9, 9, 6, 9, 9, 3, 9... | rearc | You will be given some number of paired example inputs and outputs grids. The outputs were produced by applying a transformation rule to the input grids. In addition to the paired example inputs and outputs, there is also one test input without a known output. The inputs and outputs are each “grids”. A grid is a rectan... | ```
0 0 5
0 0 5
5 5 5
``` | 3,128 |
<|im_start|>user
# ARC HINT GENERATOR
## Role & Goal
You are an expert ARC (Abstraction and Reasoning Corpus) analyst. Your task is to generate a concise, actionable hint for a user who is struggling with an ARC problem. Analyze the problem and its correct solution to produce a single standalone, targeted hint that he... | 1,552 | [
"<note1>\n<description>Look for vertical stacks of the same non-background color: contiguous cells in the same column that touch each other. These stacks are the primary objects the transformation acts upon, so treat each stack as a unit.</description>\n<example>Imagine a grid where a column has colored cells at ro... | [{"input": [[0, 0, 0, 0, 0, 0, 0, 0, 0], [0, 0, 5, 0, 0, 0, 0, 0, 0], [0, 0, 5, 0, 0, 0, 5, 0, 0], [5, 0, 5, 0, 0, 0, 5, 0, 0], [5, 0, 5, 0, 0, 0, 5, 0, 0], [5, 0, 5, 0, 5, 0, 5, 0, 0], [5, 0, 5, 0, 5, 0, 5, 0, 5], [5, 0, 5, 0, 5, 0, 5, 0, 5], [5, 0, 5, 0, 5, 0, 5, 0, 5]], "output": [[0, 0, 0, 0, 0, 0, 0, 0, 0], [0, 0,... | [{"input": [[0, 0, 0, 0, 0, 0, 0, 0, 0], [0, 0, 0, 0, 0, 0, 0, 5, 0], [0, 0, 0, 5, 0, 0, 0, 5, 0], [0, 0, 0, 5, 0, 0, 0, 5, 0], [0, 0, 0, 5, 0, 5, 0, 5, 0], [0, 0, 0, 5, 0, 5, 0, 5, 0], [0, 0, 0, 5, 0, 5, 0, 5, 0], [0, 0, 0, 5, 0, 5, 0, 5, 0], [0, 5, 0, 5, 0, 5, 0, 5, 0]], "output": [[0, 0, 0, 0, 0, 0, 0, 0, 0], [0, 0,... | arc 1 | You will be given some number of paired example inputs and outputs grids. The outputs were produced by applying a transformation rule to the input grids. In addition to the paired example inputs and outputs, there is also one test input without a known output. The inputs and outputs are each “grids”. A grid is a rectan... | ```
0 0 0 0 0 0 0 0 0
0 0 0 0 0 0 0 1 0
0 0 0 0 0 0 0 1 0
0 0 0 0 0 0 0 1 0
0 0 0 0 0 0 0 1 0
0 0 0 0 0 0 0 1 0
0 0 0 0 0 0 0 1 0
0 0 0 0 0 0 0 1 0
0 2 0 0 0 0 0 1 0
``` | 1,059 |
<|im_start|>user
# ARC HINT GENERATOR
## Role & Goal
You are an expert ARC (Abstraction and Reasoning Corpus) analyst. Your task is to generate a concise, actionable hint for a user who is struggling with an ARC problem. Analyze the problem and its correct solution to produce a single standalone, targeted hint that he... | 2,251 | [
"<note1>\n<description>Look for axis-aligned, fully filled rectangles of the background color (zeros). A true target is a block where every cell inside the bounding box is 0; that makes it a candidate for the transformation.</description>\n<example>Imagine a 4×4 grid where rows 2–3 and columns 1–2 are all zeros whi... | [{"input": [[5, 8, 0, 1], [0, 0, 2, 0], [0, 9, 3, 0], [0, 9, 0, 4], [0, 0, 0, 2], [8, 0, 0, 0], [9, 2, 0, 0], [3, 0, 9, 9], [7, 0, 0, 8], [7, 4, 4, 0], [2, 7, 0, 0], [0, 0, 0, 0], [0, 0, 7, 0], [0, 0, 5, 2], [0, 1, 7, 0], [3, 9, 0, 8], [0, 0, 0, 2], [7, 0, 0, 0], [0, 0, 0, 0], [5, 0, 2, 7], [0, 0, 2, 5], [0, 0, 0, 0], ... | [{"input": [[0, 1, 8, 0], [0, 1, 1, 0], [0, 0, 8, 0], [8, 5, 1, 1], [0, 8, 8, 0], [0, 0, 8, 1], [8, 8, 8, 8], [0, 0, 1, 1], [0, 1, 5, 0], [8, 0, 8, 8], [0, 0, 0, 0], [1, 8, 0, 0], [1, 0, 0, 0], [8, 0, 5, 1], [0, 0, 5, 0], [0, 5, 0, 8], [0, 5, 8, 0], [0, 0, 8, 0], [0, 1, 5, 5], [1, 0, 5, 1], [5, 0, 0, 1], [5, 0, 0, 0], ... | rearc | You will be given some number of paired example inputs and outputs grids. The outputs were produced by applying a transformation rule to the input grids. In addition to the paired example inputs and outputs, there is also one test input without a known output. The inputs and outputs are each “grids”. A grid is a rectan... | ```
0 1 8 0
0 1 1 0
0 0 8 0
8 5 1 1
0 8 8 0
0 0 8 1
8 8 8 8
0 0 1 1
0 1 5 0
8 0 8 8
0 0 6 6
1 8 6 6
1 0 6 6
8 0 5 1
0 0 5 0
0 5 0 8
0 5 8 0
0 0 8 0
0 1 5 5
1 0 5 1
5 6 6 1
5 6 6 0
1 6 6 8
0 0 8 5
5 0 0 5
8 0 0 5
5 0 1 0
``` | 1,758 |
<|im_start|>user
# ARC HINT GENERATOR
## Role & Goal
You are an expert ARC (Abstraction and Reasoning Corpus) analyst. Your task is to generate a concise, actionable hint for a user who is struggling with an ARC problem. Analyze the problem and its correct solution to produce a single standalone, targeted hint that he... | 1,263 | [
"<note1>\n<description>Look for whole-grid repetition: sometimes the output is formed by placing one or more copies of the entire input next to each other. This applies when you can find identical sub-rectangles in the output that match the entire input. It is effective because it preserves every pixel and its rela... | [{"input": [[9, 9, 9, 9], [1, 4, 4, 1], [1, 4, 4, 1], [1, 4, 4, 1], [1, 1, 1, 1], [9, 4, 4, 9], [1, 9, 9, 1]], "output": [[9, 9, 9, 9, 9, 9, 9, 9], [1, 4, 4, 1, 1, 4, 4, 1], [1, 4, 4, 1, 1, 4, 4, 1], [1, 4, 4, 1, 1, 4, 4, 1], [1, 1, 1, 1, 1, 1, 1, 1], [9, 4, 4, 9, 9, 4, 4, 9], [1, 9, 9, 1, 1, 9, 9, 1]]}, {"input": [[5,... | [{"input": [[4, 4, 8, 4, 4, 8, 4, 4], [8, 8, 8, 8, 8, 8, 8, 8], [3, 8, 4, 8, 8, 4, 8, 3], [8, 3, 4, 8, 8, 4, 3, 8], [3, 8, 4, 4, 4, 4, 8, 3], [4, 4, 8, 8, 8, 8, 4, 4], [4, 8, 4, 4, 4, 4, 8, 4], [3, 4, 8, 3, 3, 8, 4, 3], [8, 4, 8, 4, 4, 8, 4, 8]], "output": [[4, 4, 8, 4, 4, 8, 4, 4, 4, 4, 8, 4, 4, 8, 4, 4], [8, 8, 8, 8,... | barc_heavy | You will be given some number of paired example inputs and outputs grids. The outputs were produced by applying a transformation rule to the input grids. In addition to the paired example inputs and outputs, there is also one test input without a known output. The inputs and outputs are each “grids”. A grid is a rectan... | ```
4 4 8 4 4 8 4 4 4 4 8 4 4 8 4 4
8 8 8 8 8 8 8 8 8 8 8 8 8 8 8 8
3 8 4 8 8 4 8 3 3 8 4 8 8 4 8 3
8 3 4 8 8 4 3 8 8 3 4 8 8 4 3 8
3 8 4 4 4 4 8 3 3 8 4 4 4 4 8 3
4 4 8 8 8 8 4 4 4 4 8 8 8 8 4 4
4 8 4 4 4 4 8 4 4 8 4 4 4 4 8 4
3 4 8 3 3 8 4 3 3 4 8 3 3 8 4 3
8 4 8 4 4 8 4 8 8 4 8 4 4 8 4 8
``` | 770 |
<|im_start|>user
# ARC HINT GENERATOR
## Role & Goal
You are an expert ARC (Abstraction and Reasoning Corpus) analyst. Your task is to generate a concise, actionable hint for a user who is struggling with an ARC problem. Analyze the problem and its correct solution to produce a single standalone, targeted hint that he... | 4,387 | [
"<note1>\n<description>Start by separating background from objects: find the single color that fills most of the grid and treat every other contiguous colored region as an object. This isolates the small set of shapes that are being transformed. It is effective because the examples always have one dominant backgrou... | [{"input": [[3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 7, 7, 3, 3, 3], [3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3], [3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3], [3, 6, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3], [3, 6, 3, 3, 3, 3, 3, 3,... | [{"input": [[0, 7, 7, 7, 7, 7, 7, 7], [0, 7, 7, 7, 7, 7, 7, 7], [7, 0, 7, 7, 7, 7, 7, 7], [7, 0, 7, 7, 7, 7, 7, 7], [7, 0, 7, 7, 7, 7, 5, 7], [7, 0, 7, 7, 7, 7, 5, 7], [7, 0, 7, 7, 7, 7, 5, 7], [7, 0, 7, 7, 7, 7, 5, 7], [7, 0, 7, 7, 7, 7, 5, 7], [7, 0, 7, 7, 7, 7, 5, 7], [7, 0, 7, 7, 7, 7, 5, 7], [7, 0, 7, 7, 7, 7, 5, ... | rearc | You will be given some number of paired example inputs and outputs grids. The outputs were produced by applying a transformation rule to the input grids. In addition to the paired example inputs and outputs, there is also one test input without a known output. The inputs and outputs are each “grids”. A grid is a rectan... | ```
2 7 7 7 7 7 7 7
2 7 7 7 7 7 7 7
7 1 7 7 7 7 7 7
7 1 7 7 7 7 7 7
7 1 7 7 7 7 4 7
7 1 7 7 7 7 4 7
7 1 7 7 7 7 4 7
7 1 7 7 7 7 4 7
7 1 7 7 7 7 4 7
7 1 7 7 7 7 4 7
7 1 7 7 7 7 4 7
7 1 7 7 7 7 4 7
7 1 7 7 7 7 7 7
7 1 7 7 7 7 7 7
7 1 7 7 7 7 7 7
7 1 7 7 7 7 7 7
7 1 7 7 7 7 7 7
7 7 7 7 7 7 7 7
7 7 7 7 7 7 7 7
7 7 7 7 7 7 ... | 3,894 |
<|im_start|>user
# ARC HINT GENERATOR
## Role & Goal
You are an expert ARC (Abstraction and Reasoning Corpus) analyst. Your task is to generate a concise, actionable hint for a user who is struggling with an ARC problem. Analyze the problem and its correct solution to produce a single standalone, targeted hint that he... | 3,523 | [
"<note1>\n<description>Look for distinct objects by grouping non-background pixels into connected components and record each object's bounding box, pixel count, and centroid. These features let you compare shapes and positions across the grid without relying on raw color values.</description>\n<example>Imagine a gr... | [{"input": [[0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0], [0, 0, 0, 0, 0, 0, 0, 6, 6, 6, 6, 0, 0, 0, 0, 0, 0], [0, 0, 0, 0, 0, 0, 6, 6, 6, 6, 6, 0, 0, 0, 0, 0, 0], [0, 0, 0, 0, 0, 0, 6, 6, 6, 6, 6, 0, 0, 0, 0, 0, 0], [0, 0, 0, 0, 0, 0, 0, 6, 6, 6, 6, 0, 0, 0, 0, 0, 0], [0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, ... | [{"input": [[0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0], [0, 0, 6, 6, 6, 6, 0, 0, 9, 9, 9, 9, 0, 0], [0, 0, 6, 6, 6, 6, 0, 0, 9, 0, 0, 0, 0, 0], [0, 0, 6, 6, 6, 6, 0, 0, 9, 9, 9, 9, 0, 0], [0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0], [0, 5, 5, 5, 5, 0, 0, 0, 9, 9, 9, 9, 9, 0], [0, 5, 5, 5, 5, 0, 0, 0, 9, 0, 9, 0, 9, 0], ... | barc_heavy | You will be given some number of paired example inputs and outputs grids. The outputs were produced by applying a transformation rule to the input grids. In addition to the paired example inputs and outputs, there is also one test input without a known output. The inputs and outputs are each “grids”. A grid is a rectan... | ```
0 0 0 0 0 0 0 0 0 0 0 0 0 0
0 0 6 6 6 6 0 0 5 5 5 5 0 0
0 0 6 6 6 6 0 0 5 0 0 0 0 0
0 0 6 6 6 6 0 0 5 5 5 5 0 0
0 0 0 0 0 0 0 0 0 0 0 0 0 0
0 9 9 9 9 0 0 0 9 9 9 9 9 0
0 9 9 9 9 0 0 0 9 0 9 0 9 0
0 0 9 9 9 0 0 0 9 9 9 9 9 0
0 9 9 9 9 0 0 0 0 0 0 0 0 0
0 9 9 9 9 0 0 0 0 0 0 0 0 0
0 0 0 0 0 0 0 0 0 0 0 0 0 0
0 0 0 0 ... | 3,030 |
<|im_start|>user
# ARC HINT GENERATOR
## Role & Goal
You are an expert ARC (Abstraction and Reasoning Corpus) analyst. Your task is to generate a concise, actionable hint for a user who is struggling with an ARC problem. Analyze the problem and its correct solution to produce a single standalone, targeted hint that he... | 1,625 | [
"<note1>\n<description>Look first for a global spatial transform (rotation/reflection/transpose). A 180° rotation (flip both axes) is a common, simple operation that sends (r,c) → (R−1−r, C−1−c); it moves every non-background pixel to the opposite side of the grid. Use this test before considering more complex rear... | [{"input": [[0, 0, 0, 0, 0, 5, 0, 0], [0, 3, 0, 0, 0, 0, 9, 0], [0, 0, 7, 0, 0, 0, 5, 0], [0, 0, 0, 0, 0, 0, 0, 0], [0, 0, 0, 0, 0, 0, 0, 9], [0, 8, 0, 0, 0, 6, 0, 9], [7, 0, 7, 7, 0, 0, 3, 0], [0, 0, 0, 0, 0, 0, 0, 0]], "output": [[0, 0, 6, 0, 0, 0, 0, 0], [0, 8, 0, 0, 0, 0, 2, 0], [0, 6, 0, 0, 0, 7, 0, 0], [0, 0, 0, ... | [{"input": [[0, 5, 0, 0, 0, 0, 0, 0, 0], [0, 0, 0, 0, 0, 0, 0, 0, 0], [0, 0, 0, 0, 0, 0, 0, 0, 0], [9, 0, 0, 0, 0, 0, 0, 0, 0], [0, 0, 0, 0, 0, 5, 0, 0, 0], [0, 0, 0, 0, 6, 9, 0, 0, 6], [0, 0, 0, 0, 0, 6, 1, 0, 0], [0, 0, 0, 0, 0, 0, 0, 0, 5], [0, 0, 0, 0, 0, 0, 0, 0, 3]], "output": [[0, 0, 0, 0, 0, 0, 0, 6, 0], [0, 0,... | barc_heavy | You will be given some number of paired example inputs and outputs grids. The outputs were produced by applying a transformation rule to the input grids. In addition to the paired example inputs and outputs, there is also one test input without a known output. The inputs and outputs are each “grids”. A grid is a rectan... | ```
0 0 0 0 0 0 0 6 0
0 0 0 0 0 0 0 0 0
0 0 0 0 0 0 0 0 0
0 0 0 0 0 0 0 0 8
0 0 0 6 0 0 0 0 0
5 0 0 8 5 0 0 0 0
0 0 4 5 0 0 0 0 0
6 0 0 0 0 0 0 0 0
2 0 0 0 0 0 0 0 0
``` | 1,132 |
<|im_start|>user
# ARC HINT GENERATOR
## Role & Goal
You are an expert ARC (Abstraction and Reasoning Corpus) analyst. Your task is to generate a concise, actionable hint for a user who is struggling with an ARC problem. Analyze the problem and its correct solution to produce a single standalone, targeted hint that he... | 2,085 | [
"<note1>\n<description>Locate the anchor: many tasks use a single non-background pixel as the seed. That pixel’s color is preserved and its position determines where the transformation is centered.</description>\n<example>Imagine a 7×7 grid with one red pixel at (3,3). That red pixel is the seed: everything you add... | [{"input": [[0, 0, 0, 0, 0, 0, 0, 0], [0, 0, 0, 0, 0, 0, 0, 0], [0, 0, 0, 0, 0, 0, 0, 0], [0, 0, 0, 0, 0, 0, 0, 0], [0, 0, 0, 0, 0, 0, 0, 0], [0, 0, 0, 0, 0, 0, 0, 0], [0, 0, 0, 0, 0, 0, 0, 0], [0, 0, 0, 0, 0, 0, 8, 0], [0, 0, 0, 0, 0, 0, 0, 0], [0, 0, 0, 0, 0, 0, 0, 0], [0, 0, 0, 0, 0, 0, 0, 0], [0, 0, 0, 0, 0, 0, 0, ... | [{"input": [[0, 0, 0, 0, 0, 0, 0, 0, 0], [0, 0, 0, 0, 0, 0, 0, 0, 0], [0, 0, 0, 0, 0, 0, 0, 0, 0], [0, 0, 0, 0, 0, 0, 0, 0, 0], [0, 0, 0, 0, 0, 0, 0, 0, 0], [0, 0, 6, 0, 0, 0, 0, 0, 0], [0, 0, 0, 0, 0, 0, 0, 0, 0], [0, 0, 0, 0, 0, 0, 0, 0, 0], [0, 0, 0, 0, 0, 0, 0, 0, 0]], "output": [[0, 0, 0, 0, 0, 0, 0, 0, 0], [0, 0,... | barc_heavy | You will be given some number of paired example inputs and outputs grids. The outputs were produced by applying a transformation rule to the input grids. In addition to the paired example inputs and outputs, there is also one test input without a known output. The inputs and outputs are each “grids”. A grid is a rectan... | ```
0 0 0 0 0 0 0 0 0
0 0 0 0 0 0 0 0 0
0 0 6 0 0 0 0 0 0
6 6 6 6 6 0 0 0 0
6 6 6 6 6 0 0 0 0
6 6 6 6 6 6 0 0 0
6 6 6 6 6 0 0 0 0
6 6 6 6 6 0 0 0 0
0 0 6 0 0 0 0 0 0
``` | 1,592 |
<|im_start|>user
# ARC HINT GENERATOR
## Role & Goal
You are an expert ARC (Abstraction and Reasoning Corpus) analyst. Your task is to generate a concise, actionable hint for a user who is struggling with an ARC problem. Analyze the problem and its correct solution to produce a single standalone, targeted hint that he... | 4,185 | [
"<note1>\n<description>Look first for the dominant background color and a distinct object color that forms a contiguous block or a line. The transformation targets that object (the non-background connected region), not the background. Identifying which color is the \"object\" is the key first step.</description>\n<... | [{"input": [[6, 6, 6, 6, 6, 6, 6, 6, 6, 6], [6, 6, 6, 6, 6, 6, 4, 6, 4, 6], [4, 6, 6, 6, 6, 6, 0, 6, 0, 6], [0, 6, 6, 6, 6, 6, 0, 6, 0, 6], [0, 6, 6, 6, 6, 6, 0, 6, 0, 6], [0, 0, 0, 0, 0, 0, 0, 0, 0, 0]], "output": [[6, 6, 6, 6, 6, 6, 6, 6, 6, 6], [6, 6, 6, 6, 6, 6, 6, 6, 6, 6], [6, 6, 6, 6, 6, 6, 0, 6, 0, 6], [0, 6, 6... | [{"input": [[4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4], [4, 5, 5, 5, 5, 5, 5, 4, 5, 5, 5, 5, 5, 5, 5, 5, 5], [4, 5, 5, 5, 5, 5, 5, 4, 5, 5, 5, 5, 5, 5, 5, 5, 5], [4, 5, 5, 5, 5, 5, 5, 4, 5, 5, 5, 5, 5, 5, 5, 5, 5], [4, 5, 5, 5, 5, 5, 5, 4, 5, 5, 5, 5, 5, 5, 5, 5, 5], [4, 5, 5, 5, 5, 5, 5, 4, 5, 5, 5, 5, 5, 5, ... | rearc | You will be given some number of paired example inputs and outputs grids. The outputs were produced by applying a transformation rule to the input grids. In addition to the paired example inputs and outputs, there is also one test input without a known output. The inputs and outputs are each “grids”. A grid is a rectan... | ```
7 4 4 4 4 4 4 7 4 4 4 4 4 4 4 4 4
4 5 5 5 5 5 5 4 5 5 5 5 5 5 5 5 5
4 5 5 5 5 5 5 4 5 5 5 5 5 5 5 5 5
4 5 5 5 5 5 5 4 5 5 5 5 5 5 5 5 5
4 5 5 5 5 5 5 4 5 5 5 5 5 5 5 5 5
4 5 5 5 5 5 5 4 5 5 5 5 5 5 5 5 5
4 5 5 5 5 5 5 4 5 5 5 5 5 5 5 5 5
4 5 5 5 5 5 5 5 5 5 5 5 5 5 5 5 5
5 5 5 5 5 5 5 5 5 5 5 5 5 5 5 5 5
5 5 5 5 5 ... | 3,692 |
<|im_start|>user
# ARC HINT GENERATOR
## Role & Goal
You are an expert ARC (Abstraction and Reasoning Corpus) analyst. Your task is to generate a concise, actionable hint for a user who is struggling with an ARC problem. Analyze the problem and its correct solution to produce a single standalone, targeted hint that he... | 2,159 | [
"<note1>\n<description>Look for row/column symmetry: many ARC tasks mirror the whole grid across a horizontal and/or vertical axis. If the output looks like the input has been reflected or tiled, the transformation is a global symmetry rather than many small local edits.</description>\n<example>Imagine a 6×6 input ... | [{"input": [[0, 6, 0, 0, 0, 0, 0, 5, 0, 0], [0, 0, 0, 7, 0, 0, 7, 1, 0, 4], [0, 0, 0, 7, 0, 0, 8, 0, 0, 0], [0, 7, 4, 0, 7, 0, 6, 0, 0, 8], [0, 0, 0, 0, 0, 6, 0, 0, 0, 0], [0, 0, 0, 2, 0, 0, 0, 8, 7, 0], [7, 0, 0, 5, 0, 0, 4, 0, 0, 0], [8, 0, 0, 0, 1, 0, 0, 0, 6, 0], [0, 7, 0, 9, 0, 0, 0, 7, 4, 2], [6, 0, 6, 2, 0, 0, 0... | [{"input": [[0, 5, 0, 0, 0, 0, 5, 5, 0, 0], [7, 0, 8, 0, 0, 0, 0, 0, 1, 0], [0, 0, 0, 0, 0, 0, 3, 0, 3, 0], [0, 8, 0, 0, 0, 0, 9, 0, 0, 1], [0, 4, 0, 0, 1, 0, 0, 0, 0, 7], [0, 0, 0, 0, 2, 0, 0, 0, 9, 0], [7, 0, 4, 5, 0, 0, 0, 0, 0, 0], [0, 0, 2, 6, 0, 0, 0, 6, 8, 1], [5, 0, 0, 0, 0, 0, 0, 2, 0, 0], [3, 5, 0, 6, 0, 0, 0... | barc_heavy | You will be given some number of paired example inputs and outputs grids. The outputs were produced by applying a transformation rule to the input grids. In addition to the paired example inputs and outputs, there is also one test input without a known output. The inputs and outputs are each “grids”. A grid is a rectan... | ```
3 5 0 6 0 0 5 3 0 0
5 0 8 0 0 0 0 2 1 0
0 0 2 6 0 0 3 6 8 1
7 8 4 5 0 0 9 0 0 1
0 4 0 0 2 0 0 0 9 7
0 4 0 0 1 0 0 0 9 7
7 8 4 5 0 0 9 0 0 1
0 0 2 6 0 0 3 6 3 1
7 0 8 0 0 0 0 2 1 0
3 5 0 6 0 0 5 5 0 0
``` | 1,666 |
<|im_start|>user
# ARC HINT GENERATOR
## Role & Goal
You are an expert ARC (Abstraction and Reasoning Corpus) analyst. Your task is to generate a concise, actionable hint for a user who is struggling with an ARC problem. Analyze the problem and its correct solution to produce a single standalone, targeted hint that he... | 3,331 | [
"<note1>\n<description>First isolate the area that actually changes: find the background color (the one that fills most of the grid) and draw the smallest rectangle that contains every cell that is not that background. This bounding box is the region the transformation acts on and everything outside it stays the sa... | [{"input": [[7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7], [7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7], [7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7], [7, 7, 3, 5, 7, 7, 9, 7, 8, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7], [7, 7, 3, 5, 7, 7, 9, 7, 8, 7, 7, 7,... | [{"input": [[6, 6, 6, 6, 6, 5, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6], [6, 9, 6, 6, 6, 5, 6, 6, 2, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6], [6, 9, 6, 6, 6, 5, 6, 6, 2, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6], [6, 9, 6, 6, 6, 5, 6, 6, 2, 6, 6, 6, 0, 6, 6, 6, 6, 6, 6], [6, 9, 6, 6, 6, 5, 6, 6, 2, 6, 6, 6, 0, 6, 6, 6, 6, 6, 6], [6, 9, 6, 5, ... | rearc | You will be given some number of paired example inputs and outputs grids. The outputs were produced by applying a transformation rule to the input grids. In addition to the paired example inputs and outputs, there is also one test input without a known output. The inputs and outputs are each “grids”. A grid is a rectan... | ```
6 6 6 6 6 1 6 6 6 6 6 6 6 6 6 6 6 6 6
6 2 6 6 6 1 6 6 2 6 6 6 6 6 6 6 6 6 6
6 2 6 6 6 1 6 6 2 6 6 6 6 6 6 6 6 6 6
6 2 6 6 6 1 6 6 2 6 6 6 3 6 6 6 6 6 6
6 2 6 6 6 1 6 6 2 6 6 6 3 6 6 6 6 6 6
6 2 6 4 6 1 6 6 2 6 6 6 3 6 6 6 6 6 6
``` | 2,838 |
<|im_start|>user
# ARC HINT GENERATOR
## Role & Goal
You are an expert ARC (Abstraction and Reasoning Corpus) analyst. Your task is to generate a concise, actionable hint for a user who is struggling with an ARC problem. Analyze the problem and its correct solution to produce a single standalone, targeted hint that he... | 2,159 | [
"<note1>\n<description>Look for the few non-background pixels that are isolated and sit at corners or edges; these are usually the \"seeds\" that determine the transformation. When most of the grid is background, those seed pixels are the only information you need to propagate. Identifying them first reduces the pr... | [{"input": [[5, 0, 0, 0, 0, 0, 0, 0, 0, 1], [0, 0, 0, 0, 0, 0, 0, 0, 0, 0], [0, 0, 0, 0, 0, 0, 0, 0, 0, 0], [0, 0, 0, 0, 0, 0, 0, 0, 0, 0], [0, 0, 0, 0, 0, 0, 0, 0, 0, 0], [0, 0, 0, 0, 0, 0, 0, 0, 0, 0], [0, 0, 0, 0, 0, 0, 0, 0, 0, 0], [0, 0, 0, 0, 0, 0, 0, 0, 0, 0], [0, 0, 0, 0, 0, 0, 0, 0, 0, 0], [3, 0, 0, 0, 0, 0, 0... | [{"input": [[4, 0, 0, 0, 0, 0, 0, 0, 0, 3], [0, 0, 0, 0, 0, 0, 0, 0, 0, 0], [0, 0, 0, 0, 0, 0, 0, 0, 0, 0], [0, 0, 0, 0, 0, 0, 0, 0, 0, 0], [0, 0, 0, 0, 0, 0, 0, 0, 0, 0], [0, 0, 0, 0, 0, 0, 0, 0, 0, 0], [0, 0, 0, 0, 0, 0, 0, 0, 0, 0], [0, 0, 0, 0, 0, 0, 0, 0, 0, 0], [0, 0, 0, 0, 0, 0, 0, 0, 0, 0], [1, 0, 0, 0, 0, 0, 0... | barc_heavy | You will be given some number of paired example inputs and outputs grids. The outputs were produced by applying a transformation rule to the input grids. In addition to the paired example inputs and outputs, there is also one test input without a known output. The inputs and outputs are each “grids”. A grid is a rectan... | ```
1 3 3 3 3 3 3 3 3 2
1 0 0 0 0 0 0 0 0 2
1 0 0 0 0 0 0 0 0 2
1 0 0 0 0 0 0 0 0 2
1 0 0 0 0 0 0 0 0 2
1 0 0 0 0 0 0 0 0 2
1 0 0 0 0 0 0 0 0 2
1 0 0 0 0 0 0 0 0 2
1 0 0 0 0 0 0 0 0 2
2 2 2 2 2 2 2 2 2 2
``` | 1,666 |
<|im_start|>user
# ARC HINT GENERATOR
## Role & Goal
You are an expert ARC (Abstraction and Reasoning Corpus) analyst. Your task is to generate a concise, actionable hint for a user who is struggling with an ARC problem. Analyze the problem and its correct solution to produce a single standalone, targeted hint that he... | 1,917 | [
"<note1>\n<description>Look for a continuous row and a continuous column made of the same color; these two lines form a cross that cleanly partitions the grid into four rectangular blocks. This cross is a reliable structural cue because it is visually and numerically distinct from the surrounding colors.</descripti... | [{"input": [[0, 0, 0, 1, 3, 3, 0], [0, 0, 0, 1, 3, 3, 3], [0, 0, 0, 1, 3, 3, 3], [5, 0, 0, 1, 3, 3, 3], [0, 0, 0, 1, 3, 3, 3], [0, 0, 0, 1, 0, 0, 3], [1, 1, 1, 1, 1, 1, 1], [8, 0, 8, 1, 0, 0, 0], [8, 8, 8, 1, 4, 0, 4], [8, 8, 8, 1, 0, 0, 0], [8, 8, 8, 1, 0, 4, 0], [8, 8, 8, 1, 0, 4, 4], [8, 8, 8, 1, 4, 0, 0]], "output"... | [{"input": [[6, 6, 0, 6, 5, 6, 6, 6, 8], [0, 0, 6, 6, 5, 8, 6, 8, 8], [6, 0, 6, 6, 5, 6, 6, 8, 8], [6, 6, 6, 6, 5, 8, 8, 8, 8], [5, 5, 5, 5, 5, 5, 5, 5, 5], [6, 6, 6, 6, 5, 6, 6, 6, 6], [6, 6, 6, 6, 5, 6, 6, 6, 6], [6, 6, 6, 6, 5, 9, 6, 6, 6], [7, 6, 6, 6, 5, 6, 6, 6, 6]], "output": [[6, 6, 0, 8], [0, 0, 8, 8], [9, 0, ... | rearc | You will be given some number of paired example inputs and outputs grids. The outputs were produced by applying a transformation rule to the input grids. In addition to the paired example inputs and outputs, there is also one test input without a known output. The inputs and outputs are each “grids”. A grid is a rectan... | ```
6 6 0 8
0 0 8 8
9 0 8 8
8 8 8 8
``` | 1,424 |
<|im_start|>user
# ARC HINT GENERATOR
## Role & Goal
You are an expert ARC (Abstraction and Reasoning Corpus) analyst. Your task is to generate a concise, actionable hint for a user who is struggling with an ARC problem. Analyze the problem and its correct solution to produce a single standalone, targeted hint that he... | 3,185 | [
"<note1>\n<description>Look for a single, compact, fully filled square (a \"tile\") of one color that stands out from other shapes. This tile is the motif the task uses; it will have no holes and its width equals its height. Identifying that tile is the first key step because everything else is derived from its sha... | [{"input": [[3, 3, 0, 0, 1, 1, 0, 0, 0, 0, 3], [3, 3, 0, 0, 1, 1, 0, 0, 3, 0, 0], [0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0], [0, 0, 0, 0, 0, 0, 0, 1, 1, 0, 0], [0, 0, 3, 3, 0, 0, 0, 1, 1, 0, 0], [0, 0, 3, 3, 0, 0, 0, 0, 0, 0, 0], [0, 0, 0, 0, 0, 0, 0, 3, 3, 0, 0], [0, 0, 0, 0, 0, 0, 0, 3, 3, 0, 0], [0, 0, 0, 0, 0, 1, 0, 0, 0, ... | [{"input": [[3, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0], [0, 0, 0, 0, 0, 3, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 3, 3], [0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 3, 3], [0, 0, 0, 0, 0, 0, 0, 0, 0, 2, 0, 0, 0, 0, 1, 0, 0, 0, 0], [0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 1, 0], [0, 0, 0, 0, ... | barc_heavy | You will be given some number of paired example inputs and outputs grids. The outputs were produced by applying a transformation rule to the input grids. In addition to the paired example inputs and outputs, there is also one test input without a known output. The inputs and outputs are each “grids”. A grid is a rectan... | ```
3 3 3 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0
3 3 3 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0
3 3 3 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0
0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0
0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0
0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0
0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0
0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0
0 0 0 0 0 0 ... | 2,692 |
<|im_start|>user
# ARC HINT GENERATOR
## Role & Goal
You are an expert ARC (Abstraction and Reasoning Corpus) analyst. Your task is to generate a concise, actionable hint for a user who is struggling with an ARC problem. Analyze the problem and its correct solution to produce a single standalone, targeted hint that he... | 1,893 | [
"<note1>\n<description>Find the anchor pixels: the transformation is driven by the non-background pixels. There are two anchor colors to pay attention to: the one that appears as isolated pixels in the input (the seed) and the one that appears as a short vertical block in the output (the connector).</description>\n... | [{"input": [[0, 0, 0, 0, 0, 0, 0, 0, 0], [0, 0, 0, 0, 0, 0, 0, 0, 0], [0, 0, 0, 0, 0, 0, 0, 0, 0], [0, 0, 0, 0, 0, 0, 0, 4, 0], [0, 0, 0, 0, 0, 0, 0, 0, 0], [0, 0, 0, 0, 0, 0, 0, 0, 0], [0, 0, 0, 0, 0, 4, 0, 0, 0], [0, 0, 0, 0, 0, 0, 0, 0, 0], [0, 0, 0, 0, 0, 0, 0, 0, 0]], "output": [[0, 0, 0, 0, 0, 0, 0, 4, 0], [0, 0,... | [{"input": [[0, 0, 0, 0, 0, 0, 0, 0, 0], [0, 0, 0, 0, 0, 0, 0, 0, 0], [0, 0, 0, 0, 0, 4, 0, 0, 0], [0, 0, 0, 0, 0, 0, 0, 0, 0], [0, 0, 0, 0, 4, 0, 0, 0, 0], [0, 0, 0, 0, 0, 0, 0, 0, 0], [0, 0, 0, 0, 0, 0, 0, 0, 0], [0, 0, 0, 0, 0, 0, 0, 0, 0], [0, 0, 0, 0, 0, 0, 0, 0, 0]], "output": [[0, 0, 0, 0, 0, 4, 0, 0, 0], [0, 0,... | barc_heavy | You will be given some number of paired example inputs and outputs grids. The outputs were produced by applying a transformation rule to the input grids. In addition to the paired example inputs and outputs, there is also one test input without a known output. The inputs and outputs are each “grids”. A grid is a rectan... | ```
0 0 0 0 0 4 0 0 0
0 0 0 0 0 1 0 0 0
4 4 4 4 1 1 1 4 4
0 0 0 0 0 1 0 0 0
0 0 0 0 4 4 0 0 0
0 0 0 0 0 4 0 0 0
0 0 0 0 0 4 0 0 0
0 0 0 0 0 4 0 0 0
0 0 0 0 0 4 0 0 0
``` | 1,400 |
<|im_start|>user
# ARC HINT GENERATOR
## Role & Goal
You are an expert ARC (Abstraction and Reasoning Corpus) analyst. Your task is to generate a concise, actionable hint for a user who is struggling with an ARC problem. Analyze the problem and its correct solution to produce a single standalone, targeted hint that he... | 3,679 | [
"<note1>\n<description>Look first for a single color that forms a continuous frame or a clear rectangular outline; that color usually stays the same between input and output and defines the working region. Treat that color as the background and ignore it when deciding what to change.</description>\n<example>Imagine... | [{"input": [[6, 4, 4, 4, 4, 4, 4, 4, 4, 4, 0, 0, 0, 0, 0, 0, 4], [6, 4, 4, 4, 4, 4, 4, 4, 4, 0, 0, 0, 0, 0, 0, 4, 0], [6, 4, 4, 4, 4, 4, 4, 4, 4, 0, 0, 0, 0, 0, 4, 0, 0], [6, 4, 4, 4, 4, 4, 4, 4, 0, 0, 0, 0, 0, 4, 0, 0, 0], [6, 4, 4, 4, 4, 4, 4, 4, 0, 0, 0, 9, 9, 9, 9, 0, 0], [6, 4, 4, 4, 4, 4, 4, 9, 9, 9, 9, 9, 0, 9, ... | [{"input": [[0, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3], [3, 0, 1, 0, 0, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3], [3, 1, 0, 1, 1, 0, 0, 0, 0, 3, 3, 3, 3, 3, 3, 3], [3, 8, 1, 0, 1, 1, 1, 0, 0, 0, 0, 0, 0, 3, 3, 3], [3, 8, 8, 8, 0, 1, 1, 1, 1, 0, 8, 0, 0, 0, 0, 0], [3, 8, 8, 8, 1, 0, 1, 1, 8, 8, 8, 0, 0, 0, 0, 0], [3, 8, 8... | rearc | You will be given some number of paired example inputs and outputs grids. The outputs were produced by applying a transformation rule to the input grids. In addition to the paired example inputs and outputs, there is also one test input without a known output. The inputs and outputs are each “grids”. A grid is a rectan... | ```
0 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3
3 0 1 0 0 3 3 3 3 3 3 3 3 3 3 3
3 1 0 1 1 0 0 0 0 3 3 3 3 3 3 3
3 0 1 0 1 1 1 0 0 0 0 0 0 3 3 3
3 0 1 1 0 1 1 1 1 0 0 0 0 0 0 0
3 3 0 1 1 0 1 1 1 1 1 0 0 0 0 0
3 3 0 1 1 1 0 1 1 1 1 1 1 0 0 0
3 3 0 0 1 1 1 0 1 1 1 1 1 1 1 0
3 3 0 0 1 1 1 1 0 1 1 1 1 1 1 1
3 3 3 0 0 1 1 1 1 0 1 1 1 1 ... | 3,186 |
<|im_start|>user
# ARC HINT GENERATOR
## Role & Goal
You are an expert ARC (Abstraction and Reasoning Corpus) analyst. Your task is to generate a concise, actionable hint for a user who is struggling with an ARC problem. Analyze the problem and its correct solution to produce a single standalone, targeted hint that he... | 1,445 | [
"<note1>\n<description>Look for a single pixel that is isolated from other colored pixels (often on an edge or corner). Such a lone pixel frequently serves as a marker or \"source\" color in these tasks.</description>\n<example>Imagine a grid where every non-background pixel is part of a big shape except one single... | [{"input": [[8, 0, 0, 0, 0, 0, 0], [0, 4, 4, 4, 0, 0, 0], [0, 4, 4, 4, 4, 0, 0], [0, 4, 4, 4, 4, 4, 0], [0, 0, 4, 4, 4, 4, 0], [0, 0, 0, 4, 4, 4, 0], [0, 0, 0, 0, 0, 0, 0]], "output": [[0, 0, 0, 0, 0, 0, 0], [0, 8, 8, 8, 0, 0, 0], [0, 8, 8, 8, 8, 0, 0], [0, 8, 8, 8, 8, 8, 0], [0, 0, 8, 8, 8, 8, 0], [0, 0, 0, 8, 8, 8, 0... | [{"input": [[5, 0, 0, 0, 0, 0, 0], [0, 0, 6, 6, 0, 0, 0], [0, 0, 6, 6, 6, 6, 0], [0, 6, 6, 6, 6, 6, 0], [0, 6, 6, 6, 6, 0, 0], [0, 0, 0, 6, 6, 0, 0], [0, 0, 0, 0, 0, 0, 0]], "output": [[0, 0, 0, 0, 0, 0, 0], [0, 0, 5, 5, 0, 0, 0], [0, 0, 5, 5, 5, 5, 0], [0, 5, 5, 5, 5, 5, 0], [0, 5, 5, 5, 5, 0, 0], [0, 0, 0, 5, 5, 0, 0... | barc_heavy | You will be given some number of paired example inputs and outputs grids. The outputs were produced by applying a transformation rule to the input grids. In addition to the paired example inputs and outputs, there is also one test input without a known output. The inputs and outputs are each “grids”. A grid is a rectan... | ```
0 0 0 0 0 0 0
0 0 5 5 0 0 0
0 0 5 5 5 5 0
0 5 5 5 5 5 0
0 5 5 5 5 0 0
0 0 0 5 5 0 0
0 0 0 0 0 0 0
``` | 952 |
<|im_start|>user
# ARC HINT GENERATOR
## Role & Goal
You are an expert ARC (Abstraction and Reasoning Corpus) analyst. Your task is to generate a concise, actionable hint for a user who is struggling with an ARC problem. Analyze the problem and its correct solution to produce a single standalone, targeted hint that he... | 1,625 | [
"<note1>\n<description>Look first for a continuous single-color border (a frame) that surrounds the interior. Such a frame is often the structural anchor of the transformation because it appears on every outer row and column and is visually distinct from interior patterns.</description>\n<example>Imagine a 7×7 grid... | [{"input": [[9, 9, 9, 9, 9, 9, 9, 9], [9, 0, 6, 6, 6, 0, 0, 9], [9, 6, 6, 6, 6, 6, 0, 9], [9, 6, 6, 6, 6, 6, 6, 9], [9, 6, 6, 6, 6, 6, 6, 9], [9, 0, 6, 6, 6, 6, 6, 9], [9, 0, 0, 6, 6, 6, 6, 9], [9, 9, 9, 9, 9, 9, 9, 9]], "output": [[9, 9, 9, 9, 9, 9, 9, 9], [9, 9, 9, 9, 9, 9, 9, 9], [9, 9, 9, 9, 9, 9, 9, 9], [9, 9, 9, ... | [{"input": [[5, 5, 5, 5, 5, 5, 5, 5, 5], [5, 0, 0, 6, 6, 0, 0, 0, 5], [5, 0, 6, 6, 6, 0, 6, 0, 5], [5, 0, 0, 6, 6, 6, 6, 6, 5], [5, 6, 6, 6, 6, 6, 6, 6, 5], [5, 6, 6, 6, 6, 6, 0, 0, 5], [5, 0, 6, 0, 6, 6, 6, 0, 5], [5, 0, 0, 0, 6, 6, 0, 0, 5], [5, 5, 5, 5, 5, 5, 5, 5, 5]], "output": [[5, 5, 5, 5, 5, 5, 5, 5, 5], [5, 5,... | barc_heavy | You will be given some number of paired example inputs and outputs grids. The outputs were produced by applying a transformation rule to the input grids. In addition to the paired example inputs and outputs, there is also one test input without a known output. The inputs and outputs are each “grids”. A grid is a rectan... | ```
5 5 5 5 5 5 5 5 5
5 5 5 5 5 5 5 5 5
5 5 5 5 5 5 5 5 5
5 5 5 5 5 5 5 5 5
5 5 5 5 5 5 5 5 5
5 5 5 5 5 5 5 5 5
5 5 5 5 5 5 5 5 5
5 5 5 5 5 5 5 5 5
5 5 5 5 5 5 5 5 5
``` | 1,132 |
<|im_start|>user
# ARC HINT GENERATOR
## Role & Goal
You are an expert ARC (Abstraction and Reasoning Corpus) analyst. Your task is to generate a concise, actionable hint for a user who is struggling with an ARC problem. Analyze the problem and its correct solution to produce a single standalone, targeted hint that he... | 3,349 | [
"<note1>\n<description>Look for a full-length row or column made entirely of one color; that uninterrupted line is a divider and splits the grid into independent regions. Such a divider is usually unique and spans the whole width (if a row) or whole height (if a column).</description>\n<example>Imagine a 7×7 grid w... | [{"input": [[1, 1, 1, 1, 1, 8, 1, 4, 1, 3, 1], [1, 1, 1, 1, 1, 8, 1, 1, 1, 1, 3], [1, 1, 1, 1, 1, 8, 1, 3, 1, 1, 4], [8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8], [1, 1, 1, 1, 1, 8, 1, 1, 1, 1, 1], [1, 1, 1, 1, 1, 8, 1, 1, 1, 1, 1], [1, 1, 1, 1, 1, 8, 1, 1, 1, 1, 1]], "output": [[1, 4, 1, 3, 1, 8, 1, 4, 1, 3, 1], [1, 1, 1, 1, 3, ... | [{"input": [[5, 5, 5, 5, 1, 5, 5, 5, 5], [5, 5, 5, 5, 1, 5, 5, 5, 5], [5, 5, 5, 5, 1, 5, 5, 5, 5], [6, 5, 5, 5, 1, 5, 5, 5, 5], [1, 1, 1, 1, 1, 1, 1, 1, 1], [5, 5, 5, 5, 1, 5, 5, 5, 5], [5, 5, 5, 5, 1, 5, 5, 5, 5], [5, 5, 5, 5, 1, 5, 5, 5, 5], [5, 5, 5, 5, 1, 5, 5, 5, 5]], "output": [[5, 5, 5, 5, 1, 5, 5, 5, 5], [5, 5,... | rearc | You will be given some number of paired example inputs and outputs grids. The outputs were produced by applying a transformation rule to the input grids. In addition to the paired example inputs and outputs, there is also one test input without a known output. The inputs and outputs are each “grids”. A grid is a rectan... | ```
5 5 5 5 1 5 5 5 5
5 5 5 5 1 5 5 5 5
5 5 5 5 1 5 5 5 5
6 5 5 5 1 6 5 5 5
1 1 1 1 1 1 1 1 1
5 5 5 5 1 5 5 5 5
5 5 5 5 1 5 5 5 5
5 5 5 5 1 5 5 5 5
6 5 5 5 1 6 5 5 5
``` | 2,856 |
<|im_start|>user
# ARC HINT GENERATOR
## Role & Goal
You are an expert ARC (Abstraction and Reasoning Corpus) analyst. Your task is to generate a concise, actionable hint for a user who is struggling with an ARC problem. Analyze the problem and its correct solution to produce a single standalone, targeted hint that he... | 3,331 | [
"<note1>\n<description>Look for a single color that appears as isolated single pixels scattered across the grid; this color is the \"seed\" for the transformation. When one color is rare and appears as isolated dots while another color fills most of the grid, those rare dots are the anchors for the change.</descrip... | [{"input": [[7, 0, 0, 7, 0, 0, 0, 7, 7, 0, 0], [0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0], [0, 0, 0, 0, 7, 0, 0, 0, 0, 0, 0], [0, 0, 7, 0, 0, 0, 0, 0, 7, 7, 0]], "output": [[7, 0, 0, 7, 0, 0, 3, 7, 7, 3, 0], [0, 0, 0, 0, 0, 0, 3, 3, 3, 3, 0], [0, 0, 0, 0, 7, 0, 0, 3, 3, 3, 3], [0, 0, 7, 0, 0, 0, 0, 3, 7, 7, 3]]}, {"input": [[1,... | [{"input": [[0, 6, 6, 6, 6, 6, 6, 6, 6, 0, 6], [6, 6, 6, 6, 0, 6, 6, 6, 6, 6, 6], [6, 6, 6, 6, 6, 6, 6, 6, 0, 6, 6], [6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6], [6, 6, 6, 0, 6, 6, 6, 6, 6, 6, 6], [6, 0, 6, 6, 6, 6, 6, 6, 6, 6, 6], [6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6], [6, 6, 6, 6, 6, 0, 6, 6, 6, 0, 6], [6, 6, 6, 6, 6, 6, 6, 6, 6, ... | rearc | You will be given some number of paired example inputs and outputs grids. The outputs were produced by applying a transformation rule to the input grids. In addition to the paired example inputs and outputs, there is also one test input without a known output. The inputs and outputs are each “grids”. A grid is a rectan... | ```
0 6 6 6 6 6 6 6 6 0 6
6 6 6 6 0 6 6 6 6 6 6
6 6 6 6 6 6 6 6 0 6 6
6 6 6 6 6 6 6 6 6 6 6
6 6 6 0 6 6 6 6 6 6 6
6 0 6 6 6 6 6 6 6 6 6
6 6 6 6 6 6 6 6 6 6 6
6 6 6 6 6 0 6 6 6 0 6
6 6 6 6 6 6 6 6 6 6 6
6 6 6 6 6 6 6 0 6 6 6
6 6 0 6 6 6 6 6 6 6 0
6 6 6 6 6 6 6 6 0 6 6
6 0 6 6 6 6 6 6 6 6 6
6 6 6 6 6 6 6 6 6 6 6
6 3 3 3 ... | 2,838 |
<|im_start|>user
# ARC HINT GENERATOR
## Role & Goal
You are an expert ARC (Abstraction and Reasoning Corpus) analyst. Your task is to generate a concise, actionable hint for a user who is struggling with an ARC problem. Analyze the problem and its correct solution to produce a single standalone, targeted hint that he... | 3,863 | [
"<note1>\n<description>Locate the single non-background object and compute its bounding box (min/max row and column). The bounding box gives the object's width and height and the coordinates you will use to place the new shape.</description>\n<example>Imagine a small solid block of color X occupying rows 4–6 and co... | [{"input": [[0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0], [0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0], [0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0], [0, 0, 0, 0, 0, 0, 0, 0, 0, 6, 6, 6, 6, 0, 0, 0, 0], [0, 0, 0, 0, 0, 0, 0, 0, 0, 6, 6, 6, 6, 0, 0, 0, 0], [0, 0, 0, 0, 0, 0, 0, 0, 0, 6, 6, 6, 6, 0, ... | [{"input": [[0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0], [0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0], [0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0], [0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0], [0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0], [0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0], [0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0], [0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0], [0, ... | barc_heavy | You will be given some number of paired example inputs and outputs grids. The outputs were produced by applying a transformation rule to the input grids. In addition to the paired example inputs and outputs, there is also one test input without a known output. The inputs and outputs are each “grids”. A grid is a rectan... | ```
0 0 0 0 0 0 0 0 0 0 0 0
0 0 0 0 0 0 0 0 0 0 0 0
0 0 0 0 0 0 0 0 0 0 0 0
0 0 0 0 0 0 0 0 0 0 0 0
0 0 0 0 0 0 0 0 0 0 0 0
0 0 0 0 0 0 0 0 0 0 0 0
6 6 6 6 0 0 0 0 0 0 0 0
6 6 6 6 0 0 0 0 0 0 0 0
6 6 6 6 0 0 0 0 0 0 0 0
6 6 6 6 0 0 0 0 0 0 0 0
6 6 6 6 0 0 0 0 0 0 0 0
6 6 6 6 0 0 0 0 0 0 0 0
0 0 0 0 0 0 0 0 0 0 0 0
0 0 ... | 3,370 |
<|im_start|>user
# ARC HINT GENERATOR
## Role & Goal
You are an expert ARC (Abstraction and Reasoning Corpus) analyst. Your task is to generate a concise, actionable hint for a user who is struggling with an ARC problem. Analyze the problem and its correct solution to produce a single standalone, targeted hint that he... | 3,707 | [
"<note1>\n<description>Look for vertical pillars: contiguous vertical runs of a non-background color that appear in the same column across many rows. These pillars are the primary objects the task transforms; treat each such run as a single object to be recolored.</description>\n<example>Imagine a grid with a unifo... | [{"input": [[6, 6, 6, 6, 6, 6, 6, 6], [6, 6, 6, 6, 6, 6, 6, 6], [6, 6, 6, 6, 6, 6, 6, 6], [6, 6, 6, 6, 6, 6, 6, 6], [6, 6, 6, 6, 6, 6, 6, 6], [6, 6, 6, 6, 6, 6, 6, 6], [6, 6, 6, 6, 6, 6, 6, 6], [6, 6, 6, 6, 6, 6, 6, 2], [6, 6, 6, 2, 6, 6, 9, 2], [6, 6, 6, 2, 6, 6, 9, 2], [6, 6, 6, 2, 6, 6, 9, 2], [6, 6, 6, 2, 6, 6, 9, ... | [{"input": [[7, 7, 7, 7, 7], [7, 7, 7, 7, 7], [7, 7, 7, 7, 7], [7, 7, 7, 6, 7], [7, 7, 7, 6, 7], [7, 5, 7, 6, 7], [7, 5, 7, 6, 7], [7, 5, 7, 6, 7], [7, 5, 7, 6, 0], [7, 5, 7, 6, 0], [7, 5, 1, 6, 0], [7, 5, 1, 6, 0]], "output": [[7, 7, 7, 7, 7], [7, 7, 7, 7, 7], [7, 7, 7, 7, 7], [7, 7, 7, 1, 7], [7, 7, 7, 1, 7], [7, 2, ... | rearc | You will be given some number of paired example inputs and outputs grids. The outputs were produced by applying a transformation rule to the input grids. In addition to the paired example inputs and outputs, there is also one test input without a known output. The inputs and outputs are each “grids”. A grid is a rectan... | ```
7 7 7 7 7
7 7 7 7 7
7 7 7 7 7
7 7 7 1 7
7 7 7 1 7
7 2 7 1 7
7 2 7 1 7
7 2 7 1 7
7 2 7 1 3
7 2 7 1 3
7 2 4 1 3
7 2 4 1 3
``` | 3,214 |
<|im_start|>user
# ARC HINT GENERATOR
## Role & Goal
You are an expert ARC (Abstraction and Reasoning Corpus) analyst. Your task is to generate a concise, actionable hint for a user who is struggling with an ARC problem. Analyze the problem and its correct solution to produce a single standalone, targeted hint that he... | 3,633 | [
"<note1>\n<description>Look for a full row or column that is uniformly one color and spans the entire grid; such a line usually serves as a deliberate divider. When present, it cleanly partitions the grid into two subgrids of equal shape and is the first structural clue to the transformation.</description>\n<exampl... | [{"input": [[4, 4, 4], [4, 4, 4], [4, 4, 4], [4, 4, 8], [4, 8, 4], [7, 7, 7], [8, 8, 1], [1, 1, 1], [8, 1, 8], [1, 1, 1], [1, 8, 1]], "output": [[3, 3, 3], [3, 3, 3], [3, 3, 3], [3, 3, 3], [3, 8, 3]]}, {"input": [[0, 7, 0, 0, 0, 0, 0, 0, 0, 7, 7, 7, 0, 5, 8, 8, 8, 0, 0, 8, 8, 8, 8, 8, 8, 8, 0], [0, 0, 0, 0, 0, 0, 0, 0,... | [{"input": [[9, 9, 8, 9, 9, 8, 9, 9, 9, 8, 8, 9, 1, 5, 5, 5, 9, 5, 9, 9, 9, 9, 9, 9, 9], [9, 9, 9, 9, 8, 9, 8, 9, 8, 9, 9, 9, 1, 9, 9, 9, 9, 5, 9, 5, 9, 9, 9, 9, 9], [9, 9, 8, 9, 9, 9, 9, 9, 9, 8, 8, 9, 1, 9, 9, 5, 5, 9, 9, 9, 9, 9, 9, 9, 9], [9, 9, 8, 8, 9, 9, 9, 9, 8, 9, 9, 9, 1, 9, 9, 9, 9, 9, 5, 9, 9, 9, 9, 9, 9], ... | rearc | You will be given some number of paired example inputs and outputs grids. The outputs were produced by applying a transformation rule to the input grids. In addition to the paired example inputs and outputs, there is also one test input without a known output. The inputs and outputs are each “grids”. A grid is a rectan... | ```
3 3 3 9 3 3 9 9 9 3 3 9
9 9 9 9 3 9 3 9 3 9 9 9
9 9 3 3 9 9 9 9 9 3 3 9
9 9 3 3 9 3 9 9 3 9 9 9
9 9 9 3 3 3 3 3 9 9 9 9
9 9 3 9 9 9 9 3 9 9 9 9
9 9 9 3 3 9 9 9 3 9 3 3
9 9 9 9 3 9 9 3 3 9 3 9
9 3 9 9 9 9 9 9 9 9 3 3
9 3 9 3 3 3 9 3 3 3 3 9
9 9 3 3 3 9 3 9 9 3 3 9
9 9 3 9 9 9 3 9 9 9 3 9
3 3 9 3 3 3 3 3 9 9 3 3
9 3 ... | 3,140 |
<|im_start|>user
# ARC HINT GENERATOR
## Role & Goal
You are an expert ARC (Abstraction and Reasoning Corpus) analyst. Your task is to generate a concise, actionable hint for a user who is struggling with an ARC problem. Analyze the problem and its correct solution to produce a single standalone, targeted hint that he... | 2,247 | [
"<note1>\n<description>Look for a single, compact square object made of exactly two colors: one color forming a continuous outer ring (the frame) and a different color filling the interior. When you see that arrangement, treat the whole square as one object (a \"square frame\") rather than as separate pixels. This ... | [{"input": [[0, 0, 0, 0, 0, 0, 0, 0, 0, 0], [0, 0, 0, 0, 0, 0, 0, 0, 0, 0], [0, 0, 0, 0, 0, 0, 0, 0, 0, 0], [0, 0, 0, 4, 4, 4, 0, 0, 0, 0], [0, 0, 0, 4, 6, 4, 0, 0, 0, 0], [0, 0, 0, 4, 4, 4, 0, 0, 0, 0], [0, 0, 0, 0, 0, 0, 0, 0, 0, 0], [0, 0, 0, 0, 0, 0, 0, 0, 0, 0], [0, 0, 0, 0, 0, 0, 0, 0, 0, 0], [0, 0, 0, 0, 0, 0, 0... | [{"input": [[0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0], [0, 8, 8, 8, 0, 0, 0, 0, 0, 0, 0, 0], [0, 8, 3, 8, 0, 0, 0, 0, 0, 0, 0, 0], [0, 8, 8, 8, 0, 0, 0, 0, 0, 0, 0, 0], [0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0], [0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0], [0, 0, 0, 0, 0, 0, 8, 8, 8, 8, 0, 0], [0, 0, 0, 0, 0, 0, 8, 3, 3, 8, 0, 0], [0, ... | arc 1 | You will be given some number of paired example inputs and outputs grids. The outputs were produced by applying a transformation rule to the input grids. In addition to the paired example inputs and outputs, there is also one test input without a known output. The inputs and outputs are each “grids”. A grid is a rectan... | ```
0 8 8 8 0 0 0 0 0 0 0 0
8 3 3 3 8 0 0 0 0 0 0 0
8 3 8 3 8 0 0 0 0 0 0 0
8 3 3 3 8 0 0 0 0 0 0 0
0 8 8 8 0 0 8 8 8 8 0 0
0 0 0 0 0 0 8 8 8 8 0 0
0 0 0 0 8 8 3 3 3 3 8 8
0 0 0 0 8 8 3 8 8 3 8 8
0 0 0 0 8 8 3 8 8 3 8 8
0 0 0 0 8 8 3 3 3 3 8 8
0 0 0 0 0 0 8 8 8 8 0 0
0 0 0 0 0 0 8 8 8 8 0 0
``` | 1,754 |
<|im_start|>user
# ARC HINT GENERATOR
## Role & Goal
You are an expert ARC (Abstraction and Reasoning Corpus) analyst. Your task is to generate a concise, actionable hint for a user who is struggling with an ARC problem. Analyze the problem and its correct solution to produce a single standalone, targeted hint that he... | 1,109 | [
"<note1>\n<description>Check whether the transformation is purely a recoloring: the same pixels stay in the same positions but their numeric labels change. If shapes and adjacency are preserved exactly, the task reduces to finding a mapping from input colors to output colors rather than moving or reshaping objects.... | [{"input": [[2, 4, 4, 3, 2], [4, 2, 3, 3, 2], [3, 3, 3, 1, 2], [2, 4, 1, 3, 3], [2, 3, 3, 1, 3]], "output": [[3, 5, 5, 1, 3], [5, 3, 1, 1, 3], [1, 1, 1, 4, 3], [3, 5, 4, 1, 1], [3, 1, 1, 4, 1]]}, {"input": [[3, 2, 3, 3, 4], [1, 4, 3, 2, 3], [2, 1, 1, 2, 1], [3, 2, 1, 2, 2], [4, 1, 4, 1, 1]], "output": [[1, 3, 1, 1, 5],... | [{"input": [[1, 1, 2, 2, 1], [2, 1, 3, 2, 4], [1, 1, 4, 3, 1], [1, 2, 1, 4, 2], [1, 2, 1, 4, 1]], "output": [[4, 4, 3, 3, 4], [3, 4, 1, 3, 5], [4, 4, 5, 1, 4], [4, 3, 4, 5, 3], [4, 3, 4, 5, 4]]}] | barc_heavy | You will be given some number of paired example inputs and outputs grids. The outputs were produced by applying a transformation rule to the input grids. In addition to the paired example inputs and outputs, there is also one test input without a known output. The inputs and outputs are each “grids”. A grid is a rectan... | ```
4 4 3 3 4
3 4 1 3 5
4 4 5 1 4
4 3 4 5 3
4 3 4 5 4
``` | 616 |
<|im_start|>user
# ARC HINT GENERATOR
## Role & Goal
You are an expert ARC (Abstraction and Reasoning Corpus) analyst. Your task is to generate a concise, actionable hint for a user who is struggling with an ARC problem. Analyze the problem and its correct solution to produce a single standalone, targeted hint that he... | 2,159 | [
"<note1>\n<description>Look for a small, local change: in every example only a single non-background pixel is removed while all other pixels remain identical. This suggests the operation is a deletion of one cell rather than a global recoloring or a shape reconstruction.</description>\n<example>Imagine a grid with ... | [{"input": [[0, 0, 0, 0, 0, 0, 0, 0, 0, 7], [0, 0, 0, 0, 0, 0, 0, 0, 0, 0], [0, 0, 0, 0, 0, 0, 0, 1, 7, 0], [0, 0, 0, 0, 0, 0, 0, 0, 0, 0], [0, 0, 0, 0, 0, 0, 9, 0, 0, 0], [0, 0, 0, 0, 8, 0, 0, 0, 0, 0], [0, 0, 7, 0, 0, 0, 3, 4, 8, 2], [0, 0, 3, 7, 6, 0, 3, 0, 0, 0], [0, 0, 0, 0, 4, 0, 0, 0, 0, 0], [0, 0, 0, 4, 0, 0, 0... | [{"input": [[0, 0, 0, 0, 0, 0, 0, 0, 0, 0], [0, 0, 0, 0, 0, 0, 0, 0, 0, 0], [0, 0, 0, 0, 0, 7, 9, 0, 0, 0], [9, 0, 5, 0, 0, 0, 0, 0, 0, 0], [0, 0, 0, 0, 0, 0, 0, 0, 0, 0], [0, 0, 0, 0, 0, 0, 0, 0, 2, 0], [0, 5, 0, 0, 0, 8, 0, 0, 0, 6], [0, 5, 0, 0, 0, 0, 0, 0, 0, 0], [0, 7, 0, 0, 0, 0, 0, 0, 0, 0], [0, 0, 0, 0, 0, 0, 0... | barc_heavy | You will be given some number of paired example inputs and outputs grids. The outputs were produced by applying a transformation rule to the input grids. In addition to the paired example inputs and outputs, there is also one test input without a known output. The inputs and outputs are each “grids”. A grid is a rectan... | ```
0 0 0 0 0 0 0 0 0 0
0 0 0 0 0 0 0 0 0 0
0 0 0 0 0 7 9 0 0 0
9 0 5 0 0 0 0 0 0 0
0 0 0 0 0 0 0 0 0 0
0 0 0 0 0 0 0 0 2 0
0 0 0 0 0 8 0 0 0 6
0 5 0 0 0 0 0 0 0 0
0 7 0 0 0 0 0 0 0 0
0 0 0 0 0 0 0 0 0 0
``` | 1,666 |
<|im_start|>user
# ARC HINT GENERATOR
## Role & Goal
You are an expert ARC (Abstraction and Reasoning Corpus) analyst. Your task is to generate a concise, actionable hint for a user who is struggling with an ARC problem. Analyze the problem and its correct solution to produce a single standalone, targeted hint that he... | 2,159 | [
"<note1>\n<description>Look for a single-color hollow rectangle (a one-pixel-thick border) that encloses a small interior. That border is the frame of reference: its bounding box and the four corner cells are the anchor points for the transformation.</description>\n<example>Imagine a 7×7 grid where color A forms a ... | [{"input": [[0, 0, 0, 0, 0, 0, 0, 0, 0, 0], [0, 0, 0, 0, 0, 0, 0, 0, 0, 0], [0, 0, 0, 8, 8, 8, 8, 0, 0, 0], [0, 0, 0, 8, 4, 3, 8, 0, 0, 0], [0, 0, 0, 8, 0, 0, 8, 0, 0, 0], [0, 0, 0, 8, 2, 6, 8, 0, 0, 0], [0, 0, 0, 8, 8, 8, 8, 0, 0, 0], [0, 0, 0, 0, 0, 0, 0, 0, 0, 0], [0, 0, 0, 0, 0, 0, 0, 0, 0, 0], [0, 0, 0, 0, 0, 0, 0... | [{"input": [[0, 0, 0, 0, 0, 0, 0, 0, 0, 0], [0, 0, 0, 0, 0, 0, 0, 0, 0, 0], [0, 0, 0, 0, 0, 0, 0, 0, 0, 0], [0, 0, 3, 3, 3, 3, 3, 3, 0, 0], [0, 0, 3, 6, 0, 0, 4, 3, 0, 0], [0, 0, 3, 0, 0, 0, 0, 3, 0, 0], [0, 0, 3, 8, 0, 0, 2, 3, 0, 0], [0, 0, 3, 3, 3, 3, 3, 3, 0, 0], [0, 0, 0, 0, 0, 0, 0, 0, 0, 0], [0, 0, 0, 0, 0, 0, 0... | arc 1 | You will be given some number of paired example inputs and outputs grids. The outputs were produced by applying a transformation rule to the input grids. In addition to the paired example inputs and outputs, there is also one test input without a known output. The inputs and outputs are each “grids”. A grid is a rectan... | ```
0 0 0 0 0 0 0 0 0 0
0 0 0 0 0 0 0 0 0 0
0 2 0 0 0 0 0 0 8 0
0 0 3 3 3 3 3 3 0 0
0 0 3 0 0 0 0 3 0 0
0 0 3 0 0 0 0 3 0 0
0 0 3 0 0 0 0 3 0 0
0 0 3 3 3 3 3 3 0 0
0 4 0 0 0 0 0 0 6 0
0 0 0 0 0 0 0 0 0 0
``` | 1,666 |
<|im_start|>user
# ARC HINT GENERATOR
## Role & Goal
You are an expert ARC (Abstraction and Reasoning Corpus) analyst. Your task is to generate a concise, actionable hint for a user who is struggling with an ARC problem. Analyze the problem and its correct solution to produce a single standalone, targeted hint that he... | 2,699 | [
"<note1>\n<description>Look for a single, simple global transform (a uniform shift, a rotation, or a reflection). If every non-background pixel in the input appears in the output at the same relative offset, the transformation is a rigid motion; that offset is the key to reconstructing the output.</description>\n<e... | [{"input": [[0, 0, 0, 0, 0, 0, 0, 0, 1, 0, 0], [0, 0, 5, 0, 5, 5, 5, 1, 1, 1, 0], [0, 0, 5, 0, 0, 9, 9, 9, 1, 3, 3], [0, 0, 5, 0, 0, 9, 6, 9, 0, 4, 4], [0, 0, 0, 0, 0, 0, 0, 0, 0, 3, 3], [0, 0, 2, 0, 0, 0, 1, 1, 1, 0, 0], [0, 0, 2, 0, 0, 0, 0, 0, 1, 1, 1], [8, 0, 1, 1, 0, 0, 0, 0, 0, 0, 0], [8, 0, 0, 0, 0, 0, 0, 0, 0, ... | [{"input": [[0, 0, 0, 0, 0, 4, 0, 0, 0, 0, 0, 0], [0, 0, 0, 0, 0, 8, 0, 0, 0, 0, 0, 0], [1, 1, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0], [8, 8, 8, 0, 0, 1, 0, 0, 0, 0, 0, 0], [0, 0, 0, 1, 1, 1, 0, 0, 0, 0, 0, 0], [0, 0, 1, 0, 1, 0, 0, 0, 0, 0, 0, 0], [0, 0, 0, 0, 1, 1, 9, 1, 0, 0, 0, 0], [0, 0, 0, 0, 0, 0, 6, 1, 0, 0, 0, 0], [0, ... | barc_heavy | You will be given some number of paired example inputs and outputs grids. The outputs were produced by applying a transformation rule to the input grids. In addition to the paired example inputs and outputs, there is also one test input without a known output. The inputs and outputs are each “grids”. A grid is a rectan... | ```
0 0 0 0 0 0 0 0 0 0 0 0
0 0 0 0 0 4 0 0 0 0 0 0
0 0 0 0 0 0 0 0 0 0 0 0
1 1 1 0 0 8 0 0 0 0 0 0
0 0 0 0 0 1 0 0 0 0 0 0
0 0 8 0 1 0 0 0 0 0 0 0
0 0 0 0 1 1 0 0 0 0 0 0
0 0 0 0 0 0 9 1 0 0 0 0
0 0 0 0 0 1 6 0 0 0 0 0
8 8 0 0 0 0 0 0 0 0 0 0
0 0 0 0 0 0 0 0 0 0 0 0
0 0 0 0 0 0 0 0 0 0 0 0
``` | 2,206 |
<|im_start|>user
# ARC HINT GENERATOR
## Role & Goal
You are an expert ARC (Abstraction and Reasoning Corpus) analyst. Your task is to generate a concise, actionable hint for a user who is struggling with an ARC problem. Analyze the problem and its correct solution to produce a single standalone, targeted hint that he... | 4,311 | [
"<note1>\n<description>Check whether the transformation is a rigid rotation. A rotation preserves the set of colors and the relative arrangement of pixels but moves rows into columns (and vice versa). If the output looks like the input \"turned\" on its side, rotation is a strong candidate.</description>\n<example>... | [{"input": [[6, 6, 6, 6, 6, 6, 6, 6, 6, 2, 6, 6, 2, 6, 2, 6, 6, 3, 6, 6, 6, 6, 6, 6, 6], [6, 2, 3, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 2, 6, 6, 6, 6, 6], [6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 2, 6, 6, 6, 6, 2, 6, 2, 6, 6, 6, 6, 6, 6, 2], [2, 6, 6, 6, 6, 6, 6, 6, 6, 6, 2, 6, 5, 0, 5, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6], ... | [{"input": [[7, 6, 7, 7, 6, 6, 6], [6, 7, 7, 6, 6, 6, 6], [6, 6, 6, 7, 7, 6, 6], [6, 7, 7, 7, 6, 7, 7], [7, 7, 6, 7, 6, 6, 6], [6, 6, 6, 7, 6, 7, 6], [6, 7, 6, 6, 7, 6, 1], [6, 6, 6, 6, 6, 6, 7], [1, 7, 6, 6, 7, 6, 6], [6, 7, 6, 1, 1, 6, 6], [6, 7, 6, 7, 6, 7, 7], [6, 6, 6, 6, 7, 6, 6], [7, 7, 7, 6, 6, 6, 7], [7, 6, 6,... | rearc | You will be given some number of paired example inputs and outputs grids. The outputs were produced by applying a transformation rule to the input grids. In addition to the paired example inputs and outputs, there is also one test input without a known output. The inputs and outputs are each “grids”. A grid is a rectan... | ```
6 6 7 7 6 6 6
6 6 7 6 6 7 6
7 6 6 6 6 6 7
7 6 6 6 7 7 7
6 6 7 6 6 6 6
7 7 6 7 6 7 6
6 6 1 1 6 7 6
6 6 7 6 6 7 1
7 6 6 6 6 6 6
1 6 7 6 6 7 6
6 7 6 7 6 6 6
6 6 6 7 6 7 7
7 7 6 7 7 7 6
6 6 7 7 6 6 6
6 6 6 6 7 7 6
6 6 6 7 7 6 7
``` | 3,818 |
<|im_start|>user
# ARC HINT GENERATOR
## Role & Goal
You are an expert ARC (Abstraction and Reasoning Corpus) analyst. Your task is to generate a concise, actionable hint for a user who is struggling with an ARC problem. Analyze the problem and its correct solution to produce a single standalone, targeted hint that he... | 4,295 | [
"<note1>\n<description>Separate background from anchors: the grid usually has one dominant color that fills most cells and one or a few rare colors that act as anchors. Identifying the dominant color (by frequency) and the rare colors (by location and count) focuses the transformation on the small set of meaningful... | [{"input": [[5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 2, 5], [5, 5, 5, 5, 2, 5, 5, 5, 5, 2, 5, 5], [5, 5, 2, 5, 5, 5, 5, 5, 5, 5, 5, 5], [5, 5, 5, 5, 5, 5, 5, 5, 5, 2, 5, 5]], "output": [[5, 5, 5, 1, 1, 1, 5, 5, 1, 1, 1, 1], [5, 1, 1, 1, 1, 1, 5, 5, 1, 1, 1, 1], [5, 1, 1, 1, 1, 1, 5, 5, 1, 1, 1, 5], [5, 1, 1, 1, 5, 5, 5, 5, 1, 1,... | [{"input": [[7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 6, 7, 7], [7, 7, 7, 7, 7, 7, 7, 7, 6, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7], [7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7], [7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 6, 7, 7, 7, 7, 7, 7, 7, 6], [7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7,... | rearc | You will be given some number of paired example inputs and outputs grids. The outputs were produced by applying a transformation rule to the input grids. In addition to the paired example inputs and outputs, there is also one test input without a known output. The inputs and outputs are each “grids”. A grid is a rectan... | ```
7 7 7 7 7 7 7 1 1 1 7 7 7 7 7 7 7 1 1 1 7
7 7 7 7 7 7 7 1 1 1 7 7 7 7 7 7 7 1 1 1 7
7 7 7 7 7 7 7 1 1 1 7 1 1 1 7 7 7 7 7 1 1
7 7 7 7 7 7 7 7 7 7 7 1 1 1 7 7 7 7 7 1 1
7 7 7 7 7 7 7 7 7 7 7 1 1 1 7 7 7 1 1 1 1
7 7 7 7 7 7 7 7 7 7 7 7 7 7 7 7 1 1 1 1 7
7 7 7 7 7 7 7 7 7 7 7 7 7 7 1 1 1 1 1 1 7
7 7 7 7 7 7 7 7 7 7 7 ... | 3,802 |
<|im_start|>user
# ARC HINT GENERATOR
## Role & Goal
You are an expert ARC (Abstraction and Reasoning Corpus) analyst. Your task is to generate a concise, actionable hint for a user who is struggling with an ARC problem. Analyze the problem and its correct solution to produce a single standalone, targeted hint that he... | 1,625 | [
"<note1>\n<description>Look for the single non-background object and treat its minimal bounding rectangle as the motif. This bounding box gives you the motif’s color and its exact height and width, which are the key parameters for the rest of the transformation.</description>\n<example>Imagine a mostly-empty grid w... | [{"input": [[0, 0, 0, 0, 0, 0, 0, 0], [0, 0, 0, 0, 0, 0, 0, 0], [0, 0, 6, 6, 6, 0, 0, 0], [0, 0, 6, 6, 6, 0, 0, 0], [0, 0, 6, 6, 6, 0, 0, 0], [0, 0, 0, 0, 0, 0, 0, 0], [0, 0, 0, 0, 0, 0, 0, 0], [0, 0, 0, 0, 0, 0, 0, 0]], "output": [[6, 6, 6, 2, 2, 6, 6, 6], [6, 6, 6, 2, 2, 6, 6, 6], [6, 6, 6, 2, 2, 6, 6, 6], [2, 2, 2, ... | [{"input": [[0, 0, 0, 0, 0, 0, 0, 0, 0], [0, 0, 0, 0, 0, 0, 0, 0, 0], [0, 0, 0, 0, 0, 0, 0, 0, 0], [0, 0, 0, 6, 6, 6, 0, 0, 0], [0, 0, 0, 6, 6, 6, 0, 0, 0], [0, 0, 0, 6, 6, 6, 0, 0, 0], [0, 0, 0, 0, 0, 0, 0, 0, 0], [0, 0, 0, 0, 0, 0, 0, 0, 0], [0, 0, 0, 0, 0, 0, 0, 0, 0]], "output": [[6, 6, 6, 2, 2, 2, 6, 6, 6], [6, 6,... | barc_heavy | You will be given some number of paired example inputs and outputs grids. The outputs were produced by applying a transformation rule to the input grids. In addition to the paired example inputs and outputs, there is also one test input without a known output. The inputs and outputs are each “grids”. A grid is a rectan... | ```
6 6 6 2 2 2 6 6 6
6 6 6 2 2 2 6 6 6
6 6 6 2 2 2 6 6 6
2 2 2 2 2 2 2 2 2
2 2 2 2 2 2 2 2 2
2 2 2 2 2 2 2 2 2
6 6 6 2 2 2 6 6 6
6 6 6 2 2 2 6 6 6
6 6 6 2 2 2 6 6 6
``` | 1,132 |
<|im_start|>user
# ARC HINT GENERATOR
## Role & Goal
You are an expert ARC (Abstraction and Reasoning Corpus) analyst. Your task is to generate a concise, actionable hint for a user who is struggling with an ARC problem. Analyze the problem and its correct solution to produce a single standalone, targeted hint that he... | 2,579 | [
"<note1>\n<description>Isolate the motif by cropping to the minimal bounding rectangle that contains all non-background pixels. This reduces the problem to a small, self-contained pattern and removes irrelevant background. The cropped rectangle is the object you will compare and transform.</description>\n<example>I... | [{"input": [[0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0], [0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0], [0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0], [0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0], [0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0], [0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, ... | [{"input": [[0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0], [0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0], [0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0], [0, 0, 0, 1, 1, 1, 1, 1, 0, 0, 0, 0, 0, 0], [0, 0, 0, 1, 2, 4, 1, 1, 0, 0, 0, 0, 0, 0], [0, 0, 0, 1, 6, 6, 4, 1, 0, 0, 0, 0, 0, 0], [0, 0, 0, 1, 6, 6, 2, 1, 0, 0, 0, 0, 0, 0], ... | barc_heavy | You will be given some number of paired example inputs and outputs grids. The outputs were produced by applying a transformation rule to the input grids. In addition to the paired example inputs and outputs, there is also one test input without a known output. The inputs and outputs are each “grids”. A grid is a rectan... | ```
2 2 2 2 2
2 2 2 2 2
2 2 2 2 2
2 2 2 2 2
2 2 2 2 2
``` | 2,086 |
<|im_start|>user
# ARC HINT GENERATOR
## Role & Goal
You are an expert ARC (Abstraction and Reasoning Corpus) analyst. Your task is to generate a concise, actionable hint for a user who is struggling with an ARC problem. Analyze the problem and its correct solution to produce a single standalone, targeted hint that he... | 3,759 | [
"<note1>\n<description>Look for whole-grid repetition: sometimes the entire grid is formed by tiling a smaller rectangle multiple times. If the grid is exactly two identical blocks placed next to each other, the meaningful unit is that single block.</description>\n<example>Imagine a 4×6 grid where rows 1–3 are iden... | [{"input": [[9, 3, 3, 3, 9, 5, 3, 3, 3, 3, 3, 3, 9, 0, 0, 8, 3, 5, 3, 3, 8, 7], [0, 9, 8, 8, 9, 3, 3, 2, 0, 3, 3, 0, 2, 3, 3, 8, 8, 3, 3, 3, 3, 3], [0, 3, 2, 3, 3, 3, 0, 3, 3, 9, 3, 3, 3, 8, 3, 0, 0, 3, 9, 3, 9, 3], [2, 9, 3, 9, 3, 3, 2, 3, 3, 3, 3, 3, 2, 3, 8, 9, 3, 0, 8, 3, 3, 3], [3, 3, 0, 2, 3, 3, 2, 3, 3, 2, 0, 0,... | [{"input": [[4, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 0, 3], [0, 3, 0, 3, 3, 3, 0, 3, 3, 3, 3, 3, 3, 3, 0, 3, 0, 3], [3, 0, 0, 4, 3, 3, 0, 3, 3, 3, 3, 3, 0, 3, 3, 3, 3, 3], [4, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 0, 3], [0, 3, 0, 3, 3, 3, 0, 3, 3, 3, 3, 3, 3, 3, 0, 3, 0, 3], [3, 0, 0, 4, 3, 3, 0, 3, 3, ... | rearc | You will be given some number of paired example inputs and outputs grids. The outputs were produced by applying a transformation rule to the input grids. In addition to the paired example inputs and outputs, there is also one test input without a known output. The inputs and outputs are each “grids”. A grid is a rectan... | ```
4 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 0 3
0 3 0 3 3 3 0 3 3 3 3 3 3 3 0 3 0 3
3 0 0 4 3 3 0 3 3 3 3 3 0 3 3 3 3 3
``` | 3,266 |
<|im_start|>user
# ARC HINT GENERATOR
## Role & Goal
You are an expert ARC (Abstraction and Reasoning Corpus) analyst. Your task is to generate a concise, actionable hint for a user who is struggling with an ARC problem. Analyze the problem and its correct solution to produce a single standalone, targeted hint that he... | 1,375 | [
"<note1>\n<description>Look for a small, identical square of one color that sits in a corner; its size (how many rows and columns it occupies) is the key measurement. That square’s side length N sets the scale of the pattern you will add inside the grid.</description>\n<example>Imagine a corner contains a 2×2 red s... | [{"input": [[6, 6, 0, 0, 0, 0, 9], [6, 6, 0, 0, 0, 0, 5], [0, 0, 0, 0, 0, 0, 8], [0, 0, 0, 0, 0, 0, 1], [0, 0, 0, 0, 0, 0, 7], [9, 5, 8, 1, 7, 6, 6]], "output": [[6, 6, 0, 0, 0, 0, 9], [6, 6, 0, 0, 0, 0, 5], [0, 0, 2, 0, 0, 0, 8], [0, 0, 0, 2, 0, 0, 1], [0, 0, 0, 0, 2, 0, 7], [9, 5, 8, 1, 7, 6, 6]]}, {"input": [[7, 7, ... | [{"input": [[6, 6, 0, 0, 0, 5], [6, 6, 0, 0, 0, 8], [0, 0, 0, 0, 0, 9], [0, 0, 0, 0, 0, 7], [0, 0, 0, 0, 0, 6], [0, 0, 0, 0, 0, 2], [5, 8, 9, 7, 6, 4]], "output": [[6, 6, 0, 0, 0, 5], [6, 6, 0, 0, 0, 8], [0, 0, 2, 0, 0, 9], [0, 0, 0, 2, 0, 7], [0, 0, 0, 0, 2, 6], [0, 0, 0, 0, 0, 2], [5, 8, 9, 7, 6, 4]]}] | barc_heavy | You will be given some number of paired example inputs and outputs grids. The outputs were produced by applying a transformation rule to the input grids. In addition to the paired example inputs and outputs, there is also one test input without a known output. The inputs and outputs are each “grids”. A grid is a rectan... | ```
6 6 0 0 0 5
6 6 0 0 0 8
0 0 2 0 0 9
0 0 0 2 0 7
0 0 0 0 2 6
0 0 0 0 0 2
5 8 9 7 6 4
``` | 882 |
<|im_start|>user
# ARC HINT GENERATOR
## Role & Goal
You are an expert ARC (Abstraction and Reasoning Corpus) analyst. Your task is to generate a concise, actionable hint for a user who is struggling with an ARC problem. Analyze the problem and its correct solution to produce a single standalone, targeted hint that he... | 2,679 | [
"<note1>\n<description>Look first for a full row or full column made of the same color — that continuous stripe is usually the divider between two regions. This stripe is easy to spot because every cell along it has the same non-background color and it spans the entire width or height.</description>\n<example>Imagi... | [{"input": [[8, 0, 8, 8, 0, 8, 0, 0, 8, 8, 8, 8, 8, 8, 8, 8, 8, 0, 8, 8, 8], [0, 0, 8, 8, 8, 0, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 0, 0, 8, 8, 8], [8, 0, 8, 8, 8, 8, 0, 8, 8, 8, 8, 0, 0, 8, 8, 8, 8, 8, 8, 8, 0], [8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 0, 8, 8, 8, 8, 8, 8, 8], [8, 0, 8, 8, 8, 8, 8, 8, 0, 8, 8, 8, 8, 8, 8, 8,... | [{"input": [[0, 0, 0, 0, 0, 0, 0, 1, 0, 1, 0], [0, 1, 1, 1, 1, 0, 0, 0, 0, 1, 1], [0, 0, 0, 0, 0, 1, 1, 1, 0, 1, 0], [0, 0, 1, 0, 1, 1, 1, 1, 0, 1, 0], [0, 1, 0, 1, 1, 1, 1, 1, 0, 0, 1], [1, 0, 0, 1, 1, 1, 0, 0, 0, 1, 0], [1, 0, 1, 0, 1, 0, 0, 0, 1, 0, 0], [5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5], [0, 0, 0, 0, 0, 0, 0, 0, 0, ... | rearc | You will be given some number of paired example inputs and outputs grids. The outputs were produced by applying a transformation rule to the input grids. In addition to the paired example inputs and outputs, there is also one test input without a known output. The inputs and outputs are each “grids”. A grid is a rectan... | ```
0 0 0 0 0 0 0 3 0 3 0
0 3 3 3 3 0 0 0 0 3 0
0 0 0 3 0 3 0 3 0 3 0
0 0 3 0 3 3 3 3 0 3 0
0 3 0 3 3 3 3 3 0 3 3
3 0 0 3 0 3 0 0 0 3 0
3 0 3 0 3 3 0 0 3 0 0
``` | 2,186 |
<|im_start|>user
# ARC HINT GENERATOR
## Role & Goal
You are an expert ARC (Abstraction and Reasoning Corpus) analyst. Your task is to generate a concise, actionable hint for a user who is struggling with an ARC problem. Analyze the problem and its correct solution to produce a single standalone, targeted hint that he... | 1,101 | [
"<note1>\n<description>Look for the \"seed\" color: a non-background color that appears in the input and is used in the outputs. When examples show a single colored pixel or a small cluster, that color is typically the one propagated into the result.</description>\n<example>Imagine a grid with one green pixel on a ... | [{"input": [[8, 0, 0, 0, 0, 0], [0, 0, 0, 0, 0, 0], [0, 0, 0, 0, 0, 0], [0, 0, 0, 0, 0, 0], [0, 0, 0, 0, 0, 0], [0, 0, 0, 0, 0, 0]], "output": [[8, 8], [8, 8]]}, {"input": [[0, 7, 0, 0, 0, 0, 0], [0, 0, 0, 0, 0, 0, 0], [0, 0, 0, 0, 0, 0, 0], [0, 0, 0, 0, 0, 0, 0], [0, 0, 0, 0, 0, 0, 0], [0, 0, 0, 0, 0, 0, 0], [0, 0, 0,... | [{"input": [[5, 5, 0, 0, 0, 0, 0], [0, 5, 0, 0, 0, 0, 0], [0, 0, 0, 0, 0, 0, 0], [0, 0, 0, 0, 0, 0, 0], [0, 0, 0, 0, 0, 0, 0], [0, 0, 0, 0, 0, 0, 0], [0, 0, 0, 0, 0, 0, 0]], "output": [[0, 0, 5, 5], [0, 0, 5, 5], [5, 5, 5, 5], [5, 5, 5, 5]]}] | barc_heavy | You will be given some number of paired example inputs and outputs grids. The outputs were produced by applying a transformation rule to the input grids. In addition to the paired example inputs and outputs, there is also one test input without a known output. The inputs and outputs are each “grids”. A grid is a rectan... | ```
0 0 5 5
0 0 5 5
5 5 5 5
5 5 5 5
``` | 608 |
<|im_start|>user
# ARC HINT GENERATOR
## Role & Goal
You are an expert ARC (Abstraction and Reasoning Corpus) analyst. Your task is to generate a concise, actionable hint for a user who is struggling with an ARC problem. Analyze the problem and its correct solution to produce a single standalone, targeted hint that he... | 1,461 | [
"<note1>\n<description>Look for full rows or full columns that are a single color; these often act as separators that split the grid into independent bands. When a whole row or whole column is identical across its length, it is usually a deliberate divider rather than part of a tile. Treat such lines as boundaries ... | [{"input": [[6, 1, 6, 6], [9, 1, 9, 9], [6, 1, 6, 6], [6, 1, 6, 6], [2, 1, 2, 2], [6, 1, 6, 6], [6, 1, 6, 6], [6, 1, 6, 6], [1, 1, 1, 1], [6, 1, 6, 6], [1, 1, 1, 1], [6, 1, 6, 6], [4, 1, 4, 4], [6, 1, 6, 6], [6, 1, 6, 6], [1, 1, 1, 1], [6, 1, 6, 6], [6, 1, 6, 6], [6, 1, 6, 6], [6, 1, 6, 6], [0, 1, 0, 0], [6, 1, 6, 6]],... | [{"input": [[3, 3, 3, 3, 2, 3, 3, 2, 3, 3], [3, 3, 3, 3, 2, 3, 3, 2, 3, 3], [2, 2, 2, 2, 2, 2, 2, 2, 2, 2], [3, 3, 3, 3, 2, 3, 3, 2, 3, 3], [5, 5, 5, 5, 2, 5, 5, 2, 5, 5], [3, 3, 3, 3, 2, 3, 3, 2, 3, 3], [3, 3, 3, 3, 2, 3, 3, 2, 3, 3], [4, 4, 4, 4, 2, 4, 4, 2, 4, 4], [3, 3, 3, 3, 2, 3, 3, 2, 3, 3]], "output": [[3, 3, 3... | rearc | You will be given some number of paired example inputs and outputs grids. The outputs were produced by applying a transformation rule to the input grids. In addition to the paired example inputs and outputs, there is also one test input without a known output. The inputs and outputs are each “grids”. A grid is a rectan... | ```
3 3 3
3 3 3
3 3 3
3 3 3
``` | 968 |
<|im_start|>user
# ARC HINT GENERATOR
## Role & Goal
You are an expert ARC (Abstraction and Reasoning Corpus) analyst. Your task is to generate a concise, actionable hint for a user who is struggling with an ARC problem. Analyze the problem and its correct solution to produce a single standalone, targeted hint that he... | 3,523 | [
"<note1>\n<description>Look for the single non-background color that is being transformed across examples; that color's pixels are the only ones whose color changes. Isolating that color first simplifies the rest of the task because you only need to reason about its components.</description>\n<example>Imagine a gri... | [{"input": [[0, 0, 0, 0, 0, 0, 0, 0, 0, 2, 2, 0, 0, 0, 0, 0, 0], [0, 0, 0, 0, 0, 0, 0, 0, 0, 2, 2, 0, 0, 0, 0, 0, 0], [0, 0, 0, 0, 0, 0, 0, 0, 0, 2, 2, 0, 0, 0, 0, 0, 0], [0, 0, 0, 2, 2, 0, 0, 0, 0, 2, 2, 0, 2, 0, 0, 2, 0], [0, 0, 2, 2, 2, 0, 0, 0, 0, 0, 0, 0, 2, 2, 2, 2, 0], [0, 0, 2, 2, 2, 0, 0, 0, 0, 0, 0, 0, 2, 2, ... | [{"input": [[0, 0, 2, 2, 0, 2, 2, 0, 0, 0, 0, 0, 0, 0], [0, 0, 2, 2, 2, 2, 2, 0, 0, 2, 2, 0, 0, 0], [0, 0, 0, 0, 0, 0, 0, 0, 0, 2, 2, 0, 0, 0], [2, 2, 0, 0, 0, 0, 0, 0, 0, 2, 2, 0, 0, 0], [2, 2, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0], [2, 2, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0], [2, 2, 0, 0, 0, 0, 0, 0, 0, 0, 2, 0, 2, 0], ... | barc_heavy | You will be given some number of paired example inputs and outputs grids. The outputs were produced by applying a transformation rule to the input grids. In addition to the paired example inputs and outputs, there is also one test input without a known output. The inputs and outputs are each “grids”. A grid is a rectan... | ```
0 0 6 6 0 6 6 0 0 0 0 0 0 0
0 0 6 6 6 6 6 0 0 4 4 0 0 0
0 0 0 0 0 0 0 0 0 4 4 0 0 0
6 6 0 0 0 0 0 0 0 4 4 0 0 0
6 6 0 0 0 0 0 0 0 0 0 0 0 0
6 6 0 0 0 0 0 0 0 0 0 0 0 0
6 6 0 0 0 0 0 0 0 0 6 0 6 0
0 0 0 0 0 0 0 0 0 6 6 6 6 6
0 0 0 0 0 0 6 6 0 0 0 0 0 0
0 0 0 0 0 0 6 6 0 0 0 0 0 0
0 6 6 0 0 0 6 6 0 0 0 0 0 0
6 6 0 0 ... | 3,030 |
<|im_start|>user
# ARC HINT GENERATOR
## Role & Goal
You are an expert ARC (Abstraction and Reasoning Corpus) analyst. Your task is to generate a concise, actionable hint for a user who is struggling with an ARC problem. Analyze the problem and its correct solution to produce a single standalone, targeted hint that he... | 2,011 | [
"<note1>\n<description>Look for a single, compact non-background cluster in each input and treat it as one object. Represent that object by its minimal bounding rectangle (top, left, height, width) so you can compare its size and shape across examples.</description>\n<example>Imagine a small cluster of colored pixe... | [{"input": [[0, 0, 0, 0, 0, 0, 0, 0, 0], [0, 0, 0, 0, 0, 0, 0, 0, 0], [0, 0, 0, 0, 0, 0, 0, 0, 0], [0, 0, 0, 0, 0, 0, 0, 0, 0], [0, 0, 0, 0, 0, 0, 0, 0, 0], [0, 0, 0, 0, 0, 0, 4, 0, 0], [0, 0, 0, 0, 0, 4, 4, 4, 0], [0, 0, 0, 0, 4, 4, 4, 4, 0], [0, 0, 0, 0, 0, 0, 0, 4, 0]], "output": [[0, 0, 0, 0, 0, 0, 0, 0, 0], [0, 0,... | [{"input": [[0, 0, 0, 0, 0, 0, 0, 0], [0, 0, 0, 0, 0, 0, 0, 0], [0, 0, 0, 0, 0, 0, 0, 0], [0, 0, 0, 0, 0, 0, 0, 0], [0, 0, 0, 0, 0, 0, 0, 0], [0, 0, 0, 0, 0, 0, 0, 4], [0, 0, 0, 0, 0, 0, 4, 4], [0, 0, 0, 0, 0, 0, 0, 0]], "output": [[0, 0, 0, 0, 0, 0, 0, 0], [0, 0, 0, 0, 0, 0, 0, 0], [0, 0, 0, 0, 0, 0, 0, 0], [0, 0, 0, ... | barc_heavy | You will be given some number of paired example inputs and outputs grids. The outputs were produced by applying a transformation rule to the input grids. In addition to the paired example inputs and outputs, there is also one test input without a known output. The inputs and outputs are each “grids”. A grid is a rectan... | ```
0 0 0 0 0 0 0 0
0 0 0 0 0 0 0 0
0 0 0 0 0 0 0 0
0 0 0 0 0 0 0 0
0 0 0 0 0 0 0 0
0 0 0 0 0 0 0 0
0 0 0 0 0 0 0 2
0 0 0 0 0 0 2 2
``` | 1,518 |
<|im_start|>user
# ARC HINT GENERATOR
## Role & Goal
You are an expert ARC (Abstraction and Reasoning Corpus) analyst. Your task is to generate a concise, actionable hint for a user who is struggling with an ARC problem. Analyze the problem and its correct solution to produce a single standalone, targeted hint that he... | 3,783 | [
"<note1>\n<description>Look for the dominant (background) color and the minority colors. Often one minority color appears exactly once and acts as a “marker” or pivot; the other minority colors are the ones that get transformed. Recognizing these roles reduces the problem to a small set of objects to reason about.<... | [{"input": [[9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9], [9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9], [9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 7, 9, 9, 1], [9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9], [9, 9, 9, 9, 9, 9, 9, 7, 9, 9, 9, 9, 9, 1], [9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9], [9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 7, 9, 9], ... | [{"input": [[3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3], [3, 3, 3, 3, 3, 3, 3, 6, 3, 3, 3, 3], [3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3], [3, 3, 3, 6, 3, 3, 3, 3, 3, 3, 3, 3], [3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 0], [3, 3, 3, 3, 3, 3, 6, 3, 3, 3, 3, 3], [3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3], [3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3], [3, ... | rearc | You will be given some number of paired example inputs and outputs grids. The outputs were produced by applying a transformation rule to the input grids. In addition to the paired example inputs and outputs, there is also one test input without a known output. The inputs and outputs are each “grids”. A grid is a rectan... | ```
3 3 3 3 3 3 3 3 3 3 3 3
3 3 3 3 3 3 3 6 3 3 3 3
3 3 3 3 3 3 3 3 3 3 3 3
3 3 3 6 3 3 3 3 3 3 3 3
0 0 0 0 0 0 0 0 0 0 0 0
3 3 3 3 3 3 6 3 3 3 3 3
3 3 3 3 3 3 3 3 3 3 3 3
3 3 3 3 3 3 3 3 3 3 3 3
3 6 3 3 3 3 3 3 3 3 3 3
3 3 3 3 3 3 3 3 3 3 3 3
0 0 0 0 0 0 0 0 0 0 0 0
3 3 3 3 3 3 6 3 3 3 3 3
3 3 3 3 3 3 3 3 3 3 3 3
3 3 ... | 3,290 |
<|im_start|>user
# ARC HINT GENERATOR
## Role & Goal
You are an expert ARC (Abstraction and Reasoning Corpus) analyst. Your task is to generate a concise, actionable hint for a user who is struggling with an ARC problem. Analyze the problem and its correct solution to produce a single standalone, targeted hint that he... | 3,075 | [
"<note1>\n<description>First identify which color(s) differ between input and output examples. Often only one color is changed while the rest of the grid (background and other colors) remains identical; that tells you the transformation is a recoloring of a single color class.</description>\n<example>Imagine a smal... | [{"input": [[0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0], [0, 0, 0, 0, 4, 4, 0, 0, 0, 0, 0, 0, 0], [0, 0, 0, 0, 4, 4, 0, 0, 0, 0, 0, 0, 0], [0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0], [0, 0, 4, 4, 0, 0, 0, 0, 0, 0, 0, 0, 0], [0, 0, 4, 4, 0, 0, 0, 4, 4, 0, 0, 0, 0], [0, 0, 0, 0, 0, 0, 0, 4, 4, 0, 0, 0, 0], [0, 0, 0, 0, 0, 0, 0,... | [{"input": [[2, 2, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0], [2, 2, 0, 0, 4, 4, 0, 0, 0, 4, 4, 0, 0, 0], [2, 2, 0, 0, 4, 4, 0, 0, 0, 4, 4, 0, 0, 0], [0, 0, 0, 0, 4, 4, 0, 0, 0, 4, 4, 0, 2, 2], [0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 2], [0, 0, 0, 2, 2, 2, 0, 0, 0, 0, 0, 0, 2, 2], [0, 0, 0, 2, 2, 2, 0, 0, 0, 0, 0, 0, 0, 0], ... | barc_heavy | You will be given some number of paired example inputs and outputs grids. The outputs were produced by applying a transformation rule to the input grids. In addition to the paired example inputs and outputs, there is also one test input without a known output. The inputs and outputs are each “grids”. A grid is a rectan... | ```
3 3 0 0 0 0 0 0 0 0 0 0 0 0
3 3 0 0 4 4 0 0 0 4 4 0 0 0
3 3 0 0 4 4 0 0 0 4 4 0 0 0
0 0 0 0 4 4 0 0 0 4 4 0 3 3
0 0 0 0 0 0 0 0 0 0 0 0 0 3
0 0 0 3 3 3 0 0 0 0 0 0 3 3
0 0 0 3 3 3 0 0 0 0 0 0 0 0
0 0 0 0 0 0 0 0 0 0 0 0 0 0
0 0 0 0 0 0 0 0 0 0 0 0 3 0
0 3 3 0 0 0 0 0 0 0 0 3 3 3
0 3 3 0 0 0 4 4 4 0 0 0 3 0
0 0 0 0 ... | 2,582 |
<|im_start|>user
# ARC HINT GENERATOR
## Role & Goal
You are an expert ARC (Abstraction and Reasoning Corpus) analyst. Your task is to generate a concise, actionable hint for a user who is struggling with an ARC problem. Analyze the problem and its correct solution to produce a single standalone, targeted hint that he... | 3,725 | [
"<note1>\n<description>Separate the scene into objects by finding contiguous non-zero pixels; each contiguous group is treated independently. This isolates the units the transformation acts on and prevents mixing information from different regions.</description>\n<example>Imagine a grid with two disconnected colore... | [{"input": [[0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0], [0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0], [0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0], [0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0], [0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0], [0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0], [0, 0, 0, 0, 0, 0, 0, 0, 0... | [{"input": [[0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0], [0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0], [0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0], [0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0], [0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0], [0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0], [0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0], [0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0], [0, 0, 0, 0, 0, 0, 0, 0, 0, ... | barc_heavy | You will be given some number of paired example inputs and outputs grids. The outputs were produced by applying a transformation rule to the input grids. In addition to the paired example inputs and outputs, there is also one test input without a known output. The inputs and outputs are each “grids”. A grid is a rectan... | ```
0 0 0 0 0 0 0 0 0 0 0
0 0 0 0 0 0 0 0 0 0 0
0 0 0 0 0 0 0 0 0 0 0
0 0 0 0 0 0 0 0 0 0 0
0 0 0 0 0 0 0 0 0 0 0
0 0 0 0 0 0 0 0 0 0 0
0 0 0 0 0 0 0 0 0 0 0
0 0 0 0 0 0 0 0 0 0 0
0 0 0 0 0 0 0 0 0 0 0
0 0 0 0 0 0 0 0 0 0 0
0 0 0 0 0 0 0 0 0 0 0
0 0 0 0 0 0 0 0 0 0 0
0 0 0 0 0 0 0 0 0 0 0
0 0 0 0 0 0 0 0 0 0 0
0 0 0 0 ... | 3,232 |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.