System:
You are a Cut the Rope replayable-script solver. Given a short gameplay video of one Cut the Rope level (with a coordinate grid overlay) and a structured description of the level objects, you produce a deterministic command script that, replayed from the same initial state, wins the level.

You will receive: (a) one short gameplay video of the level, (b) a structured text body listing the canvas size, the count of each gameplay object (candy, target, ropes, bubbles, pumps, gravity switches, stars), and the level metadata.

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 commands schema described in section 8 of the user prompt: keys `commands`, `reason`, `confidence`. Multiple winning scripts may be valid; output any one. 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 solution, still emit a best-effort FINAL_JSON line with at least one command and a confidence value below 1.0. Never refuse, never return prose only.

## 1. TASK
Produce a replayable command script that wins the Cut the Rope level shown in the gameplay video. The script must be deterministic so that replaying it from the same initial state in the simulator produces a win.
The level is solved when the candy reaches the target monster's mouth. Three-star completion is preferred but stable winning is the first priority.

## 2. WORLD MODEL
- Candy: a physics object affected by gravity, ropes, bubbles, pumps, and other active objects. Must be delivered to the target.
- Target / monster: the level is won when the candy enters the target's mouth.
- Rope: a constraint between the candy (or a split-candy half) and an anchor. Cutting a rope releases the candy from that constraint. Ropes are zero-indexed.
- Grab: an anchor for a rope that can be repositioned during play. Zero-indexed.
- Bubble: when the candy enters a bubble, it usually floats upward. Pop the bubble to release the candy.
- Pump: a gust source that pushes objects. Each activation produces one impulse.
- Gravity switch: toggles gravity direction or magnitude.
- Star: collected by candy passing through its position. Up to 3 stars per level.
- Split candy: some levels start with two candy halves (`left_candy`, `right_candy`). Use the half-specific conditions before the halves merge; switch to `candy_*` conditions after they merge.

## 3. VISUAL LEGEND
- The video is a short clip showing the full level layout and a coordinate grid overlay.
- Coordinates: origin at the top-left corner. x increases to the right; y increases downward.
- Indices in the video are zero-based for ropes, bubbles, pumps, and grabs. Infer indices from object positions and the order they appear in the clip.

## 4. INPUT FIELDS
- level_id: rope-195
- canvas_size: 1920 x 1080
- two_parts (split candy): True
- object_counts:
  - target: 1
  - star: 3
  - left split candy: 1
  - right split candy: 1
  - bubble: 3
  - pump: 1
- gameplay objects in this level:
- Target (monster): the level is won when the candy reaches the monster's mouth. The target is usually fixed in place.
- Split candy: the level starts with left_candy and right_candy halves. Before they merge, use left_candy_* and right_candy_* conditions. After they touch and merge, use candy_* for the complete candy.
- Stars: candy or split-candy collects a star by passing through it. Prefer paths that collect 3 stars, but stable completion takes priority.
- Bubbles: candy entering a bubble usually floats upward. `pop_bubble N` pops bubble N. In split-candy levels, `pop_bubble_left` / `pop_bubble_right` pop the bubble holding the corresponding half.
- Pumps: activating a pump pushes nearby objects. `activate_pump N`, optionally with `times`/`every`/`until` modifiers for repeated activation.

## 5. ACTION VOCABULARY
A complete answer is one ordered command script (one command per line). Available actions:
- `cut_rope N`               — cut rope N
- `cut_rope N,M,K`           — cut several ropes simultaneously
- `pop_bubble N`             — pop bubble N
- `pop_bubble_left`          — pop the bubble holding the left split-candy half
- `pop_bubble_right`         — pop the bubble holding the right split-candy half
- `activate_pump N`          — fire pump N once
- `activate_pump N times C`  — fire C times back-to-back
- `activate_pump N times C every S` — fire C times spaced S seconds apart
- `activate_pump N every S until <CONDITION>` — fire repeatedly until CONDITION holds
- `move_grab N X`            — move grab N to x-coordinate X (y unchanged)
- `move_grab N X Y`          — move grab N to (X, Y)
- `kick_rope N`              — apply a one-shot impulse to rope N
- `toggle_gravity`           — toggle the gravity setting

Each command may be guarded by an optional `when <CONDITION>` clause. Available condition primitives:
- `candy_x > N`, `candy_x < N`, `candy_y > N`, `candy_y < N`
- `candy_near X,Y,R` — candy is within radius R of (X,Y); optional `for S` requires the predicate to hold for S seconds
- `candy_still for S` — candy speed is below threshold for S seconds (useful before cutting after a swing settles)
- `left_candy_*` and `right_candy_*` mirror the candy_* primitives for the corresponding split half
- `grab_x I > N`, `grab_y I < N`, `grab_near I,X,Y,R`
- `rope_cut N` — rope N has been cut
- `no_rope`, `candy_in_bubble`
- Conditions can be combined with `and`, `or`, and parentheses.

## 6. CONSTRAINTS
- One command per line in the `commands` string.
- Indices must be zero-based and consistent with the level video.
- `wait_frames` is NOT allowed in this benchmark version. Use condition-based waits.
- The script must be deterministic; do not output stochastic or "either-or" entries.
- The script must terminate without manual intervention; the simulator runs it from the initial state and decides win/loss.

## 7. SOLVING ADVICE
- Identify which ropes mainly control the candy first; choose a cut order that releases the candy along the shortest stable path to the target.
- When waiting for the candy to reach a place, prefer `candy_near` / `candy_y` / `candy_x` over fixed timing.
- For repeated pumping, use `activate_pump N times C every S` or `activate_pump N every S until CONDITION`.
- In split-candy levels, do NOT use `candy_still` / `candy_near` for the merged candy before the halves merge; use the `left_candy_*` / `right_candy_*` primitives instead.

## 8. OUTPUT SCHEMA
FINAL_JSON: {"commands":"<command-script with \n separators>","reason":"<one-sentence intent>","confidence":<0..1>}
- commands: string. One command per line; lines separated by `\n`.
- reason: short one-sentence explanation of the intended sequence.
- confidence: float in `[0, 1]`.

## 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.


cut_rope 0
pop_bubble 2 when candy_y < 400

cut_rope 0
pop_bubble 2 when candy_y < 400

System:
You are a Cut the Rope replayable-script solver. Given a short gameplay video of one Cut the Rope level (with a coordinate grid overlay) and a structured description of the level objects, you produce a deterministic command script that, replayed from the same initial state, wins the level.

You will receive: (a) one short gameplay video of the level, (b) a structured text body listing the canvas size, the count of each gameplay object (candy, target, ropes, bubbles, pumps, gravity switches, stars), and the level metadata.

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 commands schema described in section 8 of the user prompt: keys `commands`, `reason`, `confidence`. Multiple winning scripts may be valid; output any one. 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 solution, still emit a best-effort FINAL_JSON line with at least one command and a confidence value below 1.0. Never refuse, never return prose only.

## 1. TASK
Produce a replayable command script that wins the Cut the Rope level shown in the gameplay video. The script must be deterministic so that replaying it from the same initial state in the simulator produces a win.
The level is solved when the candy reaches the target monster's mouth. Three-star completion is preferred but stable winning is the first priority.

## 2. WORLD MODEL
- Candy: a physics object affected by gravity, ropes, bubbles, pumps, and other active objects. Must be delivered to the target.
- Target / monster: the level is won when the candy enters the target's mouth.
- Rope: a constraint between the candy (or a split-candy half) and an anchor. Cutting a rope releases the candy from that constraint. Ropes are zero-indexed.
- Grab: an anchor for a rope that can be repositioned during play. Zero-indexed.
- Bubble: when the candy enters a bubble, it usually floats upward. Pop the bubble to release the candy.
- Pump: a gust source that pushes objects. Each activation produces one impulse.
- Gravity switch: toggles gravity direction or magnitude.
- Star: collected by candy passing through its position. Up to 3 stars per level.
- Split candy: some levels start with two candy halves (`left_candy`, `right_candy`). Use the half-specific conditions before the halves merge; switch to `candy_*` conditions after they merge.

## 3. VISUAL LEGEND
- The video is a short clip showing the full level layout and a coordinate grid overlay.
- Coordinates: origin at the top-left corner. x increases to the right; y increases downward.
- Indices in the video are zero-based for ropes, bubbles, pumps, and grabs. Infer indices from object positions and the order they appear in the clip.

## 4. INPUT FIELDS
- level_id: rope-196
- canvas_size: 1920 x 1080
- two_parts (split candy): False
- object_counts:
  - target: 1
  - star: 3
  - candy: 1
  - rope/grab: 2
  - bubble: 3
- gameplay objects in this level:
- Target (monster): the level is won when the candy reaches the monster's mouth. The target is usually fixed in place.
- Candy: the candy is affected by gravity, ropes, bubbles, pumps, and other active objects. It must be delivered to the target.
- Ropes / grabs: ropes constrain the candy or split-candy movement. `cut_rope N` cuts rope N; `cut_rope N,M,K` cuts multiple at once. If a grab can move, `move_grab N X` or `move_grab N X Y` repositions it.
- Stars: candy or split-candy collects a star by passing through it. Prefer paths that collect 3 stars, but stable completion takes priority.
- Bubbles: candy entering a bubble usually floats upward. `pop_bubble N` pops bubble N. In split-candy levels, `pop_bubble_left` / `pop_bubble_right` pop the bubble holding the corresponding half.

## 5. ACTION VOCABULARY
A complete answer is one ordered command script (one command per line). Available actions:
- `cut_rope N`               — cut rope N
- `cut_rope N,M,K`           — cut several ropes simultaneously
- `pop_bubble N`             — pop bubble N
- `pop_bubble_left`          — pop the bubble holding the left split-candy half
- `pop_bubble_right`         — pop the bubble holding the right split-candy half
- `activate_pump N`          — fire pump N once
- `activate_pump N times C`  — fire C times back-to-back
- `activate_pump N times C every S` — fire C times spaced S seconds apart
- `activate_pump N every S until <CONDITION>` — fire repeatedly until CONDITION holds
- `move_grab N X`            — move grab N to x-coordinate X (y unchanged)
- `move_grab N X Y`          — move grab N to (X, Y)
- `kick_rope N`              — apply a one-shot impulse to rope N
- `toggle_gravity`           — toggle the gravity setting

