Goal Roll C449

You are given the initial state of the cube as a cross-shaped net. This net is the unfolded outer surface of the folded cube. Each visible cell is labeled as TOP, BOTTOM, FRONT, BACK, LEFT, or RIGHT. The number under each visible face is the clockwise rotation in degrees from the original upright pattern. Output a roll sequence so that, at the end, the cube's top face seen from above exactly matches the target image.

System:
You are a cube-rolling sequence solver. Given a cube whose initial outer-surface configuration is shown as a cross net and a target top-face image, output one valid sequence of N/S/E/W rolls so that the cube's top face after the sequence matches the target.

You will receive: (a) one initial cross-net image showing the visible faces of the unfolded cube with their patternIds and rotations, (b) one target top-face image showing the desired final top-face pattern and orientation, and (c) a structured text body listing every visible net cell, the target patternId+rotation, the direction vocabulary, and the maximum allowed sequence length.

You may reason step by step before the final answer. Place your final answer on the very last line of your reply, in the form: FINAL_JSON: <one-line JSON>

The JSON object must follow the directions schema described in section 8 of the user prompt. Multiple sequences may be valid — output any one that solves the puzzle. Do NOT wrap FINAL_JSON in Markdown code fences. Do NOT write anything after the FINAL_JSON line. Emit exactly one FINAL_JSON line.

If you cannot reason out a confident sequence, still output your best-effort FINAL_JSON line with at least one direction token; the only structurally invalid output is no FINAL_JSON line at all. Never refuse, never return prose only.

## 1. TASK
Output one sequence of rolls so that, at the end of the sequence, the cube's top face seen from above matches the target top face exactly (both patternId and rotation).
The puzzle is solved when the engine simulates your sequence on the initial cube and the resulting top-face pattern equals the target.

## 2. WORLD MODEL
- Cube: a unit cube with one pattern printed on each of its six outer faces. The faces are named TOP, BOTTOM, FRONT, BACK, LEFT, RIGHT in the world frame.
- Cross net: the unfolded outer surface laid flat. Each cell is one face; its label tells you which face it is and its number under the patternId is the clockwise rotation in degrees from the original upright pattern.
- Roll: tipping the cube 90° about one of its bottom edges into an adjacent grid cell. After a roll, the face that was on the side becomes the new top, the previous top moves to the opposite side, and so on.
- Direction tokens: N (roll up / north), S (roll down / south), E (roll right / east), W (roll left / west). The direction is always relative to the world frame, not the cube's current orientation.
- Target top face: the desired patternId and rotation of whichever face ends up on top after the sequence.

## 3. VISUAL LEGEND
- Image 1: initial cross-net of the cube. The TOP/BOTTOM/FRONT/BACK/LEFT/RIGHT cells are arranged in a cross. Each visible face shows its patternId and a number indicating the clockwise rotation in degrees from the upright orientation.
- Image 2: the target top-face image, showing the patternId and rotation the cube's top face must reach.
- Coordinates: the cube starts at (0, 0). N decrements y (up on screen), S increments y, E increments x (right), W decrements x.

## 4. INPUT FIELDS
- sample_id: C449
- task_type: roll_to_target_top_face
- difficulty: 5
- target_top_face: patternId=smile, rotation=180
- max_direction_steps: 20
- initial_net_layout (text view, with the BACK / LEFT-TOP-RIGHT / FRONT / BOTTOM rows of the cross):
  [BACK: patternId=smile, rotation=270]
[LEFT: patternId=smile, rotation=270] [TOP: patternId=?, rotation=0] [RIGHT: patternId=star, rotation=270]
  [FRONT: patternId=square, rotation=0]
  [BOTTOM: patternId=N, rotation=0]
- initial_net_cells (explicit list of every visible face):
- BACK: patternId=smile, rotation=270
- LEFT: patternId=smile, rotation=270
- TOP: patternId=?, rotation=0
- RIGHT: patternId=star, rotation=270
- FRONT: patternId=square, rotation=0
- BOTTOM: patternId=N, rotation=0

## 5. ACTION VOCABULARY
A complete answer is one ordered list of direction tokens:
- direction: one of {"N", "S", "E", "W"}.
- Sequence length is the number of rolls. The maximum allowed length for this task is `max_direction_steps`.
- Multiple sequences may produce the same target top face; any one of them counts as correct.

## 6. CONSTRAINTS
- Each direction token must be exactly one of N, S, E, W (uppercase).
- The sequence length must be between 1 and `max_direction_steps` inclusive.
- The sequence must be deterministic: no probabilistic or "either-or" entries. One direction per step.
- The engine evaluates by simulating your sequence on the initial cube; do not output any other JSON keys.

## 7. SOLVING ADVICE
- Track which face is currently on top after each roll. A roll N moves the FRONT face to the new TOP, S moves BACK to TOP, E moves LEFT to TOP, W moves RIGHT to TOP (with appropriate rotation).
- Confirm the rotation of the target top face — getting the patternId right but the rotation wrong is still a fail. Each roll N or S adjusts the cube's local-frame rotation by 0/180; each roll E or W adjusts it by ±90.
- A reference sequence may be inferable from the imprint history if the data includes one, but you do not need to copy it; output any valid sequence.

## 8. OUTPUT SCHEMA
FINAL_JSON: {"directions":["<N|S|E|W>", ...]}
- directions: array of direction tokens.
- Each token: one of `"N"`, `"S"`, `"E"`, `"W"`.
- Length: 1..20.

## 9. FINAL INSTRUCTION
You may include reasoning above, but the very last line of your reply must start with FINAL_JSON: followed by exactly one valid JSON object.
Do not wrap FINAL_JSON in code fences and do not write anything after it.


Goal Roll C450

Given the initial cross net and the target top-face image, output a roll sequence that moves the cube to the target state.

You are given the initial state of the cube as a cross-shaped net. This net is the unfolded outer surface of the folded cube. Each visible cell is labeled as TOP, BOTTOM, FRONT, BACK, LEFT, or RIGHT. The number under each visible face is the clockwise rotation in degrees from the original upright pattern. Output a roll sequence so that, at the end, the cube's top face seen from above exactly matches the target image.

System:
You are a cube-rolling sequence solver. Given a cube whose initial outer-surface configuration is shown as a cross net and a target top-face image, output one valid sequence of N/S/E/W rolls so that the cube's top face after the sequence matches the target.

You will receive: (a) one initial cross-net image showing the visible faces of the unfolded cube with their patternIds and rotations, (b) one target top-face image showing the desired final top-face pattern and orientation, and (c) a structured text body listing every visible net cell, the target patternId+rotation, the direction vocabulary, and the maximum allowed sequence length.

You may reason step by step before the final answer. Place your final answer on the very last line of your reply, in the form: FINAL_JSON: <one-line JSON>

The JSON object must follow the directions schema described in section 8 of the user prompt. Multiple sequences may be valid — output any one that solves the puzzle. Do NOT wrap FINAL_JSON in Markdown code fences. Do NOT write anything after the FINAL_JSON line. Emit exactly one FINAL_JSON line.

If you cannot reason out a confident sequence, still output your best-effort FINAL_JSON line with at least one direction token; the only structurally invalid output is no FINAL_JSON line at all. Never refuse, never return prose only.

## 1. TASK
Output one sequence of rolls so that, at the end of the sequence, the cube's top face seen from above matches the target top face exactly (both patternId and rotation).
The puzzle is solved when the engine simulates your sequence on the initial cube and the resulting top-face pattern equals the target.

## 2. WORLD MODEL
- Cube: a unit cube with one pattern printed on each of its six outer faces. The faces are named TOP, BOTTOM, FRONT, BACK, LEFT, RIGHT in the world frame.
- Cross net: the unfolded outer surface laid flat. Each cell is one face; its label tells you which face it is and its number under the patternId is the clockwise rotation in degrees from the original upright pattern.
- Roll: tipping the cube 90° about one of its bottom edges into an adjacent grid cell. After a roll, the face that was on the side becomes the new top, the previous top moves to the opposite side, and so on.
- Direction tokens: N (roll up / north), S (roll down / south), E (roll right / east), W (roll left / west). The direction is always relative to the world frame, not the cube's current orientation.
- Target top face: the desired patternId and rotation of whichever face ends up on top after the sequence.

## 3. VISUAL LEGEND
- Image 1: initial cross-net of the cube. The TOP/BOTTOM/FRONT/BACK/LEFT/RIGHT cells are arranged in a cross. Each visible face shows its patternId and a number indicating the clockwise rotation in degrees from the upright orientation.
- Image 2: the target top-face image, showing the patternId and rotation the cube's top face must reach.
- Coordinates: the cube starts at (0, 0). N decrements y (up on screen), S increments y, E increments x (right), W decrements x.

## 4. INPUT FIELDS
- sample_id: C450
- task_type: roll_to_target_top_face
- difficulty: 5
- target_top_face: patternId=8, rotation=270
- max_direction_steps: 20
- initial_net_layout (text view, with the BACK / LEFT-TOP-RIGHT / FRONT / BOTTOM rows of the cross):
  [BACK: patternId=8, rotation=0]
[LEFT: patternId=W, rotation=0] [TOP: patternId=C, rotation=270] [RIGHT: patternId=Q, rotation=270]
  [FRONT: patternId=R, rotation=90]
  [BOTTOM: patternId=?, rotation=0]
- initial_net_cells (explicit list of every visible face):
- BACK: patternId=8, rotation=0
- LEFT: patternId=W, rotation=0
- TOP: patternId=C, rotation=270
- RIGHT: patternId=Q, rotation=270
- FRONT: patternId=R, rotation=90
- BOTTOM: patternId=?, rotation=0

## 5. ACTION VOCABULARY
A complete answer is one ordered list of direction tokens:
- direction: one of {"N", "S", "E", "W"}.
- Sequence length is the number of rolls. The maximum allowed length for this task is `max_direction_steps`.
- Multiple sequences may produce the same target top face; any one of them counts as correct.

## 6. CONSTRAINTS
- Each direction token must be exactly one of N, S, E, W (uppercase).
- The sequence length must be between 1 and `max_direction_steps` inclusive.
- The sequence must be deterministic: no probabilistic or "either-or" entries. One direction per step.
- The engine evaluates by simulating your sequence on the initial cube; do not output any other JSON keys.

## 7. SOLVING ADVICE
- Track which face is currently on top after each roll. A roll N moves the FRONT face to the new TOP, S moves BACK to TOP, E moves LEFT to TOP, W moves RIGHT to TOP (with appropriate rotation).
- Confirm the rotation of the target top face — getting the patternId right but the rotation wrong is still a fail. Each roll N or S adjusts the cube's local-frame rotation by 0/180; each roll E or W adjusts it by ±90.
- A reference sequence may be inferable from the imprint history if the data includes one, but you do not need to copy it; output any valid sequence.

## 8. OUTPUT SCHEMA
FINAL_JSON: {"directions":["<N|S|E|W>", ...]}
- directions: array of direction tokens.
- Each token: one of `"N"`, `"S"`, `"E"`, `"W"`.
- Length: 1..20.

## 9. FINAL INSTRUCTION
You may include reasoning above, but the very last line of your reply must start with FINAL_JSON: followed by exactly one valid JSON object.
Do not wrap FINAL_JSON in code fences and do not write anything after it.


