diff --git "a/utils/testing.ipynb" "b/utils/testing.ipynb"
deleted file mode 100644--- "a/utils/testing.ipynb"
+++ /dev/null
@@ -1,2297 +0,0 @@
-{
- "cells": [
-  {
-   "cell_type": "code",
-   "execution_count": 3,
-   "id": "9adfcb20",
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "import re"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 4,
-   "id": "de910107",
-   "metadata": {},
-   "outputs": [
-    {
-     "data": {
-      "text/plain": [
-       "'if <not <touching [sprite2 v]?>> then'"
-      ]
-     },
-     "execution_count": 4,
-     "metadata": {},
-     "output_type": "execute_result"
-    }
-   ],
-   "source": [
-    "stmt=\"if <not <touching [Sprite2 v]?>> then\"\n",
-    "s = stmt.lower().strip()\n",
-    "# 1) strip ALL balanced <…>\n",
-    "while s.startswith(\"<\") and s.endswith(\">\"):\n",
-    "    s = s[1:-1].strip()\n",
-    "# 2) strip stray unmatched < or >\n",
-    "while s.startswith(\"<\") and not s.endswith(\">\"):\n",
-    "    s = s[1:].strip()\n",
-    "while s.endswith(\">\") and not s.startswith(\"<\"):\n",
-    "    s = s[:-1].strip()\n",
-    "    \n",
-    "s"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 20,
-   "id": "af367513",
-   "metadata": {},
-   "outputs": [
-    {
-     "name": "stdout",
-     "output_type": "stream",
-     "text": [
-      "None\n",
-      "the stmt was this if <<mouse down?> and <touching [mouse-pointer v]?>> then and parsed was this if <<mouse down?> and <touching [mouse-pointer v]?>> then\n"
-     ]
-    },
-    {
-     "ename": "SyntaxError",
-     "evalue": "'return' outside function (234319892.py, line 51)",
-     "output_type": "error",
-     "traceback": [
-      "  \u001b[36mCell\u001b[39m\u001b[36m \u001b[39m\u001b[32mIn[20]\u001b[39m\u001b[32m, line 51\u001b[39m\n\u001b[31m    \u001b[39m\u001b[31mreturn {\"kind\": \"block\", \"block\": block_id}\u001b[39m\n    ^\n\u001b[31mSyntaxError\u001b[39m\u001b[31m:\u001b[39m 'return' outside function\n"
-     ]
-    }
-   ],
-   "source": [
-    "import re\n",
-    "\n",
-    "s = \"if <not <touching [sprite2 v]?>> then\"\n",
-    "\n",
-    "m_touch = re.fullmatch(r\"touching\\s*\\[\\s*([^\\]]+)\\s*v\\]\\??\", s, re.IGNORECASE)\n",
-    "print(m_touch)\n",
-    "if m_touch:\n",
-    "    sprite = m_touch.group(1).strip()\n",
-    "    val = {'mouse-pointer':'_mouse_', 'edge':'_edge_'}.get(sprite, sprite)\n",
-    "    mid = _register_block(\n",
-    "        \"sensing_touchingobjectmenu\", parent_key, True, pick_key_func, all_generated_blocks,\n",
-    "        fields={\"TOUCHINGOBJECTMENU\":[val, None]}\n",
-    "    )\n",
-    "    bid = _register_block(\n",
-    "        \"sensing_touchingobject\", parent_key, False, pick_key_func, all_generated_blocks,\n",
-    "        inputs={\"TOUCHINGOBJECTMENU\":[1, mid]}\n",
-    "    )\n",
-    "    #all_generated_blocks[mid][\"parent\"] = bid \n",
-    "    print(bid)\n",
-    "    #return {\"kind\":\"block\",\"block\":bid}\n",
-    "\n",
-    "s = stmt.lower().strip()\n",
-    "#s = strip_outer_angle_brackets(s)\n",
-    "# 1) strip ALL balanced <…>\n",
-    "while s.startswith(\"<\") and s.endswith(\">\"):\n",
-    "    s = s[1:-1].strip()\n",
-    "# 2) strip stray unmatched < or >\n",
-    "while s.startswith(\"<\") and not s.endswith(\">\"):\n",
-    "    s = s[1:].strip()\n",
-    "while s.endswith(\">\") and not s.startswith(\"<\"):\n",
-    "    s = s[:-1].strip()\n",
-    "    \n",
-    "print(f\"the stmt was this {stmt} and parsed was this {s}\")\n",
-    "# 1a) Comparisons with explicit angle wrappers: < (...) op (...) >\n",
-    "m = re.fullmatch(\n",
-    "    r\"\\s*<\\s*(.+?)\\s*(?P<op><|=|>)\\s*(.+?)\\s*>\\s*\",\n",
-    "    s,\n",
-    "    re.VERBOSE\n",
-    ")\n",
-    "if m:\n",
-    "    left_txt, right_txt = m.group(1), m.group(3)\n",
-    "    operand1_obj = parse_reporter_or_value(unparen(left_txt), None, pick_key_func, all_generated_blocks)\n",
-    "    operand2_obj = parse_reporter_or_value(unparen(right_txt), None, pick_key_func, all_generated_blocks)\n",
-    "    op_map = {'<': 'operator_lt', '=': 'operator_equals', '>': 'operator_gt'}\n",
-    "    \n",
-    "    inputs = {\"OPERAND1\": operand1_obj, \"OPERAND2\": operand2_obj}\n",
-    "    block_id = _register_block(op_map[m.group('op')], parent_key, False, pick_key_func, all_generated_blocks, inputs=inputs)\n",
-    "    # Set parents for nested inputs\n",
-    "    if operand1_obj.get(\"kind\") == \"block\": all_generated_blocks[operand1_obj[\"block\"]][\"parent\"] = block_id\n",
-    "    if operand2_obj.get(\"kind\") == \"block\": all_generated_blocks[operand2_obj[\"block\"]][\"parent\"] = block_id\n",
-    "    return {\"kind\": \"block\", \"block\": block_id}\n",
-    "# 1b) Simple comparisons without angle wrappers: A op B\n",
-    "m_simple = re.fullmatch(r\"\\s*(.+?)\\s*(?P<op><|=|>)\\s*(.+?)\\s*\", s)\n",
-    "if m_simple:\n",
-    "    left_txt, right_txt = m_simple.group(1), m_simple.group(3)\n",
-    "    operand1_obj = parse_reporter_or_value(unparen(left_txt), None, pick_key_func, all_generated_blocks)\n",
-    "    operand2_obj = parse_reporter_or_value(unparen(right_txt), None, pick_key_func, all_generated_blocks)\n",
-    "    op_map = {'<': 'operator_lt', '=': 'operator_equals', '>': 'operator_gt'}\n",
-    "    \n",
-    "    inputs = {\"OPERAND1\": operand1_obj, \"OPERAND2\": operand2_obj}\n",
-    "    block_id = _register_block(op_map[m_simple.group('op')], parent_key, False, pick_key_func, all_generated_blocks, inputs=inputs)\n",
-    "    if operand1_obj.get(\"kind\") == \"block\": all_generated_blocks[operand1_obj[\"block\"]][\"parent\"] = block_id\n",
-    "    if operand2_obj.get(\"kind\") == \"block\": all_generated_blocks[operand2_obj[\"block\"]][\"parent\"] = block_id\n",
-    "    return {\"kind\": \"block\", \"block\": block_id}"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 23,
-   "id": "3a315968",
-   "metadata": {},
-   "outputs": [
-    {
-     "name": "stdout",
-     "output_type": "stream",
-     "text": [
-      "[TEST] if <mouse down?> then\n",
-      "→ Extracted: 'mouse down?'\n",
-      "  Expected: 'mouse down?'\n",
-      "  ✅ PASS\n",
-      "\n",
-      "[TEST] if <not <mouse down?>> then\n",
-      "→ Extracted: 'not <mouse down?>'\n",
-      "  Expected: 'not <mouse down?>'\n",
-      "  ✅ PASS\n",
-      "\n",
-      "[TEST] if <<mouse down?> and <touching [edge v]?>> then\n",
-      "→ Extracted: 'mouse down?> and <touching [edge v]?'\n",
-      "  Expected: 'mouse down? and touching [edge v]?'\n",
-      "  ❌ FAIL\n",
-      "\n",
-      "[TEST] if <<<mouse down?>> or <not <key pressed?>> >> then\n",
-      "→ Extracted: 'mouse down?>> or <not <key pressed?'\n",
-      "  Expected: 'mouse down? or not <key pressed?>'\n",
-      "  ❌ FAIL\n",
-      "\n",
-      "[TEST] if <(x position) < (100)> then\n",
-      "→ Extracted: '<(x position) < (100)> then'\n",
-      "  Expected: '(x position) < (100)'\n",
-      "  ❌ FAIL\n",
-      "\n"
-     ]
-    }
-   ],
-   "source": [
-    "def extract_condition_balanced(stmt):\n",
-    "    stmt = stmt.strip()\n",
-    "    if \"if \" in stmt.lower():\n",
-    "        stmt = stmt.lower().split(\"if\", 1)[1].strip()\n",
-    "\n",
-    "    # Handle bracket balancing\n",
-    "    if stmt.startswith(\"<\"):\n",
-    "        count = 0\n",
-    "        condition = \"\"\n",
-    "        for i, ch in enumerate(stmt):\n",
-    "            if ch == \"<\":\n",
-    "                count += 1\n",
-    "            elif ch == \">\":\n",
-    "                count -= 1\n",
-    "            condition += ch\n",
-    "            if count == 0:\n",
-    "                break\n",
-    "\n",
-    "        # Strip outer brackets recursively\n",
-    "        inner = condition\n",
-    "        while inner.startswith(\"<\") and inner.endswith(\">\"):\n",
-    "            inner = inner[1:-1].strip()\n",
-    "\n",
-    "        return inner\n",
-    "    return stmt.strip()\n",
-    "\n",
-    "test_cases = [\n",
-    "    (\"if <mouse down?> then\", \"mouse down?\"),\n",
-    "    (\"if <not <mouse down?>> then\", \"not <mouse down?>\"),\n",
-    "    (\"if <<mouse down?> and <touching [edge v]?>> then\", \"mouse down? and touching [edge v]?\"),\n",
-    "    (\"if <<<mouse down?>> or <not <key pressed?>> >> then\", \"mouse down? or not <key pressed?>\"),\n",
-    "    (\"if <(x position) < (100)> then\", \"(x position) < (100)\"),\n",
-    "]\n",
-    "\n",
-    "for stmt, expected in test_cases:\n",
-    "    result = extract_condition_balanced(stmt)\n",
-    "    print(f\"[TEST] {stmt}\\n→ Extracted: '{result}'\\n  Expected: '{expected}'\\n  {'✅ PASS' if result == expected else '❌ FAIL'}\\n\")\n"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 38,
-   "id": "34ddb52b",
-   "metadata": {},
-   "outputs": [
-    {
-     "name": "stdout",
-     "output_type": "stream",
-     "text": [
-      "--- Testing improved function ---\n",
-      "[TEST] if <mouse down?> then\n",
-      "→ Extracted: 'mouse down?'\n",
-      "  Expected: 'mouse down?'\n",
-      "  ✅ PASS\n",
-      "\n",
-      "[TEST] repeat until <touching [edge v]?>\n",
-      "→ Extracted: 'touching [edge v]?'\n",
-      "  Expected: 'touching [edge v]?'\n",
-      "  ✅ PASS\n",
-      "\n",
-      "[TEST] if <key [left arrow v] pressed?> then\n",
-      "→ Extracted: 'key [left arrow v] pressed?'\n",
-      "  Expected: 'key [left arrow v] pressed?'\n",
-      "  ✅ PASS\n",
-      "\n",
-      "[TEST] if <touching [edge v]?> then\n",
-      "→ Extracted: 'touching [edge v]?'\n",
-      "  Expected: 'touching [edge v]?'\n",
-      "  ✅ PASS\n",
-      "\n",
-      "[TEST] if <<mouse down?> and <touching [edge v]?>> then\n",
-      "→ Extracted: '<mouse down?> and <touching [edge v]?>'\n",
-      "  Expected: 'mouse down? and touching [edge v]?'\n",
-      "  ❌ FAIL\n",
-      "\n",
-      "[TEST] if <(x position) < (100)> then\n",
-      "→ Extracted: '(x position) < (100)'\n",
-      "  Expected: '(x position) < (100)'\n",
-      "  ✅ PASS\n",
-      "\n",
-      "[TEST] if <<mouse down?>> then\n",
-      "→ Extracted: '<mouse down?>'\n",
-      "  Expected: 'mouse down?'\n",
-      "  ❌ FAIL\n",
-      "\n",
-      "[TEST] if <not<>> then\n",
-      "→ Extracted: 'not<>'\n",
-      "  Expected: 'not<>'\n",
-      "  ✅ PASS\n",
-      "\n",
-      "[TEST] if <<> or <>> then\n",
-      "→ Extracted: '<> or <>'\n",
-      "  Expected: '<> or <>'\n",
-      "  ✅ PASS\n",
-      "\n",
-      "[TEST] if <> then\n",
-      "→ Extracted: ''\n",
-      "  Expected: ''\n",
-      "  ✅ PASS\n",
-      "\n",
-      "[TEST] if mouse down? then\n",
-      "→ Extracted: 'mouse down?'\n",
-      "  Expected: 'mouse down?'\n",
-      "  ✅ PASS\n",
-      "\n",
-      "[TEST] <mouse down?>\n",
-      "→ Extracted: 'mouse down?'\n",
-      "  Expected: 'mouse down?'\n",
-      "  ✅ PASS\n",
-      "\n"
-     ]
-    }
-   ],
-   "source": [
-    "import re\n",
-    "\n",
-    "def extract_condition_balanced(stmt):\n",
-    "    # 1. Remove \"if\" and \"then\"\n",
-    "    stmt = stmt.strip()\n",
-    "    if stmt.lower().startswith(\"if \"):\n",
-    "        stmt = stmt[3:].strip()\n",
-    "    if stmt.lower().startswith(\"repeat until\"):\n",
-    "        stmt = stmt[12:].strip()\n",
-    "    if stmt.lower().endswith(\" then\"):\n",
-    "        stmt = stmt[:-5].strip()\n",
-    "\n",
-    "    # Helper to detect and strip single outer balanced angle brackets\n",
-    "    def unwrap_balanced(s):\n",
-    "        if s.startswith(\"<\") and s.endswith(\">\"):\n",
-    "            depth = 0\n",
-    "            for i in range(len(s)):\n",
-    "                if s[i] == \"<\":\n",
-    "                    depth += 1\n",
-    "                elif s[i] == \">\":\n",
-    "                    depth -= 1\n",
-    "                    if depth == 0 and i < len(s) - 1:\n",
-    "                        return s  # Early balance → not a single outer wrapper\n",
-    "            if depth == 0:\n",
-    "                return s[1:-1].strip()\n",
-    "        return s\n",
-    "\n",
-    "    # Recursively simplify things like <not <x>> to not <x>\n",
-    "    def simplify(s):\n",
-    "        s = unwrap_balanced(s)\n",
-    "        s = s.strip()\n",
-    "\n",
-    "        # Match <not <...>> pattern\n",
-    "        m = re.fullmatch(r\"not\\s*<(.+)>\", s, re.IGNORECASE)\n",
-    "        if m:\n",
-    "            inner = m.group(1).strip()\n",
-    "            inner = simplify(inner)\n",
-    "            return f\"not <{inner}>\"\n",
-    "\n",
-    "        # Match comparison operators like <(x position) < (100)>\n",
-    "        m_comp = re.fullmatch(r\"<\\s*\\(([^<>]+?)\\)\\s*([<>=])\\s*\\(([^<>]+?)\\)\\s*>\", stmt)\n",
-    "        if m_comp:\n",
-    "            return f\"({m_comp.group(1).strip()}) {m_comp.group(2)} ({m_comp.group(3).strip()})\"\n",
-    "\n",
-    "        return s\n",
-    "\n",
-    "    return simplify(stmt)\n",
-    "\n",
-    "# Test cases\n",
-    "# test_cases = [\n",
-    "#     (\"if <mouse down?> then\", \"mouse down?\"),\n",
-    "#     (\"if <not <mouse down?>> then\", \"not <mouse down?>\"),\n",
-    "#     (\"if <<mouse down?> and <touching [edge v]?>> then\", \"<mouse down?> and <touching [edge v]?>\"),\n",
-    "#     (\"if <<mouse down?> or <not <key pressed?>>> then\", \"<mouse down?> or <not <key pressed?>>\"),\n",
-    "#     (\"if <(x position) < (100)> then\", \"(x position) < (100)\"),\n",
-    "# ]\n",
-    "test_cases = [\n",
-    "    (\"if <mouse down?> then\", \"mouse down?\"),\n",
-    "    (\"repeat until <touching [edge v]?>\", \"touching [edge v]?\"),\n",
-    "    (\"if <key [left arrow v] pressed?> then\", \"key [left arrow v] pressed?\"),\n",
-    "    (\"if <touching [edge v]?> then\", \"touching [edge v]?\"),\n",
-    "    (\"if <<mouse down?> and <touching [edge v]?>> then\", \"mouse down? and touching [edge v]?\"),\n",
-    "    (\"if <(x position) < (100)> then\", \"(x position) < (100)\"),\n",
-    "    (\"if <<mouse down?>> then\", \"mouse down?\"),\n",
-    "    (\"if <not<>> then\", \"not<>\"),\n",
-    "    (\"if <<> or <>> then\", \"<> or <>\"),\n",
-    "    (\"if <> then\", \"\"),\n",
-    "    (\"if mouse down? then\", \"mouse down?\"),\n",
-    "    (\"<mouse down?>\", \"mouse down?\"),\n",
-    "]\n",
-    "\n",
-    "print(\"--- Testing improved function ---\")\n",
-    "for stmt, expected in test_cases:\n",
-    "    result = extract_condition_balanced(stmt)\n",
-    "    print(f\"[TEST] {stmt}\\n→ Extracted: '{result}'\\n  Expected: '{expected}'\\n  {'✅ PASS' if result == expected else '❌ FAIL'}\\n\")\n"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 6,
-   "id": "bc324bc0",
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "all_logics={'logic_0': 'when green flag clicked\\n            switch backdrop to [blue sky v]\\n            set [score v] to 0\\n            show variable [score v]\\n            broadcast [Game Start v]',\n",
-    "'logic_1': 'when I receive [Game Over v]\\n            if <(score) > (High Score)> then\\n              set [High Score v] to (score)\\n            end\\n             switch backdrop to [Game Over v]',\n",
-    "'logic_2': 'when I receive [Level Up v]\\n            change [level v] by 1\\n            set [ballSpeed v] to (ballSpeed * 1.1)',\n",
-    "'logic_3': 'when green flag clicked\\n            go to x: 0 y: -100\\n            forever\\n              if <key [space v] pressed?> then\\n                jump\\n              end\\n              move 5 steps\\n              if <touching [Ball v]?> then\\n                broadcast [Game Over v]\\n               end\\n            end',\n",
-    "'logic_4': 'when [space v] key pressed\\n            change y by 10\\n            wait 0.2 seconds\\n            change y by -10',\n",
-    "'logic_5': 'when green flag clicked\\n            go to x: 0 y: 100\\n            forever\\n              glide 2 seconds to x: pick random (-240, 240) y: 100\\n              if <touching [Cat v]?> then\\n                broadcast [Game Over v]\\n              end\\n            end',\n",
-    "'logic_6': 'when green flag clicked\\n            set [score v] to 0\\n            set [health v] to 1\\n            set [speed v] to 1\\n            switch backdrop to [blue sky v]\\n            broadcast [Game Start v]',\n",
-    "'logic_7': 'when I receive [Game Over v]\\n            if <(score) > (High Score)> then\\n              set [High Score v] to (score)\\n            end\\n            switch backdrop to [Game Over v]',\n",
-    "'logic_8': 'when green flag clicked\\n            go to x: 0 y: -130\\n            set [shield v] to 0',\n",
-    "'logic_9': 'when [space v] key pressed\\n             if <(y position) = -130> then\\n              repeat (10)\\n                change y by 20\\n                wait (0.1) seconds\\n                change y by -20\\n              end\\n            end',\n",
-    "'logic_10': 'when I receive [Power-Up v]\\n            if <(Power-Up) = [Shield v]> then\\n              set [shield v] to 1\\n            end',\n",
-    "'logic_11': 'when green flag clicked\\n            go to x: 50 y: 100\\n            forever\\n              change x by 5\\n              if <(x position) > 240> then\\n                set x to -240\\n              end\\n               if <(x position) < -240> then\\n                set x to 240\\n              end\\n              if <touching [Cat v]?> then\\n                broadcast [Game Over v]\\n              end\\n            end',}"
-   ]
-  },
-  {
-   "cell_type": "markdown",
-   "id": "6de2c3ab",
-   "metadata": {},
-   "source": [
-    "1. Example for the logic_1:\n",
-    "when green flag clicked\n",
-    "            switch backdrop to [blue sky v]\n",
-    "            set [score v] to 0\n",
-    "            show variable [score v]\n",
-    "            broadcast [Game Start v]\n",
-    " [ Note:There are some mistake done by the llm to generate the above pseudo code:\n",
-    "    1. the value `0` should be enclosed in brackets `(0)` which is missing here.\n",
-    "    2. there should be `end` for the `when green flag clicked` at the last line of pesudo-code.\n",
-    "    3. correct use of variables [score v] and options [Game Start v],[blue sky v] \n",
-    " ]\n",
-    "\n",
-    "2. Example for the logic_2:\n",
-    "when I receive [Game Over v]\n",
-    "            if <(score) > (High Score)> then\n",
-    "              set [High Score v] to (score)\n",
-    "            end\n",
-    "             switch backdrop to [Game Over v]\n",
-    " [ Note:There are some mistake done by the llm to generate the above pseudo code:\n",
-    "    1. the score and High score where variable but llm conisder as string so it keep it simple but thats wrong e.g. `[High Score v]` and [score v]\n",
-    "    2. in `set [High Score v] to (score)` the `[High Score v]`is correct but the vairable should be ([score v])\n",
-    "    3. there should be `end` for the `when I receive [Game Over v]` at the last line of pesudo-code.\n",
-    "    4. correct use of options [Game Over v],[High Score v].\n",
-    " ]\n",
-    "\n",
-    "3. Example for the logic_3:\n",
-    "when I receive [Level Up v]\n",
-    "            change [level v] by 1\n",
-    "            set [ballSpeed v] to (ballSpeed * 1.1)\n",
-    " [ Note:There are some mistake done by the llm to generate the above pseudo code:\n",
-    "    1. the value `1` and should be enclosed in brackets `(1)` which is missing here.\n",
-    "    2. in `set [ballSpeed v] to (ballSpeed * 1.1)`  the problem goes with invalid use of the operator block should be like this `(([ballSpeed v])*(1.1))`\n",
-    "    3. the `ballSpeed` is variable but llm conisder as string so it keep it simple but thats wrong in the set for second occurance e.g. `[ballSpeed v]` \n",
-    "    4. there should be `end` for the `when I receive [Level Up v]` at the last line of pesudo-code.\n",
-    " ]\n",
-    "\n",
-    "4. Example for the logic_4:\n",
-    "when green flag clicked\n",
-    "            go to x: 0 y: -100\n",
-    "            forever\n",
-    "              if <key [space v] pressed?> then\n",
-    "                jump\n",
-    "              end\n",
-    "              move 5 steps\n",
-    "              if <touching [Ball v]?> then\n",
-    "                broadcast [Game Over v]\n",
-    "               end\n",
-    "            end\n",
-    " [ Note:There are some mistake done by the llm to generate the above pseudo code:\n",
-    "    1. the value `0`,`100` and `5` should be enclosed in brackets `(0)`,`(100)` and `(5)` which is missing here.\n",
-    "    2. there is invalid code use that is `jump`it should be script where you use few code of with event to have jumping motion.\n",
-    "    3. correct use of options [Game Over v],[Ball v] and  [space v]\n",
-    "    4. there should be `end` for the `when green flag clicked` at the last line of pesudo-code.\n",
-    " ]\n",
-    "\n",
-    "5. Example for the logic_5:\n",
-    "when [space v] key pressed\n",
-    "            change y by 10\n",
-    "            wait 0.2 seconds\n",
-    "            change y by -10\n",
-    " [ Note:There are some mistake done by the llm to generate the above pseudo code:\n",
-    "    1. the value `10`,`0.2` and `-10` should be enclosed in brackets`(10)`,`(0.2)` and `(-10)` which is missing here.\n",
-    "    2. correct use of options [space v]\n",
-    "    3. there should be `end` for the `when [space v] key pressed` at the last line of pesudo-code.\n",
-    " ]\n",
-    "\n",
-    "6. Example for the logic_6:\n",
-    "when green flag clicked\n",
-    "            go to x: 0 y: 100\n",
-    "            forever\n",
-    "              glide 2 seconds to x: pick random (-240, 240) y: 100 #(pick random () to ())\n",
-    "              if <touching [Cat v]?> then\n",
-    "                broadcast [Game Over v]\n",
-    "              end\n",
-    "            end\n",
-    " [ Note:There are some mistake done by the llm to generate the above pseudo code:\n",
-    "    1. the value `0`,`100` and `2` should be enclosed in brackets `(0)`,`(100)` and `(2)` which is missing here.\n",
-    "    2. incorrect use of opcode in `glide 2 seconds to x: pick random (-240, 240) y: 100` it should be `glide (2) seconds to x: (pick random (-240) to (240)) y: (100)`\n",
-    "    3. correct use of options [Game Over v],[Cat v].\n",
-    "    4. there should be `end` for the `when green flag clicked` at the last line of pesudo-code.\n",
-    " ]\n",
-    "\n",
-    "7. Example for the logic_7:\n",
-    "when green flag clicked\n",
-    "            set [score v] to 0\n",
-    "            set [health v] to 1\n",
-    "            set [speed v] to 1\n",
-    "            switch backdrop to [blue sky v]\n",
-    "            broadcast [Game Start v]\n",
-    " [ Note:There are some mistake done by the llm to generate the above pseudo code:\n",
-    "    1. the value `0`,`1` and `1` should be enclosed in brackets `(0)`,`(1)` and `(1)` which is missing here.\n",
-    "    2. there should be `end` for the `when green flag clicked` at the last line of pesudo-code.\n",
-    "    3. correct use of variables [score v] and options [Game Start v],[blue sky v] \n",
-    " ]\n",
-    "\n",
-    "8. Example for the logic_8:\n",
-    "when green flag clicked\n",
-    "            go to x: 0 y: -130\n",
-    "            set [shield v] to 0\n",
-    " [ Note:There are some mistake done by the llm to generate the above pseudo code:\n",
-    "    1. the value `0`,`-130` should be enclosed in brackets `(0)`,`(-130)` which is missing here.\n",
-    "    2. there should be `end` for the `when green flag clicked` at the last line of pesudo-code.\n",
-    "    3. correct use of variables [shield v]\n",
-    " ]\n",
-    "\n",
-    "9. Example for the logic_9:\n",
-    "when [space v] key pressed\n",
-    "             if <(y position) = -130> then\n",
-    "              repeat (10)\n",
-    "                change y by 20\n",
-    "                wait (0.1) seconds\n",
-    "                change y by -20\n",
-    "              end\n",
-    "            end\n",
-    " [ Note:There are some mistake done by the llm to generate the above pseudo code:\n",
-    "    1. the value `20`,`-130` and `-20` should be enclosed in brackets `(20)`,`(-130)` and `(-20)` which is missing here.\n",
-    "    2. the reportor block such as `(y position)` when used as nesting as seen `if <(y position) = -130> then` it should enclosed in `()` the correct use `if <((y position)) = (-130)> then`\n",
-    "    3. correct use of options [space v]\n",
-    "    4. there should be `end` for the `when [space v] key pressed` at the last line of pesudo-code.\n",
-    " ]\n",
-    "\n",
-    "10. Example for the logic_10:\n",
-    "when I receive [Power-Up v]\n",
-    "            if <(Power-Up) = [Shield v]> then\n",
-    "              set [shield v] to 1\n",
-    "            end\n",
-    " [ Note:There are some mistake done by the llm to generate the above pseudo code:\n",
-    "    1. the value `1` should be enclosed in brackets `(1)` which is missing here.\n",
-    "    2. there should be `end` for the `when I receive [Power-Up v]` at the last line of pesudo-code.\n",
-    "    3. correct use of variables [Power-Up v] and options [Power-Up v],[Shield v] \n",
-    " ]\n",
-    "\n",
-    "11. Example for the logic_11:\n",
-    "when green flag clicked\n",
-    "            go to x: 50 y: 100\n",
-    "            forever\n",
-    "              change x by 5\n",
-    "              if <(x position) > 240> then\n",
-    "                set x to -240\n",
-    "              end\n",
-    "               if <(x position) < -240> then\n",
-    "                set x to 240\n",
-    "              end\n",
-    "              if <touching [Cat v]?> then\n",
-    "                broadcast [Game Over v]\n",
-    "              end\n",
-    "            end\n",
-    " [ Note:There are some mistake done by the llm to generate the above pseudo code:\n",
-    "    1. the value `50`,`100`, `5`, `240` and `-240` should be enclosed in brackets `(50)`,`(100)`, `(5)`, `(240)` and `(-240)` which is missing here.\n",
-    "    2. the reportor block such as `(x position)` when used as nesting as seen `if <(x position) > 240> then` and if <(x position) < -240> it should enclosed in `()` the correct use if <((x position)) < (-240)> and `if <((x position)) < (-240)>`\n",
-    "    3. correct use of options [Game Over v],[Cat v] \n",
-    " ]"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 10,
-   "id": "1ee313ee",
-   "metadata": {},
-   "outputs": [
-    {
-     "name": "stdout",
-     "output_type": "stream",
-     "text": [
-      "1. Example for the logic_0:\n",
-      "when green flag clicked\n",
-      "            switch backdrop to [blue sky v]\n",
-      "            set [score v] to 0\n",
-      "            show variable [score v]\n",
-      "            broadcast [Game Start v]\n",
-      " [Note:This generated json is ]\n",
-      "1.\n",
-      "2.\n",
-      "3.\n",
-      "\n",
-      "\n",
-      "1. Example for the logic_1:\n",
-      "when I receive [Game Over v]\n",
-      "            if <(score) > (High Score)> then\n",
-      "              set [High Score v] to (score)\n",
-      "            end\n",
-      "             switch backdrop to [Game Over v]\n",
-      " [Note:This generated json is ]\n",
-      "1.\n",
-      "2.\n",
-      "3.\n",
-      "\n",
-      "\n",
-      "1. Example for the logic_2:\n",
-      "when I receive [Level Up v]\n",
-      "            change [level v] by 1\n",
-      "            set [ballSpeed v] to (ballSpeed * 1.1)\n",
-      " [Note:This generated json is ]\n",
-      "1.\n",
-      "2.\n",
-      "3.\n",
-      "\n",
-      "\n",
-      "1. Example for the logic_3:\n",
-      "when green flag clicked\n",
-      "            go to x: 0 y: -100\n",
-      "            forever\n",
-      "              if <key [space v] pressed?> then\n",
-      "                jump\n",
-      "              end\n",
-      "              move 5 steps\n",
-      "              if <touching [Ball v]?> then\n",
-      "                broadcast [Game Over v]\n",
-      "               end\n",
-      "            end\n",
-      " [Note:This generated json is ]\n",
-      "1.\n",
-      "2.\n",
-      "3.\n",
-      "\n",
-      "\n",
-      "1. Example for the logic_4:\n",
-      "when [space v] key pressed\n",
-      "            change y by 10\n",
-      "            wait 0.2 seconds\n",
-      "            change y by -10\n",
-      " [Note:This generated json is ]\n",
-      "1.\n",
-      "2.\n",
-      "3.\n",
-      "\n",
-      "\n",
-      "1. Example for the logic_5:\n",
-      "when green flag clicked\n",
-      "            go to x: 0 y: 100\n",
-      "            forever\n",
-      "              glide 2 seconds to x: pick random (-240, 240) y: 100\n",
-      "              if <touching [Cat v]?> then\n",
-      "                broadcast [Game Over v]\n",
-      "              end\n",
-      "            end\n",
-      " [Note:This generated json is ]\n",
-      "1.\n",
-      "2.\n",
-      "3.\n",
-      "\n",
-      "\n",
-      "1. Example for the logic_6:\n",
-      "when green flag clicked\n",
-      "            set [score v] to 0\n",
-      "            set [health v] to 1\n",
-      "            set [speed v] to 1\n",
-      "            switch backdrop to [blue sky v]\n",
-      "            broadcast [Game Start v]\n",
-      " [Note:This generated json is ]\n",
-      "1.\n",
-      "2.\n",
-      "3.\n",
-      "\n",
-      "\n",
-      "1. Example for the logic_7:\n",
-      "when I receive [Game Over v]\n",
-      "            if <(score) > (High Score)> then\n",
-      "              set [High Score v] to (score)\n",
-      "            end\n",
-      "            switch backdrop to [Game Over v]\n",
-      " [Note:This generated json is ]\n",
-      "1.\n",
-      "2.\n",
-      "3.\n",
-      "\n",
-      "\n",
-      "1. Example for the logic_8:\n",
-      "when green flag clicked\n",
-      "            go to x: 0 y: -130\n",
-      "            set [shield v] to 0\n",
-      " [Note:This generated json is ]\n",
-      "1.\n",
-      "2.\n",
-      "3.\n",
-      "\n",
-      "\n",
-      "1. Example for the logic_9:\n",
-      "when [space v] key pressed\n",
-      "             if <(y position) = -130> then\n",
-      "              repeat (10)\n",
-      "                change y by 20\n",
-      "                wait (0.1) seconds\n",
-      "                change y by -20\n",
-      "              end\n",
-      "            end\n",
-      " [Note:This generated json is ]\n",
-      "1.\n",
-      "2.\n",
-      "3.\n",
-      "\n",
-      "\n",
-      "1. Example for the logic_10:\n",
-      "when I receive [Power-Up v]\n",
-      "            if <(Power-Up) = [Shield v]> then\n",
-      "              set [shield v] to 1\n",
-      "            end\n",
-      " [Note:This generated json is ]\n",
-      "1.\n",
-      "2.\n",
-      "3.\n",
-      "\n",
-      "\n",
-      "1. Example for the logic_11:\n",
-      "when green flag clicked\n",
-      "            go to x: 50 y: 100\n",
-      "            forever\n",
-      "              change x by 5\n",
-      "              if <(x position) > 240> then\n",
-      "                set x to -240\n",
-      "              end\n",
-      "               if <(x position) < -240> then\n",
-      "                set x to 240\n",
-      "              end\n",
-      "              if <touching [Cat v]?> then\n",
-      "                broadcast [Game Over v]\n",
-      "              end\n",
-      "            end\n",
-      " [Note:This generated json is ]\n",
-      "1.\n",
-      "2.\n",
-      "3.\n",
-      "\n",
-      "\n"
-     ]
-    }
-   ],
-   "source": [
-    "i=1\n",
-    "for key, value in all_logics.items():\n",
-    "    print(f\"{1}. Example for the {key}:\\n{str(value)}\\n [Note:This generated json is ]\\n1.\\n2.\\n3.\\n\\n\")\n",
-    "    i += 1\n",
-    "# txt = 'when green flag clicked\\n            go to x: 50 y: 100\\n            forever\\n              change x by 5\\n              if <(x position) > 240> then\\n                set x to -240\\n              end\\n               if <(x position) < -240> then\\n                set x to 240\\n              end\\n              if <touching [Cat v]?> then\\n                broadcast [Game Over v]\\n              end\\n            end'\n",
-    "# print(str(txt))"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 1,
-   "id": "4700799d",
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "all_logics={\"logic1\": \"when green flag clicked\\n            set [score v] to (0)\\n            set [lives v] to (3)\\n            show variable [score v]\\n            show variable [lives v]\\n            broadcast [Game Start v]\",\n",
-    "\"logic2\": \"when I receive [Game Over v]\\n            broadcast [Reset Game v]\\n            set [score v] to (0)\\n            set [lives v] to (3)\",\n",
-    "\"logic3\": \"when green flag clicked\\n            go to x: (0) y: (-100)\\n            set [speed v] to (0)\",\n",
-    "\"logic4\": \"when [right arrow v] key pressed\\n            change x by (10)\",\n",
-    "\"logic5\": \"when [left arrow v] key pressed\\n            change x by (-10)\",\n",
-    "\"logic6\": \"when [space v] key pressed\\n            if <((y position)) = (-100)> then \\n              forever\\n                change y by (10)\\n                wait (0.1) seconds\\n                change y by (-10)\\n                wait (0.1) seconds\\n              end\\n            end\",\n",
-    "\"logic7\": \"when green flag clicked\\n            go to x: (0) y: (100)\\n            set [ballSpeed v] to (5)\\n            forever\\n              glide (2) seconds to x: (-240) y: (100)\\n            if <(x position) < (-235)> then\\n                set x to (240)\\n              end\\n              if <touching [Cat v]?> then\\n                broadcast [Game Over v]\\n                stop [all v]\\n              end\\n            end\",}\n"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": null,
-   "id": "4016c96d",
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "\"logic\": \"when green flag clicked\\n            set [score v] to (0)\\n            set [lives v] to (3)\\n            show variable [score v]\\n            show variable [lives v]\\n            broadcast [Game Start v]\",\n",
-    "\"logic\": \"when I receive [Game Over v]\\n            broadcast [Reset Game v]\\n            set [score v] to (0)\\n            set [lives v] to (3)\",\n",
-    "\"logic\": \"when green flag clicked\\n            go to x: (0) y: (-100)\\n            set [speed v] to (0)\",\n",
-    "\"logic\": \"when [right arrow v] key pressed\\n            change x by (10)\",\n",
-    "\"logic\": \"when [left arrow v] key pressed\\n            change x by (-10)\",\n",
-    "\"logic\": \"when [space v] key pressed\\n            if <((y position)) = (-100)> then \\n              forever\\n                change y by (10)\\n                wait (0.1) seconds\\n                change y by (-10)\\n                wait (0.1) seconds\\n              end\\n            end\",\n",
-    "\"logic\": \"when green flag clicked\\n            go to x: (0) y: (100)\\n            set [ballSpeed v] to (5)\\n            forever\\n              glide (2) seconds to x: (-240) y: (100)\\n            if <(x position) < (-235)> then\\n                set x to (240)\\n              end\\n              if <touching [Cat v]?> then\\n                broadcast [Game Over v]\\n                stop [all v]\\n              end\\n            end\","
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 15,
-   "id": "2f66b647",
-   "metadata": {},
-   "outputs": [
-    {
-     "data": {
-      "text/plain": [
-       "dict_keys(['logic1', 'logic2', 'logic3', 'logic4', 'logic5', 'logic6', 'logic7'])"
-      ]
-     },
-     "execution_count": 15,
-     "metadata": {},
-     "output_type": "execute_result"
-    }
-   ],
-   "source": [
-    "all_logics.keys()"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 2,
-   "id": "edff93c3",
-   "metadata": {},
-   "outputs": [
-    {
-     "name": "stdout",
-     "output_type": "stream",
-     "text": [
-      "1. Example for the logic1:\n",
-      "when green flag clicked\n",
-      "            set [score v] to (0)\n",
-      "            set [lives v] to (3)\n",
-      "            show variable [score v]\n",
-      "            show variable [lives v]\n",
-      "            broadcast [Game Start v]\n",
-      " [Note:This generated json is ]\n",
-      "1.\n",
-      "2.\n",
-      "3.\n",
-      "\n",
-      "\n",
-      "1. Example for the logic2:\n",
-      "when I receive [Game Over v]\n",
-      "            broadcast [Reset Game v]\n",
-      "            set [score v] to (0)\n",
-      "            set [lives v] to (3)\n",
-      " [Note:This generated json is ]\n",
-      "1.\n",
-      "2.\n",
-      "3.\n",
-      "\n",
-      "\n",
-      "1. Example for the logic3:\n",
-      "when green flag clicked\n",
-      "            go to x: (0) y: (-100)\n",
-      "            set [speed v] to (0)\n",
-      " [Note:This generated json is ]\n",
-      "1.\n",
-      "2.\n",
-      "3.\n",
-      "\n",
-      "\n",
-      "1. Example for the logic4:\n",
-      "when [right arrow v] key pressed\n",
-      "            change x by (10)\n",
-      " [Note:This generated json is ]\n",
-      "1.\n",
-      "2.\n",
-      "3.\n",
-      "\n",
-      "\n",
-      "1. Example for the logic5:\n",
-      "when [left arrow v] key pressed\n",
-      "            change x by (-10)\n",
-      " [Note:This generated json is ]\n",
-      "1.\n",
-      "2.\n",
-      "3.\n",
-      "\n",
-      "\n",
-      "1. Example for the logic6:\n",
-      "when [space v] key pressed\n",
-      "            if <((y position)) = (-100)> then \n",
-      "              forever\n",
-      "                change y by (10)\n",
-      "                wait (0.1) seconds\n",
-      "                change y by (-10)\n",
-      "                wait (0.1) seconds\n",
-      "              end\n",
-      "            end\n",
-      " [Note:This generated json is ]\n",
-      "1.\n",
-      "2.\n",
-      "3.\n",
-      "\n",
-      "\n",
-      "1. Example for the logic7:\n",
-      "when green flag clicked\n",
-      "            go to x: (0) y: (100)\n",
-      "            set [ballSpeed v] to (5)\n",
-      "            forever\n",
-      "              glide (2) seconds to x: (-240) y: (100)\n",
-      "            if <(x position) < (-235)> then\n",
-      "                set x to (240)\n",
-      "              end\n",
-      "              if <touching [Cat v]?> then\n",
-      "                broadcast [Game Over v]\n",
-      "                stop [all v]\n",
-      "              end\n",
-      "            end\n",
-      " [Note:This generated json is ]\n",
-      "1.\n",
-      "2.\n",
-      "3.\n",
-      "\n",
-      "\n"
-     ]
-    }
-   ],
-   "source": [
-    "i=1\n",
-    "for key, value in all_logics.items():\n",
-    "    print(f\"{1}. Example for the {key}:\\n{str(value)}\\n [Note:This generated json is ]\\n1.\\n2.\\n3.\\n\\n\")\n",
-    "    i += 1"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": null,
-   "id": "a396a819",
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "pseudo_code=\"\"\"\n",
-    "when green flag clicked\n",
-    "set [score v] to (0)\n",
-    "set [lives v] to (3)\n",
-    "show variable [score v]\n",
-    "show variable [lives v]\n",
-    "broadcast [Game Start v]\n",
-    "\"\"\"\n",
-    "opcode_counts=[\n",
-    "          {\n",
-    "            \"opcode\": \"event_whenflagclicked\",\n",
-    "            \"count\": 1\n",
-    "          },\n",
-    "          {\n",
-    "            \"opcode\": \"data_setvariableto\",\n",
-    "            \"count\": 2\n",
-    "          },\n",
-    "          {\n",
-    "            \"opcode\": \"data_showvariable\",\n",
-    "            \"count\": 2\n",
-    "          },\n",
-    "          {\n",
-    "            \"opcode\": \"event_broadcast\",\n",
-    "            \"count\": 1\n",
-    "          }\n",
-    "        ]\n",
-    "pseudo_code=\"\"\"\n",
-    "when I receive [Game Over v]\n",
-    "broadcast [Reset Game v]\n",
-    "set [score v] to (0)\n",
-    "set [lives v] to (3)\n",
-    "\"\"\"\n",
-    "opcode_counts=[\n",
-    "          {\n",
-    "            \"opcode\": \"event_whenbroadcastreceived\",\n",
-    "            \"count\": 1\n",
-    "          },\n",
-    "          {\n",
-    "            \"opcode\": \"event_broadcast\",\n",
-    "            \"count\": 1\n",
-    "          },\n",
-    "          {\n",
-    "            \"opcode\": \"data_setvariableto\",\n",
-    "            \"count\": 2\n",
-    "          }\n",
-    "        ]\n",
-    "\n",
-    "pseudo_code=\"\"\"\n",
-    "when green flag clicked\n",
-    "            go to x: (0) y: (-100)\n",
-    "            set [speed v] to (0)\n",
-    "\"\"\"\n",
-    "opcode_counts=[\n",
-    "          {\n",
-    "            \"opcode\": \"event_whenflagclicked\",\n",
-    "            \"count\": 1\n",
-    "          },\n",
-    "          {\n",
-    "            \"opcode\": \"motion_gotoxy\",\n",
-    "            \"count\": 1\n",
-    "          },\n",
-    "          {\n",
-    "            \"opcode\": \"data_setvariableto\",\n",
-    "            \"count\": 1\n",
-    "          }\n",
-    "        ]\n",
-    "\n",
-    "\n",
-    "pseudo_code=\"\"\"\n",
-    "when [right arrow v] key pressed\n",
-    "            change x by (10)\n",
-    "\"\"\"\n",
-    "opcode_counts=[\n",
-    "          {\n",
-    "            \"opcode\": \"event_whenkeypressed\",\n",
-    "            \"count\": 1\n",
-    "          },\n",
-    "          {\n",
-    "            \"opcode\": \"motion_changexby\",\n",
-    "            \"count\": 1\n",
-    "          }\n",
-    "        ]\n",
-    "\n",
-    "\n",
-    "\n",
-    "pseudo_code=\"\"\"\n",
-    "when [left arrow v] key pressed\n",
-    "            change x by (-10)\n",
-    "\"\"\"\n",
-    "opcode_counts=[\n",
-    "          {\n",
-    "            \"opcode\": \"event_whenkeypressed\",\n",
-    "            \"count\": 1\n",
-    "          },\n",
-    "          {\n",
-    "            \"opcode\": \"motion_changexby\",\n",
-    "            \"count\": 1\n",
-    "          }\n",
-    "        ]\n",
-    "\n",
-    "\n",
-    "pseudo_code=\"\"\"\n",
-    "when [space v] key pressed\n",
-    "            if <((y position)) = (-100)> then \n",
-    "              forever\n",
-    "                change y by (10)\n",
-    "                wait (0.1) seconds\n",
-    "                change y by (-10)\n",
-    "                wait (0.1) seconds\n",
-    "              end\n",
-    "            end\n",
-    "\"\"\"\n",
-    "opcode_counts=[\n",
-    "          {\n",
-    "            \"opcode\": \"event_whenkeypressed\",\n",
-    "            \"count\": 1\n",
-    "          },\n",
-    "          {\n",
-    "            \"opcode\": \"control_if\",\n",
-    "            \"count\": 1\n",
-    "          },\n",
-    "          {\n",
-    "            \"opcode\": \"control_forever\",\n",
-    "            \"count\": 1\n",
-    "          },\n",
-    "          {\n",
-    "            \"opcode\": \"motion_changeyby\",\n",
-    "            \"count\": 2\n",
-    "          }\n",
-    "        ]\n",
-    "\n",
-    "pseudo_code=\"\"\"\n",
-    "when green flag clicked\n",
-    "            go to x: (0) y: (100)\n",
-    "            set [ballSpeed v] to (5)\n",
-    "            forever\n",
-    "              glide (2) seconds to x: (-240) y: (100)\n",
-    "            if <(x position) < (-235)> then\n",
-    "                set x to (240)\n",
-    "              end\n",
-    "              if <touching [Cat v]?> then\n",
-    "                broadcast [Game Over v]\n",
-    "                stop [all v]\n",
-    "              end\n",
-    "            end\n",
-    "\"\"\"\n",
-    "opcode_counts=[\n",
-    "          {\n",
-    "            \"opcode\": \"event_whenflagclicked\",\n",
-    "            \"count\": 1\n",
-    "          },\n",
-    "          {\n",
-    "            \"opcode\": \"motion_gotoxy\",\n",
-    "            \"count\": 1\n",
-    "          },\n",
-    "          {\n",
-    "            \"opcode\": \"motion_glidesecstoxy\",\n",
-    "            \"count\": 1\n",
-    "          },\n",
-    "          {\n",
-    "            \"opcode\": \"motion_xposition\",\n",
-    "            \"count\": 1\n",
-    "          },\n",
-    "          {\n",
-    "            \"opcode\": \"motion_setx\",\n",
-    "            \"count\": 1\n",
-    "          },\n",
-    "          {\n",
-    "            \"opcode\": \"control_forever\",\n",
-    "            \"count\": 1\n",
-    "          },\n",
-    "          {\n",
-    "            \"opcode\": \"control_if\",\n",
-    "            \"count\": 2\n",
-    "          },\n",
-    "          {\n",
-    "            \"opcode\": \"operator_lt\",\n",
-    "            \"count\": 1\n",
-    "          },\n",
-    "          {\n",
-    "            \"opcode\": \"sensing_istouching\",\n",
-    "            \"count\": 1\n",
-    "          },\n",
-    "          {\n",
-    "            \"opcode\": \"event_broadcast\",\n",
-    "            \"count\": 1\n",
-    "          },\n",
-    "          {\n",
-    "            \"opcode\": \"control_stop\",\n",
-    "            \"count\": 1\n",
-    "          },\n",
-    "          {\n",
-    "            \"opcode\": \"data_setvariableto\",\n",
-    "            \"count\": 1\n",
-    "          }\n",
-    "        ]\n",
-    "\n"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": null,
-   "id": "1ac34c30",
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "{\n",
-    "  \"Stage\": {\n",
-    "    \"description\": \"Background and global game state management, including broadcasts, rewards, and score.\",\n",
-    "    \"plans\": [\n",
-    "      {\n",
-    "        \"event\": \"event_whenflagclicked\",\n",
-    "        \"logic\": \"when green flag clicked\\n            set [score v] to (0)\\n            set [lives v] to (3)\\n            show variable [score v]\\n            show variable [lives v]\\n            broadcast [Game Start v]\",\n",
-    "        \"motion\": [],\n",
-    "        \"control\": [],\n",
-    "        \"operator\": [],\n",
-    "        \"sensing\": [],\n",
-    "        \"looks\": [],\n",
-    "        \"sounds\": [],\n",
-    "        \"events\": [\n",
-    "          \"event_broadcast\"\n",
-    "        ],\n",
-    "        \"data\": [\n",
-    "          \"data_setvariableto\",\n",
-    "          \"data_showvariable\"\n",
-    "        ],\n",
-    "        \"opcode_counts\": [\n",
-    "          {\n",
-    "            \"opcode\": \"event_whenflagclicked\",\n",
-    "            \"count\": 1\n",
-    "          },\n",
-    "          {\n",
-    "            \"opcode\": \"data_setvariableto\",\n",
-    "            \"count\": 2\n",
-    "          },\n",
-    "          {\n",
-    "            \"opcode\": \"data_showvariable\",\n",
-    "            \"count\": 2\n",
-    "          },\n",
-    "          {\n",
-    "            \"opcode\": \"event_broadcast\",\n",
-    "            \"count\": 1\n",
-    "          }\n",
-    "        ]\n",
-    "      },\n",
-    "      {\n",
-    "        \"event\": \"event_whenbroadcastreceived\",\n",
-    "        \"logic\": \"when I receive [Game Over v]\\n            broadcast [Reset Game v]\\n            set [score v] to (0)\\n            set [lives v] to (3)\",\n",
-    "        \"motion\": [],\n",
-    "        \"control\": [],\n",
-    "        \"operator\": [],\n",
-    "        \"sensing\": [],\n",
-    "        \"looks\": [],\n",
-    "        \"sounds\": [],\n",
-    "        \"events\": [],\n",
-    "        \"data\": [\n",
-    "          \"data_setvariableto\"\n",
-    "        ],\n",
-    "        \"opcode_counts\": [\n",
-    "          {\n",
-    "            \"opcode\": \"event_whenbroadcastreceived\",\n",
-    "            \"count\": 1\n",
-    "          },\n",
-    "          {\n",
-    "            \"opcode\": \"event_broadcast\",\n",
-    "            \"count\": 1\n",
-    "          },\n",
-    "          {\n",
-    "            \"opcode\": \"data_setvariableto\",\n",
-    "            \"count\": 2\n",
-    "          }\n",
-    "        ]\n",
-    "      }\n",
-    "    ]\n",
-    "  },\n",
-    "  \"Cat\": {\n",
-    "    \"description\": \"Main character (cat) actions\",\n",
-    "    \"plans\": [\n",
-    "      {\n",
-    "        \"event\": \"event_whenflagclicked\",\n",
-    "        \"logic\": \"when green flag clicked\\n            go to x: (0) y: (-100)\\n            set [speed v] to (0)\",\n",
-    "        \"motion\": [\n",
-    "          \"motion_gotoxy\"\n",
-    "        ],\n",
-    "        \"control\": [],\n",
-    "        \"operator\": [],\n",
-    "        \"sensing\": [],\n",
-    "        \"looks\": [],\n",
-    "        \"sounds\": [],\n",
-    "        \"events\": [],\n",
-    "        \"data\": [],\n",
-    "        \"opcode_counts\": [\n",
-    "          {\n",
-    "            \"opcode\": \"event_whenflagclicked\",\n",
-    "            \"count\": 1\n",
-    "          },\n",
-    "          {\n",
-    "            \"opcode\": \"motion_gotoxy\",\n",
-    "            \"count\": 1\n",
-    "          },\n",
-    "          {\n",
-    "            \"opcode\": \"data_setvariableto\",\n",
-    "            \"count\": 1\n",
-    "          }\n",
-    "        ]\n",
-    "      },\n",
-    "      {\n",
-    "        \"event\": \"event_whenkeypressed\",\n",
-    "        \"logic\": \"when [right arrow v] key pressed\\n            change x by (10)\",\n",
-    "        \"motion\": [\n",
-    "          \"motion_changexby\"\n",
-    "        ],\n",
-    "        \"control\": [],\n",
-    "        \"operator\": [],\n",
-    "        \"sensing\": [],\n",
-    "        \"looks\": [],\n",
-    "        \"sounds\": [],\n",
-    "        \"events\": [],\n",
-    "        \"data\": [],\n",
-    "        \"opcode_counts\": [\n",
-    "          {\n",
-    "            \"opcode\": \"event_whenkeypressed\",\n",
-    "            \"count\": 1\n",
-    "          },\n",
-    "          {\n",
-    "            \"opcode\": \"motion_changexby\",\n",
-    "            \"count\": 1\n",
-    "          }\n",
-    "        ]\n",
-    "      },\n",
-    "      {\n",
-    "        \"event\": \"event_whenkeypressed\",\n",
-    "        \"logic\": \"when [left arrow v] key pressed\\n            change x by (-10)\",\n",
-    "        \"motion\": [\n",
-    "          \"motion_changexby\"\n",
-    "        ],\n",
-    "        \"control\": [],\n",
-    "        \"operator\": [],\n",
-    "        \"sensing\": [],\n",
-    "        \"looks\": [],\n",
-    "        \"sounds\": [],\n",
-    "        \"events\": [],\n",
-    "        \"data\": [],\n",
-    "        \"opcode_counts\": [\n",
-    "          {\n",
-    "            \"opcode\": \"event_whenkeypressed\",\n",
-    "            \"count\": 1\n",
-    "          },\n",
-    "          {\n",
-    "            \"opcode\": \"motion_changexby\",\n",
-    "            \"count\": 1\n",
-    "          }\n",
-    "        ]\n",
-    "      },\n",
-    "      {\n",
-    "        \"event\": \"event_whenkeypressed\",\n",
-    "        \"logic\": \"when [space v] key pressed\\n            if <((y position)) = (-100)> then \\n              forever\\n                change y by (10)\\n                wait (0.1) seconds\\n                change y by (-10)\\n                wait (0.1) seconds\\n              end\\n            end\",\n",
-    "        \"motion\": [\n",
-    "          \"motion_changeyby\"\n",
-    "        ],\n",
-    "        \"control\": [\n",
-    "          \"control_forever\",\n",
-    "          \"control_if\"\n",
-    "        ],\n",
-    "        \"operator\": [],\n",
-    "        \"sensing\": [],\n",
-    "        \"looks\": [],\n",
-    "        \"sounds\": [],\n",
-    "        \"events\": [],\n",
-    "        \"data\": [],\n",
-    "        \"opcode_counts\": [\n",
-    "          {\n",
-    "            \"opcode\": \"event_whenkeypressed\",\n",
-    "            \"count\": 1\n",
-    "          },\n",
-    "          {\n",
-    "            \"opcode\": \"control_if\",\n",
-    "            \"count\": 1\n",
-    "          },\n",
-    "          {\n",
-    "            \"opcode\": \"control_forever\",\n",
-    "            \"count\": 1\n",
-    "          },\n",
-    "          {\n",
-    "            \"opcode\": \"motion_changeyby\",\n",
-    "            \"count\": 2\n",
-    "          }\n",
-    "        ]\n",
-    "      }\n",
-    "    ]\n",
-    "  },\n",
-    "  \"ball\": {\n",
-    "    \"description\": \"Obstacle movement and interaction\",\n",
-    "    \"plans\": [\n",
-    "      {\n",
-    "        \"event\": \"event_whenflagclicked\",\n",
-    "        \"logic\": \"when green flag clicked\\n            go to x: (0) y: (100)\\n            set [ballSpeed v] to (5)\\n            forever\\n              glide (2) seconds to x: (-240) y: (100)\\n            \n",
-    "  if <(x position) < (-235)> then\\n                set x to (240)\\n              end\\n              if <touching [Cat v]?> then\\n                broadcast [Game Over v]\\n                stop [all v]\\n              end\\n            end\",\n",
-    "        \"motion\": [\n",
-    "          \"motion_gotoxy\",\n",
-    "          \"motion_glidesecstoxy\",\n",
-    "          \"motion_xposition\",\n",
-    "          \"motion_setx\"\n",
-    "        ],\n",
-    "        \"control\": [\n",
-    "          \"control_forever\",\n",
-    "          \"control_if\",\n",
-    "          \"control_stop\"\n",
-    "        ],\n",
-    "        \"operator\": [\n",
-    "          \"operator_lt\"\n",
-    "        ],\n",
-    "        \"sensing\": [\n",
-    "          \"sensing_istouching\"\n",
-    "        ],\n",
-    "        \"looks\": [],\n",
-    "        \"sounds\": [],\n",
-    "        \"events\": [\n",
-    "          \"event_broadcast\"\n",
-    "        ],\n",
-    "        \"data\": [],\n",
-    "        \"opcode_counts\": [\n",
-    "          {\n",
-    "            \"opcode\": \"event_whenflagclicked\",\n",
-    "            \"count\": 1\n",
-    "          },\n",
-    "          {\n",
-    "            \"opcode\": \"motion_gotoxy\",\n",
-    "            \"count\": 1\n",
-    "          },\n",
-    "          {\n",
-    "            \"opcode\": \"motion_glidesecstoxy\",\n",
-    "            \"count\": 1\n",
-    "          },\n",
-    "          {\n",
-    "            \"opcode\": \"motion_xposition\",\n",
-    "            \"count\": 1\n",
-    "          },\n",
-    "          {\n",
-    "            \"opcode\": \"motion_setx\",\n",
-    "            \"count\": 1\n",
-    "          },\n",
-    "          {\n",
-    "            \"opcode\": \"control_forever\",\n",
-    "            \"count\": 1\n",
-    "          },\n",
-    "          {\n",
-    "            \"opcode\": \"control_if\",\n",
-    "            \"count\": 2\n",
-    "          },\n",
-    "          {\n",
-    "            \"opcode\": \"operator_lt\",\n",
-    "            \"count\": 1\n",
-    "          },\n",
-    "          {\n",
-    "            \"opcode\": \"sensing_istouching\",\n",
-    "            \"count\": 1\n",
-    "          },\n",
-    "          {\n",
-    "            \"opcode\": \"event_broadcast\",\n",
-    "            \"count\": 1\n",
-    "          },\n",
-    "          {\n",
-    "            \"opcode\": \"control_stop\",\n",
-    "            \"count\": 1\n",
-    "          },\n",
-    "          {\n",
-    "            \"opcode\": \"data_setvariableto\",\n",
-    "            \"count\": 1\n",
-    "          }\n",
-    "        ]\n",
-    "      }\n",
-    "    ]\n",
-    "  }\n",
-    "}"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 2,
-   "id": "6a14fb61",
-   "metadata": {},
-   "outputs": [
-    {
-     "name": "stdout",
-     "output_type": "stream",
-     "text": [
-      "None\n",
-      "None\n",
-      "None\n"
-     ]
-    }
-   ],
-   "source": [
-    "def split_arithmetic(text: str):\n",
-    "    \"\"\"\n",
-    "    Splits `text` of the form \"(…) + (…)\" or \"a - b\" into (lhs_str, operator, rhs_str),\n",
-    "    ignoring any + - * / inside parentheses.\n",
-    "    Returns (None, None, None) if no top-level operator is found.\n",
-    "    \"\"\"\n",
-    "    depth = 0\n",
-    "    for idx, ch in enumerate(text):\n",
-    "        if ch == '(':\n",
-    "            depth += 1\n",
-    "        elif ch == ')':\n",
-    "            depth -= 1\n",
-    "        # If we find an operator at depth zero, that's our split point\n",
-    "        elif ch in '+-*/' and depth == 0:\n",
-    "            lhs = text[:idx].strip()\n",
-    "            op  = ch\n",
-    "            rhs = text[idx+1:].strip()\n",
-    "            return lhs, op, rhs\n",
-    "    return None, None, None\n",
-    "\n",
-    "text = \"number 1) - (number 2\"\n",
-    "lhs_str, operator_symbol, rhs_str = split_arithmetic(text)\n",
-    "print(lhs_str)\n",
-    "print(operator_symbol)\n",
-    "print(rhs_str)"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 37,
-   "id": "07ffb848",
-   "metadata": {},
-   "outputs": [
-    {
-     "name": "stdout",
-     "output_type": "stream",
-     "text": [
-      "{'lwrap': '(', 'left': '(x position', 'lwrap_close': ')', 'op': '*', 'rwrap': '(', 'right': 'x position) ) + ( (y position) * (y position) )', 'rwrap_close': ')'}\n",
-      "<re.Match object; span=(0, 67), match='( (x position) * (x position) ) + ( (y position) >\n"
-     ]
-    }
-   ],
-   "source": [
-    "import re\n",
-    "\n",
-    "text= \"( (x position) * (x position) ) + ( (y position) * (y position) ) )\"\n",
-    "\n",
-    "# Precompile once at module scope\n",
-    "_arith = re.compile(r\"\"\"^\\s*(?P<lwrap>[\\(\\[]*)\\s*(?P<left>.+?)\\s*(?P<lwrap_close>[\\)\\]]*)\\s*(?P<op>[+\\-*/])\\s*(?P<rwrap>[\\(\\[]*)\\s*(?P<right>.+?)\\s*(?P<rwrap_close>[\\)\\]]*)\\s*$\"\"\", re.VERBOSE)\n",
-    "\n",
-    "m = _arith.match(text)\n",
-    "print(m.groupdict())\n",
-    "print(m)\n",
-    "if m:\n",
-    "    def peel(s): return s.strip(\"()  \\t\\n\")\n",
-    "    left_str  = peel(m.group(\"left\") + m.group(\"lwrap_close\"))\n",
-    "    right_str = peel(m.group(\"rwrap\")+ m.group(\"right\"))\n",
-    "    operator  = m.group(\"op\")\n",
-    "\n"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 38,
-   "id": "64eeff39",
-   "metadata": {},
-   "outputs": [
-    {
-     "name": "stdout",
-     "output_type": "stream",
-     "text": [
-      "x position --- * --- x position) ) + ( (y position) * (y position\n"
-     ]
-    }
-   ],
-   "source": [
-    "print(f\"{left_str} --- {operator} --- {right_str}\")\n"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 39,
-   "id": "1b73791a",
-   "metadata": {},
-   "outputs": [
-    {
-     "name": "stdout",
-     "output_type": "stream",
-     "text": [
-      "No match\n"
-     ]
-    }
-   ],
-   "source": [
-    "import re\n",
-    "\n",
-    "text = \"( (x position) * (x position) ) + ( (y position) * (y position) ) )\"\n",
-    "\n",
-    "_arith = re.compile(r\"\"\"\n",
-    "    ^\\s*\n",
-    "    (?P<left>\n",
-    "        (?:                    # left is one or more of:\n",
-    "            [^()+\\-\\*/]+       #  • runs of chars that are not parentheses or ops\n",
-    "          | \\([^()]*\\)         #  • or a single balanced (...) with no inner ()\n",
-    "        )+\n",
-    "    )\n",
-    "    \\s*\n",
-    "    (?P<op>[+\\-*/])            # the first top‐level operator\n",
-    "    \\s*\n",
-    "    (?P<right>\n",
-    "        (?:                    # right is the same pattern\n",
-    "            [^()+\\-\\*/]+\n",
-    "          | \\([^()]*\\)\n",
-    "        )+\n",
-    "    )\n",
-    "    \\s*$\n",
-    "\"\"\", re.VERBOSE)\n",
-    "\n",
-    "m = _arith.match(text)\n",
-    "if m:\n",
-    "    # strip only parentheses and whitespace—leave inner operators/brackets intact\n",
-    "    def peel_parens(s):\n",
-    "        return s.strip(\"() \\t\\n\")\n",
-    "\n",
-    "    left_str  = peel_parens(m.group(\"left\"))\n",
-    "    operator  = m.group(\"op\")\n",
-    "    right_str = peel_parens(m.group(\"right\"))\n",
-    "\n",
-    "    print(\"LEFT :\", left_str)\n",
-    "    print(\"OP   :\", operator)\n",
-    "    print(\"RIGHT:\", right_str)\n",
-    "else:\n",
-    "    print(\"No match\")\n"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": null,
-   "id": "76df947b",
-   "metadata": {},
-   "outputs": [],
-   "source": []
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 27,
-   "id": "376da28a",
-   "metadata": {},
-   "outputs": [
-    {
-     "name": "stdout",
-     "output_type": "stream",
-     "text": [
-      "None\n"
-     ]
-    }
-   ],
-   "source": [
-    "import re\n",
-    "\n",
-    "text = \"( ([total score v]) / ([number of students v]) )\"\n",
-    "\n",
-    "_arith = re.compile(r\"\"\"\n",
-    "    ^\\s*\n",
-    "    (?P<lwrap>[\\(\\[]*)                                 # any leading \"(\" or \"[\"\n",
-    "    \\s*\n",
-    "    (?P<left>(?:\\[[^\\]]*\\]|[^\\[\\]\\(\\)]+)+?)            # ← atomic \"[...]\" or non‑bracket runs\n",
-    "    \\s*\n",
-    "    (?P<lwrap_close>[\\)\\]]*)                           # any trailing \")\" or \"]\"\n",
-    "    \\s*\n",
-    "    (?P<op>[+\\-*/])                                    # the operator\n",
-    "    \\s*\n",
-    "    (?P<rwrap>[\\(\\[]*)                                 # any leading \"(\" or \"[\"\n",
-    "    \\s*\n",
-    "    (?P<right>(?:\\[[^\\]]*\\]|[^\\[\\]\\(\\)]+)+?)           # same for right side\n",
-    "    \\s*\n",
-    "    (?P<rwrap_close>[\\)\\]]*)                          # any trailing \")\" or \"]\"\n",
-    "    \\s*$\n",
-    "\"\"\", re.VERBOSE)\n",
-    "\n",
-    "m = _arith.match(text)\n",
-    "#print(m.groupdict())  \n",
-    "# → {\n",
-    "#    'lwrap': '(', \n",
-    "#    'left': '[total score v]', \n",
-    "#    'lwrap_close': '', \n",
-    "#    'op': '/', \n",
-    "#    'rwrap': '([', \n",
-    "#    'right': '[number of students v]', \n",
-    "#    'rwrap_close': ')'\n",
-    "# }\n",
-    "print(m)\n",
-    "if m:\n",
-    "    # only peel off parentheses/witespace—leave [ ] intact\n",
-    "    def peel_parens(s): \n",
-    "        return s.strip(\"() \\t\\n\")\n",
-    "\n",
-    "    left_str  = peel_parens(m.group(\"left\"))\n",
-    "    right_str = peel_parens(m.group(\"right\"))\n",
-    "    operator  = m.group(\"op\")\n",
-    "\n",
-    "    print(left_str)   # → [total score v]\n",
-    "    print(operator)   # → /\n",
-    "    print(right_str)  # → [number of students v]\n"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 41,
-   "id": "ae15b8fb",
-   "metadata": {},
-   "outputs": [
-    {
-     "name": "stdout",
-     "output_type": "stream",
-     "text": [
-      "\n",
-      "--- Test Case 1 ---\n",
-      "Input: ( (x position) * (x position) ) + ( (y position) * (y position) )\n",
-      "Parsed Structure (Abstract Syntax Tree):\n",
-      "LEFT :\n",
-      "  LEFT :\n",
-      "    x position\n",
-      "  OP   : *\n",
-      "  RIGHT:\n",
-      "    x position\n",
-      "OP   : +\n",
-      "RIGHT:\n",
-      "  LEFT :\n",
-      "    y position\n",
-      "  OP   : *\n",
-      "  RIGHT:\n",
-      "    y position\n",
-      "\n",
-      "--- Test Case 2 ---\n",
-      "Input: ( (number 1) + number 2 )\n",
-      "Parsed Structure (Abstract Syntax Tree):\n",
-      "LEFT :\n",
-      "  number 1\n",
-      "OP   : +\n",
-      "RIGHT:\n",
-      "  number 2\n",
-      "\n",
-      "--- Test Case 3 ---\n",
-      "Input: ( number 1 + (number 2) )\n",
-      "Parsed Structure (Abstract Syntax Tree):\n",
-      "LEFT :\n",
-      "  number 1\n",
-      "OP   : +\n",
-      "RIGHT:\n",
-      "  number 2\n",
-      "\n",
-      "--- Test Case 4 ---\n",
-      "Input: ( ([number 1 v]) + (number 2) )\n",
-      "Parsed Structure (Abstract Syntax Tree):\n",
-      "LEFT :\n",
-      "  [number 1 v]\n",
-      "OP   : +\n",
-      "RIGHT:\n",
-      "  number 2\n",
-      "\n",
-      "--- Test Case 5 ---\n",
-      "Input: ( number 1 + ([number 2 v]) )\n",
-      "Parsed Structure (Abstract Syntax Tree):\n",
-      "LEFT :\n",
-      "  number 1\n",
-      "OP   : +\n",
-      "RIGHT:\n",
-      "  [number 2 v]\n",
-      "\n",
-      "--- Test Case 6 ---\n",
-      "Input: ( ( (x position) + (x position) ) / ( (y position) * (y position) ) )\n",
-      "Parsed Structure (Abstract Syntax Tree):\n",
-      "LEFT :\n",
-      "  LEFT :\n",
-      "    x position\n",
-      "  OP   : +\n",
-      "  RIGHT:\n",
-      "    x position\n",
-      "OP   : /\n",
-      "RIGHT:\n",
-      "  LEFT :\n",
-      "    y position\n",
-      "  OP   : *\n",
-      "  RIGHT:\n",
-      "    y position\n",
-      "\n",
-      "--- Test Case 7 ---\n",
-      "Input: ( ( (x position) * (x position) ) + ( (y position) * (y position) ) ))\n",
-      "Error parsing: Unconsumed tokens at end of expression: [')']\n",
-      "\n",
-      "--- Test Case 8 ---\n",
-      "Input: x position * y position\n",
-      "Parsed Structure (Abstract Syntax Tree):\n",
-      "LEFT :\n",
-      "  x position\n",
-      "OP   : *\n",
-      "RIGHT:\n",
-      "  y position\n",
-      "\n",
-      "--- Test Case 9 ---\n",
-      "Input: 1 + 2 * 3\n",
-      "Parsed Structure (Abstract Syntax Tree):\n",
-      "LEFT :\n",
-      "  1\n",
-      "OP   : +\n",
-      "RIGHT:\n",
-      "  LEFT :\n",
-      "    2\n",
-      "  OP   : *\n",
-      "  RIGHT:\n",
-      "    3\n",
-      "\n",
-      "--- Test Case 10 ---\n",
-      "Input: ([complex phrase inside brackets]) + number 1\n",
-      "Parsed Structure (Abstract Syntax Tree):\n",
-      "LEFT :\n",
-      "  [complex phrase inside brackets]\n",
-      "OP   : +\n",
-      "RIGHT:\n",
-      "  number 1\n",
-      "\n",
-      "--- Test Case 11 ---\n",
-      "Input: ((a) + (b)) * c\n",
-      "Error parsing: Unexpected token when expecting an atom: 'a'\n"
-     ]
-    }
-   ],
-   "source": [
-    "import re\n",
-    "\n",
-    "def parse_expression(expression_text):\n",
-    "    # Step 1: Tokenization\n",
-    "    # This regex will split the string into tokens:\n",
-    "    # - Words or phrases that are not operators or parentheses/brackets\n",
-    "    # - Numbers (integers or decimals)\n",
-    "    # - Operators (+, -, *, /)\n",
-    "    # - Parentheses or brackets ( (, ), [, ])\n",
-    "    # It also handles whitespace by implicitly treating it as delimiters between tokens.\n",
-    "    \n",
-    "    # Updated regex for more robust tokenization, especially for multi-word \"variables\"\n",
-    "    # It ensures full words/phrases are captured, handles numbers, and single chars.\n",
-    "    # The '|' in the middle creates alternatives.\n",
-    "    # (?:...) creates a non-capturing group for the alternatives.\n",
-    "    # \\s* at the start and end of individual parts helps consume whitespace\n",
-    "    # while re.findall will return non-empty matches.\n",
-    "    \n",
-    "    tokens = re.findall(r'(\\[[^\\]]*\\]|\\b\\w+\\b(?:\\s+\\b\\w+\\b)*|\\d+\\.?\\d*|[+\\-*/()])', expression_text)\n",
-    "\n",
-    "    # Filter out any potential empty strings if the regex or input causes them,\n",
-    "    # though the current regex should be quite good at avoiding this.\n",
-    "    tokens = [token.strip() for token in tokens if token.strip()]\n",
-    "    \n",
-    "    # print(f\"Tokens: {tokens}\") # For debugging purposes\n",
-    "\n",
-    "    # Step 2: Recursive Parsing\n",
-    "    # We'll use a simple recursive descent parser.\n",
-    "    # It assumes operators have a fixed precedence (e.g., * / before + -)\n",
-    "\n",
-    "    def parse_atom(current_tokens):\n",
-    "        \"\"\"Parses the most basic unit: a number, a variable, or a parenthesized/bracketed expression.\"\"\"\n",
-    "        if not current_tokens:\n",
-    "            raise ValueError(\"Unexpected end of expression: Expected an atom\")\n",
-    "\n",
-    "        token = current_tokens.pop(0)\n",
-    "\n",
-    "        if token == '(':\n",
-    "            # If it's an opening parenthesis, parse the sub-expression\n",
-    "            result = parse_expression_recursive(current_tokens)\n",
-    "            if not current_tokens or current_tokens.pop(0) != ')':\n",
-    "                raise ValueError(\"Mismatched parentheses: Expected ')'\")\n",
-    "            return result\n",
-    "        elif token.startswith('['): # Check for start of a bracketed term\n",
-    "            # For simplicity, if it's a bracketed term, treat it as an atomic unit.\n",
-    "            # No internal parsing is done here based on your requirement \"should be keep as it is\".\n",
-    "            return token # Return the full bracketed string as a token\n",
-    "        elif re.fullmatch(r'\\b\\w[\\w\\s]*\\w\\b|\\d+\\.?\\d*', token): # Matches words/phrases or numbers\n",
-    "            return token\n",
-    "        else:\n",
-    "            raise ValueError(f\"Unexpected token when expecting an atom: '{token}'\")\n",
-    "\n",
-    "    def parse_term(current_tokens):\n",
-    "        \"\"\"Parses multiplication and division.\"\"\"\n",
-    "        left = parse_atom(current_tokens)\n",
-    "        while current_tokens and current_tokens[0] in ('*', '/'):\n",
-    "            op = current_tokens.pop(0)\n",
-    "            right = parse_atom(current_tokens)\n",
-    "            left = {'left': left, 'op': op, 'right': right} # Represent as a dictionary for structure\n",
-    "        return left\n",
-    "\n",
-    "    def parse_expression_recursive(current_tokens):\n",
-    "        \"\"\"Parses addition and subtraction (lower precedence).\"\"\"\n",
-    "        left = parse_term(current_tokens)\n",
-    "        while current_tokens and current_tokens[0] in ('+', '-'):\n",
-    "            op = current_tokens.pop(0)\n",
-    "            right = parse_term(current_tokens)\n",
-    "            left = {'left': left, 'op': op, 'right': right}\n",
-    "        return left\n",
-    "\n",
-    "    # Start the parsing process by passing the initial list of tokens\n",
-    "    # to the main recursive parsing function.\n",
-    "    parsed_structure = parse_expression_recursive(tokens)\n",
-    "    \n",
-    "    # We need to ensure all tokens are consumed at the end for a valid expression\n",
-    "    if tokens: # If there are still tokens left in the list\n",
-    "        raise ValueError(f\"Unconsumed tokens at end of expression: {tokens}\")\n",
-    "\n",
-    "    return parsed_structure\n",
-    "\n",
-    "def print_parsed_structure_recursive(structure, indent=0):\n",
-    "    \"\"\"Helper function to pretty-print the parsed structure recursively.\"\"\"\n",
-    "    prefix = \"  \" * indent\n",
-    "    if isinstance(structure, dict):\n",
-    "        print(f\"{prefix}LEFT :\")\n",
-    "        print_parsed_structure_recursive(structure['left'], indent + 1)\n",
-    "        print(f\"{prefix}OP   : {structure['op']}\")\n",
-    "        print(f\"{prefix}RIGHT:\")\n",
-    "        print_parsed_structure_recursive(structure['right'], indent + 1)\n",
-    "    else:\n",
-    "        # This is an atomic element (string)\n",
-    "        print(f\"{prefix}{structure}\")\n",
-    "\n",
-    "# --- Test Cases ---\n",
-    "test_cases = [\n",
-    "    \"( (x position) * (x position) ) + ( (y position) * (y position) )\",\n",
-    "    \"( (number 1) + number 2 )\",\n",
-    "    \"( number 1 + (number 2) )\",\n",
-    "    \"( ([number 1 v]) + (number 2) )\",\n",
-    "    \"( number 1 + ([number 2 v]) )\",\n",
-    "    \"( ( (x position) + (x position) ) / ( (y position) * (y position) ) )\", # Original problematic case\n",
-    "    \"( ( (x position) * (x position) ) + ( (y position) * (y position) ) ))\", # Malformed case with extra ')'\n",
-    "    \"x position * y position\", # Simple case\n",
-    "    \"1 + 2 * 3\", # Precedence test\n",
-    "    \"([complex phrase inside brackets]) + number 1\",\n",
-    "    \"((a) + (b)) * c\"\n",
-    "]\n",
-    "\n",
-    "for i, text in enumerate(test_cases):\n",
-    "    print(f\"\\n--- Test Case {i+1} ---\")\n",
-    "    print(f\"Input: {text}\")\n",
-    "    try:\n",
-    "        parsed_result = parse_expression(text)\n",
-    "        print(\"Parsed Structure (Abstract Syntax Tree):\")\n",
-    "        \n",
-    "        # Use the recursive print helper for better visualization\n",
-    "        print_parsed_structure_recursive(parsed_result)\n",
-    "            \n",
-    "    except ValueError as e:\n",
-    "        print(f\"Error parsing: {e}\")"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": null,
-   "id": "389197dd",
-   "metadata": {},
-   "outputs": [
-    {
-     "name": "stdout",
-     "output_type": "stream",
-     "text": [
-      "\n",
-      "--- Test Case 1 ---\n",
-      "Input: ( (x position) * (x position) ) + ( (y position) * (y position) )\n",
-      "Error parsing: Unconsumed tokens at end of expression: [')', '+', '(', '(', 'y position', ')', '*', '(', 'y position', ')']\n",
-      "\n",
-      "--- Test Case 2 ---\n",
-      "Input: ( (number 1) + number 2 )\n",
-      "Error parsing: Mismatched parentheses: Expected ')'\n",
-      "\n",
-      "--- Test Case 3 ---\n",
-      "Input: ( number 1 + (number 2) )\n",
-      "Error parsing: Unconsumed tokens at end of expression: ['1', '+', '(', 'number', '2', ')']\n",
-      "\n",
-      "--- Test Case 4 ---\n",
-      "Input: ( ([number 1 v]) + (number 2) )\n",
-      "Error parsing: Mismatched parentheses: Expected ')'\n",
-      "\n",
-      "--- Test Case 5 ---\n",
-      "Input: ( number 1 + ([number 2 v]) )\n",
-      "Error parsing: Unconsumed tokens at end of expression: ['1', '+', '(', '[number 2 v]', ')']\n",
-      "\n",
-      "--- Test Case 6 ---\n",
-      "Input: ( ( (x position) * (x position) ) + ( (y position) * (y position) ) )\n",
-      "Parsed Structure (Abstract Syntax Tree):\n",
-      "LEFT :\n",
-      "  LEFT :\n",
-      "    x position\n",
-      "  OP   : *\n",
-      "  RIGHT:\n",
-      "    x position\n",
-      "OP   : +\n",
-      "RIGHT:\n",
-      "  LEFT :\n",
-      "    y position\n",
-      "  OP   : *\n",
-      "  RIGHT:\n",
-      "    y position\n",
-      "\n",
-      "--- Test Case 7 ---\n",
-      "Input: ( ( (x position) * (x position) ) + ( (y position) * (y position) ) ))\n",
-      "Error parsing: Unconsumed tokens at end of expression: [')']\n",
-      "\n",
-      "--- Test Case 8 ---\n",
-      "Input: x position * y position\n",
-      "Parsed Structure (Abstract Syntax Tree):\n",
-      "LEFT :\n",
-      "  x position\n",
-      "OP   : *\n",
-      "RIGHT:\n",
-      "  y position\n",
-      "\n",
-      "--- Test Case 9 ---\n",
-      "Input: 1 + 2 * 3\n",
-      "Parsed Structure (Abstract Syntax Tree):\n",
-      "LEFT :\n",
-      "  1\n",
-      "OP   : +\n",
-      "RIGHT:\n",
-      "  LEFT :\n",
-      "    2\n",
-      "  OP   : *\n",
-      "  RIGHT:\n",
-      "    3\n",
-      "\n",
-      "--- Test Case 10 ---\n",
-      "Input: ([complex phrase inside brackets]) + number 1\n",
-      "Error parsing: Unconsumed tokens at end of expression: ['1']\n",
-      "\n",
-      "--- Test Case 11 ---\n",
-      "Input: ((a) + (b)) * c\n",
-      "Parsed Structure (Abstract Syntax Tree):\n",
-      "LEFT :\n",
-      "  LEFT :\n",
-      "    a\n",
-      "  OP   : +\n",
-      "  RIGHT:\n",
-      "    b\n",
-      "OP   : *\n",
-      "RIGHT:\n",
-      "  c\n"
-     ]
-    }
-   ],
-   "source": [
-    "def parse_expression(expression_text):\n",
-    "    # Step 1: Tokenization\n",
-    "    # This regex will split the string into tokens:\n",
-    "    # - Words or phrases that are not operators or parentheses/brackets\n",
-    "    # - Numbers (integers or decimals)\n",
-    "    # - Operators (+, -, *, /)\n",
-    "    # - Parentheses or brackets ( (, ), [, ])\n",
-    "    # It also handles whitespace by implicitly treating it as delimiters between tokens.\n",
-    "\n",
-    "    # Updated regex for more robust tokenization, especially for multi-word \"variables\"\n",
-    "    # It ensures full words/phrases are captured, handles numbers, and single chars.\n",
-    "    # The '|' in the middle creates alternatives.\n",
-    "    # (?:...) creates a non-capturing group for the alternatives.\n",
-    "    # \\s* at the start and end of individual parts helps consume whitespace\n",
-    "    # while re.findall will return non-empty matches.\n",
-    "\n",
-    "    tokens = re.findall(r'(\\[[^\\]]*\\]|\\b\\w+\\b(?:\\s+\\b\\w+\\b)*|\\d+\\.?\\d*|[+\\-*/()])', expression_text)\n",
-    "\n",
-    "    # Filter out any potential empty strings if the regex or input causes them,\n",
-    "    # though the current regex should be quite good at avoiding this.\n",
-    "    tokens = [token.strip() for token in tokens if token.strip()]\n",
-    "\n",
-    "    # print(f\"Tokens: {tokens}\") # For debugging purposes\n",
-    "\n",
-    "    # Step 2: Recursive Parsing\n",
-    "    # We'll use a simple recursive descent parser.\n",
-    "    # It assumes operators have a fixed precedence (e.g., * / before + -)\n",
-    "\n",
-    "    def parse_atom(current_tokens):\n",
-    "        \"\"\"Parses the most basic unit: a number, a variable, or a parenthesized/bracketed expression.\"\"\"\n",
-    "        if not current_tokens:\n",
-    "            raise ValueError(\"Unexpected end of expression: Expected an atom\")\n",
-    "\n",
-    "        token = current_tokens.pop(0)\n",
-    "\n",
-    "        if token == '(':\n",
-    "            # If it's an opening parenthesis, parse the sub-expression\n",
-    "            result = parse_expression_recursive(current_tokens)\n",
-    "            if not current_tokens or current_tokens.pop(0) != ')':\n",
-    "                raise ValueError(\"Mismatched parentheses: Expected ')'\")\n",
-    "            return result\n",
-    "        elif token.startswith('['): # Check for start of a bracketed term\n",
-    "            # For simplicity, if it's a bracketed term, treat it as an atomic unit.\n",
-    "            # No internal parsing is done here based on your requirement \"should be keep as it is\".\n",
-    "            return token # Return the full bracketed string as a token\n",
-    "        elif re.fullmatch(r'\\b\\w[\\w\\s]*\\w\\b|\\d+\\.?\\d*', token): # Matches words/phrases or numbers\n",
-    "            return token\n",
-    "        else:\n",
-    "            raise ValueError(f\"Unexpected token when expecting an atom: '{token}'\")\n",
-    "\n",
-    "    def parse_term(current_tokens):\n",
-    "        \"\"\"Parses multiplication and division.\"\"\"\n",
-    "        left = parse_atom(current_tokens)\n",
-    "        while current_tokens and current_tokens[0] in ('*', '/'):\n",
-    "            op = current_tokens.pop(0)\n",
-    "            right = parse_atom(current_tokens)\n",
-    "            left = {'left': left, 'op': op, 'right': right} # Represent as a dictionary for structure\n",
-    "        return left\n",
-    "\n",
-    "    def parse_expression_recursive(current_tokens):\n",
-    "        \"\"\"Parses addition and subtraction (lower precedence).\"\"\"\n",
-    "        left = parse_term(current_tokens)\n",
-    "        while current_tokens and current_tokens[0] in ('+', '-'):\n",
-    "            op = current_tokens.pop(0)\n",
-    "            right = parse_term(current_tokens)\n",
-    "            left = {'left': left, 'op': op, 'right': right}\n",
-    "        return left"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": null,
-   "id": "abca0291",
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "try:\n",
-    "    # Check if the text itself, after balancing, looks like an expression\n",
-    "    # This requires a heuristic. For now, we'll try to parse it if it contains operators or parentheses.\n",
-    "    if any(op in text for op in ['+', '-', '*', '/']) or '(' in text or '[' in text:\n",
-    "        parsed_ast = parse_expression(original_text) # Use original_text for full expression parsing\n",
-    "        return convert_ast_to_blocks(parsed_ast, parent_key)\n",
-    "except ValueError as e:\n",
-    "    # If it's not a valid expression, let other parsing logic handle it.\n",
-    "    # print(f\"Not a complex expression or malformed: {e}\") # For debugging\n",
-    "    pass # Continue to other parsing rules"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 45,
-   "id": "7291817c",
-   "metadata": {},
-   "outputs": [
-    {
-     "name": "stdout",
-     "output_type": "stream",
-     "text": [
-      "You are an expert in Scratch 3.0 game development, specializing in understanding block relationships (stacked, nested).\n",
-      "\"Analyze the Scratch code-block image and generate Pseudo-Code for what this logic appears to be doing.\"\n",
-      "From Image, you also have to detect a value of Key given in Text form \"Script for: \". Below is the example\n",
-      "Example: \"Script for: Bear\", \"Script for:\" is a key and \"Bear\" is value and check if there is related target name available.\n",
-      "\n",
-      "**Targets in Game (Sprites and Stage) available in project_json:** {', '.join(target_names)}\n",
-      "\n",
-      "--- Scratch 3.0 Block Reference ---\n",
-      "\n",
-      "### Hat Blocks\n",
-      "Description: {hat_description}\n",
-      "Blocks:\n",
-      "{hat_opcodes_functionalities}\n",
-      "\n",
-      "### Boolean Blocks\n",
-      "Description: {boolean_description}\n",
-      "Blocks:\n",
-      "{boolean_opcodes_functionalities}\n",
-      "\n",
-      "### C Blocks\n",
-      "Description: {c_description}\n",
-      "Blocks:\n",
-      "{c_opcodes_functionalities}\n",
-      "\n",
-      "### Cap Blocks\n",
-      "Description: {cap_description}\n",
-      "Blocks:\n",
-      "{cap_opcodes_functionalities}\n",
-      "\n",
-      "### Reporter Blocks\n",
-      "Description: {reporter_description}\n",
-      "Blocks:\n",
-      "{reporter_opcodes_functionalities}\n",
-      "\n",
-      "### Stack Blocks\n",
-      "Description: {stack_description}\n",
-      "Blocks:\n",
-      "{stack_opcodes_functionalities}\n",
-      "-----------------------------------\n",
-      "\n",
-      "Your task is to:\n",
-      "If you don't find any \"Code-Blocks\" then,\n",
-      "    **Don't generate Pseudo Code, and pass the message \"No Code-blocks\"\n",
-      "If you find any \"Code-Blocks\" then,\n",
-      "1. **Refine the 'logic'**: Make it precise, accurate, and fully aligned with the Game Description. Use Scratch‑consistent verbs and phrasing. **Do NOT** use raw double‑quotes inside the logic string.\n",
-      "\n",
-      "2. **Structural requirements**:\n",
-      "    - **Numeric values** `(e.g., 0, 5, 0.2, -130)` **must** be in parentheses: `(0)`, `(5)`, `(0.2)`, `(-130)`.\n",
-      "    - **AlphaNumeric values** `(e.g., hello, say 5, 4, hi!)` **must** be in parentheses: `(hello)`, `(say 5)`, `(4)`, `(hi!)`.\n",
-      "    - **Variables** must be in the form `[variable v]` (e.g., `[score v]`), even when used inside expressions two example use `set [score v] to (1)` or `show variable ([speed v])`.\n",
-      "    - **Dropdown options** must be in the form `[option v]` (e.g., `[Game Start v]`, `[blue sky v]`). example use `when [space v] key pressed`.\n",
-      "    - **Reporter blocks** used as inputs must be double‑wrapped: `((x position))`, `((y position))`. example use `if <((y position)) = (-130)> then` or `(((x position)) * (1))`.\n",
-      "    - **Boolean blocks** in conditions must be inside `< >`, including nested ones: `<not <condition>>`, `<<cond1> and <cond2>>`,`<<cond1> or <cond2>>`.\n",
-      "    - **Other Boolean blocks** in conditions must be inside `< >`, including nested ones or values or variables: `<(block/value/variable) * (block/value/variable)>`,`<(block/value/variable) < (block/value/variable)>`, and example of another variable`<[apple v] contains [a v]?>`.\n",
-      "    - **Operator expressions** must use explicit Scratch operator blocks, e.g.:\n",
-      "      ```\n",
-      "      (([ballSpeed v]) * (1.1))\n",
-      "      ```\n",
-      "    - **Every hat block script must end** with a final `end` on its own line.\n",
-      "    \n",
-      "3. **Pseudo‑code formatting**:\n",
-      "    - Represent each block or nested block on its own line.\n",
-      "    - Indent nested blocks by 4 spaces under their parent (`forever`, `if`, etc.).\n",
-      "    - No comments or explanatory text—just the block sequence.\n",
-      "    - a natural language breakdown of each step taken after the event, formatted as a multi-line string representing pseudo-code. Ensure clarity and granularity—each described action should map closely to a Scratch block or tight sequence.\n",
-      "\n",
-      "4. **Logic content**:\n",
-      "    - Build clear flow for mechanics (movement, jumping, flying, scoring, collisions).\n",
-      "    - Match each action closely to a Scratch block or tight sequence.\n",
-      "    - Do **NOT** include any justification or comments—only the raw logic.\n",
-      "\n",
-      "5. **Examples for reference**: \n",
-      "**Correct** pattern for a simple start script:\n",
-      "    ```\n",
-      "    when green flag clicked\n",
-      "    switch backdrop to [blue sky v]\n",
-      "    set [score v] to (0)\n",
-      "    show variable [score v]\n",
-      "    broadcast [Game Start v]\n",
-      "    end\n",
-      "    ```\n",
-      "**Correct** pattern for updating the high score variable handling:\n",
-      "    ```\n",
-      "    when I receive [Game Over v]\n",
-      "    if <((score)) > (([High Score v]))> then\n",
-      "    set [High Score v] to ([score v])\n",
-      "    end\n",
-      "    switch backdrop to [Game Over v]\n",
-      "    end\n",
-      "    ```\n",
-      "**Correct** pattern for level up and increase difficulty use:\n",
-      "    ```\n",
-      "    when I receive [Level Up v]\n",
-      "    change [level v] by (1)\n",
-      "    set [ballSpeed v] to ((([ballSpeed v]) * (1.1)))\n",
-      "    end\n",
-      "    ```\n",
-      "**Correct** pattern for jumping mechanics use:\n",
-      "    ```\n",
-      "    when [space v] key pressed\n",
-      "    if <((y position)) = (-100)> then\n",
-      "    repeat (5)\n",
-      "    change y by (100)\n",
-      "    wait (0.1) seconds\n",
-      "    change y by (-100)\n",
-      "    wait (0.1) seconds\n",
-      "    end\n",
-      "    end\n",
-      "    end\n",
-      "    ```\n",
-      "**Correct** pattern for continuos moving objects use:\n",
-      "    ```\n",
-      "    when green flag clicked\n",
-      "    go to x: (240) y: (-100)\n",
-      "    set [speed v] to (-5)\n",
-      "    show variable [speed v]\n",
-      "    forever\n",
-      "    change x by ([speed v])\n",
-      "    if <((x position)) < (-240)> then\n",
-      "    go to x: (240) y: (-100)\n",
-      "    end\n",
-      "    end\n",
-      "    end\n",
-      "    ```\n",
-      "**Correct** pattern for continuos moving objects use:\n",
-      "    ```\n",
-      "    when green flag clicked\n",
-      "    go to x: (240) y: (-100)\n",
-      "    set [speed v] to (-5)\n",
-      "    show variable [speed v]\n",
-      "    forever\n",
-      "    change x by ([speed v])\n",
-      "    if <((x position)) < (-240)> then\n",
-      "    go to x: (240) y: (-100)\n",
-      "    end\n",
-      "    end\n",
-      "    end\n",
-      "    ```\n",
-      "6. **Do not** add any explanation of logic or comments to justify or explain just put the logic content in the JSON.\n",
-      "7. **Output**: \n",
-      "Return **only** a JSON object, using double quotes everywhere, where the key for the pseudo-code will be the target name closest to the \"Script for:\" value. If no code-blocks are found, return `{\"refined_logic\": \"No Code-blocks\"}`.\n",
-      "\n",
-      "```json\n",
-      "{\n",
-      "\"refined_logic\":{\n",
-      "    \"[Target name similar to script for]\": {\n",
-      "    \"plan\":[\n",
-      "        {\"pseudocode\":\"…your fully‑formatted pseudo‑code here…\"},\n",
-      "        {\"pseudocode\":\"…your fully‑formatted pseudo‑code here…\"}\n",
-      "    ]\n",
-      "        }\n",
-      "}\n",
-      "}\n",
-      "```\n"
-     ]
-    }
-   ],
-   "source": [
-    "\n",
-    "test=\"You are an expert in Scratch 3.0 game development, specializing in understanding block relationships (stacked, nested).\\n\\\"Analyze the Scratch code-block image and generate Pseudo-Code for what this logic appears to be doing.\\\"\\nFrom Image, you also have to detect a value of Key given in Text form \\\"Script for: \\\". Below is the example\\nExample: \\\"Script for: Bear\\\", \\\"Script for:\\\" is a key and \\\"Bear\\\" is value and check if there is related target name available.\\n\\n**Targets in Game (Sprites and Stage) available in project_json:** {', '.join(target_names)}\\n\\n--- Scratch 3.0 Block Reference ---\\n\\n### Hat Blocks\\nDescription: {hat_description}\\nBlocks:\\n{hat_opcodes_functionalities}\\n\\n### Boolean Blocks\\nDescription: {boolean_description}\\nBlocks:\\n{boolean_opcodes_functionalities}\\n\\n### C Blocks\\nDescription: {c_description}\\nBlocks:\\n{c_opcodes_functionalities}\\n\\n### Cap Blocks\\nDescription: {cap_description}\\nBlocks:\\n{cap_opcodes_functionalities}\\n\\n### Reporter Blocks\\nDescription: {reporter_description}\\nBlocks:\\n{reporter_opcodes_functionalities}\\n\\n### Stack Blocks\\nDescription: {stack_description}\\nBlocks:\\n{stack_opcodes_functionalities}\\n-----------------------------------\\n\\nYour task is to:\\nIf you don't find any \\\"Code-Blocks\\\" then,\\n    **Don't generate Pseudo Code, and pass the message \\\"No Code-blocks\\\"\\nIf you find any \\\"Code-Blocks\\\" then,\\n1. **Refine the 'logic'**: Make it precise, accurate, and fully aligned with the Game Description. Use Scratch‑consistent verbs and phrasing. **Do NOT** use raw double‑quotes inside the logic string.\\n\\n2. **Structural requirements**:\\n    - **Numeric values** `(e.g., 0, 5, 0.2, -130)` **must** be in parentheses: `(0)`, `(5)`, `(0.2)`, `(-130)`.\\n    - **AlphaNumeric values** `(e.g., hello, say 5, 4, hi!)` **must** be in parentheses: `(hello)`, `(say 5)`, `(4)`, `(hi!)`.\\n    - **Variables** must be in the form `[variable v]` (e.g., `[score v]`), even when used inside expressions two example use `set [score v] to (1)` or `show variable ([speed v])`.\\n    - **Dropdown options** must be in the form `[option v]` (e.g., `[Game Start v]`, `[blue sky v]`). example use `when [space v] key pressed`.\\n    - **Reporter blocks** used as inputs must be double‑wrapped: `((x position))`, `((y position))`. example use `if <((y position)) = (-130)> then` or `(((x position)) * (1))`.\\n    - **Boolean blocks** in conditions must be inside `< >`, including nested ones: `<not <condition>>`, `<<cond1> and <cond2>>`,`<<cond1> or <cond2>>`.\\n    - **Other Boolean blocks** in conditions must be inside `< >`, including nested ones or values or variables: `<(block/value/variable) * (block/value/variable)>`,`<(block/value/variable) < (block/value/variable)>`, and example of another variable`<[apple v] contains [a v]?>`.\\n    - **Operator expressions** must use explicit Scratch operator blocks, e.g.:\\n      ```\\n      (([ballSpeed v]) * (1.1))\\n      ```\\n    - **Every hat block script must end** with a final `end` on its own line.\\n    \\n3. **Pseudo‑code formatting**:\\n    - Represent each block or nested block on its own line.\\n    - Indent nested blocks by 4 spaces under their parent (`forever`, `if`, etc.).\\n    - No comments or explanatory text—just the block sequence.\\n    - a natural language breakdown of each step taken after the event, formatted as a multi-line string representing pseudo-code. Ensure clarity and granularity—each described action should map closely to a Scratch block or tight sequence.\\n\\n4. **Logic content**:\\n    - Build clear flow for mechanics (movement, jumping, flying, scoring, collisions).\\n    - Match each action closely to a Scratch block or tight sequence.\\n    - Do **NOT** include any justification or comments—only the raw logic.\\n\\n5. **Examples for reference**: \\n**Correct** pattern for a simple start script:\\n    ```\\n    when green flag clicked\\n    switch backdrop to [blue sky v]\\n    set [score v] to (0)\\n    show variable [score v]\\n    broadcast [Game Start v]\\n    end\\n    ```\\n**Correct** pattern for updating the high score variable handling:\\n    ```\\n    when I receive [Game Over v]\\n    if <((score)) > (([High Score v]))> then\\n    set [High Score v] to ([score v])\\n    end\\n    switch backdrop to [Game Over v]\\n    end\\n    ```\\n**Correct** pattern for level up and increase difficulty use:\\n    ```\\n    when I receive [Level Up v]\\n    change [level v] by (1)\\n    set [ballSpeed v] to ((([ballSpeed v]) * (1.1)))\\n    end\\n    ```\\n**Correct** pattern for jumping mechanics use:\\n    ```\\n    when [space v] key pressed\\n    if <((y position)) = (-100)> then\\n    repeat (5)\\n    change y by (100)\\n    wait (0.1) seconds\\n    change y by (-100)\\n    wait (0.1) seconds\\n    end\\n    end\\n    end\\n    ```\\n**Correct** pattern for continuos moving objects use:\\n    ```\\n    when green flag clicked\\n    go to x: (240) y: (-100)\\n    set [speed v] to (-5)\\n    show variable [speed v]\\n    forever\\n    change x by ([speed v])\\n    if <((x position)) < (-240)> then\\n    go to x: (240) y: (-100)\\n    end\\n    end\\n    end\\n    ```\\n**Correct** pattern for continuos moving objects use:\\n    ```\\n    when green flag clicked\\n    go to x: (240) y: (-100)\\n    set [speed v] to (-5)\\n    show variable [speed v]\\n    forever\\n    change x by ([speed v])\\n    if <((x position)) < (-240)> then\\n    go to x: (240) y: (-100)\\n    end\\n    end\\n    end\\n    ```\\n6. **Do not** add any explanation of logic or comments to justify or explain just put the logic content in the JSON.\\n7. **Output**: \\nReturn **only** a JSON object, using double quotes everywhere, where the key for the pseudo-code will be the target name closest to the \\\"Script for:\\\" value. If no code-blocks are found, return `{\\\"refined_logic\\\": \\\"No Code-blocks\\\"}`.\\n\\n```json\\n{\\n\\\"refined_logic\\\":{\\n    \\\"[Target name similar to script for]\\\": {\\n    \\\"plan\\\":[\\n        {\\\"pseudocode\\\":\\\"…your fully‑formatted pseudo‑code here…\\\"},\\n        {\\\"pseudocode\\\":\\\"…your fully‑formatted pseudo‑code here…\\\"}\\n    ]\\n        }\\n}\\n}\\n```\"\n",
-    "print(test)"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 47,
-   "id": "e3fac594",
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "from pathlib import Path\n",
-    "BASE_DIR = Path.cwd() \n",
-    "#BASE_DIR = Path(__file__).parent\n",
-    "BLOCKS_DIR      = BASE_DIR / \"blocks\"\n",
-    "STATIC_DIR      = BASE_DIR / \"static\"\n",
-    "GEN_PROJECT_DIR = BASE_DIR / \"generated_projects\"\n",
-    "BACKDROP_DIR = BLOCKS_DIR / \"Backdrops\"\n",
-    "SPRITE_DIR = BLOCKS_DIR / \"sprites\"\n",
-    "OUTPUT_DIR = BASE_DIR / \"OUTPUTS\"\n",
-    "DETECTED_IMAGE_DIR = OUTPUT_DIR / \"DETECTED_IMAGE\"\n",
-    "IMAGE_DIR = OUTPUT_DIR / \"SCANNED_IMAGE\"\n",
-    "JSON_DIR = OUTPUT_DIR / \"EXTRACTED_JSON\"\n",
-    "\n",
-    "folder_image_paths = folder_image_paths = [\n",
-    "    #backdrops\n",
-    "    BACKDROP_DIR / \"badroom3.sb3\" / \"8cc0b88d53345b3e337e8f028a32a4e7.png\",\n",
-    "    BACKDROP_DIR / \"baseball2.sb3\" / \"7be1f5b3e682813dac1f297e52ff7dca.png\",\n",
-    "    BACKDROP_DIR / \"beach_malibu.sb3\" / \"050615fe992a00d6af0e664e497ebf53.png\",\n",
-    "    BACKDROP_DIR / \"castle2.sb3\" / \"951765ee7f7370f120c9df20b577c22f.png\",\n",
-    "    BACKDROP_DIR / \"hall.sb3\" / \"ea86ca30b346f27ca5faf1254f6a31e3.png\",\n",
-    "    BACKDROP_DIR / \"jungle.sb3\" / \"f4f908da19e2753f3ed679d7b37650ca.png\",\n",
-    "    #sprite\n",
-    "    SPRITE_DIR / \"Batter.sprite3\" / \"baseball_sprite_motion_1.png\",\n",
-    "    SPRITE_DIR / \"Bear.sprite3\" / \"bear_motion_2.png\",\n",
-    "    SPRITE_DIR / \"Beetle.sprite3\" / \"46d0dfd4ae7e9bfe3a6a2e35a4905eae.png\",\n",
-    "    SPRITE_DIR / \"cat\" / \"cat_motion_1.png\",\n",
-    "    SPRITE_DIR / \"Centaur.sprite3\" / \"2373556e776cad3ba4d6ee04fc34550b.png\",\n",
-    "    SPRITE_DIR / \"Crab.sprite3\" / \"bear_element.png\",\n",
-    "    SPRITE_DIR / \"Soccer Ball.sprite3\" / \"cat_football.png\",\n",
-    "    ]"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 48,
-   "id": "ee3c8d01",
-   "metadata": {},
-   "outputs": [
-    {
-     "data": {
-      "text/plain": [
-       "[WindowsPath('d:/DEV PATEL/2025/scratch_VLM/scratch_agent/utils/blocks/Backdrops/badroom3.sb3/8cc0b88d53345b3e337e8f028a32a4e7.png'),\n",
-       " WindowsPath('d:/DEV PATEL/2025/scratch_VLM/scratch_agent/utils/blocks/Backdrops/baseball2.sb3/7be1f5b3e682813dac1f297e52ff7dca.png'),\n",
-       " WindowsPath('d:/DEV PATEL/2025/scratch_VLM/scratch_agent/utils/blocks/Backdrops/beach_malibu.sb3/050615fe992a00d6af0e664e497ebf53.png'),\n",
-       " WindowsPath('d:/DEV PATEL/2025/scratch_VLM/scratch_agent/utils/blocks/Backdrops/castle2.sb3/951765ee7f7370f120c9df20b577c22f.png'),\n",
-       " WindowsPath('d:/DEV PATEL/2025/scratch_VLM/scratch_agent/utils/blocks/Backdrops/hall.sb3/ea86ca30b346f27ca5faf1254f6a31e3.png'),\n",
-       " WindowsPath('d:/DEV PATEL/2025/scratch_VLM/scratch_agent/utils/blocks/Backdrops/jungle.sb3/f4f908da19e2753f3ed679d7b37650ca.png'),\n",
-       " WindowsPath('d:/DEV PATEL/2025/scratch_VLM/scratch_agent/utils/blocks/sprites/Batter.sprite3/baseball_sprite_motion_1.png'),\n",
-       " WindowsPath('d:/DEV PATEL/2025/scratch_VLM/scratch_agent/utils/blocks/sprites/Bear.sprite3/bear_motion_2.png'),\n",
-       " WindowsPath('d:/DEV PATEL/2025/scratch_VLM/scratch_agent/utils/blocks/sprites/Beetle.sprite3/46d0dfd4ae7e9bfe3a6a2e35a4905eae.png'),\n",
-       " WindowsPath('d:/DEV PATEL/2025/scratch_VLM/scratch_agent/utils/blocks/sprites/cat/cat_motion_1.png'),\n",
-       " WindowsPath('d:/DEV PATEL/2025/scratch_VLM/scratch_agent/utils/blocks/sprites/Centaur.sprite3/2373556e776cad3ba4d6ee04fc34550b.png'),\n",
-       " WindowsPath('d:/DEV PATEL/2025/scratch_VLM/scratch_agent/utils/blocks/sprites/Crab.sprite3/bear_element.png'),\n",
-       " WindowsPath('d:/DEV PATEL/2025/scratch_VLM/scratch_agent/utils/blocks/sprites/Soccer Ball.sprite3/cat_football.png')]"
-      ]
-     },
-     "execution_count": 48,
-     "metadata": {},
-     "output_type": "execute_result"
-    }
-   ],
-   "source": [
-    "folder_image_paths"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": null,
-   "id": "9475e0ac",
-   "metadata": {},
-   "outputs": [],
-   "source": []
-  }
- ],
- "metadata": {
-  "kernelspec": {
-   "display_name": "scratch_env",
-   "language": "python",
-   "name": "python3"
-  },
-  "language_info": {
-   "codemirror_mode": {
-    "name": "ipython",
-    "version": 3
-   },
-   "file_extension": ".py",
-   "mimetype": "text/x-python",
-   "name": "python",
-   "nbconvert_exporter": "python",
-   "pygments_lexer": "ipython3",
-   "version": "3.12.11"
-  }
- },
- "nbformat": 4,
- "nbformat_minor": 5
-}