Each command may be guarded by an optional `when <CONDITION>` clause. Available condition primitives:
- `candy_x > N`, `candy_x < N`, `candy_y > N`, `candy_y < N`
- `candy_near X,Y,R` — candy is within radius R of (X,Y); optional `for S` requires the predicate to hold for S seconds
- `candy_still for S` — candy speed is below threshold for S seconds (useful before cutting after a swing settles)
- `left_candy_*` and `right_candy_*` mirror the candy_* primitives for the corresponding split half
- `grab_x I > N`, `grab_y I < N`, `grab_near I,X,Y,R`
- `rope_cut N` — rope N has been cut
- `no_rope`, `candy_in_bubble`
- Conditions can be combined with `and`, `or`, and parentheses.

## 6. CONSTRAINTS
- One command per line in the `commands` string.
- Indices must be zero-based and consistent with the level video.
- `wait_frames` is NOT allowed in this benchmark version. Use condition-based waits.
- The script must be deterministic; do not output stochastic or "either-or" entries.
- The script must terminate without manual intervention; the simulator runs it from the initial state and decides win/loss.

## 7. SOLVING ADVICE
- Identify which ropes mainly control the candy first; choose a cut order that releases the candy along the shortest stable path to the target.
- When waiting for the candy to reach a place, prefer `candy_near` / `candy_y` / `candy_x` over fixed timing.
- For repeated pumping, use `activate_pump N times C every S` or `activate_pump N every S until CONDITION`.
- In split-candy levels, do NOT use `candy_still` / `candy_near` for the merged candy before the halves merge; use the `left_candy_*` / `right_candy_*` primitives instead.

## 8. OUTPUT SCHEMA
FINAL_JSON: {"commands":"<command-script with \n separators>","reason":"<one-sentence intent>","confidence":<0..1>}
- commands: string. One command per line; lines separated by `\n`.
- reason: short one-sentence explanation of the intended sequence.
- confidence: float in `[0, 1]`.

## 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.


activate_pump 1 when candy_still for 0.3 and candy_near 1000,570,60
activate_pump 0 when candy_y < 370
cut_rope 1 when candy_still for 0.3 and candy_near 1000,360,60
cut_rope 3
cut_rope 0 when candy_x > 1130
cut_rope 2 when candy_x > 1200

activate_pump 1 when candy_still for 0.3 and candy_near 1000,570,60
activate_pump 0 when candy_y < 370
cut_rope 1 when candy_still for 0.3 and candy_near 1000,360,60
cut_rope 3
cut_rope 0 when candy_x > 1130
cut_rope 2 when candy_x > 1200

System:
You are a Cut the Rope replayable-script solver. Given a short gameplay video of one Cut the Rope level (with a coordinate grid overlay) and a structured description of the level objects, you produce a deterministic command script that, replayed from the same initial state, wins the level.

You will receive: (a) one short gameplay video of the level, (b) a structured text body listing the canvas size, the count of each gameplay object (candy, target, ropes, bubbles, pumps, gravity switches, stars), and the level metadata.

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 commands schema described in section 8 of the user prompt: keys `commands`, `reason`, `confidence`. Multiple winning scripts may be valid; output any one. 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 solution, still emit a best-effort FINAL_JSON line with at least one command and a confidence value below 1.0. Never refuse, never return prose only.

## 1. TASK
Produce a replayable command script that wins the Cut the Rope level shown in the gameplay video. The script must be deterministic so that replaying it from the same initial state in the simulator produces a win.
The level is solved when the candy reaches the target monster's mouth. Three-star completion is preferred but stable winning is the first priority.

## 2. WORLD MODEL
- Candy: a physics object affected by gravity, ropes, bubbles, pumps, and other active objects. Must be delivered to the target.
- Target / monster: the level is won when the candy enters the target's mouth.
- Rope: a constraint between the candy (or a split-candy half) and an anchor. Cutting a rope releases the candy from that constraint. Ropes are zero-indexed.
- Grab: an anchor for a rope that can be repositioned during play. Zero-indexed.
- Bubble: when the candy enters a bubble, it usually floats upward. Pop the bubble to release the candy.
- Pump: a gust source that pushes objects. Each activation produces one impulse.
- Gravity switch: toggles gravity direction or magnitude.
- Star: collected by candy passing through its position. Up to 3 stars per level.
- Split candy: some levels start with two candy halves (`left_candy`, `right_candy`). Use the half-specific conditions before the halves merge; switch to `candy_*` conditions after they merge.

## 3. VISUAL LEGEND
- The video is a short clip showing the full level layout and a coordinate grid overlay.
- Coordinates: origin at the top-left corner. x increases to the right; y increases downward.
- Indices in the video are zero-based for ropes, bubbles, pumps, and grabs. Infer indices from object positions and the order they appear in the clip.

## 4. INPUT FIELDS
- level_id: rope-197
- canvas_size: 1920 x 1080
- two_parts (split candy): False
- object_counts:
  - target: 1
  - star: 3
  - candy: 1
  - rope/grab: 4
  - pump: 2
- gameplay objects in this level:
- Target (monster): the level is won when the candy reaches the monster's mouth. The target is usually fixed in place.
- Candy: the candy is affected by gravity, ropes, bubbles, pumps, and other active objects. It must be delivered to the target.
- Ropes / grabs: ropes constrain the candy or split-candy movement. `cut_rope N` cuts rope N; `cut_rope N,M,K` cuts multiple at once. If a grab can move, `move_grab N X` or `move_grab N X Y` repositions it.
- Stars: candy or split-candy collects a star by passing through it. Prefer paths that collect 3 stars, but stable completion takes priority.
- Pumps: activating a pump pushes nearby objects. `activate_pump N`, optionally with `times`/`every`/`until` modifiers for repeated activation.

## 5. ACTION VOCABULARY
A complete answer is one ordered command script (one command per line). Available actions:
- `cut_rope N`               — cut rope N
- `cut_rope N,M,K`           — cut several ropes simultaneously
- `pop_bubble N`             — pop bubble N
- `pop_bubble_left`          — pop the bubble holding the left split-candy half
- `pop_bubble_right`         — pop the bubble holding the right split-candy half
- `activate_pump N`          — fire pump N once
- `activate_pump N times C`  — fire C times back-to-back
- `activate_pump N times C every S` — fire C times spaced S seconds apart
- `activate_pump N every S until <CONDITION>` — fire repeatedly until CONDITION holds
- `move_grab N X`            — move grab N to x-coordinate X (y unchanged)
- `move_grab N X Y`          — move grab N to (X, Y)
- `kick_rope N`              — apply a one-shot impulse to rope N
- `toggle_gravity`           — toggle the gravity setting

Each command may be guarded by an optional `when <CONDITION>` clause. Available condition primitives:
- `candy_x > N`, `candy_x < N`, `candy_y > N`, `candy_y < N`
- `candy_near X,Y,R` — candy is within radius R of (X,Y); optional `for S` requires the predicate to hold for S seconds
- `candy_still for S` — candy speed is below threshold for S seconds (useful before cutting after a swing settles)
- `left_candy_*` and `right_candy_*` mirror the candy_* primitives for the corresponding split half
- `grab_x I > N`, `grab_y I < N`, `grab_near I,X,Y,R`
- `rope_cut N` — rope N has been cut
- `no_rope`, `candy_in_bubble`
- Conditions can be combined with `and`, `or`, and parentheses.

## 6. CONSTRAINTS
- One command per line in the `commands` string.
- Indices must be zero-based and consistent with the level video.
- `wait_frames` is NOT allowed in this benchmark version. Use condition-based waits.
- The script must be deterministic; do not output stochastic or "either-or" entries.
- The script must terminate without manual intervention; the simulator runs it from the initial state and decides win/loss.

## 7. SOLVING ADVICE
- Identify which ropes mainly control the candy first; choose a cut order that releases the candy along the shortest stable path to the target.
- When waiting for the candy to reach a place, prefer `candy_near` / `candy_y` / `candy_x` over fixed timing.
- For repeated pumping, use `activate_pump N times C every S` or `activate_pump N every S until CONDITION`.
- In split-candy levels, do NOT use `candy_still` / `candy_near` for the merged candy before the halves merge; use the `left_candy_*` / `right_candy_*` primitives instead.

## 8. OUTPUT SCHEMA
FINAL_JSON: {"commands":"<command-script with \n separators>","reason":"<one-sentence intent>","confidence":<0..1>}
- commands: string. One command per line; lines separated by `\n`.
- reason: short one-sentence explanation of the intended sequence.
- confidence: float in `[0, 1]`.

## 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.


cut_rope 2
cut_rope 0 when candy_y < 500

cut_rope 2
cut_rope 0 when candy_y < 500

System:
You are a Cut the Rope replayable-script solver. Given a short gameplay video of one Cut the Rope level (with a coordinate grid overlay) and a structured description of the level objects, you produce a deterministic command script that, replayed from the same initial state, wins the level.

You will receive: (a) one short gameplay video of the level, (b) a structured text body listing the canvas size, the count of each gameplay object (candy, target, ropes, bubbles, pumps, gravity switches, stars), and the level metadata.

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 commands schema described in section 8 of the user prompt: keys `commands`, `reason`, `confidence`. Multiple winning scripts may be valid; output any one. 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 solution, still emit a best-effort FINAL_JSON line with at least one command and a confidence value below 1.0. Never refuse, never return prose only.

## 1. TASK
Produce a replayable command script that wins the Cut the Rope level shown in the gameplay video. The script must be deterministic so that replaying it from the same initial state in the simulator produces a win.
The level is solved when the candy reaches the target monster's mouth. Three-star completion is preferred but stable winning is the first priority.