Goal Roll C451

You are given the initial state of the cube as a cross-shaped net. This net is the unfolded outer surface of the folded cube. Each visible cell is labeled as TOP, BOTTOM, FRONT, BACK, LEFT, or RIGHT. The number under each visible face is the clockwise rotation in degrees from the original upright pattern. Output a roll sequence so that, at the end, the cube's top face seen from above exactly matches the target image.

System:
You are a cube-rolling sequence solver. Given a cube whose initial outer-surface configuration is shown as a cross net and a target top-face image, output one valid sequence of N/S/E/W rolls so that the cube's top face after the sequence matches the target.

You will receive: (a) one initial cross-net image showing the visible faces of the unfolded cube with their patternIds and rotations, (b) one target top-face image showing the desired final top-face pattern and orientation, and (c) a structured text body listing every visible net cell, the target patternId+rotation, the direction vocabulary, and the maximum allowed sequence length.

You may reason step by step before the final answer. Place your final answer on the very last line of your reply, in the form: FINAL_JSON: <one-line JSON>

The JSON object must follow the directions schema described in section 8 of the user prompt. Multiple sequences may be valid — output any one that solves the puzzle. Do NOT wrap FINAL_JSON in Markdown code fences. Do NOT write anything after the FINAL_JSON line. Emit exactly one FINAL_JSON line.

If you cannot reason out a confident sequence, still output your best-effort FINAL_JSON line with at least one direction token; the only structurally invalid output is no FINAL_JSON line at all. Never refuse, never return prose only.

## 1. TASK
Output one sequence of rolls so that, at the end of the sequence, the cube's top face seen from above matches the target top face exactly (both patternId and rotation).
The puzzle is solved when the engine simulates your sequence on the initial cube and the resulting top-face pattern equals the target.

## 2. WORLD MODEL
- Cube: a unit cube with one pattern printed on each of its six outer faces. The faces are named TOP, BOTTOM, FRONT, BACK, LEFT, RIGHT in the world frame.
- Cross net: the unfolded outer surface laid flat. Each cell is one face; its label tells you which face it is and its number under the patternId is the clockwise rotation in degrees from the original upright pattern.
- Roll: tipping the cube 90° about one of its bottom edges into an adjacent grid cell. After a roll, the face that was on the side becomes the new top, the previous top moves to the opposite side, and so on.
- Direction tokens: N (roll up / north), S (roll down / south), E (roll right / east), W (roll left / west). The direction is always relative to the world frame, not the cube's current orientation.
- Target top face: the desired patternId and rotation of whichever face ends up on top after the sequence.

## 3. VISUAL LEGEND
- Image 1: initial cross-net of the cube. The TOP/BOTTOM/FRONT/BACK/LEFT/RIGHT cells are arranged in a cross. Each visible face shows its patternId and a number indicating the clockwise rotation in degrees from the upright orientation.
- Image 2: the target top-face image, showing the patternId and rotation the cube's top face must reach.
- Coordinates: the cube starts at (0, 0). N decrements y (up on screen), S increments y, E increments x (right), W decrements x.

## 4. INPUT FIELDS
- sample_id: C451
- task_type: roll_to_target_top_face
- difficulty: 5
- target_top_face: patternId=circle, rotation=90
- max_direction_steps: 20
- initial_net_layout (text view, with the BACK / LEFT-TOP-RIGHT / FRONT / BOTTOM rows of the cross):
  [BACK: patternId=M, rotation=90]
[LEFT: patternId=circle, rotation=270] [TOP: patternId=I, rotation=270] [RIGHT: patternId=U, rotation=270]
  [FRONT: patternId=F, rotation=270]
  [BOTTOM: patternId=arrow_down, rotation=0]
- initial_net_cells (explicit list of every visible face):
- BACK: patternId=M, rotation=90
- LEFT: patternId=circle, rotation=270
- TOP: patternId=I, rotation=270
- RIGHT: patternId=U, rotation=270
- FRONT: patternId=F, rotation=270
- BOTTOM: patternId=arrow_down, rotation=0

## 5. ACTION VOCABULARY
A complete answer is one ordered list of direction tokens:
- direction: one of {"N", "S", "E", "W"}.
- Sequence length is the number of rolls. The maximum allowed length for this task is `max_direction_steps`.
- Multiple sequences may produce the same target top face; any one of them counts as correct.

## 6. CONSTRAINTS
- Each direction token must be exactly one of N, S, E, W (uppercase).
- The sequence length must be between 1 and `max_direction_steps` inclusive.
- The sequence must be deterministic: no probabilistic or "either-or" entries. One direction per step.
- The engine evaluates by simulating your sequence on the initial cube; do not output any other JSON keys.

## 7. SOLVING ADVICE
- Track which face is currently on top after each roll. A roll N moves the FRONT face to the new TOP, S moves BACK to TOP, E moves LEFT to TOP, W moves RIGHT to TOP (with appropriate rotation).
- Confirm the rotation of the target top face — getting the patternId right but the rotation wrong is still a fail. Each roll N or S adjusts the cube's local-frame rotation by 0/180; each roll E or W adjusts it by ±90.
- A reference sequence may be inferable from the imprint history if the data includes one, but you do not need to copy it; output any valid sequence.

## 8. OUTPUT SCHEMA
FINAL_JSON: {"directions":["<N|S|E|W>", ...]}
- directions: array of direction tokens.
- Each token: one of `"N"`, `"S"`, `"E"`, `"W"`.
- Length: 1..20.

## 9. FINAL INSTRUCTION
You may include reasoning above, but the very last line of your reply must start with FINAL_JSON: followed by exactly one valid JSON object.
Do not wrap FINAL_JSON in code fences and do not write anything after it.


Goal Roll C452

You are given the initial state of the cube as a cross-shaped net. This net is the unfolded outer surface of the folded cube. Each visible cell is labeled as TOP, BOTTOM, FRONT, BACK, LEFT, or RIGHT. The number under each visible face is the clockwise rotation in degrees from the original upright pattern. Output a roll sequence so that, at the end, the cube's top face seen from above exactly matches the target image.

System:
You are a cube-rolling sequence solver. Given a cube whose initial outer-surface configuration is shown as a cross net and a target top-face image, output one valid sequence of N/S/E/W rolls so that the cube's top face after the sequence matches the target.

You will receive: (a) one initial cross-net image showing the visible faces of the unfolded cube with their patternIds and rotations, (b) one target top-face image showing the desired final top-face pattern and orientation, and (c) a structured text body listing every visible net cell, the target patternId+rotation, the direction vocabulary, and the maximum allowed sequence length.

You may reason step by step before the final answer. Place your final answer on the very last line of your reply, in the form: FINAL_JSON: <one-line JSON>

The JSON object must follow the directions schema described in section 8 of the user prompt. Multiple sequences may be valid — output any one that solves the puzzle. Do NOT wrap FINAL_JSON in Markdown code fences. Do NOT write anything after the FINAL_JSON line. Emit exactly one FINAL_JSON line.

If you cannot reason out a confident sequence, still output your best-effort FINAL_JSON line with at least one direction token; the only structurally invalid output is no FINAL_JSON line at all. Never refuse, never return prose only.

## 1. TASK
Output one sequence of rolls so that, at the end of the sequence, the cube's top face seen from above matches the target top face exactly (both patternId and rotation).
The puzzle is solved when the engine simulates your sequence on the initial cube and the resulting top-face pattern equals the target.

## 2. WORLD MODEL
- Cube: a unit cube with one pattern printed on each of its six outer faces. The faces are named TOP, BOTTOM, FRONT, BACK, LEFT, RIGHT in the world frame.
- Cross net: the unfolded outer surface laid flat. Each cell is one face; its label tells you which face it is and its number under the patternId is the clockwise rotation in degrees from the original upright pattern.
- Roll: tipping the cube 90° about one of its bottom edges into an adjacent grid cell. After a roll, the face that was on the side becomes the new top, the previous top moves to the opposite side, and so on.
- Direction tokens: N (roll up / north), S (roll down / south), E (roll right / east), W (roll left / west). The direction is always relative to the world frame, not the cube's current orientation.
- Target top face: the desired patternId and rotation of whichever face ends up on top after the sequence.

## 3. VISUAL LEGEND
- Image 1: initial cross-net of the cube. The TOP/BOTTOM/FRONT/BACK/LEFT/RIGHT cells are arranged in a cross. Each visible face shows its patternId and a number indicating the clockwise rotation in degrees from the upright orientation.
- Image 2: the target top-face image, showing the patternId and rotation the cube's top face must reach.
- Coordinates: the cube starts at (0, 0). N decrements y (up on screen), S increments y, E increments x (right), W decrements x.

## 4. INPUT FIELDS
- sample_id: C452
- task_type: roll_to_target_top_face
- difficulty: 5
- target_top_face: patternId=X, rotation=90
- max_direction_steps: 20
- initial_net_layout (text view, with the BACK / LEFT-TOP-RIGHT / FRONT / BOTTOM rows of the cross):
  [BACK: patternId=4, rotation=0]
[LEFT: patternId=R, rotation=180] [TOP: patternId=X, rotation=0] [RIGHT: patternId=L, rotation=180]
  [FRONT: patternId=W, rotation=90]
  [BOTTOM: patternId=B, rotation=180]
- initial_net_cells (explicit list of every visible face):
- BACK: patternId=4, rotation=0
- LEFT: patternId=R, rotation=180
- TOP: patternId=X, rotation=0
- RIGHT: patternId=L, rotation=180
- FRONT: patternId=W, rotation=90
- BOTTOM: patternId=B, rotation=180

## 5. ACTION VOCABULARY
A complete answer is one ordered list of direction tokens:
- direction: one of {"N", "S", "E", "W"}.
- Sequence length is the number of rolls. The maximum allowed length for this task is `max_direction_steps`.
- Multiple sequences may produce the same target top face; any one of them counts as correct.

## 6. CONSTRAINTS
- Each direction token must be exactly one of N, S, E, W (uppercase).
- The sequence length must be between 1 and `max_direction_steps` inclusive.
- The sequence must be deterministic: no probabilistic or "either-or" entries. One direction per step.
- The engine evaluates by simulating your sequence on the initial cube; do not output any other JSON keys.

## 7. SOLVING ADVICE
- Track which face is currently on top after each roll. A roll N moves the FRONT face to the new TOP, S moves BACK to TOP, E moves LEFT to TOP, W moves RIGHT to TOP (with appropriate rotation).
- Confirm the rotation of the target top face — getting the patternId right but the rotation wrong is still a fail. Each roll N or S adjusts the cube's local-frame rotation by 0/180; each roll E or W adjusts it by ±90.
- A reference sequence may be inferable from the imprint history if the data includes one, but you do not need to copy it; output any valid sequence.

## 8. OUTPUT SCHEMA
FINAL_JSON: {"directions":["<N|S|E|W>", ...]}
- directions: array of direction tokens.
- Each token: one of `"N"`, `"S"`, `"E"`, `"W"`.
- Length: 1..20.

## 9. FINAL INSTRUCTION
You may include reasoning above, but the very last line of your reply must start with FINAL_JSON: followed by exactly one valid JSON object.
Do not wrap FINAL_JSON in code fences and do not write anything after it.