## 2. WORLD MODEL
- Candy: a physics object affected by gravity, ropes, bubbles, pumps, and other active objects. Must be delivered to the target.
- Target / monster: the level is won when the candy enters the target's mouth.
- Rope: a constraint between the candy (or a split-candy half) and an anchor. Cutting a rope releases the candy from that constraint. Ropes are zero-indexed.
- Grab: an anchor for a rope that can be repositioned during play. Zero-indexed.
- Bubble: when the candy enters a bubble, it usually floats upward. Pop the bubble to release the candy.
- Pump: a gust source that pushes objects. Each activation produces one impulse.
- Gravity switch: toggles gravity direction or magnitude.
- Star: collected by candy passing through its position. Up to 3 stars per level.
- Split candy: some levels start with two candy halves (`left_candy`, `right_candy`). Use the half-specific conditions before the halves merge; switch to `candy_*` conditions after they merge.

## 3. VISUAL LEGEND
- The video is a short clip showing the full level layout and a coordinate grid overlay.
- Coordinates: origin at the top-left corner. x increases to the right; y increases downward.
- Indices in the video are zero-based for ropes, bubbles, pumps, and grabs. Infer indices from object positions and the order they appear in the clip.

## 4. INPUT FIELDS
- level_id: rope-198
- canvas_size: 1920 x 1080
- two_parts (split candy): False
- object_counts:
  - target: 1
  - star: 3
  - candy: 1
  - rope/grab: 3
- gameplay objects in this level:
- Target (monster): the level is won when the candy reaches the monster's mouth. The target is usually fixed in place.
- Candy: the candy is affected by gravity, ropes, bubbles, pumps, and other active objects. It must be delivered to the target.
- Ropes / grabs: ropes constrain the candy or split-candy movement. `cut_rope N` cuts rope N; `cut_rope N,M,K` cuts multiple at once. If a grab can move, `move_grab N X` or `move_grab N X Y` repositions it.
- Stars: candy or split-candy collects a star by passing through it. Prefer paths that collect 3 stars, but stable completion takes priority.

## 5. ACTION VOCABULARY
A complete answer is one ordered command script (one command per line). Available actions:
- `cut_rope N`               — cut rope N
- `cut_rope N,M,K`           — cut several ropes simultaneously
- `pop_bubble N`             — pop bubble N
- `pop_bubble_left`          — pop the bubble holding the left split-candy half
- `pop_bubble_right`         — pop the bubble holding the right split-candy half
- `activate_pump N`          — fire pump N once
- `activate_pump N times C`  — fire C times back-to-back
- `activate_pump N times C every S` — fire C times spaced S seconds apart
- `activate_pump N every S until <CONDITION>` — fire repeatedly until CONDITION holds
- `move_grab N X`            — move grab N to x-coordinate X (y unchanged)
- `move_grab N X Y`          — move grab N to (X, Y)
- `kick_rope N`              — apply a one-shot impulse to rope N
- `toggle_gravity`           — toggle the gravity setting

Each command may be guarded by an optional `when <CONDITION>` clause. Available condition primitives:
- `candy_x > N`, `candy_x < N`, `candy_y > N`, `candy_y < N`
- `candy_near X,Y,R` — candy is within radius R of (X,Y); optional `for S` requires the predicate to hold for S seconds
- `candy_still for S` — candy speed is below threshold for S seconds (useful before cutting after a swing settles)
- `left_candy_*` and `right_candy_*` mirror the candy_* primitives for the corresponding split half
- `grab_x I > N`, `grab_y I < N`, `grab_near I,X,Y,R`
- `rope_cut N` — rope N has been cut
- `no_rope`, `candy_in_bubble`
- Conditions can be combined with `and`, `or`, and parentheses.

## 6. CONSTRAINTS
- One command per line in the `commands` string.
- Indices must be zero-based and consistent with the level video.
- `wait_frames` is NOT allowed in this benchmark version. Use condition-based waits.
- The script must be deterministic; do not output stochastic or "either-or" entries.
- The script must terminate without manual intervention; the simulator runs it from the initial state and decides win/loss.

## 7. SOLVING ADVICE
- Identify which ropes mainly control the candy first; choose a cut order that releases the candy along the shortest stable path to the target.
- When waiting for the candy to reach a place, prefer `candy_near` / `candy_y` / `candy_x` over fixed timing.
- For repeated pumping, use `activate_pump N times C every S` or `activate_pump N every S until CONDITION`.
- In split-candy levels, do NOT use `candy_still` / `candy_near` for the merged candy before the halves merge; use the `left_candy_*` / `right_candy_*` primitives instead.

## 8. OUTPUT SCHEMA
FINAL_JSON: {"commands":"<command-script with \n separators>","reason":"<one-sentence intent>","confidence":<0..1>}
- commands: string. One command per line; lines separated by `\n`.
- reason: short one-sentence explanation of the intended sequence.
- confidence: float in `[0, 1]`.

## 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.


cut_rope 1
cut_rope 2 when candy_x < 920
cut_rope 0 when candy_near 1200,630,60
cut_rope 3 when candy_near 770,920,60

cut_rope 1
cut_rope 2 when candy_x < 920
cut_rope 0 when candy_near 1200,630,60
cut_rope 3 when candy_near 770,920,60

System:
You are a Cut the Rope replayable-script solver. Given a short gameplay video of one Cut the Rope level (with a coordinate grid overlay) and a structured description of the level objects, you produce a deterministic command script that, replayed from the same initial state, wins the level.

You will receive: (a) one short gameplay video of the level, (b) a structured text body listing the canvas size, the count of each gameplay object (candy, target, ropes, bubbles, pumps, gravity switches, stars), and the level metadata.

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 commands schema described in section 8 of the user prompt: keys `commands`, `reason`, `confidence`. Multiple winning scripts may be valid; output any one. 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 solution, still emit a best-effort FINAL_JSON line with at least one command and a confidence value below 1.0. Never refuse, never return prose only.

## 1. TASK
Produce a replayable command script that wins the Cut the Rope level shown in the gameplay video. The script must be deterministic so that replaying it from the same initial state in the simulator produces a win.
The level is solved when the candy reaches the target monster's mouth. Three-star completion is preferred but stable winning is the first priority.

## 2. WORLD MODEL
- Candy: a physics object affected by gravity, ropes, bubbles, pumps, and other active objects. Must be delivered to the target.
- Target / monster: the level is won when the candy enters the target's mouth.
- Rope: a constraint between the candy (or a split-candy half) and an anchor. Cutting a rope releases the candy from that constraint. Ropes are zero-indexed.
- Grab: an anchor for a rope that can be repositioned during play. Zero-indexed.
- Bubble: when the candy enters a bubble, it usually floats upward. Pop the bubble to release the candy.
- Pump: a gust source that pushes objects. Each activation produces one impulse.
- Gravity switch: toggles gravity direction or magnitude.
- Star: collected by candy passing through its position. Up to 3 stars per level.
- Split candy: some levels start with two candy halves (`left_candy`, `right_candy`). Use the half-specific conditions before the halves merge; switch to `candy_*` conditions after they merge.

## 3. VISUAL LEGEND
- The video is a short clip showing the full level layout and a coordinate grid overlay.
- Coordinates: origin at the top-left corner. x increases to the right; y increases downward.
- Indices in the video are zero-based for ropes, bubbles, pumps, and grabs. Infer indices from object positions and the order they appear in the clip.

## 4. INPUT FIELDS
- level_id: rope-199
- canvas_size: 1920 x 1080
- two_parts (split candy): False
- object_counts:
  - target: 1
  - star: 3
  - candy: 1
  - rope/grab: 4
- gameplay objects in this level:
- Target (monster): the level is won when the candy reaches the monster's mouth. The target is usually fixed in place.
- Candy: the candy is affected by gravity, ropes, bubbles, pumps, and other active objects. It must be delivered to the target.
- Ropes / grabs: ropes constrain the candy or split-candy movement. `cut_rope N` cuts rope N; `cut_rope N,M,K` cuts multiple at once. If a grab can move, `move_grab N X` or `move_grab N X Y` repositions it.
- Stars: candy or split-candy collects a star by passing through it. Prefer paths that collect 3 stars, but stable completion takes priority.

## 5. ACTION VOCABULARY
A complete answer is one ordered command script (one command per line). Available actions:
- `cut_rope N`               — cut rope N
- `cut_rope N,M,K`           — cut several ropes simultaneously
- `pop_bubble N`             — pop bubble N
- `pop_bubble_left`          — pop the bubble holding the left split-candy half
- `pop_bubble_right`         — pop the bubble holding the right split-candy half
- `activate_pump N`          — fire pump N once
- `activate_pump N times C`  — fire C times back-to-back
- `activate_pump N times C every S` — fire C times spaced S seconds apart
- `activate_pump N every S until <CONDITION>` — fire repeatedly until CONDITION holds
- `move_grab N X`            — move grab N to x-coordinate X (y unchanged)
- `move_grab N X Y`          — move grab N to (X, Y)
- `kick_rope N`              — apply a one-shot impulse to rope N
- `toggle_gravity`           — toggle the gravity setting

Each command may be guarded by an optional `when <CONDITION>` clause. Available condition primitives:
- `candy_x > N`, `candy_x < N`, `candy_y > N`, `candy_y < N`
- `candy_near X,Y,R` — candy is within radius R of (X,Y); optional `for S` requires the predicate to hold for S seconds
- `candy_still for S` — candy speed is below threshold for S seconds (useful before cutting after a swing settles)
- `left_candy_*` and `right_candy_*` mirror the candy_* primitives for the corresponding split half
- `grab_x I > N`, `grab_y I < N`, `grab_near I,X,Y,R`
- `rope_cut N` — rope N has been cut
- `no_rope`, `candy_in_bubble`
- Conditions can be combined with `and`, `or`, and parentheses.

## 6. CONSTRAINTS
- One command per line in the `commands` string.
- Indices must be zero-based and consistent with the level video.
- `wait_frames` is NOT allowed in this benchmark version. Use condition-based waits.
- The script must be deterministic; do not output stochastic or "either-or" entries.
- The script must terminate without manual intervention; the simulator runs it from the initial state and decides win/loss.

## 7. SOLVING ADVICE
- Identify which ropes mainly control the candy first; choose a cut order that releases the candy along the shortest stable path to the target.
- When waiting for the candy to reach a place, prefer `candy_near` / `candy_y` / `candy_x` over fixed timing.
- For repeated pumping, use `activate_pump N times C every S` or `activate_pump N every S until CONDITION`.
- In split-candy levels, do NOT use `candy_still` / `candy_near` for the merged candy before the halves merge; use the `left_candy_*` / `right_candy_*` primitives instead.