Goal Roll C453

You are given the initial state of the cube as a cross-shaped net. This net is the unfolded outer surface of the folded cube. Each visible cell is labeled as TOP, BOTTOM, FRONT, BACK, LEFT, or RIGHT. The number under each visible face is the clockwise rotation in degrees from the original upright pattern. Output a roll sequence so that, at the end, the cube's top face seen from above exactly matches the target image.

System:
You are a cube-rolling sequence solver. Given a cube whose initial outer-surface configuration is shown as a cross net and a target top-face image, output one valid sequence of N/S/E/W rolls so that the cube's top face after the sequence matches the target.

You will receive: (a) one initial cross-net image showing the visible faces of the unfolded cube with their patternIds and rotations, (b) one target top-face image showing the desired final top-face pattern and orientation, and (c) a structured text body listing every visible net cell, the target patternId+rotation, the direction vocabulary, and the maximum allowed sequence length.

You may reason step by step before the final answer. Place your final answer on the very last line of your reply, in the form: FINAL_JSON: <one-line JSON>

The JSON object must follow the directions schema described in section 8 of the user prompt. Multiple sequences may be valid — output any one that solves the puzzle. Do NOT wrap FINAL_JSON in Markdown code fences. Do NOT write anything after the FINAL_JSON line. Emit exactly one FINAL_JSON line.

If you cannot reason out a confident sequence, still output your best-effort FINAL_JSON line with at least one direction token; the only structurally invalid output is no FINAL_JSON line at all. Never refuse, never return prose only.

## 1. TASK
Output one sequence of rolls so that, at the end of the sequence, the cube's top face seen from above matches the target top face exactly (both patternId and rotation).
The puzzle is solved when the engine simulates your sequence on the initial cube and the resulting top-face pattern equals the target.

## 2. WORLD MODEL
- Cube: a unit cube with one pattern printed on each of its six outer faces. The faces are named TOP, BOTTOM, FRONT, BACK, LEFT, RIGHT in the world frame.
- Cross net: the unfolded outer surface laid flat. Each cell is one face; its label tells you which face it is and its number under the patternId is the clockwise rotation in degrees from the original upright pattern.
- Roll: tipping the cube 90° about one of its bottom edges into an adjacent grid cell. After a roll, the face that was on the side becomes the new top, the previous top moves to the opposite side, and so on.
- Direction tokens: N (roll up / north), S (roll down / south), E (roll right / east), W (roll left / west). The direction is always relative to the world frame, not the cube's current orientation.
- Target top face: the desired patternId and rotation of whichever face ends up on top after the sequence.

## 3. VISUAL LEGEND
- Image 1: initial cross-net of the cube. The TOP/BOTTOM/FRONT/BACK/LEFT/RIGHT cells are arranged in a cross. Each visible face shows its patternId and a number indicating the clockwise rotation in degrees from the upright orientation.
- Image 2: the target top-face image, showing the patternId and rotation the cube's top face must reach.
- Coordinates: the cube starts at (0, 0). N decrements y (up on screen), S increments y, E increments x (right), W decrements x.

## 4. INPUT FIELDS
- sample_id: C453
- task_type: roll_to_target_top_face
- difficulty: 5
- target_top_face: patternId=4, rotation=270
- max_direction_steps: 20
- initial_net_layout (text view, with the BACK / LEFT-TOP-RIGHT / FRONT / BOTTOM rows of the cross):
  [BACK: patternId=4, rotation=180]
[LEFT: patternId=?, rotation=0] [TOP: patternId=plus, rotation=90] [RIGHT: patternId=O, rotation=270]
  [FRONT: patternId=A, rotation=270]
  [BOTTOM: patternId=9, rotation=270]
- initial_net_cells (explicit list of every visible face):
- BACK: patternId=4, rotation=180
- LEFT: patternId=?, rotation=0
- TOP: patternId=plus, rotation=90
- RIGHT: patternId=O, rotation=270
- FRONT: patternId=A, rotation=270
- BOTTOM: patternId=9, rotation=270

## 5. ACTION VOCABULARY
A complete answer is one ordered list of direction tokens:
- direction: one of {"N", "S", "E", "W"}.
- Sequence length is the number of rolls. The maximum allowed length for this task is `max_direction_steps`.
- Multiple sequences may produce the same target top face; any one of them counts as correct.

## 6. CONSTRAINTS
- Each direction token must be exactly one of N, S, E, W (uppercase).
- The sequence length must be between 1 and `max_direction_steps` inclusive.
- The sequence must be deterministic: no probabilistic or "either-or" entries. One direction per step.
- The engine evaluates by simulating your sequence on the initial cube; do not output any other JSON keys.

## 7. SOLVING ADVICE
- Track which face is currently on top after each roll. A roll N moves the FRONT face to the new TOP, S moves BACK to TOP, E moves LEFT to TOP, W moves RIGHT to TOP (with appropriate rotation).
- Confirm the rotation of the target top face — getting the patternId right but the rotation wrong is still a fail. Each roll N or S adjusts the cube's local-frame rotation by 0/180; each roll E or W adjusts it by ±90.
- A reference sequence may be inferable from the imprint history if the data includes one, but you do not need to copy it; output any valid sequence.

## 8. OUTPUT SCHEMA
FINAL_JSON: {"directions":["<N|S|E|W>", ...]}
- directions: array of direction tokens.
- Each token: one of `"N"`, `"S"`, `"E"`, `"W"`.
- Length: 1..20.

## 9. FINAL INSTRUCTION
You may include reasoning above, but the very last line of your reply must start with FINAL_JSON: followed by exactly one valid JSON object.
Do not wrap FINAL_JSON in code fences and do not write anything after it.


Goal Roll C454

You are given the initial state of the cube as a cross-shaped net. This net is the unfolded outer surface of the folded cube. Each visible cell is labeled as TOP, BOTTOM, FRONT, BACK, LEFT, or RIGHT. The number under each visible face is the clockwise rotation in degrees from the original upright pattern. Output a roll sequence so that, at the end, the cube's top face seen from above exactly matches the target image.

System:
You are a cube-rolling sequence solver. Given a cube whose initial outer-surface configuration is shown as a cross net and a target top-face image, output one valid sequence of N/S/E/W rolls so that the cube's top face after the sequence matches the target.

You will receive: (a) one initial cross-net image showing the visible faces of the unfolded cube with their patternIds and rotations, (b) one target top-face image showing the desired final top-face pattern and orientation, and (c) a structured text body listing every visible net cell, the target patternId+rotation, the direction vocabulary, and the maximum allowed sequence length.

You may reason step by step before the final answer. Place your final answer on the very last line of your reply, in the form: FINAL_JSON: <one-line JSON>

The JSON object must follow the directions schema described in section 8 of the user prompt. Multiple sequences may be valid — output any one that solves the puzzle. Do NOT wrap FINAL_JSON in Markdown code fences. Do NOT write anything after the FINAL_JSON line. Emit exactly one FINAL_JSON line.

If you cannot reason out a confident sequence, still output your best-effort FINAL_JSON line with at least one direction token; the only structurally invalid output is no FINAL_JSON line at all. Never refuse, never return prose only.

## 1. TASK
Output one sequence of rolls so that, at the end of the sequence, the cube's top face seen from above matches the target top face exactly (both patternId and rotation).
The puzzle is solved when the engine simulates your sequence on the initial cube and the resulting top-face pattern equals the target.

## 2. WORLD MODEL
- Cube: a unit cube with one pattern printed on each of its six outer faces. The faces are named TOP, BOTTOM, FRONT, BACK, LEFT, RIGHT in the world frame.
- Cross net: the unfolded outer surface laid flat. Each cell is one face; its label tells you which face it is and its number under the patternId is the clockwise rotation in degrees from the original upright pattern.
- Roll: tipping the cube 90° about one of its bottom edges into an adjacent grid cell. After a roll, the face that was on the side becomes the new top, the previous top moves to the opposite side, and so on.
- Direction tokens: N (roll up / north), S (roll down / south), E (roll right / east), W (roll left / west). The direction is always relative to the world frame, not the cube's current orientation.
- Target top face: the desired patternId and rotation of whichever face ends up on top after the sequence.

## 3. VISUAL LEGEND
- Image 1: initial cross-net of the cube. The TOP/BOTTOM/FRONT/BACK/LEFT/RIGHT cells are arranged in a cross. Each visible face shows its patternId and a number indicating the clockwise rotation in degrees from the upright orientation.
- Image 2: the target top-face image, showing the patternId and rotation the cube's top face must reach.
- Coordinates: the cube starts at (0, 0). N decrements y (up on screen), S increments y, E increments x (right), W decrements x.

## 4. INPUT FIELDS
- sample_id: C454
- task_type: roll_to_target_top_face
- difficulty: 5
- target_top_face: patternId=N, rotation=0
- max_direction_steps: 20
- initial_net_layout (text view, with the BACK / LEFT-TOP-RIGHT / FRONT / BOTTOM rows of the cross):
  [BACK: patternId=R, rotation=270]
[LEFT: patternId=W, rotation=90] [TOP: patternId=N, rotation=270] [RIGHT: patternId=arrow_left, rotation=90]
  [FRONT: patternId=J, rotation=0]
  [BOTTOM: patternId=arrow_left, rotation=0]
- initial_net_cells (explicit list of every visible face):
- BACK: patternId=R, rotation=270
- LEFT: patternId=W, rotation=90
- TOP: patternId=N, rotation=270
- RIGHT: patternId=arrow_left, rotation=90
- FRONT: patternId=J, rotation=0
- BOTTOM: patternId=arrow_left, rotation=0

## 5. ACTION VOCABULARY
A complete answer is one ordered list of direction tokens:
- direction: one of {"N", "S", "E", "W"}.
- Sequence length is the number of rolls. The maximum allowed length for this task is `max_direction_steps`.
- Multiple sequences may produce the same target top face; any one of them counts as correct.

## 6. CONSTRAINTS
- Each direction token must be exactly one of N, S, E, W (uppercase).
- The sequence length must be between 1 and `max_direction_steps` inclusive.
- The sequence must be deterministic: no probabilistic or "either-or" entries. One direction per step.
- The engine evaluates by simulating your sequence on the initial cube; do not output any other JSON keys.

## 7. SOLVING ADVICE
- Track which face is currently on top after each roll. A roll N moves the FRONT face to the new TOP, S moves BACK to TOP, E moves LEFT to TOP, W moves RIGHT to TOP (with appropriate rotation).
- Confirm the rotation of the target top face — getting the patternId right but the rotation wrong is still a fail. Each roll N or S adjusts the cube's local-frame rotation by 0/180; each roll E or W adjusts it by ±90.
- A reference sequence may be inferable from the imprint history if the data includes one, but you do not need to copy it; output any valid sequence.

## 8. OUTPUT SCHEMA
FINAL_JSON: {"directions":["<N|S|E|W>", ...]}
- directions: array of direction tokens.
- Each token: one of `"N"`, `"S"`, `"E"`, `"W"`.
- Length: 1..20.

## 9. FINAL INSTRUCTION
You may include reasoning above, but the very last line of your reply must start with FINAL_JSON: followed by exactly one valid JSON object.
Do not wrap FINAL_JSON in code fences and do not write anything after it.


Goal Roll C455

You are given the initial state of the cube as a cross-shaped net. This net is the unfolded outer surface of the folded cube. Each visible cell is labeled as TOP, BOTTOM, FRONT, BACK, LEFT, or RIGHT. The number under each visible face is the clockwise rotation in degrees from the original upright pattern. Output a roll sequence so that, at the end, the cube's top face seen from above exactly matches the target image.

System:
You are a cube-rolling sequence solver. Given a cube whose initial outer-surface configuration is shown as a cross net and a target top-face image, output one valid sequence of N/S/E/W rolls so that the cube's top face after the sequence matches the target.

You will receive: (a) one initial cross-net image showing the visible faces of the unfolded cube with their patternIds and rotations, (b) one target top-face image showing the desired final top-face pattern and orientation, and (c) a structured text body listing every visible net cell, the target patternId+rotation, the direction vocabulary, and the maximum allowed sequence length.

You may reason step by step before the final answer. Place your final answer on the very last line of your reply, in the form: FINAL_JSON: <one-line JSON>

The JSON object must follow the directions schema described in section 8 of the user prompt. Multiple sequences may be valid — output any one that solves the puzzle. Do NOT wrap FINAL_JSON in Markdown code fences. Do NOT write anything after the FINAL_JSON line. Emit exactly one FINAL_JSON line.

If you cannot reason out a confident sequence, still output your best-effort FINAL_JSON line with at least one direction token; the only structurally invalid output is no FINAL_JSON line at all. Never refuse, never return prose only.

## 1. TASK
Output one sequence of rolls so that, at the end of the sequence, the cube's top face seen from above matches the target top face exactly (both patternId and rotation).
The puzzle is solved when the engine simulates your sequence on the initial cube and the resulting top-face pattern equals the target.

## 2. WORLD MODEL
- Cube: a unit cube with one pattern printed on each of its six outer faces. The faces are named TOP, BOTTOM, FRONT, BACK, LEFT, RIGHT in the world frame.
- Cross net: the unfolded outer surface laid flat. Each cell is one face; its label tells you which face it is and its number under the patternId is the clockwise rotation in degrees from the original upright pattern.
- Roll: tipping the cube 90° about one of its bottom edges into an adjacent grid cell. After a roll, the face that was on the side becomes the new top, the previous top moves to the opposite side, and so on.
- Direction tokens: N (roll up / north), S (roll down / south), E (roll right / east), W (roll left / west). The direction is always relative to the world frame, not the cube's current orientation.
- Target top face: the desired patternId and rotation of whichever face ends up on top after the sequence.

## 3. VISUAL LEGEND
- Image 1: initial cross-net of the cube. The TOP/BOTTOM/FRONT/BACK/LEFT/RIGHT cells are arranged in a cross. Each visible face shows its patternId and a number indicating the clockwise rotation in degrees from the upright orientation.
- Image 2: the target top-face image, showing the patternId and rotation the cube's top face must reach.
- Coordinates: the cube starts at (0, 0). N decrements y (up on screen), S increments y, E increments x (right), W decrements x.

## 4. INPUT FIELDS
- sample_id: C455
- task_type: roll_to_target_top_face
- difficulty: 5
- target_top_face: patternId=star, rotation=180
- max_direction_steps: 20
- initial_net_layout (text view, with the BACK / LEFT-TOP-RIGHT / FRONT / BOTTOM rows of the cross):
  [BACK: patternId=diamond, rotation=180]
[LEFT: patternId=?, rotation=0] [TOP: patternId=?, rotation=0] [RIGHT: patternId=G, rotation=0]
  [FRONT: patternId=star, rotation=180]
  [BOTTOM: patternId=star, rotation=90]
- initial_net_cells (explicit list of every visible face):
- BACK: patternId=diamond, rotation=180
- LEFT: patternId=?, rotation=0
- TOP: patternId=?, rotation=0
- RIGHT: patternId=G, rotation=0
- FRONT: patternId=star, rotation=180
- BOTTOM: patternId=star, rotation=90

## 5. ACTION VOCABULARY
A complete answer is one ordered list of direction tokens:
- direction: one of {"N", "S", "E", "W"}.
- Sequence length is the number of rolls. The maximum allowed length for this task is `max_direction_steps`.
- Multiple sequences may produce the same target top face; any one of them counts as correct.

## 6. CONSTRAINTS
- Each direction token must be exactly one of N, S, E, W (uppercase).
- The sequence length must be between 1 and `max_direction_steps` inclusive.
- The sequence must be deterministic: no probabilistic or "either-or" entries. One direction per step.
- The engine evaluates by simulating your sequence on the initial cube; do not output any other JSON keys.

## 7. SOLVING ADVICE
- Track which face is currently on top after each roll. A roll N moves the FRONT face to the new TOP, S moves BACK to TOP, E moves LEFT to TOP, W moves RIGHT to TOP (with appropriate rotation).
- Confirm the rotation of the target top face — getting the patternId right but the rotation wrong is still a fail. Each roll N or S adjusts the cube's local-frame rotation by 0/180; each roll E or W adjusts it by ±90.
- A reference sequence may be inferable from the imprint history if the data includes one, but you do not need to copy it; output any valid sequence.

## 8. OUTPUT SCHEMA
FINAL_JSON: {"directions":["<N|S|E|W>", ...]}
- directions: array of direction tokens.
- Each token: one of `"N"`, `"S"`, `"E"`, `"W"`.
- Length: 1..20.

## 9. FINAL INSTRUCTION
You may include reasoning above, but the very last line of your reply must start with FINAL_JSON: followed by exactly one valid JSON object.
Do not wrap FINAL_JSON in code fences and do not write anything after it.


Goal Roll C456

You are given the initial state of the cube as a cross-shaped net. This net is the unfolded outer surface of the folded cube. Each visible cell is labeled as TOP, BOTTOM, FRONT, BACK, LEFT, or RIGHT. The number under each visible face is the clockwise rotation in degrees from the original upright pattern. Output a roll sequence so that, at the end, the cube's top face seen from above exactly matches the target image.

System:
You are a cube-rolling sequence solver. Given a cube whose initial outer-surface configuration is shown as a cross net and a target top-face image, output one valid sequence of N/S/E/W rolls so that the cube's top face after the sequence matches the target.

You will receive: (a) one initial cross-net image showing the visible faces of the unfolded cube with their patternIds and rotations, (b) one target top-face image showing the desired final top-face pattern and orientation, and (c) a structured text body listing every visible net cell, the target patternId+rotation, the direction vocabulary, and the maximum allowed sequence length.

You may reason step by step before the final answer. Place your final answer on the very last line of your reply, in the form: FINAL_JSON: <one-line JSON>

The JSON object must follow the directions schema described in section 8 of the user prompt. Multiple sequences may be valid — output any one that solves the puzzle. Do NOT wrap FINAL_JSON in Markdown code fences. Do NOT write anything after the FINAL_JSON line. Emit exactly one FINAL_JSON line.

If you cannot reason out a confident sequence, still output your best-effort FINAL_JSON line with at least one direction token; the only structurally invalid output is no FINAL_JSON line at all. Never refuse, never return prose only.

## 1. TASK
Output one sequence of rolls so that, at the end of the sequence, the cube's top face seen from above matches the target top face exactly (both patternId and rotation).
The puzzle is solved when the engine simulates your sequence on the initial cube and the resulting top-face pattern equals the target.

## 2. WORLD MODEL
- Cube: a unit cube with one pattern printed on each of its six outer faces. The faces are named TOP, BOTTOM, FRONT, BACK, LEFT, RIGHT in the world frame.
- Cross net: the unfolded outer surface laid flat. Each cell is one face; its label tells you which face it is and its number under the patternId is the clockwise rotation in degrees from the original upright pattern.
- Roll: tipping the cube 90° about one of its bottom edges into an adjacent grid cell. After a roll, the face that was on the side becomes the new top, the previous top moves to the opposite side, and so on.
- Direction tokens: N (roll up / north), S (roll down / south), E (roll right / east), W (roll left / west). The direction is always relative to the world frame, not the cube's current orientation.
- Target top face: the desired patternId and rotation of whichever face ends up on top after the sequence.

## 3. VISUAL LEGEND
- Image 1: initial cross-net of the cube. The TOP/BOTTOM/FRONT/BACK/LEFT/RIGHT cells are arranged in a cross. Each visible face shows its patternId and a number indicating the clockwise rotation in degrees from the upright orientation.
- Image 2: the target top-face image, showing the patternId and rotation the cube's top face must reach.
- Coordinates: the cube starts at (0, 0). N decrements y (up on screen), S increments y, E increments x (right), W decrements x.

## 4. INPUT FIELDS
- sample_id: C456
- task_type: roll_to_target_top_face
- difficulty: 5
- target_top_face: patternId=Z, rotation=270
- max_direction_steps: 20
- initial_net_layout (text view, with the BACK / LEFT-TOP-RIGHT / FRONT / BOTTOM rows of the cross):
  [BACK: patternId=star, rotation=90]
[LEFT: patternId=Z, rotation=0] [TOP: patternId=?, rotation=0] [RIGHT: patternId=9, rotation=270]
  [FRONT: patternId=B, rotation=270]
  [BOTTOM: patternId=smile, rotation=90]
- initial_net_cells (explicit list of every visible face):
- BACK: patternId=star, rotation=90
- LEFT: patternId=Z, rotation=0
- TOP: patternId=?, rotation=0
- RIGHT: patternId=9, rotation=270
- FRONT: patternId=B, rotation=270
- BOTTOM: patternId=smile, rotation=90

## 5. ACTION VOCABULARY
A complete answer is one ordered list of direction tokens:
- direction: one of {"N", "S", "E", "W"}.
- Sequence length is the number of rolls. The maximum allowed length for this task is `max_direction_steps`.
- Multiple sequences may produce the same target top face; any one of them counts as correct.

## 6. CONSTRAINTS
- Each direction token must be exactly one of N, S, E, W (uppercase).
- The sequence length must be between 1 and `max_direction_steps` inclusive.
- The sequence must be deterministic: no probabilistic or "either-or" entries. One direction per step.
- The engine evaluates by simulating your sequence on the initial cube; do not output any other JSON keys.

## 7. SOLVING ADVICE
- Track which face is currently on top after each roll. A roll N moves the FRONT face to the new TOP, S moves BACK to TOP, E moves LEFT to TOP, W moves RIGHT to TOP (with appropriate rotation).
- Confirm the rotation of the target top face — getting the patternId right but the rotation wrong is still a fail. Each roll N or S adjusts the cube's local-frame rotation by 0/180; each roll E or W adjusts it by ±90.
- A reference sequence may be inferable from the imprint history if the data includes one, but you do not need to copy it; output any valid sequence.

## 8. OUTPUT SCHEMA
FINAL_JSON: {"directions":["<N|S|E|W>", ...]}
- directions: array of direction tokens.
- Each token: one of `"N"`, `"S"`, `"E"`, `"W"`.
- Length: 1..20.

## 9. FINAL INSTRUCTION
You may include reasoning above, but the very last line of your reply must start with FINAL_JSON: followed by exactly one valid JSON object.
Do not wrap FINAL_JSON in code fences and do not write anything after it.