## 8. OUTPUT SCHEMA
FINAL_JSON: {"commands":"<command-script with \n separators>","reason":"<one-sentence intent>","confidence":<0..1>}
- commands: string. One command per line; lines separated by `\n`.
- reason: short one-sentence explanation of the intended sequence.
- confidence: float in `[0, 1]`.

## 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.


cut_rope 0 when candy_still for 0.3 and candy_near 610,370,60
cut_rope 4
cut_rope 2 when candy_x < 420
cut_rope 3 when candy_y > 690
cut_rope 1 when candy_still for 0.3

cut_rope 0 when candy_still for 0.3 and candy_near 610,370,60
cut_rope 4
cut_rope 2 when candy_x < 420
cut_rope 3 when candy_y > 690
cut_rope 1 when candy_still for 0.3

System:
You are a Cut the Rope replayable-script solver. Given a short gameplay video of one Cut the Rope level (with a coordinate grid overlay) and a structured description of the level objects, you produce a deterministic command script that, replayed from the same initial state, wins the level.

You will receive: (a) one short gameplay video of the level, (b) a structured text body listing the canvas size, the count of each gameplay object (candy, target, ropes, bubbles, pumps, gravity switches, stars), and the level metadata.

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 commands schema described in section 8 of the user prompt: keys `commands`, `reason`, `confidence`. Multiple winning scripts may be valid; output any one. 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 solution, still emit a best-effort FINAL_JSON line with at least one command and a confidence value below 1.0. Never refuse, never return prose only.

## 1. TASK
Produce a replayable command script that wins the Cut the Rope level shown in the gameplay video. The script must be deterministic so that replaying it from the same initial state in the simulator produces a win.
The level is solved when the candy reaches the target monster's mouth. Three-star completion is preferred but stable winning is the first priority.

## 2. WORLD MODEL
- Candy: a physics object affected by gravity, ropes, bubbles, pumps, and other active objects. Must be delivered to the target.
- Target / monster: the level is won when the candy enters the target's mouth.
- Rope: a constraint between the candy (or a split-candy half) and an anchor. Cutting a rope releases the candy from that constraint. Ropes are zero-indexed.
- Grab: an anchor for a rope that can be repositioned during play. Zero-indexed.
- Bubble: when the candy enters a bubble, it usually floats upward. Pop the bubble to release the candy.
- Pump: a gust source that pushes objects. Each activation produces one impulse.
- Gravity switch: toggles gravity direction or magnitude.
- Star: collected by candy passing through its position. Up to 3 stars per level.
- Split candy: some levels start with two candy halves (`left_candy`, `right_candy`). Use the half-specific conditions before the halves merge; switch to `candy_*` conditions after they merge.

## 3. VISUAL LEGEND
- The video is a short clip showing the full level layout and a coordinate grid overlay.
- Coordinates: origin at the top-left corner. x increases to the right; y increases downward.
- Indices in the video are zero-based for ropes, bubbles, pumps, and grabs. Infer indices from object positions and the order they appear in the clip.

## 4. INPUT FIELDS
- level_id: rope-200
- canvas_size: 1920 x 1080
- two_parts (split candy): False
- object_counts:
  - target: 1
  - star: 3
  - candy: 1
  - rope/grab: 5
  - bubble: 1
- gameplay objects in this level:
- Target (monster): the level is won when the candy reaches the monster's mouth. The target is usually fixed in place.
- Candy: the candy is affected by gravity, ropes, bubbles, pumps, and other active objects. It must be delivered to the target.
- Ropes / grabs: ropes constrain the candy or split-candy movement. `cut_rope N` cuts rope N; `cut_rope N,M,K` cuts multiple at once. If a grab can move, `move_grab N X` or `move_grab N X Y` repositions it.
- Stars: candy or split-candy collects a star by passing through it. Prefer paths that collect 3 stars, but stable completion takes priority.
- Bubbles: candy entering a bubble usually floats upward. `pop_bubble N` pops bubble N. In split-candy levels, `pop_bubble_left` / `pop_bubble_right` pop the bubble holding the corresponding half.

## 5. ACTION VOCABULARY
A complete answer is one ordered command script (one command per line). Available actions:
- `cut_rope N`               — cut rope N
- `cut_rope N,M,K`           — cut several ropes simultaneously
- `pop_bubble N`             — pop bubble N
- `pop_bubble_left`          — pop the bubble holding the left split-candy half
- `pop_bubble_right`         — pop the bubble holding the right split-candy half
- `activate_pump N`          — fire pump N once
- `activate_pump N times C`  — fire C times back-to-back
- `activate_pump N times C every S` — fire C times spaced S seconds apart
- `activate_pump N every S until <CONDITION>` — fire repeatedly until CONDITION holds
- `move_grab N X`            — move grab N to x-coordinate X (y unchanged)
- `move_grab N X Y`          — move grab N to (X, Y)
- `kick_rope N`              — apply a one-shot impulse to rope N
- `toggle_gravity`           — toggle the gravity setting

Each command may be guarded by an optional `when <CONDITION>` clause. Available condition primitives:
- `candy_x > N`, `candy_x < N`, `candy_y > N`, `candy_y < N`
- `candy_near X,Y,R` — candy is within radius R of (X,Y); optional `for S` requires the predicate to hold for S seconds
- `candy_still for S` — candy speed is below threshold for S seconds (useful before cutting after a swing settles)
- `left_candy_*` and `right_candy_*` mirror the candy_* primitives for the corresponding split half
- `grab_x I > N`, `grab_y I < N`, `grab_near I,X,Y,R`
- `rope_cut N` — rope N has been cut
- `no_rope`, `candy_in_bubble`
- Conditions can be combined with `and`, `or`, and parentheses.

## 6. CONSTRAINTS
- One command per line in the `commands` string.
- Indices must be zero-based and consistent with the level video.
- `wait_frames` is NOT allowed in this benchmark version. Use condition-based waits.
- The script must be deterministic; do not output stochastic or "either-or" entries.
- The script must terminate without manual intervention; the simulator runs it from the initial state and decides win/loss.

## 7. SOLVING ADVICE
- Identify which ropes mainly control the candy first; choose a cut order that releases the candy along the shortest stable path to the target.
- When waiting for the candy to reach a place, prefer `candy_near` / `candy_y` / `candy_x` over fixed timing.
- For repeated pumping, use `activate_pump N times C every S` or `activate_pump N every S until CONDITION`.
- In split-candy levels, do NOT use `candy_still` / `candy_near` for the merged candy before the halves merge; use the `left_candy_*` / `right_candy_*` primitives instead.

## 8. OUTPUT SCHEMA
FINAL_JSON: {"commands":"<command-script with \n separators>","reason":"<one-sentence intent>","confidence":<0..1>}
- commands: string. One command per line; lines separated by `\n`.
- reason: short one-sentence explanation of the intended sequence.
- confidence: float in `[0, 1]`.

## 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.


cut_rope 1
cut_rope 2 when candy_x > 1220
pop_bubble 0 when candy_still for 0.3
cut_rope 3 when candy_still for 0.3
pop_bubble 1

cut_rope 1
cut_rope 2 when candy_x > 1220
pop_bubble 0 when candy_still for 0.3
cut_rope 3 when candy_still for 0.3
pop_bubble 1

System:
You are a Cut the Rope replayable-script solver. Given a short gameplay video of one Cut the Rope level (with a coordinate grid overlay) and a structured description of the level objects, you produce a deterministic command script that, replayed from the same initial state, wins the level.

You will receive: (a) one short gameplay video of the level, (b) a structured text body listing the canvas size, the count of each gameplay object (candy, target, ropes, bubbles, pumps, gravity switches, stars), and the level metadata.

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 commands schema described in section 8 of the user prompt: keys `commands`, `reason`, `confidence`. Multiple winning scripts may be valid; output any one. 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 solution, still emit a best-effort FINAL_JSON line with at least one command and a confidence value below 1.0. Never refuse, never return prose only.

## 1. TASK
Produce a replayable command script that wins the Cut the Rope level shown in the gameplay video. The script must be deterministic so that replaying it from the same initial state in the simulator produces a win.
The level is solved when the candy reaches the target monster's mouth. Three-star completion is preferred but stable winning is the first priority.

## 2. WORLD MODEL
- Candy: a physics object affected by gravity, ropes, bubbles, pumps, and other active objects. Must be delivered to the target.
- Target / monster: the level is won when the candy enters the target's mouth.
- Rope: a constraint between the candy (or a split-candy half) and an anchor. Cutting a rope releases the candy from that constraint. Ropes are zero-indexed.
- Grab: an anchor for a rope that can be repositioned during play. Zero-indexed.
- Bubble: when the candy enters a bubble, it usually floats upward. Pop the bubble to release the candy.
- Pump: a gust source that pushes objects. Each activation produces one impulse.
- Gravity switch: toggles gravity direction or magnitude.
- Star: collected by candy passing through its position. Up to 3 stars per level.
- Split candy: some levels start with two candy halves (`left_candy`, `right_candy`). Use the half-specific conditions before the halves merge; switch to `candy_*` conditions after they merge.

## 3. VISUAL LEGEND
- The video is a short clip showing the full level layout and a coordinate grid overlay.
- Coordinates: origin at the top-left corner. x increases to the right; y increases downward.
- Indices in the video are zero-based for ropes, bubbles, pumps, and grabs. Infer indices from object positions and the order they appear in the clip.

## 4. INPUT FIELDS
- level_id: rope-201
- canvas_size: 1920 x 1080
- two_parts (split candy): False
- object_counts:
  - target: 1
  - star: 3
  - candy: 1
  - rope/grab: 4
  - bubble: 2
- gameplay objects in this level:
- Target (monster): the level is won when the candy reaches the monster's mouth. The target is usually fixed in place.
- Candy: the candy is affected by gravity, ropes, bubbles, pumps, and other active objects. It must be delivered to the target.
- Ropes / grabs: ropes constrain the candy or split-candy movement. `cut_rope N` cuts rope N; `cut_rope N,M,K` cuts multiple at once. If a grab can move, `move_grab N X` or `move_grab N X Y` repositions it.
- Stars: candy or split-candy collects a star by passing through it. Prefer paths that collect 3 stars, but stable completion takes priority.
- Bubbles: candy entering a bubble usually floats upward. `pop_bubble N` pops bubble N. In split-candy levels, `pop_bubble_left` / `pop_bubble_right` pop the bubble holding the corresponding half.