Goal Roll C457

You are given the initial state of the cube as a cross-shaped net. This net is the unfolded outer surface of the folded cube. Each visible cell is labeled as TOP, BOTTOM, FRONT, BACK, LEFT, or RIGHT. The number under each visible face is the clockwise rotation in degrees from the original upright pattern. Output a roll sequence so that, at the end, the cube's top face seen from above exactly matches the target image.

System:
You are a cube-rolling sequence solver. Given a cube whose initial outer-surface configuration is shown as a cross net and a target top-face image, output one valid sequence of N/S/E/W rolls so that the cube's top face after the sequence matches the target.

You will receive: (a) one initial cross-net image showing the visible faces of the unfolded cube with their patternIds and rotations, (b) one target top-face image showing the desired final top-face pattern and orientation, and (c) a structured text body listing every visible net cell, the target patternId+rotation, the direction vocabulary, and the maximum allowed sequence length.

You may reason step by step before the final answer. Place your final answer on the very last line of your reply, in the form: FINAL_JSON: <one-line JSON>

The JSON object must follow the directions schema described in section 8 of the user prompt. Multiple sequences may be valid — output any one that solves the puzzle. Do NOT wrap FINAL_JSON in Markdown code fences. Do NOT write anything after the FINAL_JSON line. Emit exactly one FINAL_JSON line.

If you cannot reason out a confident sequence, still output your best-effort FINAL_JSON line with at least one direction token; the only structurally invalid output is no FINAL_JSON line at all. Never refuse, never return prose only.

## 1. TASK
Output one sequence of rolls so that, at the end of the sequence, the cube's top face seen from above matches the target top face exactly (both patternId and rotation).
The puzzle is solved when the engine simulates your sequence on the initial cube and the resulting top-face pattern equals the target.

## 2. WORLD MODEL
- Cube: a unit cube with one pattern printed on each of its six outer faces. The faces are named TOP, BOTTOM, FRONT, BACK, LEFT, RIGHT in the world frame.
- Cross net: the unfolded outer surface laid flat. Each cell is one face; its label tells you which face it is and its number under the patternId is the clockwise rotation in degrees from the original upright pattern.
- Roll: tipping the cube 90° about one of its bottom edges into an adjacent grid cell. After a roll, the face that was on the side becomes the new top, the previous top moves to the opposite side, and so on.
- Direction tokens: N (roll up / north), S (roll down / south), E (roll right / east), W (roll left / west). The direction is always relative to the world frame, not the cube's current orientation.
- Target top face: the desired patternId and rotation of whichever face ends up on top after the sequence.

## 3. VISUAL LEGEND
- Image 1: initial cross-net of the cube. The TOP/BOTTOM/FRONT/BACK/LEFT/RIGHT cells are arranged in a cross. Each visible face shows its patternId and a number indicating the clockwise rotation in degrees from the upright orientation.
- Image 2: the target top-face image, showing the patternId and rotation the cube's top face must reach.
- Coordinates: the cube starts at (0, 0). N decrements y (up on screen), S increments y, E increments x (right), W decrements x.

## 4. INPUT FIELDS
- sample_id: C457
- task_type: roll_to_target_top_face
- difficulty: 5
- target_top_face: patternId=K, rotation=90
- max_direction_steps: 20
- initial_net_layout (text view, with the BACK / LEFT-TOP-RIGHT / FRONT / BOTTOM rows of the cross):
  [BACK: patternId=7, rotation=270]
[LEFT: patternId=3, rotation=180] [TOP: patternId=X, rotation=0] [RIGHT: patternId=smile, rotation=0]
  [FRONT: patternId=arrow_up, rotation=270]
  [BOTTOM: patternId=K, rotation=270]
- initial_net_cells (explicit list of every visible face):
- BACK: patternId=7, rotation=270
- LEFT: patternId=3, rotation=180
- TOP: patternId=X, rotation=0
- RIGHT: patternId=smile, rotation=0
- FRONT: patternId=arrow_up, rotation=270
- BOTTOM: patternId=K, rotation=270

## 5. ACTION VOCABULARY
A complete answer is one ordered list of direction tokens:
- direction: one of {"N", "S", "E", "W"}.
- Sequence length is the number of rolls. The maximum allowed length for this task is `max_direction_steps`.
- Multiple sequences may produce the same target top face; any one of them counts as correct.

## 6. CONSTRAINTS
- Each direction token must be exactly one of N, S, E, W (uppercase).
- The sequence length must be between 1 and `max_direction_steps` inclusive.
- The sequence must be deterministic: no probabilistic or "either-or" entries. One direction per step.
- The engine evaluates by simulating your sequence on the initial cube; do not output any other JSON keys.

## 7. SOLVING ADVICE
- Track which face is currently on top after each roll. A roll N moves the FRONT face to the new TOP, S moves BACK to TOP, E moves LEFT to TOP, W moves RIGHT to TOP (with appropriate rotation).
- Confirm the rotation of the target top face — getting the patternId right but the rotation wrong is still a fail. Each roll N or S adjusts the cube's local-frame rotation by 0/180; each roll E or W adjusts it by ±90.
- A reference sequence may be inferable from the imprint history if the data includes one, but you do not need to copy it; output any valid sequence.

## 8. OUTPUT SCHEMA
FINAL_JSON: {"directions":["<N|S|E|W>", ...]}
- directions: array of direction tokens.
- Each token: one of `"N"`, `"S"`, `"E"`, `"W"`.
- Length: 1..20.

## 9. FINAL INSTRUCTION
You may include reasoning above, but the very last line of your reply must start with FINAL_JSON: followed by exactly one valid JSON object.
Do not wrap FINAL_JSON in code fences and do not write anything after it.


Goal Roll C458

You are given the initial state of the cube as a cross-shaped net. This net is the unfolded outer surface of the folded cube. Each visible cell is labeled as TOP, BOTTOM, FRONT, BACK, LEFT, or RIGHT. The number under each visible face is the clockwise rotation in degrees from the original upright pattern. Output a roll sequence so that, at the end, the cube's top face seen from above exactly matches the target image.

System:
You are a cube-rolling sequence solver. Given a cube whose initial outer-surface configuration is shown as a cross net and a target top-face image, output one valid sequence of N/S/E/W rolls so that the cube's top face after the sequence matches the target.

You will receive: (a) one initial cross-net image showing the visible faces of the unfolded cube with their patternIds and rotations, (b) one target top-face image showing the desired final top-face pattern and orientation, and (c) a structured text body listing every visible net cell, the target patternId+rotation, the direction vocabulary, and the maximum allowed sequence length.

You may reason step by step before the final answer. Place your final answer on the very last line of your reply, in the form: FINAL_JSON: <one-line JSON>

The JSON object must follow the directions schema described in section 8 of the user prompt. Multiple sequences may be valid — output any one that solves the puzzle. Do NOT wrap FINAL_JSON in Markdown code fences. Do NOT write anything after the FINAL_JSON line. Emit exactly one FINAL_JSON line.

If you cannot reason out a confident sequence, still output your best-effort FINAL_JSON line with at least one direction token; the only structurally invalid output is no FINAL_JSON line at all. Never refuse, never return prose only.

## 1. TASK
Output one sequence of rolls so that, at the end of the sequence, the cube's top face seen from above matches the target top face exactly (both patternId and rotation).
The puzzle is solved when the engine simulates your sequence on the initial cube and the resulting top-face pattern equals the target.

## 2. WORLD MODEL
- Cube: a unit cube with one pattern printed on each of its six outer faces. The faces are named TOP, BOTTOM, FRONT, BACK, LEFT, RIGHT in the world frame.
- Cross net: the unfolded outer surface laid flat. Each cell is one face; its label tells you which face it is and its number under the patternId is the clockwise rotation in degrees from the original upright pattern.
- Roll: tipping the cube 90° about one of its bottom edges into an adjacent grid cell. After a roll, the face that was on the side becomes the new top, the previous top moves to the opposite side, and so on.
- Direction tokens: N (roll up / north), S (roll down / south), E (roll right / east), W (roll left / west). The direction is always relative to the world frame, not the cube's current orientation.
- Target top face: the desired patternId and rotation of whichever face ends up on top after the sequence.

## 3. VISUAL LEGEND
- Image 1: initial cross-net of the cube. The TOP/BOTTOM/FRONT/BACK/LEFT/RIGHT cells are arranged in a cross. Each visible face shows its patternId and a number indicating the clockwise rotation in degrees from the upright orientation.
- Image 2: the target top-face image, showing the patternId and rotation the cube's top face must reach.
- Coordinates: the cube starts at (0, 0). N decrements y (up on screen), S increments y, E increments x (right), W decrements x.

## 4. INPUT FIELDS
- sample_id: C458
- task_type: roll_to_target_top_face
- difficulty: 5
- target_top_face: patternId=F, rotation=0
- max_direction_steps: 20
- initial_net_layout (text view, with the BACK / LEFT-TOP-RIGHT / FRONT / BOTTOM rows of the cross):
  [BACK: patternId=heart, rotation=270]
[LEFT: patternId=?, rotation=0] [TOP: patternId=smile, rotation=270] [RIGHT: patternId=P, rotation=180]
  [FRONT: patternId=F, rotation=180]
  [BOTTOM: patternId=J, rotation=90]
- initial_net_cells (explicit list of every visible face):
- BACK: patternId=heart, rotation=270
- LEFT: patternId=?, rotation=0
- TOP: patternId=smile, rotation=270
- RIGHT: patternId=P, rotation=180
- FRONT: patternId=F, rotation=180
- BOTTOM: patternId=J, rotation=90

## 5. ACTION VOCABULARY
A complete answer is one ordered list of direction tokens:
- direction: one of {"N", "S", "E", "W"}.
- Sequence length is the number of rolls. The maximum allowed length for this task is `max_direction_steps`.
- Multiple sequences may produce the same target top face; any one of them counts as correct.

## 6. CONSTRAINTS
- Each direction token must be exactly one of N, S, E, W (uppercase).
- The sequence length must be between 1 and `max_direction_steps` inclusive.
- The sequence must be deterministic: no probabilistic or "either-or" entries. One direction per step.
- The engine evaluates by simulating your sequence on the initial cube; do not output any other JSON keys.

## 7. SOLVING ADVICE
- Track which face is currently on top after each roll. A roll N moves the FRONT face to the new TOP, S moves BACK to TOP, E moves LEFT to TOP, W moves RIGHT to TOP (with appropriate rotation).
- Confirm the rotation of the target top face — getting the patternId right but the rotation wrong is still a fail. Each roll N or S adjusts the cube's local-frame rotation by 0/180; each roll E or W adjusts it by ±90.
- A reference sequence may be inferable from the imprint history if the data includes one, but you do not need to copy it; output any valid sequence.

## 8. OUTPUT SCHEMA
FINAL_JSON: {"directions":["<N|S|E|W>", ...]}
- directions: array of direction tokens.
- Each token: one of `"N"`, `"S"`, `"E"`, `"W"`.
- Length: 1..20.

## 9. FINAL INSTRUCTION
You may include reasoning above, but the very last line of your reply must start with FINAL_JSON: followed by exactly one valid JSON object.
Do not wrap FINAL_JSON in code fences and do not write anything after it.


Goal Roll C459

You are given the initial state of the cube as a cross-shaped net. This net is the unfolded outer surface of the folded cube. Each visible cell is labeled as TOP, BOTTOM, FRONT, BACK, LEFT, or RIGHT. The number under each visible face is the clockwise rotation in degrees from the original upright pattern. Output a roll sequence so that, at the end, the cube's top face seen from above exactly matches the target image.

System:
You are a cube-rolling sequence solver. Given a cube whose initial outer-surface configuration is shown as a cross net and a target top-face image, output one valid sequence of N/S/E/W rolls so that the cube's top face after the sequence matches the target.

You will receive: (a) one initial cross-net image showing the visible faces of the unfolded cube with their patternIds and rotations, (b) one target top-face image showing the desired final top-face pattern and orientation, and (c) a structured text body listing every visible net cell, the target patternId+rotation, the direction vocabulary, and the maximum allowed sequence length.

You may reason step by step before the final answer. Place your final answer on the very last line of your reply, in the form: FINAL_JSON: <one-line JSON>

The JSON object must follow the directions schema described in section 8 of the user prompt. Multiple sequences may be valid — output any one that solves the puzzle. Do NOT wrap FINAL_JSON in Markdown code fences. Do NOT write anything after the FINAL_JSON line. Emit exactly one FINAL_JSON line.

If you cannot reason out a confident sequence, still output your best-effort FINAL_JSON line with at least one direction token; the only structurally invalid output is no FINAL_JSON line at all. Never refuse, never return prose only.

## 1. TASK
Output one sequence of rolls so that, at the end of the sequence, the cube's top face seen from above matches the target top face exactly (both patternId and rotation).
The puzzle is solved when the engine simulates your sequence on the initial cube and the resulting top-face pattern equals the target.

## 2. WORLD MODEL
- Cube: a unit cube with one pattern printed on each of its six outer faces. The faces are named TOP, BOTTOM, FRONT, BACK, LEFT, RIGHT in the world frame.
- Cross net: the unfolded outer surface laid flat. Each cell is one face; its label tells you which face it is and its number under the patternId is the clockwise rotation in degrees from the original upright pattern.
- Roll: tipping the cube 90° about one of its bottom edges into an adjacent grid cell. After a roll, the face that was on the side becomes the new top, the previous top moves to the opposite side, and so on.
- Direction tokens: N (roll up / north), S (roll down / south), E (roll right / east), W (roll left / west). The direction is always relative to the world frame, not the cube's current orientation.
- Target top face: the desired patternId and rotation of whichever face ends up on top after the sequence.

## 3. VISUAL LEGEND
- Image 1: initial cross-net of the cube. The TOP/BOTTOM/FRONT/BACK/LEFT/RIGHT cells are arranged in a cross. Each visible face shows its patternId and a number indicating the clockwise rotation in degrees from the upright orientation.
- Image 2: the target top-face image, showing the patternId and rotation the cube's top face must reach.
- Coordinates: the cube starts at (0, 0). N decrements y (up on screen), S increments y, E increments x (right), W decrements x.

## 4. INPUT FIELDS
- sample_id: C459
- task_type: roll_to_target_top_face
- difficulty: 5
- target_top_face: patternId=L, rotation=0
- max_direction_steps: 20
- initial_net_layout (text view, with the BACK / LEFT-TOP-RIGHT / FRONT / BOTTOM rows of the cross):
  [BACK: patternId=star, rotation=180]
[LEFT: patternId=L, rotation=270] [TOP: patternId=smile, rotation=0] [RIGHT: patternId=S, rotation=90]
  [FRONT: patternId=Z, rotation=270]
  [BOTTOM: patternId=X, rotation=90]
- initial_net_cells (explicit list of every visible face):
- BACK: patternId=star, rotation=180
- LEFT: patternId=L, rotation=270
- TOP: patternId=smile, rotation=0
- RIGHT: patternId=S, rotation=90
- FRONT: patternId=Z, rotation=270
- BOTTOM: patternId=X, rotation=90

## 5. ACTION VOCABULARY
A complete answer is one ordered list of direction tokens:
- direction: one of {"N", "S", "E", "W"}.
- Sequence length is the number of rolls. The maximum allowed length for this task is `max_direction_steps`.
- Multiple sequences may produce the same target top face; any one of them counts as correct.

## 6. CONSTRAINTS
- Each direction token must be exactly one of N, S, E, W (uppercase).
- The sequence length must be between 1 and `max_direction_steps` inclusive.
- The sequence must be deterministic: no probabilistic or "either-or" entries. One direction per step.
- The engine evaluates by simulating your sequence on the initial cube; do not output any other JSON keys.

## 7. SOLVING ADVICE
- Track which face is currently on top after each roll. A roll N moves the FRONT face to the new TOP, S moves BACK to TOP, E moves LEFT to TOP, W moves RIGHT to TOP (with appropriate rotation).
- Confirm the rotation of the target top face — getting the patternId right but the rotation wrong is still a fail. Each roll N or S adjusts the cube's local-frame rotation by 0/180; each roll E or W adjusts it by ±90.
- A reference sequence may be inferable from the imprint history if the data includes one, but you do not need to copy it; output any valid sequence.

## 8. OUTPUT SCHEMA
FINAL_JSON: {"directions":["<N|S|E|W>", ...]}
- directions: array of direction tokens.
- Each token: one of `"N"`, `"S"`, `"E"`, `"W"`.
- Length: 1..20.

## 9. FINAL INSTRUCTION
You may include reasoning above, but the very last line of your reply must start with FINAL_JSON: followed by exactly one valid JSON object.
Do not wrap FINAL_JSON in code fences and do not write anything after it.


Goal Roll C460

You are given the initial state of the cube as a cross-shaped net. This net is the unfolded outer surface of the folded cube. Each visible cell is labeled as TOP, BOTTOM, FRONT, BACK, LEFT, or RIGHT. The number under each visible face is the clockwise rotation in degrees from the original upright pattern. Output a roll sequence so that, at the end, the cube's top face seen from above exactly matches the target image.

System:
You are a cube-rolling sequence solver. Given a cube whose initial outer-surface configuration is shown as a cross net and a target top-face image, output one valid sequence of N/S/E/W rolls so that the cube's top face after the sequence matches the target.

You will receive: (a) one initial cross-net image showing the visible faces of the unfolded cube with their patternIds and rotations, (b) one target top-face image showing the desired final top-face pattern and orientation, and (c) a structured text body listing every visible net cell, the target patternId+rotation, the direction vocabulary, and the maximum allowed sequence length.

You may reason step by step before the final answer. Place your final answer on the very last line of your reply, in the form: FINAL_JSON: <one-line JSON>

The JSON object must follow the directions schema described in section 8 of the user prompt. Multiple sequences may be valid — output any one that solves the puzzle. Do NOT wrap FINAL_JSON in Markdown code fences. Do NOT write anything after the FINAL_JSON line. Emit exactly one FINAL_JSON line.

If you cannot reason out a confident sequence, still output your best-effort FINAL_JSON line with at least one direction token; the only structurally invalid output is no FINAL_JSON line at all. Never refuse, never return prose only.

## 1. TASK
Output one sequence of rolls so that, at the end of the sequence, the cube's top face seen from above matches the target top face exactly (both patternId and rotation).
The puzzle is solved when the engine simulates your sequence on the initial cube and the resulting top-face pattern equals the target.

## 2. WORLD MODEL
- Cube: a unit cube with one pattern printed on each of its six outer faces. The faces are named TOP, BOTTOM, FRONT, BACK, LEFT, RIGHT in the world frame.
- Cross net: the unfolded outer surface laid flat. Each cell is one face; its label tells you which face it is and its number under the patternId is the clockwise rotation in degrees from the original upright pattern.
- Roll: tipping the cube 90° about one of its bottom edges into an adjacent grid cell. After a roll, the face that was on the side becomes the new top, the previous top moves to the opposite side, and so on.
- Direction tokens: N (roll up / north), S (roll down / south), E (roll right / east), W (roll left / west). The direction is always relative to the world frame, not the cube's current orientation.
- Target top face: the desired patternId and rotation of whichever face ends up on top after the sequence.

## 3. VISUAL LEGEND
- Image 1: initial cross-net of the cube. The TOP/BOTTOM/FRONT/BACK/LEFT/RIGHT cells are arranged in a cross. Each visible face shows its patternId and a number indicating the clockwise rotation in degrees from the upright orientation.
- Image 2: the target top-face image, showing the patternId and rotation the cube's top face must reach.
- Coordinates: the cube starts at (0, 0). N decrements y (up on screen), S increments y, E increments x (right), W decrements x.

## 4. INPUT FIELDS
- sample_id: C460
- task_type: roll_to_target_top_face
- difficulty: 5
- target_top_face: patternId=D, rotation=0
- max_direction_steps: 20
- initial_net_layout (text view, with the BACK / LEFT-TOP-RIGHT / FRONT / BOTTOM rows of the cross):
  [BACK: patternId=1, rotation=0]
[LEFT: patternId=P, rotation=0] [TOP: patternId=7, rotation=0] [RIGHT: patternId=B, rotation=270]
  [FRONT: patternId=H, rotation=0]
  [BOTTOM: patternId=D, rotation=180]
- initial_net_cells (explicit list of every visible face):
- BACK: patternId=1, rotation=0
- LEFT: patternId=P, rotation=0
- TOP: patternId=7, rotation=0
- RIGHT: patternId=B, rotation=270
- FRONT: patternId=H, rotation=0
- BOTTOM: patternId=D, rotation=180

## 5. ACTION VOCABULARY
A complete answer is one ordered list of direction tokens:
- direction: one of {"N", "S", "E", "W"}.
- Sequence length is the number of rolls. The maximum allowed length for this task is `max_direction_steps`.
- Multiple sequences may produce the same target top face; any one of them counts as correct.

## 6. CONSTRAINTS
- Each direction token must be exactly one of N, S, E, W (uppercase).
- The sequence length must be between 1 and `max_direction_steps` inclusive.
- The sequence must be deterministic: no probabilistic or "either-or" entries. One direction per step.
- The engine evaluates by simulating your sequence on the initial cube; do not output any other JSON keys.

## 7. SOLVING ADVICE
- Track which face is currently on top after each roll. A roll N moves the FRONT face to the new TOP, S moves BACK to TOP, E moves LEFT to TOP, W moves RIGHT to TOP (with appropriate rotation).
- Confirm the rotation of the target top face — getting the patternId right but the rotation wrong is still a fail. Each roll N or S adjusts the cube's local-frame rotation by 0/180; each roll E or W adjusts it by ±90.
- A reference sequence may be inferable from the imprint history if the data includes one, but you do not need to copy it; output any valid sequence.

## 8. OUTPUT SCHEMA
FINAL_JSON: {"directions":["<N|S|E|W>", ...]}
- directions: array of direction tokens.
- Each token: one of `"N"`, `"S"`, `"E"`, `"W"`.
- Length: 1..20.

## 9. FINAL INSTRUCTION
You may include reasoning above, but the very last line of your reply must start with FINAL_JSON: followed by exactly one valid JSON object.
Do not wrap FINAL_JSON in code fences and do not write anything after it.