## 5. ACTION VOCABULARY
A complete answer is one ordered command script (one command per line). Available actions:
- `cut_rope N`               — cut rope N
- `cut_rope N,M,K`           — cut several ropes simultaneously
- `pop_bubble N`             — pop bubble N
- `pop_bubble_left`          — pop the bubble holding the left split-candy half
- `pop_bubble_right`         — pop the bubble holding the right split-candy half
- `activate_pump N`          — fire pump N once
- `activate_pump N times C`  — fire C times back-to-back
- `activate_pump N times C every S` — fire C times spaced S seconds apart
- `activate_pump N every S until <CONDITION>` — fire repeatedly until CONDITION holds
- `move_grab N X`            — move grab N to x-coordinate X (y unchanged)
- `move_grab N X Y`          — move grab N to (X, Y)
- `kick_rope N`              — apply a one-shot impulse to rope N
- `toggle_gravity`           — toggle the gravity setting

Each command may be guarded by an optional `when <CONDITION>` clause. Available condition primitives:
- `candy_x > N`, `candy_x < N`, `candy_y > N`, `candy_y < N`
- `candy_near X,Y,R` — candy is within radius R of (X,Y); optional `for S` requires the predicate to hold for S seconds
- `candy_still for S` — candy speed is below threshold for S seconds (useful before cutting after a swing settles)
- `left_candy_*` and `right_candy_*` mirror the candy_* primitives for the corresponding split half
- `grab_x I > N`, `grab_y I < N`, `grab_near I,X,Y,R`
- `rope_cut N` — rope N has been cut
- `no_rope`, `candy_in_bubble`
- Conditions can be combined with `and`, `or`, and parentheses.

## 6. CONSTRAINTS
- One command per line in the `commands` string.
- Indices must be zero-based and consistent with the level video.
- `wait_frames` is NOT allowed in this benchmark version. Use condition-based waits.
- The script must be deterministic; do not output stochastic or "either-or" entries.
- The script must terminate without manual intervention; the simulator runs it from the initial state and decides win/loss.

## 7. SOLVING ADVICE
- Identify which ropes mainly control the candy first; choose a cut order that releases the candy along the shortest stable path to the target.
- When waiting for the candy to reach a place, prefer `candy_near` / `candy_y` / `candy_x` over fixed timing.
- For repeated pumping, use `activate_pump N times C every S` or `activate_pump N every S until CONDITION`.
- In split-candy levels, do NOT use `candy_still` / `candy_near` for the merged candy before the halves merge; use the `left_candy_*` / `right_candy_*` primitives instead.

## 8. OUTPUT SCHEMA
FINAL_JSON: {"commands":"<command-script with \n separators>","reason":"<one-sentence intent>","confidence":<0..1>}
- commands: string. One command per line; lines separated by `\n`.
- reason: short one-sentence explanation of the intended sequence.
- confidence: float in `[0, 1]`.

## 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.


pop_bubble 0
cut_rope 0,1
pop_bubble 2 when candy_y < 100
activate_pump 0 when candy_near 750,590,50
pop_bubble 1 when candy_y < 180

pop_bubble 0
cut_rope 0,1
pop_bubble 2 when candy_y < 100
activate_pump 0 when candy_near 750,590,50
pop_bubble 1 when candy_y < 180

System:
You are a Cut the Rope replayable-script solver. Given a short gameplay video of one Cut the Rope level (with a coordinate grid overlay) and a structured description of the level objects, you produce a deterministic command script that, replayed from the same initial state, wins the level.

You will receive: (a) one short gameplay video of the level, (b) a structured text body listing the canvas size, the count of each gameplay object (candy, target, ropes, bubbles, pumps, gravity switches, stars), and the level metadata.

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 commands schema described in section 8 of the user prompt: keys `commands`, `reason`, `confidence`. Multiple winning scripts may be valid; output any one. 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 solution, still emit a best-effort FINAL_JSON line with at least one command and a confidence value below 1.0. Never refuse, never return prose only.

## 1. TASK
Produce a replayable command script that wins the Cut the Rope level shown in the gameplay video. The script must be deterministic so that replaying it from the same initial state in the simulator produces a win.
The level is solved when the candy reaches the target monster's mouth. Three-star completion is preferred but stable winning is the first priority.

## 2. WORLD MODEL
- Candy: a physics object affected by gravity, ropes, bubbles, pumps, and other active objects. Must be delivered to the target.
- Target / monster: the level is won when the candy enters the target's mouth.
- Rope: a constraint between the candy (or a split-candy half) and an anchor. Cutting a rope releases the candy from that constraint. Ropes are zero-indexed.
- Grab: an anchor for a rope that can be repositioned during play. Zero-indexed.
- Bubble: when the candy enters a bubble, it usually floats upward. Pop the bubble to release the candy.
- Pump: a gust source that pushes objects. Each activation produces one impulse.
- Gravity switch: toggles gravity direction or magnitude.
- Star: collected by candy passing through its position. Up to 3 stars per level.
- Split candy: some levels start with two candy halves (`left_candy`, `right_candy`). Use the half-specific conditions before the halves merge; switch to `candy_*` conditions after they merge.

## 3. VISUAL LEGEND
- The video is a short clip showing the full level layout and a coordinate grid overlay.
- Coordinates: origin at the top-left corner. x increases to the right; y increases downward.
- Indices in the video are zero-based for ropes, bubbles, pumps, and grabs. Infer indices from object positions and the order they appear in the clip.

## 4. INPUT FIELDS
- level_id: rope-202
- canvas_size: 1920 x 1080
- two_parts (split candy): False
- object_counts:
  - target: 1
  - star: 3
  - candy: 1
  - rope/grab: 2
  - bubble: 3
  - pump: 1
- gameplay objects in this level:
- Target (monster): the level is won when the candy reaches the monster's mouth. The target is usually fixed in place.
- Candy: the candy is affected by gravity, ropes, bubbles, pumps, and other active objects. It must be delivered to the target.
- Ropes / grabs: ropes constrain the candy or split-candy movement. `cut_rope N` cuts rope N; `cut_rope N,M,K` cuts multiple at once. If a grab can move, `move_grab N X` or `move_grab N X Y` repositions it.
- Stars: candy or split-candy collects a star by passing through it. Prefer paths that collect 3 stars, but stable completion takes priority.
- Bubbles: candy entering a bubble usually floats upward. `pop_bubble N` pops bubble N. In split-candy levels, `pop_bubble_left` / `pop_bubble_right` pop the bubble holding the corresponding half.
- Pumps: activating a pump pushes nearby objects. `activate_pump N`, optionally with `times`/`every`/`until` modifiers for repeated activation.

## 5. ACTION VOCABULARY
A complete answer is one ordered command script (one command per line). Available actions:
- `cut_rope N`               — cut rope N
- `cut_rope N,M,K`           — cut several ropes simultaneously
- `pop_bubble N`             — pop bubble N
- `pop_bubble_left`          — pop the bubble holding the left split-candy half
- `pop_bubble_right`         — pop the bubble holding the right split-candy half
- `activate_pump N`          — fire pump N once
- `activate_pump N times C`  — fire C times back-to-back
- `activate_pump N times C every S` — fire C times spaced S seconds apart
- `activate_pump N every S until <CONDITION>` — fire repeatedly until CONDITION holds
- `move_grab N X`            — move grab N to x-coordinate X (y unchanged)
- `move_grab N X Y`          — move grab N to (X, Y)
- `kick_rope N`              — apply a one-shot impulse to rope N
- `toggle_gravity`           — toggle the gravity setting

Each command may be guarded by an optional `when <CONDITION>` clause. Available condition primitives:
- `candy_x > N`, `candy_x < N`, `candy_y > N`, `candy_y < N`
- `candy_near X,Y,R` — candy is within radius R of (X,Y); optional `for S` requires the predicate to hold for S seconds
- `candy_still for S` — candy speed is below threshold for S seconds (useful before cutting after a swing settles)
- `left_candy_*` and `right_candy_*` mirror the candy_* primitives for the corresponding split half
- `grab_x I > N`, `grab_y I < N`, `grab_near I,X,Y,R`
- `rope_cut N` — rope N has been cut
- `no_rope`, `candy_in_bubble`
- Conditions can be combined with `and`, `or`, and parentheses.

## 6. CONSTRAINTS
- One command per line in the `commands` string.
- Indices must be zero-based and consistent with the level video.
- `wait_frames` is NOT allowed in this benchmark version. Use condition-based waits.
- The script must be deterministic; do not output stochastic or "either-or" entries.
- The script must terminate without manual intervention; the simulator runs it from the initial state and decides win/loss.

## 7. SOLVING ADVICE
- Identify which ropes mainly control the candy first; choose a cut order that releases the candy along the shortest stable path to the target.
- When waiting for the candy to reach a place, prefer `candy_near` / `candy_y` / `candy_x` over fixed timing.
- For repeated pumping, use `activate_pump N times C every S` or `activate_pump N every S until CONDITION`.
- In split-candy levels, do NOT use `candy_still` / `candy_near` for the merged candy before the halves merge; use the `left_candy_*` / `right_candy_*` primitives instead.

## 8. OUTPUT SCHEMA
FINAL_JSON: {"commands":"<command-script with \n separators>","reason":"<one-sentence intent>","confidence":<0..1>}
- commands: string. One command per line; lines separated by `\n`.
- reason: short one-sentence explanation of the intended sequence.
- confidence: float in `[0, 1]`.

## 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.


You can restart the level by pressing the

button

Вы можете перезапустить уровень, нажав кнопку

Vous pouvez redémarrer le niveau en appuyant sur le bouton

Du kannst das Level neustarten, indem du das Symbol antippst

System:
You are a Cut the Rope replayable-script solver. Given a short gameplay video of one Cut the Rope level (with a coordinate grid overlay) and a structured description of the level objects, you produce a deterministic command script that, replayed from the same initial state, wins the level.