Goal Roll C461

You are given the initial state of the cube as a cross-shaped net. This net is the unfolded outer surface of the folded cube. Each visible cell is labeled as TOP, BOTTOM, FRONT, BACK, LEFT, or RIGHT. The number under each visible face is the clockwise rotation in degrees from the original upright pattern. Output a roll sequence so that, at the end, the cube's top face seen from above exactly matches the target image.

System:
You are a cube-rolling sequence solver. Given a cube whose initial outer-surface configuration is shown as a cross net and a target top-face image, output one valid sequence of N/S/E/W rolls so that the cube's top face after the sequence matches the target.

You will receive: (a) one initial cross-net image showing the visible faces of the unfolded cube with their patternIds and rotations, (b) one target top-face image showing the desired final top-face pattern and orientation, and (c) a structured text body listing every visible net cell, the target patternId+rotation, the direction vocabulary, and the maximum allowed sequence length.

You may reason step by step before the final answer. Place your final answer on the very last line of your reply, in the form: FINAL_JSON: <one-line JSON>

The JSON object must follow the directions schema described in section 8 of the user prompt. Multiple sequences may be valid — output any one that solves the puzzle. Do NOT wrap FINAL_JSON in Markdown code fences. Do NOT write anything after the FINAL_JSON line. Emit exactly one FINAL_JSON line.

If you cannot reason out a confident sequence, still output your best-effort FINAL_JSON line with at least one direction token; the only structurally invalid output is no FINAL_JSON line at all. Never refuse, never return prose only.

## 1. TASK
Output one sequence of rolls so that, at the end of the sequence, the cube's top face seen from above matches the target top face exactly (both patternId and rotation).
The puzzle is solved when the engine simulates your sequence on the initial cube and the resulting top-face pattern equals the target.

## 2. WORLD MODEL
- Cube: a unit cube with one pattern printed on each of its six outer faces. The faces are named TOP, BOTTOM, FRONT, BACK, LEFT, RIGHT in the world frame.
- Cross net: the unfolded outer surface laid flat. Each cell is one face; its label tells you which face it is and its number under the patternId is the clockwise rotation in degrees from the original upright pattern.
- Roll: tipping the cube 90° about one of its bottom edges into an adjacent grid cell. After a roll, the face that was on the side becomes the new top, the previous top moves to the opposite side, and so on.
- Direction tokens: N (roll up / north), S (roll down / south), E (roll right / east), W (roll left / west). The direction is always relative to the world frame, not the cube's current orientation.
- Target top face: the desired patternId and rotation of whichever face ends up on top after the sequence.

## 3. VISUAL LEGEND
- Image 1: initial cross-net of the cube. The TOP/BOTTOM/FRONT/BACK/LEFT/RIGHT cells are arranged in a cross. Each visible face shows its patternId and a number indicating the clockwise rotation in degrees from the upright orientation.
- Image 2: the target top-face image, showing the patternId and rotation the cube's top face must reach.
- Coordinates: the cube starts at (0, 0). N decrements y (up on screen), S increments y, E increments x (right), W decrements x.

## 4. INPUT FIELDS
- sample_id: C461
- task_type: roll_to_target_top_face
- difficulty: 5
- target_top_face: patternId=A, rotation=0
- max_direction_steps: 20
- initial_net_layout (text view, with the BACK / LEFT-TOP-RIGHT / FRONT / BOTTOM rows of the cross):
  [BACK: patternId=diamond, rotation=180]
[LEFT: patternId=diamond, rotation=270] [TOP: patternId=plus, rotation=90] [RIGHT: patternId=A, rotation=270]
  [FRONT: patternId=K, rotation=90]
  [BOTTOM: patternId=triangle, rotation=0]
- initial_net_cells (explicit list of every visible face):
- BACK: patternId=diamond, rotation=180
- LEFT: patternId=diamond, rotation=270
- TOP: patternId=plus, rotation=90
- RIGHT: patternId=A, rotation=270
- FRONT: patternId=K, rotation=90
- BOTTOM: patternId=triangle, rotation=0

## 5. ACTION VOCABULARY
A complete answer is one ordered list of direction tokens:
- direction: one of {"N", "S", "E", "W"}.
- Sequence length is the number of rolls. The maximum allowed length for this task is `max_direction_steps`.
- Multiple sequences may produce the same target top face; any one of them counts as correct.

## 6. CONSTRAINTS
- Each direction token must be exactly one of N, S, E, W (uppercase).
- The sequence length must be between 1 and `max_direction_steps` inclusive.
- The sequence must be deterministic: no probabilistic or "either-or" entries. One direction per step.
- The engine evaluates by simulating your sequence on the initial cube; do not output any other JSON keys.

## 7. SOLVING ADVICE
- Track which face is currently on top after each roll. A roll N moves the FRONT face to the new TOP, S moves BACK to TOP, E moves LEFT to TOP, W moves RIGHT to TOP (with appropriate rotation).
- Confirm the rotation of the target top face — getting the patternId right but the rotation wrong is still a fail. Each roll N or S adjusts the cube's local-frame rotation by 0/180; each roll E or W adjusts it by ±90.
- A reference sequence may be inferable from the imprint history if the data includes one, but you do not need to copy it; output any valid sequence.

## 8. OUTPUT SCHEMA
FINAL_JSON: {"directions":["<N|S|E|W>", ...]}
- directions: array of direction tokens.
- Each token: one of `"N"`, `"S"`, `"E"`, `"W"`.
- Length: 1..20.

## 9. FINAL INSTRUCTION
You may include reasoning above, but the very last line of your reply must start with FINAL_JSON: followed by exactly one valid JSON object.
Do not wrap FINAL_JSON in code fences and do not write anything after it.


Goal Roll C462

You are given the initial state of the cube as a cross-shaped net. This net is the unfolded outer surface of the folded cube. Each visible cell is labeled as TOP, BOTTOM, FRONT, BACK, LEFT, or RIGHT. The number under each visible face is the clockwise rotation in degrees from the original upright pattern. Output a roll sequence so that, at the end, the cube's top face seen from above exactly matches the target image.

System:
You are a cube-rolling sequence solver. Given a cube whose initial outer-surface configuration is shown as a cross net and a target top-face image, output one valid sequence of N/S/E/W rolls so that the cube's top face after the sequence matches the target.

You will receive: (a) one initial cross-net image showing the visible faces of the unfolded cube with their patternIds and rotations, (b) one target top-face image showing the desired final top-face pattern and orientation, and (c) a structured text body listing every visible net cell, the target patternId+rotation, the direction vocabulary, and the maximum allowed sequence length.

You may reason step by step before the final answer. Place your final answer on the very last line of your reply, in the form: FINAL_JSON: <one-line JSON>

The JSON object must follow the directions schema described in section 8 of the user prompt. Multiple sequences may be valid — output any one that solves the puzzle. Do NOT wrap FINAL_JSON in Markdown code fences. Do NOT write anything after the FINAL_JSON line. Emit exactly one FINAL_JSON line.

If you cannot reason out a confident sequence, still output your best-effort FINAL_JSON line with at least one direction token; the only structurally invalid output is no FINAL_JSON line at all. Never refuse, never return prose only.

## 1. TASK
Output one sequence of rolls so that, at the end of the sequence, the cube's top face seen from above matches the target top face exactly (both patternId and rotation).
The puzzle is solved when the engine simulates your sequence on the initial cube and the resulting top-face pattern equals the target.

## 2. WORLD MODEL
- Cube: a unit cube with one pattern printed on each of its six outer faces. The faces are named TOP, BOTTOM, FRONT, BACK, LEFT, RIGHT in the world frame.
- Cross net: the unfolded outer surface laid flat. Each cell is one face; its label tells you which face it is and its number under the patternId is the clockwise rotation in degrees from the original upright pattern.
- Roll: tipping the cube 90° about one of its bottom edges into an adjacent grid cell. After a roll, the face that was on the side becomes the new top, the previous top moves to the opposite side, and so on.
- Direction tokens: N (roll up / north), S (roll down / south), E (roll right / east), W (roll left / west). The direction is always relative to the world frame, not the cube's current orientation.
- Target top face: the desired patternId and rotation of whichever face ends up on top after the sequence.

## 3. VISUAL LEGEND
- Image 1: initial cross-net of the cube. The TOP/BOTTOM/FRONT/BACK/LEFT/RIGHT cells are arranged in a cross. Each visible face shows its patternId and a number indicating the clockwise rotation in degrees from the upright orientation.
- Image 2: the target top-face image, showing the patternId and rotation the cube's top face must reach.
- Coordinates: the cube starts at (0, 0). N decrements y (up on screen), S increments y, E increments x (right), W decrements x.

## 4. INPUT FIELDS
- sample_id: C462
- task_type: roll_to_target_top_face
- difficulty: 5
- target_top_face: patternId=8, rotation=0
- max_direction_steps: 20
- initial_net_layout (text view, with the BACK / LEFT-TOP-RIGHT / FRONT / BOTTOM rows of the cross):
  [BACK: patternId=?, rotation=0]
[LEFT: patternId=8, rotation=270] [TOP: patternId=E, rotation=0] [RIGHT: patternId=arrow_right, rotation=270]
  [FRONT: patternId=1, rotation=90]
  [BOTTOM: patternId=5, rotation=270]
- initial_net_cells (explicit list of every visible face):
- BACK: patternId=?, rotation=0
- LEFT: patternId=8, rotation=270
- TOP: patternId=E, rotation=0
- RIGHT: patternId=arrow_right, rotation=270
- FRONT: patternId=1, rotation=90
- BOTTOM: patternId=5, rotation=270

## 5. ACTION VOCABULARY
A complete answer is one ordered list of direction tokens:
- direction: one of {"N", "S", "E", "W"}.
- Sequence length is the number of rolls. The maximum allowed length for this task is `max_direction_steps`.
- Multiple sequences may produce the same target top face; any one of them counts as correct.

## 6. CONSTRAINTS
- Each direction token must be exactly one of N, S, E, W (uppercase).
- The sequence length must be between 1 and `max_direction_steps` inclusive.
- The sequence must be deterministic: no probabilistic or "either-or" entries. One direction per step.
- The engine evaluates by simulating your sequence on the initial cube; do not output any other JSON keys.

## 7. SOLVING ADVICE
- Track which face is currently on top after each roll. A roll N moves the FRONT face to the new TOP, S moves BACK to TOP, E moves LEFT to TOP, W moves RIGHT to TOP (with appropriate rotation).
- Confirm the rotation of the target top face — getting the patternId right but the rotation wrong is still a fail. Each roll N or S adjusts the cube's local-frame rotation by 0/180; each roll E or W adjusts it by ±90.
- A reference sequence may be inferable from the imprint history if the data includes one, but you do not need to copy it; output any valid sequence.

## 8. OUTPUT SCHEMA
FINAL_JSON: {"directions":["<N|S|E|W>", ...]}
- directions: array of direction tokens.
- Each token: one of `"N"`, `"S"`, `"E"`, `"W"`.
- Length: 1..20.

## 9. FINAL INSTRUCTION
You may include reasoning above, but the very last line of your reply must start with FINAL_JSON: followed by exactly one valid JSON object.
Do not wrap FINAL_JSON in code fences and do not write anything after it.


Goal Roll C463

You are given the initial state of the cube as a cross-shaped net. This net is the unfolded outer surface of the folded cube. Each visible cell is labeled as TOP, BOTTOM, FRONT, BACK, LEFT, or RIGHT. The number under each visible face is the clockwise rotation in degrees from the original upright pattern. Output a roll sequence so that, at the end, the cube's top face seen from above exactly matches the target image.

System:
You are a cube-rolling sequence solver. Given a cube whose initial outer-surface configuration is shown as a cross net and a target top-face image, output one valid sequence of N/S/E/W rolls so that the cube's top face after the sequence matches the target.

You will receive: (a) one initial cross-net image showing the visible faces of the unfolded cube with their patternIds and rotations, (b) one target top-face image showing the desired final top-face pattern and orientation, and (c) a structured text body listing every visible net cell, the target patternId+rotation, the direction vocabulary, and the maximum allowed sequence length.

You may reason step by step before the final answer. Place your final answer on the very last line of your reply, in the form: FINAL_JSON: <one-line JSON>

The JSON object must follow the directions schema described in section 8 of the user prompt. Multiple sequences may be valid — output any one that solves the puzzle. Do NOT wrap FINAL_JSON in Markdown code fences. Do NOT write anything after the FINAL_JSON line. Emit exactly one FINAL_JSON line.

If you cannot reason out a confident sequence, still output your best-effort FINAL_JSON line with at least one direction token; the only structurally invalid output is no FINAL_JSON line at all. Never refuse, never return prose only.

## 1. TASK
Output one sequence of rolls so that, at the end of the sequence, the cube's top face seen from above matches the target top face exactly (both patternId and rotation).
The puzzle is solved when the engine simulates your sequence on the initial cube and the resulting top-face pattern equals the target.

## 2. WORLD MODEL
- Cube: a unit cube with one pattern printed on each of its six outer faces. The faces are named TOP, BOTTOM, FRONT, BACK, LEFT, RIGHT in the world frame.
- Cross net: the unfolded outer surface laid flat. Each cell is one face; its label tells you which face it is and its number under the patternId is the clockwise rotation in degrees from the original upright pattern.
- Roll: tipping the cube 90° about one of its bottom edges into an adjacent grid cell. After a roll, the face that was on the side becomes the new top, the previous top moves to the opposite side, and so on.
- Direction tokens: N (roll up / north), S (roll down / south), E (roll right / east), W (roll left / west). The direction is always relative to the world frame, not the cube's current orientation.
- Target top face: the desired patternId and rotation of whichever face ends up on top after the sequence.

## 3. VISUAL LEGEND
- Image 1: initial cross-net of the cube. The TOP/BOTTOM/FRONT/BACK/LEFT/RIGHT cells are arranged in a cross. Each visible face shows its patternId and a number indicating the clockwise rotation in degrees from the upright orientation.
- Image 2: the target top-face image, showing the patternId and rotation the cube's top face must reach.
- Coordinates: the cube starts at (0, 0). N decrements y (up on screen), S increments y, E increments x (right), W decrements x.

## 4. INPUT FIELDS
- sample_id: C463
- task_type: roll_to_target_top_face
- difficulty: 5
- target_top_face: patternId=T, rotation=90
- max_direction_steps: 20
- initial_net_layout (text view, with the BACK / LEFT-TOP-RIGHT / FRONT / BOTTOM rows of the cross):
  [BACK: patternId=T, rotation=90]
[LEFT: patternId=circle, rotation=90] [TOP: patternId=D, rotation=0] [RIGHT: patternId=D, rotation=180]
  [FRONT: patternId=I, rotation=270]
  [BOTTOM: patternId=J, rotation=0]
- initial_net_cells (explicit list of every visible face):
- BACK: patternId=T, rotation=90
- LEFT: patternId=circle, rotation=90
- TOP: patternId=D, rotation=0
- RIGHT: patternId=D, rotation=180
- FRONT: patternId=I, rotation=270
- BOTTOM: patternId=J, rotation=0

## 5. ACTION VOCABULARY
A complete answer is one ordered list of direction tokens:
- direction: one of {"N", "S", "E", "W"}.
- Sequence length is the number of rolls. The maximum allowed length for this task is `max_direction_steps`.
- Multiple sequences may produce the same target top face; any one of them counts as correct.

## 6. CONSTRAINTS
- Each direction token must be exactly one of N, S, E, W (uppercase).
- The sequence length must be between 1 and `max_direction_steps` inclusive.
- The sequence must be deterministic: no probabilistic or "either-or" entries. One direction per step.
- The engine evaluates by simulating your sequence on the initial cube; do not output any other JSON keys.

## 7. SOLVING ADVICE
- Track which face is currently on top after each roll. A roll N moves the FRONT face to the new TOP, S moves BACK to TOP, E moves LEFT to TOP, W moves RIGHT to TOP (with appropriate rotation).
- Confirm the rotation of the target top face — getting the patternId right but the rotation wrong is still a fail. Each roll N or S adjusts the cube's local-frame rotation by 0/180; each roll E or W adjusts it by ±90.
- A reference sequence may be inferable from the imprint history if the data includes one, but you do not need to copy it; output any valid sequence.

## 8. OUTPUT SCHEMA
FINAL_JSON: {"directions":["<N|S|E|W>", ...]}
- directions: array of direction tokens.
- Each token: one of `"N"`, `"S"`, `"E"`, `"W"`.
- Length: 1..20.

## 9. FINAL INSTRUCTION
You may include reasoning above, but the very last line of your reply must start with FINAL_JSON: followed by exactly one valid JSON object.
Do not wrap FINAL_JSON in code fences and do not write anything after it.


Goal Roll C464

You are given the initial state of the cube as a cross-shaped net. This net is the unfolded outer surface of the folded cube. Each visible cell is labeled as TOP, BOTTOM, FRONT, BACK, LEFT, or RIGHT. The number under each visible face is the clockwise rotation in degrees from the original upright pattern. Output a roll sequence so that, at the end, the cube's top face seen from above exactly matches the target image.

System:
You are a cube-rolling sequence solver. Given a cube whose initial outer-surface configuration is shown as a cross net and a target top-face image, output one valid sequence of N/S/E/W rolls so that the cube's top face after the sequence matches the target.

You will receive: (a) one initial cross-net image showing the visible faces of the unfolded cube with their patternIds and rotations, (b) one target top-face image showing the desired final top-face pattern and orientation, and (c) a structured text body listing every visible net cell, the target patternId+rotation, the direction vocabulary, and the maximum allowed sequence length.

You may reason step by step before the final answer. Place your final answer on the very last line of your reply, in the form: FINAL_JSON: <one-line JSON>

The JSON object must follow the directions schema described in section 8 of the user prompt. Multiple sequences may be valid — output any one that solves the puzzle. Do NOT wrap FINAL_JSON in Markdown code fences. Do NOT write anything after the FINAL_JSON line. Emit exactly one FINAL_JSON line.

If you cannot reason out a confident sequence, still output your best-effort FINAL_JSON line with at least one direction token; the only structurally invalid output is no FINAL_JSON line at all. Never refuse, never return prose only.

## 1. TASK
Output one sequence of rolls so that, at the end of the sequence, the cube's top face seen from above matches the target top face exactly (both patternId and rotation).
The puzzle is solved when the engine simulates your sequence on the initial cube and the resulting top-face pattern equals the target.

## 2. WORLD MODEL
- Cube: a unit cube with one pattern printed on each of its six outer faces. The faces are named TOP, BOTTOM, FRONT, BACK, LEFT, RIGHT in the world frame.
- Cross net: the unfolded outer surface laid flat. Each cell is one face; its label tells you which face it is and its number under the patternId is the clockwise rotation in degrees from the original upright pattern.
- Roll: tipping the cube 90° about one of its bottom edges into an adjacent grid cell. After a roll, the face that was on the side becomes the new top, the previous top moves to the opposite side, and so on.
- Direction tokens: N (roll up / north), S (roll down / south), E (roll right / east), W (roll left / west). The direction is always relative to the world frame, not the cube's current orientation.
- Target top face: the desired patternId and rotation of whichever face ends up on top after the sequence.

## 3. VISUAL LEGEND
- Image 1: initial cross-net of the cube. The TOP/BOTTOM/FRONT/BACK/LEFT/RIGHT cells are arranged in a cross. Each visible face shows its patternId and a number indicating the clockwise rotation in degrees from the upright orientation.
- Image 2: the target top-face image, showing the patternId and rotation the cube's top face must reach.
- Coordinates: the cube starts at (0, 0). N decrements y (up on screen), S increments y, E increments x (right), W decrements x.

## 4. INPUT FIELDS
- sample_id: C464
- task_type: roll_to_target_top_face
- difficulty: 5
- target_top_face: patternId=square, rotation=270
- max_direction_steps: 20
- initial_net_layout (text view, with the BACK / LEFT-TOP-RIGHT / FRONT / BOTTOM rows of the cross):
  [BACK: patternId=U, rotation=180]
[LEFT: patternId=?, rotation=0] [TOP: patternId=O, rotation=90] [RIGHT: patternId=T, rotation=90]
  [FRONT: patternId=square, rotation=180]
  [BOTTOM: patternId=?, rotation=0]
- initial_net_cells (explicit list of every visible face):
- BACK: patternId=U, rotation=180
- LEFT: patternId=?, rotation=0
- TOP: patternId=O, rotation=90
- RIGHT: patternId=T, rotation=90
- FRONT: patternId=square, rotation=180
- BOTTOM: patternId=?, rotation=0

## 5. ACTION VOCABULARY
A complete answer is one ordered list of direction tokens:
- direction: one of {"N", "S", "E", "W"}.
- Sequence length is the number of rolls. The maximum allowed length for this task is `max_direction_steps`.
- Multiple sequences may produce the same target top face; any one of them counts as correct.

## 6. CONSTRAINTS
- Each direction token must be exactly one of N, S, E, W (uppercase).
- The sequence length must be between 1 and `max_direction_steps` inclusive.
- The sequence must be deterministic: no probabilistic or "either-or" entries. One direction per step.
- The engine evaluates by simulating your sequence on the initial cube; do not output any other JSON keys.

## 7. SOLVING ADVICE
- Track which face is currently on top after each roll. A roll N moves the FRONT face to the new TOP, S moves BACK to TOP, E moves LEFT to TOP, W moves RIGHT to TOP (with appropriate rotation).
- Confirm the rotation of the target top face — getting the patternId right but the rotation wrong is still a fail. Each roll N or S adjusts the cube's local-frame rotation by 0/180; each roll E or W adjusts it by ±90.
- A reference sequence may be inferable from the imprint history if the data includes one, but you do not need to copy it; output any valid sequence.

## 8. OUTPUT SCHEMA
FINAL_JSON: {"directions":["<N|S|E|W>", ...]}
- directions: array of direction tokens.
- Each token: one of `"N"`, `"S"`, `"E"`, `"W"`.
- Length: 1..20.

## 9. FINAL INSTRUCTION
You may include reasoning above, but the very last line of your reply must start with FINAL_JSON: followed by exactly one valid JSON object.
Do not wrap FINAL_JSON in code fences and do not write anything after it.