You will receive: (a) one short gameplay video of the level, (b) a structured text body listing the canvas size, the count of each gameplay object (candy, target, ropes, bubbles, pumps, gravity switches, stars), and the level metadata.

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 commands schema described in section 8 of the user prompt: keys `commands`, `reason`, `confidence`. Multiple winning scripts may be valid; output any one. 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 solution, still emit a best-effort FINAL_JSON line with at least one command and a confidence value below 1.0. Never refuse, never return prose only.

## 1. TASK
Produce a replayable command script that wins the Cut the Rope level shown in the gameplay video. The script must be deterministic so that replaying it from the same initial state in the simulator produces a win.
The level is solved when the candy reaches the target monster's mouth. Three-star completion is preferred but stable winning is the first priority.

## 2. WORLD MODEL
- Candy: a physics object affected by gravity, ropes, bubbles, pumps, and other active objects. Must be delivered to the target.
- Target / monster: the level is won when the candy enters the target's mouth.
- Rope: a constraint between the candy (or a split-candy half) and an anchor. Cutting a rope releases the candy from that constraint. Ropes are zero-indexed.
- Grab: an anchor for a rope that can be repositioned during play. Zero-indexed.
- Bubble: when the candy enters a bubble, it usually floats upward. Pop the bubble to release the candy.
- Pump: a gust source that pushes objects. Each activation produces one impulse.
- Gravity switch: toggles gravity direction or magnitude.
- Star: collected by candy passing through its position. Up to 3 stars per level.
- Split candy: some levels start with two candy halves (`left_candy`, `right_candy`). Use the half-specific conditions before the halves merge; switch to `candy_*` conditions after they merge.

## 3. VISUAL LEGEND
- The video is a short clip showing the full level layout and a coordinate grid overlay.
- Coordinates: origin at the top-left corner. x increases to the right; y increases downward.
- Indices in the video are zero-based for ropes, bubbles, pumps, and grabs. Infer indices from object positions and the order they appear in the clip.

## 4. INPUT FIELDS
- level_id: rope-203
- canvas_size: 1920 x 1080
- two_parts (split candy): False
- object_counts:
  - target: 1
  - star: 3
  - candy: 1
  - rope/grab: 1
  - bubble: 1
- gameplay objects in this level:
- Target (monster): the level is won when the candy reaches the monster's mouth. The target is usually fixed in place.
- Candy: the candy is affected by gravity, ropes, bubbles, pumps, and other active objects. It must be delivered to the target.
- Ropes / grabs: ropes constrain the candy or split-candy movement. `cut_rope N` cuts rope N; `cut_rope N,M,K` cuts multiple at once. If a grab can move, `move_grab N X` or `move_grab N X Y` repositions it.
- Stars: candy or split-candy collects a star by passing through it. Prefer paths that collect 3 stars, but stable completion takes priority.
- Bubbles: candy entering a bubble usually floats upward. `pop_bubble N` pops bubble N. In split-candy levels, `pop_bubble_left` / `pop_bubble_right` pop the bubble holding the corresponding half.

## 5. ACTION VOCABULARY
A complete answer is one ordered command script (one command per line). Available actions:
- `cut_rope N`               — cut rope N
- `cut_rope N,M,K`           — cut several ropes simultaneously
- `pop_bubble N`             — pop bubble N
- `pop_bubble_left`          — pop the bubble holding the left split-candy half
- `pop_bubble_right`         — pop the bubble holding the right split-candy half
- `activate_pump N`          — fire pump N once
- `activate_pump N times C`  — fire C times back-to-back
- `activate_pump N times C every S` — fire C times spaced S seconds apart
- `activate_pump N every S until <CONDITION>` — fire repeatedly until CONDITION holds
- `move_grab N X`            — move grab N to x-coordinate X (y unchanged)
- `move_grab N X Y`          — move grab N to (X, Y)
- `kick_rope N`              — apply a one-shot impulse to rope N
- `toggle_gravity`           — toggle the gravity setting

Each command may be guarded by an optional `when <CONDITION>` clause. Available condition primitives:
- `candy_x > N`, `candy_x < N`, `candy_y > N`, `candy_y < N`
- `candy_near X,Y,R` — candy is within radius R of (X,Y); optional `for S` requires the predicate to hold for S seconds
- `candy_still for S` — candy speed is below threshold for S seconds (useful before cutting after a swing settles)
- `left_candy_*` and `right_candy_*` mirror the candy_* primitives for the corresponding split half
- `grab_x I > N`, `grab_y I < N`, `grab_near I,X,Y,R`
- `rope_cut N` — rope N has been cut
- `no_rope`, `candy_in_bubble`
- Conditions can be combined with `and`, `or`, and parentheses.

## 6. CONSTRAINTS
- One command per line in the `commands` string.
- Indices must be zero-based and consistent with the level video.
- `wait_frames` is NOT allowed in this benchmark version. Use condition-based waits.
- The script must be deterministic; do not output stochastic or "either-or" entries.
- The script must terminate without manual intervention; the simulator runs it from the initial state and decides win/loss.

## 7. SOLVING ADVICE
- Identify which ropes mainly control the candy first; choose a cut order that releases the candy along the shortest stable path to the target.
- When waiting for the candy to reach a place, prefer `candy_near` / `candy_y` / `candy_x` over fixed timing.
- For repeated pumping, use `activate_pump N times C every S` or `activate_pump N every S until CONDITION`.
- In split-candy levels, do NOT use `candy_still` / `candy_near` for the merged candy before the halves merge; use the `left_candy_*` / `right_candy_*` primitives instead.

## 8. OUTPUT SCHEMA
FINAL_JSON: {"commands":"<command-script with \n separators>","reason":"<one-sentence intent>","confidence":<0..1>}
- commands: string. One command per line; lines separated by `\n`.
- reason: short one-sentence explanation of the intended sequence.
- confidence: float in `[0, 1]`.

## 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.


cut_rope 0
cut_rope 1 when candy_x < 740
cut_rope 2 when candy_still for 0.3
cut_rope 3 when candy_y > 910

cut_rope 0
cut_rope 1 when candy_x < 740
cut_rope 2 when candy_still for 0.3
cut_rope 3 when candy_y > 910

System:
You are a Cut the Rope replayable-script solver. Given a short gameplay video of one Cut the Rope level (with a coordinate grid overlay) and a structured description of the level objects, you produce a deterministic command script that, replayed from the same initial state, wins the level.

You will receive: (a) one short gameplay video of the level, (b) a structured text body listing the canvas size, the count of each gameplay object (candy, target, ropes, bubbles, pumps, gravity switches, stars), and the level metadata.

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 commands schema described in section 8 of the user prompt: keys `commands`, `reason`, `confidence`. Multiple winning scripts may be valid; output any one. 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 solution, still emit a best-effort FINAL_JSON line with at least one command and a confidence value below 1.0. Never refuse, never return prose only.

## 1. TASK
Produce a replayable command script that wins the Cut the Rope level shown in the gameplay video. The script must be deterministic so that replaying it from the same initial state in the simulator produces a win.
The level is solved when the candy reaches the target monster's mouth. Three-star completion is preferred but stable winning is the first priority.

## 2. WORLD MODEL
- Candy: a physics object affected by gravity, ropes, bubbles, pumps, and other active objects. Must be delivered to the target.
- Target / monster: the level is won when the candy enters the target's mouth.
- Rope: a constraint between the candy (or a split-candy half) and an anchor. Cutting a rope releases the candy from that constraint. Ropes are zero-indexed.
- Grab: an anchor for a rope that can be repositioned during play. Zero-indexed.
- Bubble: when the candy enters a bubble, it usually floats upward. Pop the bubble to release the candy.
- Pump: a gust source that pushes objects. Each activation produces one impulse.
- Gravity switch: toggles gravity direction or magnitude.
- Star: collected by candy passing through its position. Up to 3 stars per level.
- Split candy: some levels start with two candy halves (`left_candy`, `right_candy`). Use the half-specific conditions before the halves merge; switch to `candy_*` conditions after they merge.

## 3. VISUAL LEGEND
- The video is a short clip showing the full level layout and a coordinate grid overlay.
- Coordinates: origin at the top-left corner. x increases to the right; y increases downward.
- Indices in the video are zero-based for ropes, bubbles, pumps, and grabs. Infer indices from object positions and the order they appear in the clip.

## 4. INPUT FIELDS
- level_id: rope-204
- canvas_size: 1920 x 1080
- two_parts (split candy): False
- object_counts:
  - target: 1
  - star: 3
  - candy: 1
  - rope/grab: 5
- gameplay objects in this level:
- Target (monster): the level is won when the candy reaches the monster's mouth. The target is usually fixed in place.
- Candy: the candy is affected by gravity, ropes, bubbles, pumps, and other active objects. It must be delivered to the target.
- Ropes / grabs: ropes constrain the candy or split-candy movement. `cut_rope N` cuts rope N; `cut_rope N,M,K` cuts multiple at once. If a grab can move, `move_grab N X` or `move_grab N X Y` repositions it.
- Stars: candy or split-candy collects a star by passing through it. Prefer paths that collect 3 stars, but stable completion takes priority.

## 5. ACTION VOCABULARY
A complete answer is one ordered command script (one command per line). Available actions:
- `cut_rope N`               — cut rope N
- `cut_rope N,M,K`           — cut several ropes simultaneously
- `pop_bubble N`             — pop bubble N
- `pop_bubble_left`          — pop the bubble holding the left split-candy half
- `pop_bubble_right`         — pop the bubble holding the right split-candy half
- `activate_pump N`          — fire pump N once
- `activate_pump N times C`  — fire C times back-to-back
- `activate_pump N times C every S` — fire C times spaced S seconds apart
- `activate_pump N every S until <CONDITION>` — fire repeatedly until CONDITION holds
- `move_grab N X`            — move grab N to x-coordinate X (y unchanged)
- `move_grab N X Y`          — move grab N to (X, Y)
- `kick_rope N`              — apply a one-shot impulse to rope N
- `toggle_gravity`           — toggle the gravity setting

Each command may be guarded by an optional `when <CONDITION>` clause. Available condition primitives:
- `candy_x > N`, `candy_x < N`, `candy_y > N`, `candy_y < N`
- `candy_near X,Y,R` — candy is within radius R of (X,Y); optional `for S` requires the predicate to hold for S seconds
- `candy_still for S` — candy speed is below threshold for S seconds (useful before cutting after a swing settles)
- `left_candy_*` and `right_candy_*` mirror the candy_* primitives for the corresponding split half
- `grab_x I > N`, `grab_y I < N`, `grab_near I,X,Y,R`
- `rope_cut N` — rope N has been cut
- `no_rope`, `candy_in_bubble`
- Conditions can be combined with `and`, `or`, and parentheses.

## 6. CONSTRAINTS
- One command per line in the `commands` string.
- Indices must be zero-based and consistent with the level video.
- `wait_frames` is NOT allowed in this benchmark version. Use condition-based waits.
- The script must be deterministic; do not output stochastic or "either-or" entries.
- The script must terminate without manual intervention; the simulator runs it from the initial state and decides win/loss.

## 7. SOLVING ADVICE
- Identify which ropes mainly control the candy first; choose a cut order that releases the candy along the shortest stable path to the target.
- When waiting for the candy to reach a place, prefer `candy_near` / `candy_y` / `candy_x` over fixed timing.
- For repeated pumping, use `activate_pump N times C every S` or `activate_pump N every S until CONDITION`.
- In split-candy levels, do NOT use `candy_still` / `candy_near` for the merged candy before the halves merge; use the `left_candy_*` / `right_candy_*` primitives instead.

## 8. OUTPUT SCHEMA
FINAL_JSON: {"commands":"<command-script with \n separators>","reason":"<one-sentence intent>","confidence":<0..1>}
- commands: string. One command per line; lines separated by `\n`.
- reason: short one-sentence explanation of the intended sequence.
- confidence: float in `[0, 1]`.

## 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.


You can cut several ropes at once

Вы можете перерезать несколько веревок одновременно

Tu peux couper plusieurs cordes à la fois

Du kannst mehrere Seile gleichzeitig durchschneiden

cut_rope 0,1 when candy_still for 0.3
cut_rope 2,3 when candy_still for 0.3

cut_rope 0,1 when candy_still for 0.3
cut_rope 2,3 when candy_still for 0.3

System:
You are a Cut the Rope replayable-script solver. Given a short gameplay video of one Cut the Rope level (with a coordinate grid overlay) and a structured description of the level objects, you produce a deterministic command script that, replayed from the same initial state, wins the level.

You will receive: (a) one short gameplay video of the level, (b) a structured text body listing the canvas size, the count of each gameplay object (candy, target, ropes, bubbles, pumps, gravity switches, stars), and the level metadata.

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 commands schema described in section 8 of the user prompt: keys `commands`, `reason`, `confidence`. Multiple winning scripts may be valid; output any one. 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 solution, still emit a best-effort FINAL_JSON line with at least one command and a confidence value below 1.0. Never refuse, never return prose only.

## 1. TASK
Produce a replayable command script that wins the Cut the Rope level shown in the gameplay video. The script must be deterministic so that replaying it from the same initial state in the simulator produces a win.
The level is solved when the candy reaches the target monster's mouth. Three-star completion is preferred but stable winning is the first priority.

## 2. WORLD MODEL
- Candy: a physics object affected by gravity, ropes, bubbles, pumps, and other active objects. Must be delivered to the target.
- Target / monster: the level is won when the candy enters the target's mouth.
- Rope: a constraint between the candy (or a split-candy half) and an anchor. Cutting a rope releases the candy from that constraint. Ropes are zero-indexed.
- Grab: an anchor for a rope that can be repositioned during play. Zero-indexed.
- Bubble: when the candy enters a bubble, it usually floats upward. Pop the bubble to release the candy.
- Pump: a gust source that pushes objects. Each activation produces one impulse.
- Gravity switch: toggles gravity direction or magnitude.
- Star: collected by candy passing through its position. Up to 3 stars per level.
- Split candy: some levels start with two candy halves (`left_candy`, `right_candy`). Use the half-specific conditions before the halves merge; switch to `candy_*` conditions after they merge.

## 3. VISUAL LEGEND
- The video is a short clip showing the full level layout and a coordinate grid overlay.
- Coordinates: origin at the top-left corner. x increases to the right; y increases downward.
- Indices in the video are zero-based for ropes, bubbles, pumps, and grabs. Infer indices from object positions and the order they appear in the clip.

## 4. INPUT FIELDS
- level_id: rope-205
- canvas_size: 1920 x 1080
- two_parts (split candy): False
- object_counts:
  - target: 1
  - star: 3
  - candy: 1
  - rope/grab: 4
- gameplay objects in this level:
- Target (monster): the level is won when the candy reaches the monster's mouth. The target is usually fixed in place.
- Candy: the candy is affected by gravity, ropes, bubbles, pumps, and other active objects. It must be delivered to the target.
- Ropes / grabs: ropes constrain the candy or split-candy movement. `cut_rope N` cuts rope N; `cut_rope N,M,K` cuts multiple at once. If a grab can move, `move_grab N X` or `move_grab N X Y` repositions it.
- Stars: candy or split-candy collects a star by passing through it. Prefer paths that collect 3 stars, but stable completion takes priority.

## 5. ACTION VOCABULARY
A complete answer is one ordered command script (one command per line). Available actions:
- `cut_rope N`               — cut rope N
- `cut_rope N,M,K`           — cut several ropes simultaneously
- `pop_bubble N`             — pop bubble N
- `pop_bubble_left`          — pop the bubble holding the left split-candy half
- `pop_bubble_right`         — pop the bubble holding the right split-candy half
- `activate_pump N`          — fire pump N once
- `activate_pump N times C`  — fire C times back-to-back
- `activate_pump N times C every S` — fire C times spaced S seconds apart
- `activate_pump N every S until <CONDITION>` — fire repeatedly until CONDITION holds
- `move_grab N X`            — move grab N to x-coordinate X (y unchanged)
- `move_grab N X Y`          — move grab N to (X, Y)
- `kick_rope N`              — apply a one-shot impulse to rope N
- `toggle_gravity`           — toggle the gravity setting

Each command may be guarded by an optional `when <CONDITION>` clause. Available condition primitives:
- `candy_x > N`, `candy_x < N`, `candy_y > N`, `candy_y < N`
- `candy_near X,Y,R` — candy is within radius R of (X,Y); optional `for S` requires the predicate to hold for S seconds
- `candy_still for S` — candy speed is below threshold for S seconds (useful before cutting after a swing settles)
- `left_candy_*` and `right_candy_*` mirror the candy_* primitives for the corresponding split half
- `grab_x I > N`, `grab_y I < N`, `grab_near I,X,Y,R`
- `rope_cut N` — rope N has been cut
- `no_rope`, `candy_in_bubble`
- Conditions can be combined with `and`, `or`, and parentheses.

## 6. CONSTRAINTS
- One command per line in the `commands` string.
- Indices must be zero-based and consistent with the level video.
- `wait_frames` is NOT allowed in this benchmark version. Use condition-based waits.
- The script must be deterministic; do not output stochastic or "either-or" entries.
- The script must terminate without manual intervention; the simulator runs it from the initial state and decides win/loss.

## 7. SOLVING ADVICE
- Identify which ropes mainly control the candy first; choose a cut order that releases the candy along the shortest stable path to the target.
- When waiting for the candy to reach a place, prefer `candy_near` / `candy_y` / `candy_x` over fixed timing.
- For repeated pumping, use `activate_pump N times C every S` or `activate_pump N every S until CONDITION`.
- In split-candy levels, do NOT use `candy_still` / `candy_near` for the merged candy before the halves merge; use the `left_candy_*` / `right_candy_*` primitives instead.

## 8. OUTPUT SCHEMA
FINAL_JSON: {"commands":"<command-script with \n separators>","reason":"<one-sentence intent>","confidence":<0..1>}
- commands: string. One command per line; lines separated by `\n`.
- reason: short one-sentence explanation of the intended sequence.
- confidence: float in `[0, 1]`.

## 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.


System:
You are a Cut the Rope replayable-script solver. Given a short gameplay video of one Cut the Rope level (with a coordinate grid overlay) and a structured description of the level objects, you produce a deterministic command script that, replayed from the same initial state, wins the level.

You will receive: (a) one short gameplay video of the level, (b) a structured text body listing the canvas size, the count of each gameplay object (candy, target, ropes, bubbles, pumps, gravity switches, stars), and the level metadata.

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 commands schema described in section 8 of the user prompt: keys `commands`, `reason`, `confidence`. Multiple winning scripts may be valid; output any one. 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 solution, still emit a best-effort FINAL_JSON line with at least one command and a confidence value below 1.0. Never refuse, never return prose only.

## 1. TASK
Produce a replayable command script that wins the Cut the Rope level shown in the gameplay video. The script must be deterministic so that replaying it from the same initial state in the simulator produces a win.
The level is solved when the candy reaches the target monster's mouth. Three-star completion is preferred but stable winning is the first priority.

## 2. WORLD MODEL
- Candy: a physics object affected by gravity, ropes, bubbles, pumps, and other active objects. Must be delivered to the target.
- Target / monster: the level is won when the candy enters the target's mouth.
- Rope: a constraint between the candy (or a split-candy half) and an anchor. Cutting a rope releases the candy from that constraint. Ropes are zero-indexed.
- Grab: an anchor for a rope that can be repositioned during play. Zero-indexed.
- Bubble: when the candy enters a bubble, it usually floats upward. Pop the bubble to release the candy.
- Pump: a gust source that pushes objects. Each activation produces one impulse.
- Gravity switch: toggles gravity direction or magnitude.
- Star: collected by candy passing through its position. Up to 3 stars per level.
- Split candy: some levels start with two candy halves (`left_candy`, `right_candy`). Use the half-specific conditions before the halves merge; switch to `candy_*` conditions after they merge.

## 3. VISUAL LEGEND
- The video is a short clip showing the full level layout and a coordinate grid overlay.
- Coordinates: origin at the top-left corner. x increases to the right; y increases downward.
- Indices in the video are zero-based for ropes, bubbles, pumps, and grabs. Infer indices from object positions and the order they appear in the clip.

## 4. INPUT FIELDS
- level_id: rope-206
- canvas_size: 1920 x 1080
- two_parts (split candy): False
- object_counts:
  - target: 1
  - star: 3
  - candy: 1
  - rope/grab: 3
- gameplay objects in this level:
- Target (monster): the level is won when the candy reaches the monster's mouth. The target is usually fixed in place.
- Candy: the candy is affected by gravity, ropes, bubbles, pumps, and other active objects. It must be delivered to the target.
- Ropes / grabs: ropes constrain the candy or split-candy movement. `cut_rope N` cuts rope N; `cut_rope N,M,K` cuts multiple at once. If a grab can move, `move_grab N X` or `move_grab N X Y` repositions it.
- Stars: candy or split-candy collects a star by passing through it. Prefer paths that collect 3 stars, but stable completion takes priority.

## 5. ACTION VOCABULARY
A complete answer is one ordered command script (one command per line). Available actions:
- `cut_rope N`               — cut rope N
- `cut_rope N,M,K`           — cut several ropes simultaneously
- `pop_bubble N`             — pop bubble N
- `pop_bubble_left`          — pop the bubble holding the left split-candy half
- `pop_bubble_right`         — pop the bubble holding the right split-candy half
- `activate_pump N`          — fire pump N once
- `activate_pump N times C`  — fire C times back-to-back
- `activate_pump N times C every S` — fire C times spaced S seconds apart
- `activate_pump N every S until <CONDITION>` — fire repeatedly until CONDITION holds
- `move_grab N X`            — move grab N to x-coordinate X (y unchanged)
- `move_grab N X Y`          — move grab N to (X, Y)
- `kick_rope N`              — apply a one-shot impulse to rope N
- `toggle_gravity`           — toggle the gravity setting

Each command may be guarded by an optional `when <CONDITION>` clause. Available condition primitives:
- `candy_x > N`, `candy_x < N`, `candy_y > N`, `candy_y < N`
- `candy_near X,Y,R` — candy is within radius R of (X,Y); optional `for S` requires the predicate to hold for S seconds
- `candy_still for S` — candy speed is below threshold for S seconds (useful before cutting after a swing settles)
- `left_candy_*` and `right_candy_*` mirror the candy_* primitives for the corresponding split half
- `grab_x I > N`, `grab_y I < N`, `grab_near I,X,Y,R`
- `rope_cut N` — rope N has been cut
- `no_rope`, `candy_in_bubble`
- Conditions can be combined with `and`, `or`, and parentheses.

## 6. CONSTRAINTS
- One command per line in the `commands` string.
- Indices must be zero-based and consistent with the level video.
- `wait_frames` is NOT allowed in this benchmark version. Use condition-based waits.
- The script must be deterministic; do not output stochastic or "either-or" entries.
- The script must terminate without manual intervention; the simulator runs it from the initial state and decides win/loss.

## 7. SOLVING ADVICE
- Identify which ropes mainly control the candy first; choose a cut order that releases the candy along the shortest stable path to the target.
- When waiting for the candy to reach a place, prefer `candy_near` / `candy_y` / `candy_x` over fixed timing.
- For repeated pumping, use `activate_pump N times C every S` or `activate_pump N every S until CONDITION`.
- In split-candy levels, do NOT use `candy_still` / `candy_near` for the merged candy before the halves merge; use the `left_candy_*` / `right_candy_*` primitives instead.

## 8. OUTPUT SCHEMA
FINAL_JSON: {"commands":"<command-script with \n separators>","reason":"<one-sentence intent>","confidence":<0..1>}
- commands: string. One command per line; lines separated by `\n`.
- reason: short one-sentence explanation of the intended sequence.
- confidence: float in `[0, 1]`.

## 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.


Click the air cushion to blow object

Нажмите на подушку чтобы подуть на леденец

Clique le coussin d'air pour souffler sur les objets

Klicke auf das Luftkissen, um auf den Gegenstand zu blasen

activate_pump 1
activate_pump 0 when candy_still for 0.3
cut_rope 0 when candy_x > 1130

activate_pump 1
activate_pump 0 when candy_still for 0.3
cut_rope 0 when candy_x > 1130

System:
You are a Cut the Rope replayable-script solver. Given a short gameplay video of one Cut the Rope level (with a coordinate grid overlay) and a structured description of the level objects, you produce a deterministic command script that, replayed from the same initial state, wins the level.

You will receive: (a) one short gameplay video of the level, (b) a structured text body listing the canvas size, the count of each gameplay object (candy, target, ropes, bubbles, pumps, gravity switches, stars), and the level metadata.

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 commands schema described in section 8 of the user prompt: keys `commands`, `reason`, `confidence`. Multiple winning scripts may be valid; output any one. 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 solution, still emit a best-effort FINAL_JSON line with at least one command and a confidence value below 1.0. Never refuse, never return prose only.

## 1. TASK
Produce a replayable command script that wins the Cut the Rope level shown in the gameplay video. The script must be deterministic so that replaying it from the same initial state in the simulator produces a win.
The level is solved when the candy reaches the target monster's mouth. Three-star completion is preferred but stable winning is the first priority.

## 2. WORLD MODEL
- Candy: a physics object affected by gravity, ropes, bubbles, pumps, and other active objects. Must be delivered to the target.
- Target / monster: the level is won when the candy enters the target's mouth.
- Rope: a constraint between the candy (or a split-candy half) and an anchor. Cutting a rope releases the candy from that constraint. Ropes are zero-indexed.
- Grab: an anchor for a rope that can be repositioned during play. Zero-indexed.
- Bubble: when the candy enters a bubble, it usually floats upward. Pop the bubble to release the candy.
- Pump: a gust source that pushes objects. Each activation produces one impulse.
- Gravity switch: toggles gravity direction or magnitude.
- Star: collected by candy passing through its position. Up to 3 stars per level.
- Split candy: some levels start with two candy halves (`left_candy`, `right_candy`). Use the half-specific conditions before the halves merge; switch to `candy_*` conditions after they merge.

## 3. VISUAL LEGEND
- The video is a short clip showing the full level layout and a coordinate grid overlay.
- Coordinates: origin at the top-left corner. x increases to the right; y increases downward.
- Indices in the video are zero-based for ropes, bubbles, pumps, and grabs. Infer indices from object positions and the order they appear in the clip.

## 4. INPUT FIELDS
- level_id: rope-207
- canvas_size: 1920 x 1080
- two_parts (split candy): False
- object_counts:
  - target: 1
  - star: 3
  - candy: 1
  - rope/grab: 1
  - pump: 2
- gameplay objects in this level:
- Target (monster): the level is won when the candy reaches the monster's mouth. The target is usually fixed in place.
- Candy: the candy is affected by gravity, ropes, bubbles, pumps, and other active objects. It must be delivered to the target.
- Ropes / grabs: ropes constrain the candy or split-candy movement. `cut_rope N` cuts rope N; `cut_rope N,M,K` cuts multiple at once. If a grab can move, `move_grab N X` or `move_grab N X Y` repositions it.
- Stars: candy or split-candy collects a star by passing through it. Prefer paths that collect 3 stars, but stable completion takes priority.
- Pumps: activating a pump pushes nearby objects. `activate_pump N`, optionally with `times`/`every`/`until` modifiers for repeated activation.

## 5. ACTION VOCABULARY
A complete answer is one ordered command script (one command per line). Available actions:
- `cut_rope N`               — cut rope N
- `cut_rope N,M,K`           — cut several ropes simultaneously
- `pop_bubble N`             — pop bubble N
- `pop_bubble_left`          — pop the bubble holding the left split-candy half
- `pop_bubble_right`         — pop the bubble holding the right split-candy half
- `activate_pump N`          — fire pump N once
- `activate_pump N times C`  — fire C times back-to-back
- `activate_pump N times C every S` — fire C times spaced S seconds apart
- `activate_pump N every S until <CONDITION>` — fire repeatedly until CONDITION holds
- `move_grab N X`            — move grab N to x-coordinate X (y unchanged)
- `move_grab N X Y`          — move grab N to (X, Y)
- `kick_rope N`              — apply a one-shot impulse to rope N
- `toggle_gravity`           — toggle the gravity setting

Each command may be guarded by an optional `when <CONDITION>` clause. Available condition primitives:
- `candy_x > N`, `candy_x < N`, `candy_y > N`, `candy_y < N`
- `candy_near X,Y,R` — candy is within radius R of (X,Y); optional `for S` requires the predicate to hold for S seconds
- `candy_still for S` — candy speed is below threshold for S seconds (useful before cutting after a swing settles)
- `left_candy_*` and `right_candy_*` mirror the candy_* primitives for the corresponding split half
- `grab_x I > N`, `grab_y I < N`, `grab_near I,X,Y,R`
- `rope_cut N` — rope N has been cut
- `no_rope`, `candy_in_bubble`
- Conditions can be combined with `and`, `or`, and parentheses.

## 6. CONSTRAINTS
- One command per line in the `commands` string.
- Indices must be zero-based and consistent with the level video.
- `wait_frames` is NOT allowed in this benchmark version. Use condition-based waits.
- The script must be deterministic; do not output stochastic or "either-or" entries.
- The script must terminate without manual intervention; the simulator runs it from the initial state and decides win/loss.

## 7. SOLVING ADVICE
- Identify which ropes mainly control the candy first; choose a cut order that releases the candy along the shortest stable path to the target.
- When waiting for the candy to reach a place, prefer `candy_near` / `candy_y` / `candy_x` over fixed timing.
- For repeated pumping, use `activate_pump N times C every S` or `activate_pump N every S until CONDITION`.
- In split-candy levels, do NOT use `candy_still` / `candy_near` for the merged candy before the halves merge; use the `left_candy_*` / `right_candy_*` primitives instead.

## 8. OUTPUT SCHEMA
FINAL_JSON: {"commands":"<command-script with \n separators>","reason":"<one-sentence intent>","confidence":<0..1>}
- commands: string. One command per line; lines separated by `\n`.
- reason: short one-sentence explanation of the intended sequence.
- confidence: float in `[0, 1]`.

## 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.