utils/script_plan.py

import json
import copy
import re

def generate_blocks_from_opcodes(opcode_counts, all_block_definitions):
    """
    Generates a dictionary of Scratch-like blocks based on a list of opcodes and a reference block definition.
    It now correctly links parent and menu blocks using their generated unique keys, and handles various block categories.
    It ensures that menu blocks are only generated as children of their respective parent blocks.

    Args:
        opcode_counts (list): An array of objects, each with an 'opcode' and 'count' property.
                              Example: [{"opcode": "motion_gotoxy", "count": 1}]
        all_block_definitions (dict): A comprehensive dictionary containing definitions for all block types.

    Returns:
        tuple: A tuple containing:
            - dict: A JSON object where keys are generated block IDs and values are the block definitions.
            - dict: The opcode_occurrences dictionary for consistent unique key generation across functions.
    """
    generated_blocks = {}
    opcode_occurrences = {}  # To keep track of how many times each opcode (main or menu) has been used for unique keys

    # Define explicit parent-menu relationships for linking purposes
    # This maps main_opcode -> list of (input_field_name, menu_opcode)
    explicit_menu_links = {
        "motion_goto": [("TO", "motion_goto_menu")],
        "motion_glideto": [("TO", "motion_glideto_menu")],
        "motion_pointtowards": [("TOWARDS", "motion_pointtowards_menu")],
        "sensing_keypressed": [("KEY_OPTION", "sensing_keyoptions")],
        "sensing_of": [("OBJECT", "sensing_of_object_menu")],
        "sensing_touchingobject": [("TOUCHINGOBJECTMENU", "sensing_touchingobjectmenu")],
        "control_create_clone_of": [("CLONE_OPTION", "control_create_clone_of_menu")],
        "sound_play": [("SOUND_MENU", "sound_sounds_menu")],
        "sound_playuntildone": [("SOUND_MENU", "sound_sounds_menu")],
        "looks_switchcostumeto": [("COSTUME", "looks_costume")],
        "looks_switchbackdropto": [("BACKDROP", "looks_backdrops")],
    }

    # --- Step 1: Process explicitly requested opcodes and generate their instances and associated menus ---
    for item in opcode_counts:
        opcode = item.get("opcode")
        count = item.get("count", 1)

        # Special handling for 'sensing_istouching' which maps to 'sensing_touchingobject'
        if opcode == "sensing_istouching":
            opcode = "sensing_touchingobject"

        if not opcode:
            print("Warning: Skipping item with missing 'opcode'.")
            continue

        if opcode not in all_block_definitions:
            print(f"Warning: Opcode '{opcode}' not found in all_block_definitions. Skipping.")
            continue

        for _ in range(count):
            # Increment occurrence count for the current main opcode
            opcode_occurrences[opcode] = opcode_occurrences.get(opcode, 0) + 1
            main_block_instance_num = opcode_occurrences[opcode]
            
            main_block_unique_key = f"{opcode}_{main_block_instance_num}"
            
            # Create a deep copy of the main block definition
            main_block_data = copy.deepcopy(all_block_definitions[opcode])
            
            # Set properties for a top-level main block
            main_block_data["parent"] = None
            main_block_data["next"] = None
            main_block_data["topLevel"] = True
            main_block_data["shadow"] = False # Main blocks are typically not shadows

            generated_blocks[main_block_unique_key] = main_block_data

            # If this main block has associated menus, generate and link them now
            if opcode in explicit_menu_links:
                for input_field_name, menu_opcode_type in explicit_menu_links[opcode]:
                    if menu_opcode_type in all_block_definitions:
                        # Increment the occurrence for the menu block type
                        opcode_occurrences[menu_opcode_type] = opcode_occurrences.get(menu_opcode_type, 0) + 1
                        menu_block_instance_num = opcode_occurrences[menu_opcode_type]

                        menu_block_data = copy.deepcopy(all_block_definitions[menu_opcode_type])
                        
                        # Generate a unique key for this specific menu instance
                        menu_unique_key = f"{menu_opcode_type}_{menu_block_instance_num}"
                        
                        # Set properties for a shadow menu block
                        menu_block_data["shadow"] = True
                        menu_block_data["topLevel"] = False
                        menu_block_data["next"] = None
                        menu_block_data["parent"] = main_block_unique_key # Link menu to its parent instance

                        # Update the main block's input to point to this unique menu instance
                        if input_field_name in main_block_data.get("inputs", {}) and \
                           isinstance(main_block_data["inputs"][input_field_name], list) and \
                           len(main_block_data["inputs"][input_field_name]) > 1 and \
                           main_block_data["inputs"][input_field_name][0] == 1:
                            
                            main_block_data["inputs"][input_field_name][1] = menu_unique_key
                        
                        generated_blocks[menu_unique_key] = menu_block_data
            
    return generated_blocks, opcode_occurrences

def interpret_pseudo_code_and_update_blocks(generated_blocks_json, pseudo_code, all_block_definitions, opcode_occurrences):
    """
    Interprets pseudo-code to update the generated Scratch blocks, replacing static values
    with dynamic values and establishing stacking/nesting logic.

    Args:
        generated_blocks_json (dict): The JSON object of pre-generated blocks.
        pseudo_code (str): The pseudo-code string to interpret.
        all_block_definitions (dict): A comprehensive dictionary containing definitions for all block types.
        opcode_occurrences (dict): A dictionary to keep track of opcode occurrences for unique key generation.

    Returns:
        dict: The updated JSON object of Scratch blocks.
    """
    updated_blocks = copy.deepcopy(generated_blocks_json)
    
    # Helper to create a new block instance (used for shadows/nested blocks)
    def create_block_instance_for_parsing(opcode, parent_key=None, is_shadow=False, is_top_level=False):
        opcode_occurrences[opcode] = opcode_occurrences.get(opcode, 0) + 1
        unique_key = f"{opcode}_{opcode_occurrences[opcode]}"
        
        new_block = copy.deepcopy(all_block_definitions.get(opcode, {}))
        if not new_block:
            print(f"Error: Definition for opcode '{opcode}' not found when creating instance for parsing.")
            return None, None

        new_block["parent"] = parent_key
        new_block["next"] = None
        new_block["topLevel"] = is_top_level
        new_block["shadow"] = is_shadow

        # Initialize inputs/fields to default empty values, but preserve structure
        if "inputs" in new_block:
            for input_name, input_data in new_block["inputs"].items():
                if isinstance(input_data, list) and len(input_data) > 1:
                    if input_data[0] == 1: # Block reference
                        new_block["inputs"][input_name][1] = None # Placeholder for linked block ID
                    elif input_data[0] in [4, 5, 6, 7, 8, 9, 10]: # Literal types
                        new_block["inputs"][input_name][1] = "" # Default empty literal
        if "fields" in new_block:
            for field_name, field_data in new_block["fields"].items():
                if isinstance(field_data, list) and len(field_data) > 0:
                    new_block["fields"][field_name][0] = "" # Default empty field value

        updated_blocks[unique_key] = new_block
        return unique_key, new_block

    # Helper to parse input values from pseudo-code and create nested blocks if necessary
    def parse_and_link_input(parent_block_key, input_type, pseudo_value, input_name_in_parent=None, field_name_in_parent=None):
        pseudo_value = pseudo_value.strip()

        # 1. Handle literal numbers (e.g., "2", "+1", "-135")
        if re.fullmatch(r"[-+]?\d+(\.\d+)?", pseudo_value):
            return [4, pseudo_value] # Type 4 for number literal

        # 2. Handle literal strings (e.g., "Game Over") - often in quotes or simply text
        # If it's a broadcast message, it's typically a string literal.
        # If it's a 'say' message, it's a string literal.
        # If it's a variable name, it's handled by specific patterns later.
        if pseudo_value.startswith('"') and pseudo_value.endswith('"'):
            return [10, pseudo_value.strip('"')] # Type 10 for string literal
        
        # 3. Handle variable names (e.g., "[score v]", "[Sprite1 v]", "[Game Over v]")
        # These can be fields or inputs that expect a variable reporter block.
        var_match = re.match(r"\[(.+?) v\]", pseudo_value)
        if var_match:
            var_name = var_match.group(1).strip()
            # If it's a field (like for set variable, show variable)
            if field_name_in_parent:
                return var_name # Return name, parent block will set its field
            # If it's an input that expects a variable reporter (e.g., 'say (score)')
            # Create a data_variable shadow block
            var_reporter_key, var_reporter_data = create_block_instance_for_parsing(
                "data_variable", parent_key=parent_block_key, is_shadow=True
            )
            if var_reporter_key:
                var_reporter_data["fields"]["VARIABLE"] = [var_name, f"`var_{var_name}"] # Placeholder ID
                return [1, var_reporter_key] # Type 1 for block reference
            else:
                print(f"Warning: Could not create data_variable block for '{var_name}'")
                return [10, var_name] # Fallback to string literal

        # 4. Handle nested reporter blocks (e.g., "(x position)")
        reporter_match = re.match(r"\((.+?)\)", pseudo_value)
        if reporter_match:
            inner_content = reporter_match.group(1).strip()
            # Check if it's a known reporter block (like "x position")
            if inner_content in reporter_opcode_lookup:
                reporter_opcode = reporter_opcode_lookup[inner_content]
                reporter_block_key, reporter_block_data = create_block_instance_for_parsing(
                    reporter_opcode, parent_key=parent_block_key, is_shadow=True
                )
                if reporter_block_key:
                    return [1, reporter_block_key] # Type 1 for block reference
                else:
                    print(f"Warning: Could not create reporter block for '{inner_content}'")
                    return [10, inner_content] # Fallback to string literal
            else: # It's a literal number or string inside parentheses
                return parse_and_link_input(parent_block_key, input_type, inner_content) # Recurse for inner content

        # 5. Handle nested boolean blocks (e.g., "<(...) < (...)>")
        boolean_match = re.match(r"<(.+?)>", pseudo_value)
        if boolean_match:
            inner_condition_str = boolean_match.group(1).strip()
            # This is typically handled by the parent block's parsing (e.g., control_if)
            # For now, if called directly, it implies a boolean reporter.
            # We'll need specific logic for operator_lt, operator_and, etc.
            # This part is complex and often handled by the parent block's specific regex.
            # For this problem, the 'if' block's logic will create the boolean shadow.
            print(f"Warning: Direct parsing of standalone boolean '{pseudo_value}' not fully supported here.")
            return [10, pseudo_value] # Fallback to string literal

        # Default to string literal if no other pattern matches
        return [10, pseudo_value]

    lines = [line.strip() for line in pseudo_code.strip().split('\n') if line.strip()]

    # Track the current script and nesting
    current_script_head = None
    block_stack = [] # Stores (parent_block_key, indent_level, last_child_key_in_scope)

    # Create a mapping from block name patterns to their opcodes and input/field details
    # The 'input_map' keys are the internal Scratch input names, values are regex group indices.
    # The 'field_map' keys are the internal Scratch field names, values are regex group indices.
    # 'condition_opcode' is for 'if' blocks that take a specific boolean reporter.
    pseudo_code_to_opcode_map = {
        re.compile(r"when green flag clicked"): {"opcode": "event_whenflagclicked"},
        re.compile(r"go to x: \((.+?)\) y: \((.+?)\)"): {"opcode": "motion_gotoxy", "input_map": {"X": 0, "Y": 1}},
        re.compile(r"set \[(.+?) v\] to (.+)"): {"opcode": "data_setvariableto", "field_map": {"VARIABLE": 0}, "input_map": {"VALUE": 1}},
        re.compile(r"show variable \[(.+?) v\]"): {"opcode": "data_showvariable", "field_map": {"VARIABLE": 0}},
        re.compile(r"forever"): {"opcode": "control_forever"},
        re.compile(r"glide \((.+?)\) seconds to x: \((.+?)\) y: \((.+?)\)"): {"opcode": "motion_glidesecstoxy", "input_map": {"SECS": 0, "X": 1, "Y": 2}},
        re.compile(r"if <\((.+)\) < \((.+)\)> then"): {"opcode": "control_if", "condition_type": "operator_lt", "condition_input_map": {"OPERAND1": 0, "OPERAND2": 1}},
        re.compile(r"set x to \((.+?)\)"): {"opcode": "motion_setx", "input_map": {"X": 0}},
        re.compile(r"if <touching \[(.+?) v\]\?> then"): {"opcode": "control_if", "condition_type": "sensing_touchingobject", "condition_field_map": {"TOUCHINGOBJECTMENU": 0}},
        re.compile(r"broadcast \[(.+?) v\]"): {"opcode": "event_broadcast", "input_map": {"BROADCAST_INPUT": 0}},
        re.compile(r"stop \[(.+?) v\]"): {"opcode": "control_stop", "field_map": {"STOP_OPTION": 0}},
        re.compile(r"end"): {"opcode": "end_block"}, # Special marker for script end/C-block end
    }

    # Create a reverse lookup for reporter block opcodes based on their pseudo-code representation
    reporter_opcode_lookup = {}
    for opcode, definition in all_block_definitions.items():
        if definition.get("block_shape") == "Reporter Block":
            block_name = definition.get("block_name")
            if block_name:
                # Clean up block name for matching: remove parentheses, 'v' for variable, etc.
                clean_name = block_name.replace("(", "").replace(")", "").replace("[", "").replace("]", "").replace(" v", "").strip()
                reporter_opcode_lookup[clean_name] = opcode
                # Add specific entries for common reporters if their pseudo-code differs from clean_name
                if opcode == "motion_xposition":
                    reporter_opcode_lookup["x position"] = opcode
                elif opcode == "motion_yposition":
                    reporter_opcode_lookup["y position"] = opcode
                # Add more as needed based on pseudo-code patterns

    for line_idx, raw_line in enumerate(lines):
        current_line_indent = len(raw_line) - len(raw_line.lstrip())
        line = raw_line.strip()

        # Adjust block_stack based on current indent level
        while block_stack and current_line_indent <= block_stack[-1][1]:
            block_stack.pop()

        matched_block_info = None
        matched_values = None
        
        # Try to match the line against known block patterns
        for pattern_regex, info in pseudo_code_to_opcode_map.items():
            match = pattern_regex.match(line)
            if match:
                matched_block_info = info
                matched_values = match.groups()
                break
        
        if not matched_block_info:
            print(f"Warning: Could not interpret line: '{line}' at line {line_idx + 1}")
            continue

        opcode = matched_block_info["opcode"]

        # Handle 'end' block separately as it signifies closing a C-block
        if opcode == "end_block":
            # This 'end' matches the most recent C-block on the stack.
            # The while loop at the beginning of the iteration already handles popping.
            continue

        parent_key = None
        if block_stack:
            parent_key = block_stack[-1][0] # The last block on the stack is the parent

        # Create the new block instance
        new_block_key, new_block_data = create_block_instance_for_parsing(
            opcode, 
            parent_key=parent_key, 
            is_top_level=(parent_key is None)
        )
        if not new_block_key:
            continue

        # Link to previous block in the same script/nesting level
        if block_stack:
            # Update the 'next' of the previous block in the current scope
            last_child_key_in_scope = block_stack[-1][2] if len(block_stack[-1]) > 2 else None
            if last_child_key_in_scope and last_child_key_in_scope in updated_blocks:
                updated_blocks[last_child_key_in_scope]["next"] = new_block_key
            
            # Update the last child in the current scope
            block_stack[-1] = (block_stack[-1][0], block_stack[-1][1], new_block_key)
        
        # Populate inputs and fields based on matched_block_info and matched_values
        if matched_values:
            # Handle fields
            if "field_map" in matched_block_info:
                for field_name, group_idx in matched_block_info["field_map"].items():
                    pseudo_field_value = matched_values[group_idx].replace(' v', '').strip()
                    if field_name == "VARIABLE":
                        # For variable fields, the actual variable ID is often derived or generated.
                        # For now, we use a placeholder and the name.
                        new_block_data["fields"][field_name] = [pseudo_field_value, f"`var_{pseudo_field_value}"]
                    elif field_name == "STOP_OPTION":
                        new_block_data["fields"][field_name] = [pseudo_field_value, None] # No ID needed for dropdown option
                    else:
                        new_block_data["fields"][field_name][0] = pseudo_field_value

            # Handle inputs
            if "input_map" in matched_block_info:
                for input_name, group_idx in matched_block_info["input_map"].items():
                    pseudo_input_value = matched_values[group_idx].strip()
                    
                    parsed_input_info = parse_and_link_input(new_block_key, new_block_data["inputs"][input_name][0], pseudo_input_value, input_name_in_parent=input_name)
                    
                    if parsed_input_info:
                        if parsed_input_info[0] == 1: # It's a linked block (shadow reporter/boolean/menu)
                            new_block_data["inputs"][input_name][1] = parsed_input_info[1] # Link block ID
                            new_block_data["inputs"][input_name][0] = parsed_input_info[0] # Set type to 1 (block)
                        else: # It's a literal value
                            new_block_data["inputs"][input_name][1] = parsed_input_info[1]
                            new_block_data["inputs"][input_name][0] = parsed_input_info[0] # Set appropriate type (4 for number, 10 for string)
            
            # Special handling for 'if' block conditions
            if opcode == "control_if":
                condition_type = matched_block_info.get("condition_type")
                if condition_type:
                    condition_block_key, condition_block_data = create_block_instance_for_parsing(
                        condition_type, parent_key=new_block_key, is_shadow=True
                    )
                    if condition_block_key:
                        new_block_data["inputs"]["CONDITION"] = [2, condition_block_key] # Type 2 for boolean block reference

                        # Populate inputs for the condition block (e.g., operator_lt)
                        if "condition_input_map" in matched_block_info:
                            for cond_input_name, cond_group_idx in matched_block_info["condition_input_map"].items():
                                pseudo_cond_value = matched_values[cond_group_idx].strip()
                                parsed_cond_input_info = parse_and_link_input(condition_block_key, condition_block_data["inputs"][cond_input_name][0], pseudo_cond_value)
                                if parsed_cond_input_info:
                                    if parsed_cond_input_info[0] == 1:
                                        condition_block_data["inputs"][cond_input_name][1] = parsed_cond_input_info[1]
                                        condition_block_data["inputs"][cond_input_name][0] = parsed_cond_input_info[0]
                                    else:
                                        condition_block_data["inputs"][cond_input_name][1] = parsed_cond_input_info[1]
                                        condition_block_data["inputs"][cond_input_name][0] = parsed_cond_input_info[0]
                        
                        # Populate fields for the condition block (e.g., sensing_touchingobject's menu)
                        if "condition_field_map" in matched_block_info:
                            for cond_field_name, cond_group_idx in matched_block_info["condition_field_map"].items():
                                pseudo_cond_field_value = matched_values[cond_group_idx].replace(' v', '').strip()
                                if cond_field_name == "TOUCHINGOBJECTMENU":
                                    # Create the menu block for TOUCHINGOBJECTMENU
                                    menu_opcode = "sensing_touchingobjectmenu"
                                    menu_key, menu_data = create_block_instance_for_parsing(
                                        menu_opcode,
                                        parent_key=condition_block_key,
                                        is_shadow=True
                                    )
                                    if menu_key:
                                        condition_block_data["inputs"]["TOUCHINGOBJECTMENU"] = [1, menu_key] # Link to menu block
                                        menu_data["fields"]["TOUCHINGOBJECTMENU"] = [pseudo_cond_field_value, None] # Set menu value
                                    else:
                                        print(f"Warning: Could not create menu block for touching object: '{pseudo_cond_field_value}'")
                                else:
                                    condition_block_data["fields"][cond_field_name][0] = pseudo_cond_field_value
                    else:
                        print(f"Warning: Could not create condition block '{condition_type}' for 'if' statement.")


        # For C-blocks, push onto stack to track nesting
        # 'control_if' is a C-block, but its 'next' is inside its substack.
        # 'control_forever' is also a C-block.
        if all_block_definitions[opcode].get("block_shape") == "C-Block" and opcode != "control_if":
            # For C-blocks, the 'next' of the parent is usually null, and children start in 'SUBSTACK'
            # We add the block to the stack, and its "next" will be its first child.
            # The 'next' of the *last child* in its substack will point to the block after the C-block.
            block_stack.append((new_block_key, current_line_indent, None)) # (parent_key, indent, last_child_key_in_substack)
            
            # For C-blocks, the first child is linked via the 'SUBSTACK' input
            new_block_data["inputs"]["SUBSTACK"] = [2, None] # Placeholder for the first child block ID

        # For 'if' blocks, the 'next' of the parent is usually null, and children start in 'SUBSTACK'
        if opcode == "control_if":
            block_stack.append((new_block_key, current_line_indent, None))
            new_block_data["inputs"]["SUBSTACK"] = [2, None] # Placeholder for the first child block ID


    # Final pass to ensure topLevel is correctly set for the very first block of a script
    for key, block in updated_blocks.items():
        if block.get("parent") is None and block.get("next") is not None:
            block["topLevel"] = True
        elif block.get("parent") is None and block.get("next") is None and block.get("opcode") == "event_whenflagclicked":
             block["topLevel"] = True # Ensure hat blocks are always topLevel

    return updated_blocks

# --- Consolidated Block Definitions from all provided JSONs ---
# This dictionary should contain ALL block definitions from your JSON files.
# I'm using the provided definitions from the previous turn.
all_block_definitions = {
    # motion_block.json
    "motion_movesteps": {
        "block_name": "move () steps", "block_type": "Motion", "block_shape": "Stack Block", "op_code": "motion_movesteps",
        "functionality": "Moves the sprite forward by the specified number of steps in the direction it is currently facing. A positive value moves it forward, and a negative value moves it backward.",
        "inputs": {"STEPS": [1, [4, "10"]]}, "fields": {}, "shadow": False, "topLevel": True
    },
    "motion_turnright": {
        "block_name": "turn right () degrees", "block_type": "Motion", "block_shape": "Stack Block", "op_code": "motion_turnright",
        "functionality": "Turns the sprite clockwise by the specified number of degrees.",
        "inputs": {"DEGREES": [1, [4, "15"]]}, "fields": {}, "shadow": False, "topLevel": True
    },
    "motion_turnleft": {
        "block_name": "turn left () degrees", "block_type": "Motion", "block_shape": "Stack Block", "op_code": "motion_turnleft",
        "functionality": "Turns the sprite counter-clockwise by the specified number of degrees.",
        "inputs": {"DEGREES": [1, [4, "15"]]}, "fields": {}, "shadow": False, "topLevel": True
    },
    "motion_goto": {
        "block_name": "go to ()", "block_type": "Motion", "block_shape": "Stack Block", "op_code": "motion_goto",
        "functionality": "Moves the sprite to a specified location, which can be a random position or at the mouse pointer or another to the sprite.",
        "inputs": {"TO": [1, "motion_goto_menu"]}, "fields": {}, "shadow": False, "topLevel": True
    },
    "motion_goto_menu": {
        "block_name": "go to menu", "block_type": "Motion", "block_shape": "Reporter Block", "op_code": "motion_goto_menu",
        "functionality": "Menu for go to block.",
        "inputs": {}, "fields": {"TO": ["_random_", None]}, "shadow": True, "topLevel": False
    },
    "motion_gotoxy": {
        "block_name": "go to x: () y: ()", "block_type": "Motion", "block_shape": "Stack Block", "op_code": "motion_gotoxy",
        "functionality": "Moves the sprite to the specified X and Y coordinates on the stage.",
        "inputs": {"X": [1, [4, "0"]], "Y": [1, [4, "0"]]}, "fields": {}, "shadow": False, "topLevel": True
    },
    "motion_glideto": {
        "block_name": "glide () secs to ()", "block_type": "Motion", "block_shape": "Stack Block", "op_code": "motion_glideto",
        "functionality": "Glides the sprite smoothly to a specified location (random position, mouse pointer, or another sprite) over a given number of seconds.",
        "inputs": {"SECS": [1, [4, "1"]], "TO": [1, "motion_glideto_menu"]}, "fields": {}, "shadow": False, "topLevel": True
    },
    "motion_glideto_menu": {
        "block_name": "glide to menu", "block_type": "Motion", "block_shape": "Reporter Block", "op_code": "motion_glideto_menu",
        "functionality": "Menu for glide to block.",
        "inputs": {}, "fields": {"TO": ["_random_", None]}, "shadow": True, "topLevel": False
    },
    "motion_glidesecstoxy": {
        "block_name": "glide () secs to x: () y: ()", "block_type": "Motion", "block_shape": "Stack Block", "op_code": "motion_glidesecstoxy",
        "functionality": "Glides the sprite smoothly to the specified X and Y coordinates over a given number of seconds.",
        "inputs": {"SECS": [1, [4, "1"]], "X": [1, [4, "0"]], "Y": [1, [4, "0"]]}, "fields": {}, "shadow": False, "topLevel": True
    },
    "motion_pointindirection": {
        "block_name": "point in direction ()", "block_type": "Motion", "block_shape": "Stack Block", "op_code": "motion_pointindirection",
        "functionality": "Sets the sprite's direction to a specified angle in degrees (0 = up, 90 = right, 180 = down, -90 = left).",
        "inputs": {"DIRECTION": [1, [8, "90"]]}, "fields": {}, "shadow": False, "topLevel": True
    },
    "motion_pointtowards": {
        "block_name": "point towards ()", "block_type": "Motion", "block_shape": "Stack Block", "op_code": "motion_pointtowards",
        "functionality": "Points the sprite towards the mouse pointer or another specified sprite.",
        "inputs": {"TOWARDS": [1, "motion_pointtowards_menu"]}, "fields": {}, "shadow": False, "topLevel": True
    },
    "motion_pointtowards_menu": {
        "block_name": "point towards menu", "block_type": "Motion", "block_shape": "Reporter Block", "op_code": "motion_pointtowards_menu",
        "functionality": "Menu for point towards block.",
        "inputs": {}, "fields": {"TOWARDS": ["_mouse_", None]}, "shadow": True, "topLevel": False
    },
    "motion_changexby": {
        "block_name": "change x by ()", "block_type": "Motion", "block_shape": "Stack Block", "op_code": "motion_changexby",
        "functionality": "Changes the sprite's X-coordinate by the specified amount, moving it horizontally.",
        "inputs": {"DX": [1, [4, "10"]]}, "fields": {}, "shadow": False, "topLevel": True
    },
    "motion_setx": {
        "block_name": "set x to ()", "block_type": "Motion", "block_shape": "Stack Block", "op_code": "motion_setx",
        "functionality": "Sets the sprite's X-coordinate to a specific value, placing it at a precise horizontal position.",
        "inputs": {"X": [1, [4, "0"]]}, "fields": {}, "shadow": False, "topLevel": True
    },
    "motion_changeyby": {
        "block_name": "change y by ()", "block_type": "Motion", "block_shape": "Stack Block", "op_code": "motion_changeyby",
        "functionality": "Changes the sprite's Y-coordinate by the specified amount, moving it vertically.",
        "inputs": {"DY": [1, [4, "10"]]}, "fields": {}, "shadow": False, "topLevel": True
    },
    "motion_sety": {
        "block_name": "set y to ()", "block_type": "Motion", "block_shape": "Stack Block", "op_code": "motion_sety",
        "functionality": "Sets the sprite's Y-coordinate to a specific value, placing it at a precise vertical position.",
        "inputs": {"Y": [1, [4, "0"]]}, "fields": {}, "shadow": False, "topLevel": True
    },
    "motion_ifonedgebounce": {
        "block_name": "if on edge, bounce", "block_type": "Motion", "block_shape": "Stack Block", "op_code": "motion_ifonedgebounce",
        "functionality": "Reverses the sprite's direction if it touches the edge of the stage.",
        "inputs": {}, "fields": {}, "shadow": False, "topLevel": True
    },
    "motion_setrotationstyle": {
        "block_name": "set rotation style ()", "block_type": "Motion", "block_shape": "Stack Block", "op_code": "motion_setrotationstyle",
        "functionality": "Determines how the sprite rotates: 'left-right' (flips horizontally), 'don't rotate' (stays facing one direction), or 'all around' (rotates freely).",
        "inputs": {}, "fields": {"STYLE": ["left-right", None]}, "shadow": False, "topLevel": True
    },
    "motion_xposition": {
        "block_name": "(x position)", "block_type": "Motion", "block_shape": "Reporter Block", "op_code": "motion_xposition",
        "functionality": "Reports the current X-coordinate of the sprite.[NOTE: not used in stage/backdrops]",
        "inputs": {}, "fields": {}, "shadow": False, "topLevel": True
    },
    "motion_yposition": {
        "block_name": "(y position)", "block_type": "Motion", "block_shape": "Reporter Block", "op_code": "motion_yposition",
        "functionality": "Reports the current Y coordinate of the sprite on the stage.[NOTE: not used in stage/backdrops]",
        "inputs": {}, "fields": {}, "shadow": False, "topLevel": True
    },
    "motion_direction": {
        "block_name": "(direction)", "block_type": "Motion", "block_shape": "Reporter Block", "op_code": "motion_direction",
        "functionality": "Reports the current direction of the sprite in degrees (0 = up, 90 = right, 180 = down, -90 = left).[NOTE: not used in stage/backdrops]",
        "inputs": {}, "fields": {}, "shadow": False, "topLevel": True
    },

    # control_block.json
    "control_wait": {
        "block_name": "wait () seconds", "block_type": "Control", "block_shape": "Stack Block", "op_code": "control_wait",
        "functionality": "Pauses the script for a specified duration.",
        "inputs": {"DURATION": [1, [5, "1"]]}, "fields": {}, "shadow": False, "topLevel": True
    },
    "control_repeat": {
        "block_name": "repeat ()", "block_type": "Control", "block_shape": "C-Block", "op_code": "control_repeat",
        "functionality": "Repeats the blocks inside it a specified number of times.",
        "inputs": {"TIMES": [1, [6, "10"]], "SUBSTACK": [2, None]}, "fields": {}, "shadow": False, "topLevel": True
    },
    "control_forever": {
        "block_name": "forever", "block_type": "Control", "block_shape": "C-Block", "op_code": "control_forever",
        "functionality": "Continuously runs the blocks inside it.",
        "inputs": {"SUBSTACK": [2, None]}, "fields": {}, "shadow": False, "topLevel": True
    },
    "control_if": {
        "block_name": "if <> then", "block_type": "Control", "block_shape": "C-Block", "op_code": "control_if",
        "functionality": "Executes the blocks inside it only if the specified boolean condition is true. [NOTE: it takes boolean blocks as input]",
        "inputs": {"CONDITION": [2, None], "SUBSTACK": [2, None]}, "fields": {}, "shadow": False, "topLevel": True
    },
    "control_if_else": {
        "block_name": "if <> then else", "block_type": "Control", "block_shape": "C-Block", "op_code": "control_if_else",
        "functionality": "Executes one set of blocks if the specified boolean condition is true, and a different set of blocks if the condition is false. [NOTE: it takes boolean blocks as input]",
        "inputs": {"CONDITION": [2, None], "SUBSTACK": [2, None], "SUBSTACK2": [2, None]}, "fields": {}, "shadow": False, "topLevel": True
    },
    "control_wait_until": {
        "block_name": "wait until <>", "block_type": "Control", "block_shape": "Stack Block", "op_code": "control_wait_until",
        "functionality": "Pauses the script until the specified boolean condition becomes true. [NOTE: it takes boolean blocks as input]",
        "inputs": {"CONDITION": [2, None]}, "fields": {}, "shadow": False, "topLevel": True
    },
    "control_repeat_until": {
        "block_name": "repeat until <>", "block_type": "Control", "block_shape": "C-Block", "op_code": "control_repeat_until",
        "functionality": "Repeats the blocks inside it until the specified boolean condition becomes true. [NOTE: it takes boolean blocks as input]",
        "inputs": {"CONDITION": [2, None], "SUBSTACK": [2, None]}, "fields": {}, "shadow": False, "topLevel": True
    },
    "control_stop": {
        "block_name": "stop [v]", "block_type": "Control", "block_shape": "Cap Block", "op_code": "control_stop",
        "functionality": "Halts all scripts, only the current script, or other scripts within the same sprite. Its shape can dynamically change based on the selected option.",
        "inputs": {}, "fields": {"STOP_OPTION": ["all", None]}, "shadow": False, "topLevel": True, "mutation": {"tagName": "mutation", "children": [], "hasnext": "false"}
    },
    "control_start_as_clone": {
        "block_name": "When I Start as a Clone", "block_type": "Control", "block_shape": "Hat Block", "op_code": "control_start_as_clone",
        "functionality": "This Hat block initiates the script when a clone of the sprite is created. It defines the behavior of individual clones.",
        "inputs": {}, "fields": {}, "shadow": False, "topLevel": True
    },
    "control_create_clone_of": {
        "block_name": "create clone of ()", "block_type": "Control", "block_shape": "Stack Block", "op_code": "control_create_clone_of",
        "functionality": "Generates a copy, or clone, of a specified sprite (or 'myself' for the current sprite).",
        "inputs": {"CLONE_OPTION": [1, "control_create_clone_of_menu"]}, "fields": {}, "shadow": False, "topLevel": True
    },
    "control_create_clone_of_menu": {
        "block_name": "create clone of menu", "block_type": "Control", "block_shape": "Reporter Block", "op_code": "control_create_clone_of_menu",
        "functionality": "Menu for create clone of block.",
        "inputs": {}, "fields": {"CLONE_OPTION": ["_myself_", None]}, "shadow": True, "topLevel": False
    },
    "control_delete_this_clone": {
        "block_name": "delete this clone", "block_type": "Control", "block_shape": "Cap Block", "op_code": "control_delete_this_clone",
        "functionality": "Removes the clone that is executing it from the stage.",
        "inputs":None, "fields": {}, "shadow": False, "topLevel": True
    },

    # data_block.json
    "data_setvariableto": {
        "block_name": "set [my variable v] to ()", "block_type": "Data", "block_shape": "Stack Block", "op_code": "data_setvariableto",
        "functionality": "Assigns a specific value (number, string, or boolean) to a variable.",
        "inputs": {"VALUE": [1, [10, "0"]]}, "fields": {"VARIABLE": ["my variable", "`jEk@4|i[#Fk?(8x)AV.-my variable"]}, "shadow": False, "topLevel": True
    },
    "data_changevariableby": {
        "block_name": "change [my variable v] by ()", "block_type": "Data", "block_shape": "Stack Block", "op_code": "data_changevariableby",
        "functionality": "Increases or decreases a variable's numerical value by a specified amount.",
        "inputs": {"VALUE": [1, [4, "1"]]}, "fields": {"VARIABLE": ["my variable", "`jEk@4|i[#Fk?(8x)AV.-my variable"]}, "shadow": False, "topLevel": True
    },
    "data_showvariable": {
        "block_name": "show variable [my variable v]", "block_type": "Data", "block_shape": "Stack Block", "op_code": "data_showvariable",
        "functionality": "Makes a variable's monitor visible on the stage.",
        "inputs": {}, "fields": {"VARIABLE": ["my variable", "`jEk@4|i[#Fk?(8x)AV.-my variable"]}, "shadow": False, "topLevel": True
    },
    "data_hidevariable": {
        "block_name": "hide variable [my variable v]", "block_type": "Data", "block_shape": "Stack Block", "op_code": "data_hidevariable",
        "functionality": "Hides a variable's monitor from the stage.",
        "inputs": {}, "fields": {"VARIABLE": ["my variable", "`jEk@4|i[#Fk?(8x)AV.-my variable"]}, "shadow": False, "topLevel": True
    },
    "data_addtolist": {
        "block_name": "add () to [my list v]", "block_type": "Data", "block_shape": "Stack Block", "op_code": "data_addtolist",
        "functionality": "Appends an item to the end of a list.",
        "inputs": {"ITEM": [1, [10, "thing"]]}, "fields": {"LIST": ["MY_LIST", "o6`kIhtT{xWH+rX(5d,A"]}, "shadow": False, "topLevel": True
    },
    "data_deleteoflist": {
        "block_name": "delete () of [my list v]", "block_type": "Data", "block_shape": "Stack Block", "op_code": "data_deleteoflist",
        "functionality": "Removes an item from a list by its index or by selecting 'all' items.",
        "inputs": {"INDEX": [1, [7, "1"]]}, "fields": {"LIST": ["MY_LIST", "o6`kIhtT{xWH+rX(5d,A"]}, "shadow": False, "topLevel": True
    },
    "data_deletealloflist": {
        "block_name": "delete all of [my list v]", "block_type": "Data", "block_shape": "Stack Block", "op_code": "data_deletealloflist",
        "functionality": "Removes all items from a list.",
        "inputs": {}, "fields": {"LIST": ["MY_LIST", "o6`kIhtT{xWH+rX(5d,A"]}, "shadow": False, "topLevel": True
    },
    "data_insertatlist": {
        "block_name": "insert () at () of [my list v]", "block_type": "Data", "block_shape": "Stack Block", "op_code": "data_insertatlist",
        "functionality": "Inserts an item at a specific position within a list.",
        "inputs": {"ITEM": [1, [10, "thing"]], "INDEX": [1, [7, "1"]]}, "fields": {"LIST": ["MY_LIST", "o6`kIhtT{xWH+rX(5d,A"]}, "shadow": False, "topLevel": True
    },
    "data_replaceitemoflist": {
        "block_name": "replace item () of [my list v] with ()", "block_type": "Data", "block_shape": "Stack Block", "op_code": "data_replaceitemoflist",
        "functionality": "Replaces an item at a specific position in a list with a new value.",
        "inputs": {"INDEX": [1, [7, "1"]], "ITEM": [1, [10, "thing"]]}, "fields": {"LIST": ["MY_LIST", "o6`kIhtT{xWH+rX(5d,A"]}, "shadow": False, "topLevel": True
    },
    "data_itemoflist": {
        "block_name": "(item (2) of [myList v])", "block_type": "Data", "block_shape": "Reporter Block", "op_code": "data_itemoflist",
        "functionality": "Reports the item located at a specific position in a list.",
        "inputs": {"INDEX": [1, [7, "1"]]}, "fields": {"LIST": ["MY_LIST", "o6`kIhtT{xWH+rX(5d,A"]}, "shadow": False, "topLevel": True
    },
    "data_itemnumoflist": {
        "block_name": "(item # of [Dog] in [myList v])", "block_type": "Data", "block_shape": "Reporter Block", "op_code": "data_itemnumoflist",
        "functionality": "Reports the index number of the first occurrence of a specified item in a list. If the item is not found, it reports 0.",
        "inputs": {"ITEM": [1, [10, "thing"]]}, "fields": {"LIST": ["MY_LIST", "o6`kIhtT{xWH+rX(5d,A"]}, "shadow": False, "topLevel": True
    },
    "data_lengthoflist": {
        "block_name": "(length of [myList v])", "block_type": "Data", "block_shape": "Reporter Block", "op_code": "data_lengthoflist",
        "functionality": "Provides the total number of items contained in a list.",
        "inputs": {}, "fields": {"LIST": ["MY_LIST", "o6`kIhtT{xWH+rX(5d,A"]}, "shadow": False, "topLevel": True
    },
    "data_listcontainsitem": {
        "block_name": "<[my list v] contains ()?>", "block_type": "Data", "block_shape": "Boolean Block", "op_code": "data_listcontainsitem",
        "functionality": "Checks if a list includes a specific item.",
        "inputs": {"ITEM": [1, [10, "thing"]]}, "fields": {"LIST": ["MY_LIST", "o6`kIhtT{xWH+rX(5d,A"]}, "shadow": False, "topLevel": True
    },
    "data_showlist": {
        "block_name": "show list [my list v]", "block_type": "Data", "block_shape": "Stack Block", "op_code": "data_showlist",
        "functionality": "Makes a list's monitor visible on the stage.",
        "inputs": {}, "fields": {"LIST": ["MY_LIST", "o6`kIhtT{xWH+rX(5d,A"]}, "shadow": False, "topLevel": True
    },
    "data_hidelist": {
        "block_name": "hide list [my list v]", "block_type": "Data", "block_shape": "Stack Block", "op_code": "data_hidelist",
        "functionality": "Hides a list's monitor from the stage.",
        "inputs": {}, "fields": {"LIST": ["MY_LIST", "o6`kIhtT{xWH+rX(5d,A"]}, "shadow": False, "topLevel": True
    },
    "data_variable": { # This is a reporter block for a variable's value
        "block_name": "[variable v]", "block_type": "Data", "block_shape": "Reporter Block", "op_code": "data_variable",
        "functionality": "Provides the current value stored in a variable.",
        "inputs": {}, "fields": {"VARIABLE": ["my variable", None]}, "shadow": True, "topLevel": False
    },

    # event_block.json
    "event_whenflagclicked": {
        "block_name": "when green flag pressed", "block_type": "Events", "op_code": "event_whenflagclicked", "block_shape": "Hat Block",
        "functionality": "This Hat block initiates the script when the green flag is clicked, serving as the common starting point for most Scratch projects.",
        "inputs": {}, "fields": {}, "shadow": False, "topLevel": True
    },
    "event_whenkeypressed": {
        "block_name": "when () key pressed", "block_type": "Events", "op_code": "event_whenkeypressed", "block_shape": "Hat Block",
        "functionality": "This Hat block initiates the script when a specified keyboard key is pressed.",
        "inputs": {}, "fields": {"KEY_OPTION": ["space", None]}, "shadow": False, "topLevel": True
    },
    "event_whenthisspriteclicked": {
        "block_name": "when this sprite clicked", "block_type": "Events", "op_code": "event_whenthisspriteclicked", "block_shape": "Hat Block",
        "functionality": "This Hat block starts the script when the sprite itself is clicked.",
        "inputs": {}, "fields": {}, "shadow": False, "topLevel": True
    },
    "event_whenbackdropswitchesto": {
        "block_name": "when backdrop switches to ()", "block_type": "Events", "op_code": "event_whenbackdropswitchesto", "block_shape": "Hat Block",
        "functionality": "This Hat block triggers the script when the stage backdrop changes to a specified backdrop.",
        "inputs": {}, "fields": {"BACKDROP": ["backdrop1", None]}, "shadow": False, "topLevel": True
    },
    "event_whengreaterthan": {
        "block_name": "when () > ()", "block_type": "Events", "op_code": "event_whengreaterthan", "block_shape": "Hat Block",
        "functionality": "This Hat block starts the script when a certain value (e.g., loudness from a microphone, or the timer) exceeds a defined threshold.",
        "inputs": {"VALUE": [1, [4, "10"]]}, "fields": {"WHENGREATERTHANMENU": ["LOUDNESS", None]}, "shadow": False, "topLevel": True
    },
    "event_whenbroadcastreceived": {
        "block_name": "when I receive ()", "block_type": "Events", "op_code": "event_whenbroadcastreceived", "block_shape": "Hat Block",
        "functionality": "This Hat block initiates the script upon the reception of a specific broadcast message. This mechanism facilitates indirect communication between sprites or the stage.",
        "inputs": {}, "fields": {"BROADCAST_OPTION": ["message1", "5O!nei;S$!c!=hCT}0:a"]}, "shadow": False, "topLevel": True
    },
    "event_broadcast": {
        "block_name": "broadcast ()", "block_type": "Events", "block_shape": "Stack Block", "op_code": "event_broadcast",
        "functionality": "Sends a broadcast message throughout the Scratch program, activating any 'when I receive ()' blocks that are set to listen for that message, enabling indirect communication.",
        "inputs": {"BROADCAST_INPUT": [1, [11, "message1", "5O!nei;S$!c!=hCT}0:a"]]}, "fields": {}, "shadow": False, "topLevel": True
    },
    "event_broadcastandwait": {
        "block_name": "broadcast () and wait", "block_type": "Events", "block_shape": "Stack Block", "op_code": "event_broadcastandwait",
        "functionality": "Sends a broadcast message and pauses the current script until all other scripts activated by that broadcast have completed their execution, ensuring sequential coordination.",
        "inputs": {"BROADCAST_INPUT": [1, [11, "message1", "5O!nei;S$!c!=hCT}0:a"]]}, "fields": {}, "shadow": False, "topLevel": True
    },

    # looks_block.json
    "looks_sayforsecs": {
        "block_name": "say () for () seconds", "block_type": "Looks", "block_shape": "Stack Block", "op_code": "looks_sayforsecs",
        "functionality": "Displays a speech bubble containing specified text for a set duration.",
        "inputs": {"MESSAGE": [1, [10, "Hello!"]], "SECS": [1, [4, "2"]]}, "fields": {}, "shadow": False, "topLevel": True
    },
    "looks_say": {
        "block_name": "say ()", "block_type": "Looks", "block_shape": "Stack Block", "op_code": "looks_say",
        "functionality": "Displays a speech bubble with the specified text indefinitely until another 'say' or 'think' block is activated.",
        "inputs": {"MESSAGE": [1, [10, "Hello!"]]}, "fields": {}, "shadow": False, "topLevel": True
    },
    "looks_thinkforsecs": {
        "block_name": "think () for () seconds", "block_type": "Looks", "block_shape": "Stack Block", "op_code": "looks_thinkforsecs",
        "functionality": "Displays a thought bubble containing specified text for a set duration.",
        "inputs": {"MESSAGE": [1, [10, "Hmm..."]], "SECS": [1, [4, "2"]]}, "fields": {}, "shadow": False, "topLevel": True
    },
    "looks_think": {
        "block_name": "think ()", "block_type": "Looks", "block_shape": "Stack Block", "op_code": "looks_think",
        "functionality": "Displays a thought bubble with the specified text indefinitely until another 'say' or 'think' block is activated.",
        "inputs": {"MESSAGE": [1, [10, "Hmm..."]]}, "fields": {}, "shadow": False, "topLevel": True
    },
    "looks_switchcostumeto": {
        "block_name": "switch costume to ()", "block_type": "Looks", "block_shape": "Stack Block", "op_code": "looks_switchcostumeto",
        "functionality": "Alters the sprite's appearance to a designated costume.",
        "inputs": {"COSTUME": [1, "looks_costume"]}, "fields": {}, "shadow": False, "topLevel": True
    },
    "looks_costume": {
        "block_name": "costume menu", "block_type": "Looks", "block_shape": "Reporter Block", "op_code": "looks_costume",
        "functionality": "Menu for switch costume to block.",
        "inputs": {}, "fields": {"COSTUME": ["costume1", None]}, "shadow": True, "topLevel": False
    },
    "looks_nextcostume": {
        "block_name": "next costume", "block_type": "Looks", "block_shape": "Stack Block", "op_code": "looks_nextcostume",
        "functionality": "Switches the sprite's costume to the next one in its costume list. If it's the last costume, it cycles back to the first.",
        "inputs": {}, "fields": {}, "shadow": False, "topLevel": True
    },
    "looks_switchbackdropto": {
        "block_name": "switch backdrop to ()", "block_type": "Looks", "block_shape": "Stack Block", "op_code": "looks_switchbackdropto",
        "functionality": "Changes the stage's backdrop to a specified backdrop.",
        "inputs": {"BACKDROP": [1, "looks_backdrops"]}, "fields": {}, "shadow": False, "topLevel": True
    },
    "looks_backdrops": {
        "block_name": "backdrop menu", "block_type": "Looks", "block_shape": "Reporter Block", "op_code": "looks_backdrops",
        "functionality": "Menu for switch backdrop to block.",
        "inputs": {}, "fields": {"BACKDROP": ["backdrop1", None]}, "shadow": True, "topLevel": False
    },
    "looks_switchbackdroptowait": {
        "block_name": "switch backdrop to () and wait", "block_type": "Looks", "block_shape": "Stack Block", "op_code": "looks_switchbackdroptowait",
        "functionality": "Changes the stage's backdrop to a specified backdrop and pauses the script until any 'When backdrop switches to' scripts for that backdrop have finished.",
        "inputs": {"BACKDROP": [1, "looks_backdrops"]}, "fields": {}, "shadow": False, "topLevel": True
    },
    "looks_nextbackdrop": {
        "block_name": "next backdrop", "block_type": "Looks", "block_shape": "Stack Block", "op_code": "looks_nextbackdrop",
        "functionality": "Switches the stage's backdrop to the next one in its backdrop list. If it's the last backdrop, it cycles back to the first.",
        "inputs": {}, "fields": {}, "shadow": False, "topLevel": True
    },
    "looks_changesizeby": {
        "block_name": "change size by ()", "block_type": "Looks", "block_shape": "Stack Block", "op_code": "looks_changesizeby",
        "functionality": "Changes the sprite's size by a specified percentage. Positive values make it larger, negative values make it smaller.",
        "inputs": {"CHANGE": [1, [4, "10"]]}, "fields": {}, "shadow": False, "topLevel": True
    },
    "looks_setsizeto": {
        "block_name": "set size to () %", "block_type": "Looks", "block_shape": "Stack Block", "op_code": "looks_setsizeto",
        "functionality": "Sets the sprite's size to a specific percentage of its original size.",
        "inputs": {"SIZE": [1, [4, "100"]]}, "fields": {}, "shadow": False, "topLevel": True
    },
    "looks_changeeffectby": {
        "block_name": "change () effect by ()", "block_type": "Looks", "block_shape": "Stack Block", "op_code": "looks_changeeffectby",
        "functionality": "Changes a visual effect on the sprite by a specified amount (e.g., color, fisheye, whirl, pixelate, mosaic, brightness, ghost).",
        "inputs": {"CHANGE": [1, [4, "25"]]}, "fields": {"EFFECT": ["COLOR", None]}, "shadow": False, "topLevel": True
    },
    "looks_seteffectto": {
        "block_name": "set () effect to ()", "block_type": "Looks", "block_shape": "Stack Block", "op_code": "looks_seteffectto",
        "functionality": "Sets a visual effect on the sprite to a specific value.",
        "inputs": {"VALUE": [1, [4, "0"]]}, "fields": {"EFFECT": ["COLOR", None]}, "shadow": False, "topLevel": True
    },
    "looks_cleargraphiceffects": {
        "block_name": "clear graphic effects", "block_type": "Looks", "block_shape": "Stack Block", "op_code": "looks_cleargraphiceffects",
        "functionality": "Removes all visual effects applied to the sprite.",
        "inputs": {}, "fields": {}, "shadow": False, "topLevel": True
    },
    "looks_show": {
        "block_name": "show", "block_type": "Looks", "block_shape": "Stack Block", "op_code": "looks_show",
        "functionality": "Makes the sprite visible on the stage.",
        "inputs": {}, "fields": {}, "shadow": False, "topLevel": True
    },
    "looks_hide": {
        "block_name": "hide", "block_type": "Looks", "block_shape": "Stack Block", "op_code": "looks_hide",
        "functionality": "Makes the sprite invisible on the stage.",
        "inputs": {}, "fields": {}, "shadow": False, "topLevel": True
    },
    "looks_gotofrontback": {
        "block_name": "go to () layer", "block_type": "Looks", "block_shape": "Stack Block", "op_code": "looks_gotofrontback",
        "functionality": "Moves the sprite to the front-most or back-most layer of other sprites on the stage.",
        "inputs": {}, "fields": {"FRONT_BACK": ["front", None]}, "shadow": False, "topLevel": True
    },
    "looks_goforwardbackwardlayers": {
        "block_name": "go () layers", "block_type": "Looks", "block_shape": "Stack Block", "op_code": "looks_goforwardbackwardlayers",
        "functionality": "Moves the sprite forward or backward a specified number of layers in relation to other sprites.",
        "inputs": {"NUM": [1, [7, "1"]]}, "fields": {"FORWARD_BACKWARD": ["forward", None]}, "shadow": False, "topLevel": True
    },
    "looks_costumenumbername": {
        "block_name": "(costume ())", "block_type": "Looks", "block_shape": "Reporter Block", "op_code": "looks_costumenumbername",
        "functionality": "Reports the current costume's number or name.",
        "inputs": {}, "fields": {"NUMBER_NAME": ["number", None]}, "shadow": False, "topLevel": True
    },
    "looks_backdropnumbername": {
        "block_name": "(backdrop ())", "block_type": "Looks", "block_shape": "Reporter Block", "op_code": "looks_backdropnumbername",
        "functionality": "Reports the current backdrop's number or name.",
        "inputs": {}, "fields": {"NUMBER_NAME": ["number", None]}, "shadow": False, "topLevel": True
    },
    "looks_size": {
        "block_name": "(size)", "block_type": "Looks", "block_shape": "Reporter Block", "op_code": "looks_size",
        "functionality": "Reports the current size of the sprite as a percentage.",
        "inputs": {}, "fields": {}, "shadow": False, "topLevel": True
    },

    # operator_block.json
    "operator_add": {
        "block_name": "(() + ())", "block_type": "operator", "block_shape": "Reporter Block", "op_code": "operator_add",
        "functionality": "Adds two numerical values.",
        "inputs": {"NUM1": [1, [4, ""]], "NUM2": [1, [4, ""]]}, "fields": {}, "shadow": False, "topLevel": True
    },
    "operator_subtract": {
        "block_name": "(() - ())", "block_type": "operator", "block_shape": "Reporter Block", "op_code": "operator_subtract",
        "functionality": "Subtracts the second numerical value from the first.",
        "inputs": {"NUM1": [1, [4, ""]], "NUM2": [1, [4, ""]]}, "fields": {}, "shadow": False, "topLevel": True
    },
    "operator_multiply": {
        "block_name": "(() * ())", "block_type": "operator", "block_shape": "Reporter Block", "op_code": "operator_multiply",
        "functionality": "Multiplies two numerical values.",
        "inputs": {"NUM1": [1, [4, ""]], "NUM2": [1, [4, ""]]}, "fields": {}, "shadow": False, "topLevel": True
    },
    "operator_divide": {
        "block_name": "(() / ())", "block_type": "operator", "block_shape": "Reporter Block", "op_code": "operator_divide",
        "functionality": "Divides the first numerical value by the second.",
        "inputs": {"NUM1": [1, [4, ""]], "NUM2": [1, [4, ""]]}, "fields": {}, "shadow": False, "topLevel": True
    },
    "operator_random": {
        "block_name": "(pick random () to ())", "block_type": "operator", "block_shape": "Reporter Block", "op_code": "operator_random",
        "functionality": "Generates a random integer within a specified inclusive range.",
        "inputs": {"FROM": [1, [4, "1"]], "TO": [1, [4, "10"]]}, "fields": {}, "shadow": False, "topLevel": True
    },
    "operator_gt": {
        "block_name": "<() > ()>", "block_type": "operator", "block_shape": "Boolean Block", "op_code": "operator_gt",
        "functionality": "Checks if the first value is greater than the second.",
        "inputs": {"OPERAND1": [1, [10, ""]], "OPERAND2": [1, [10, "50"]]}, "fields": {}, "shadow": False, "topLevel": True
    },
    "operator_lt": {
        "block_name": "<() < ()>", "block_type": "operator", "block_shape": "Boolean Block", "op_code": "operator_lt",
        "functionality": "Checks if the first value is less than the second.",
        "inputs": {"OPERAND1": [1, [10, ""]], "OPERAND2": [1, [10, "50"]]}, "fields": {}, "shadow": False, "topLevel": True
    },
    "operator_equals": {
        "block_name": "<() = ()>", "block_type": "operator", "block_shape": "Boolean Block", "op_code": "operator_equals",
        "functionality": "Checks if two values are equal.",
        "inputs": {"OPERAND1": [1, [10, ""]], "OPERAND2": [1, [10, "50"]]}, "fields": {}, "shadow": False, "topLevel": True
    },
    "operator_and": {
        "block_name": "<<> and <>>", "block_type": "operator", "block_shape": "Boolean Block", "op_code": "operator_and",
        "functionality": "Returns 'true' if both provided Boolean conditions are 'true'.",
        "inputs": {"OPERAND1": [2, None], "OPERAND2": [2, None]}, "fields": {}, "shadow": False, "topLevel": True
    },
    "operator_or": {
        "block_name": "<<> or <>>", "block_type": "operator", "block_shape": "Boolean Block", "op_code": "operator_or",
        "functionality": "Returns 'true' if at least one of the provided Boolean conditions is 'true'.",
        "inputs": {"OPERAND1": [2, None], "OPERAND2": [2, None]}, "fields": {}, "shadow": False, "topLevel": True
    },
    "operator_not": {
        "block_name": "<not <>>", "block_type": "operator", "block_shape": "Boolean Block", "op_code": "operator_not",
        "functionality": "Returns 'true' if the provided Boolean condition is 'false', and 'false' if it is 'true'.",
        "inputs": {"OPERAND": [2, None]}, "fields": {}, "shadow": False, "topLevel": True
    },
    "operator_join": {
        "block_name": "(join ()())", "block_type": "operator", "block_shape": "Reporter Block", "op_code": "operator_join",
        "functionality": "Concatenates two strings or values into a single string.",
        "inputs": {"STRING1": [1, [10, "apple "]], "STRING2": [1, [10, "banana"]]}, "fields": {}, "shadow": False, "topLevel": True
    },
    "operator_letterof": {
        "block_name": "letter () of ()", "block_type": "operator", "block_shape": "Reporter Block", "op_code": "operator_letterof",
        "functionality": "Reports the character at a specific numerical position within a string.",
        "inputs": {"LETTER": [1, [6, "1"]], "STRING": [1, [10, "apple"]]}, "fields": {}, "shadow": False, "topLevel": True
    },
    "operator_length": {
        "block_name": "(length of ())", "block_type": "operator", "block_shape": "Reporter Block", "op_code": "operator_length",
        "functionality": "Reports the total number of characters in a given string.",
        "inputs": {"STRING": [1, [10, "apple"]]}, "fields": {}, "shadow": False, "topLevel": True
    },
    "operator_contains": {
        "block_name": "<() contains ()?>", "block_type": "operator", "block_shape": "Boolean Block", "op_code": "operator_contains",
        "functionality": "Checks if one string contains another string.",
        "inputs": {"STRING1": [1, [10, "apple"]], "STRING2": [1, [10, "a"]]}, "fields": {}, "shadow": False, "topLevel": True
    },
    "operator_mod": {
        "block_name": "(() mod ())", "block_type": "operator", "block_shape": "Reporter Block", "op_code": "operator_mod",
        "functionality": "Reports the remainder when the first number is divided by the second.",
        "inputs": {"NUM1": [1, [4, ""]], "NUM2": [1, [4, ""]]}, "fields": {}, "shadow": False, "topLevel": True
    },
    "operator_round": {
        "block_name": "(round ())", "block_type": "operator", "block_shape": "Reporter Block", "op_code": "operator_round",
        "functionality": "Rounds a numerical value to the nearest integer.",
        "inputs": {"NUM": [1, [4, ""]]}, "fields": {}, "shadow": False, "topLevel": True
    },
    "operator_mathop": {
        "block_name": "(() of ())", "block_type": "operator", "block_shape": "Reporter Block", "op_code": "operator_mathop",
        "functionality": "Performs various mathematical functions (e.g., absolute value, square root, trigonometric functions).",
        "inputs": {"NUM": [1, [4, ""]]}, "fields": {"OPERATOR": ["abs", None]}, "shadow": False, "topLevel": True
    },

    # sensing_block.json
    "sensing_touchingobject": {
        "block_name": "<touching [edge v]?>", "block_type": "Sensing", "op_code": "sensing_touchingobject", "block_shape": "Boolean Block",
        "functionality": "Checks if its sprite is touching the mouse-pointer, edge, or another specified sprite.",
        "inputs": {"TOUCHINGOBJECTMENU": [1, "sensing_touchingobjectmenu"]}, "fields": {}, "shadow": False, "topLevel": True
    },
    "sensing_touchingobjectmenu": {
        "block_name": "touching object menu", "block_type": "Sensing", "block_shape": "Reporter Block", "op_code": "sensing_touchingobjectmenu",
        "functionality": "Menu for touching object block.",
        "inputs": {}, "fields": {"TOUCHINGOBJECTMENU": ["_mouse_", None]}, "shadow": True, "topLevel": False
    },
    "sensing_touchingcolor": {
        "block_name": "<touching color ()?>", "block_type": "Sensing", "op_code": "sensing_touchingcolor", "block_shape": "Boolean Block",
        "functionality": "Checks whether its sprite is touching a specified color.",
        "inputs": {"COLOR": [1, [9, "#55b888"]]}, "fields": {}, "shadow": False, "topLevel": True
    },
    "sensing_coloristouchingcolor": {
        "block_name": "<color () is touching ()?>", "block_type": "Sensing", "op_code": "sensing_coloristouchingcolor", "block_shape": "Boolean Block",
        "functionality": "Checks whether a specific color on its sprite is touching another specified color on the stage or another sprite.",
        "inputs": {"COLOR1": [1, [9, "#d019f2"]], "COLOR2": [1, [9, "#2b0de3"]]}, "fields": {}, "shadow": False, "topLevel": True
    },
    "sensing_askandwait": {
        "block_name": "Ask () and Wait", "block_type": "Sensing", "block_shape": "Stack Block", "op_code": "sensing_askandwait",
        "functionality": "Displays an input box with specified text at the bottom of the screen, allowing users to input text, which is stored in the 'Answer' block.",
        "inputs": {"QUESTION": [1, [10, "What's your name?"]]}, "fields": {}, "shadow": False, "topLevel": True
    },
    "sensing_answer": {
        "block_name": "(answer)", "block_type": "Sensing", "block_shape": "Reporter Block", "op_code": "sensing_answer",
        "functionality": "Holds the most recent text inputted using the 'Ask () and Wait' block.",
        "inputs": {}, "fields": {}, "shadow": False, "topLevel": True
    },
    "sensing_keypressed": {
        "block_name": "<key () pressed?>", "block_type": "Sensing", "op_code": "sensing_keypressed", "block_shape": "Boolean Block",
        "functionality": "Checks if a specified keyboard key is currently being pressed.",
        "inputs": {"KEY_OPTION": [1, "sensing_keyoptions"]}, "fields": {}, "shadow": False, "topLevel": True
    },
    "sensing_keyoptions": {
        "block_name": "key options menu", "block_type": "Sensing", "block_shape": "Reporter Block", "op_code": "sensing_keyoptions",
        "functionality": "Menu for key pressed block.",
        "inputs": {}, "fields": {"KEY_OPTION": ["space", None]}, "shadow": True, "topLevel": False
    },
    "sensing_mousedown": {
        "block_name": "<mouse down?>", "block_type": "Sensing", "op_code": "sensing_mousedown", "block_shape": "Boolean Block",
        "functionality": "Checks if the computer mouse's primary button is being clicked while the cursor is over the stage.",
        "inputs": {}, "fields": {}, "shadow": False, "topLevel": True
    },
    "sensing_mousex": {
        "block_name": "(mouse x)", "block_type": "Sensing", "block_shape": "Reporter Block", "op_code": "sensing_mousex",
        "functionality": "Reports the mouse-pointer’s current X position on the stage.",
        "inputs": {}, "fields": {}, "shadow": False, "topLevel": True
    },
    "sensing_mousey": {
        "block_name": "(mouse y)", "block_type": "Sensing", "block_shape": "Reporter Block", "op_code": "sensing_mousey",
        "functionality": "Reports the mouse-pointer’s current Y position on the stage.",
        "inputs": {}, "fields": {}, "shadow": False, "topLevel": True
    },
    "sensing_setdragmode": {
        "block_name": "set drag mode [draggable v]", "block_type": "Sensing", "block_shape": "Stack Block", "op_code": "sensing_setdragmode",
        "functionality": "Sets whether the sprite can be dragged by the mouse on the stage.",
        "inputs": {}, "fields": {"DRAG_MODE": ["draggable", None]}, "shadow": False, "topLevel": True
    },
    "sensing_loudness": {
        "block_name": "(loudness)", "block_type": "Sensing", "block_shape": "Reporter Block", "op_code": "sensing_loudness",
        "functionality": "Reports the loudness of noise received by a microphone on a scale of 0 to 100.",
        "inputs": {}, "fields": {}, "shadow": False, "topLevel": True
    },
    "sensing_timer": {
        "block_name": "(timer)", "block_type": "Sensing", "block_shape": "Reporter Block", "op_code": "sensing_timer",
        "functionality": "Reports the elapsed time since Scratch was launched or the timer was reset, increasing by 1 every second.",
        "inputs": {}, "fields": {}, "shadow": False, "topLevel": True
    },
    "sensing_resettimer": {
        "block_name": "Reset Timer", "block_type": "Sensing", "block_shape": "Stack Block", "op_code": "sensing_resettimer",
        "functionality": "Sets the timer’s value back to 0.0.",
        "inputs": {}, "fields": {}, "shadow": False, "topLevel": True
    },
    "sensing_of": {
        "block_name": "(() of ())", "block_type": "Sensing", "block_shape": "Reporter Block", "op_code": "sensing_of",
        "functionality": "Reports a specified value (e.g., x position, direction, costume number) of a specified sprite or the Stage to be accessed in current sprite or stage.",
        "inputs": {"OBJECT": [1, "sensing_of_object_menu"]}, "fields": {"PROPERTY": ["backdrop #", None]}, "shadow": False, "topLevel": True
    },
    "sensing_of_object_menu": {
        "block_name": "of object menu", "block_type": "Sensing", "block_shape": "Reporter Block", "op_code": "sensing_of_object_menu",
        "functionality": "Menu for of block.",
        "inputs": {}, "fields": {"OBJECT": ["_stage_", None]}, "shadow": True, "topLevel": False
    },
    "sensing_current": {
        "block_name": "(current ())", "block_type": "Sensing", "block_shape": "Reporter Block", "op_code": "sensing_current",
        "functionality": "Reports the current local year, month, date, day of the week, hour, minutes, or seconds.",
        "inputs": {}, "fields": {"CURRENTMENU": ["YEAR", None]}, "shadow": False, "topLevel": True
    },
    "sensing_dayssince2000": {
        "block_name": "(days since 2000)", "block_type": "Sensing", "block_shape": "Reporter Block", "op_code": "sensing_dayssince2000",
        "functionality": "Reports the number of days (and fractions of a day) since 00:00:00 UTC on January 1, 2000.",
        "inputs": {}, "fields": {}, "shadow": False, "topLevel": True
    },
    "sensing_username": {
        "block_name": "(username)", "block_type": "Sensing", "block_shape": "Reporter Block", "op_code": "sensing_username",
        "functionality": "Reports the username of the user currently logged into Scratch. If no user is logged in, it reports nothing.",
        "inputs": {}, "fields": {}, "shadow": False, "topLevel": True
    },

    # sound_block.json
    "sound_playuntildone": {
        "block_name": "play sound () until done", "block_type": "Sound", "block_shape": "Stack Block", "op_code": "sound_playuntildone",
        "functionality": "Plays a specified sound and pauses the script's execution until the sound has completed.",
        "inputs": {"SOUND_MENU": [1, "sound_sounds_menu"]}, "fields": {}, "shadow": False, "topLevel": True
    },
    "sound_sounds_menu": {
        "block_name": "sound menu", "block_type": "Sound", "block_shape": "Reporter Block", "op_code": "sound_sounds_menu",
        "functionality": "Menu for sound blocks.",
        "inputs": {}, "fields": {"SOUND_MENU": ["Meow", None]}, "shadow": True, "topLevel": False
    },
    "sound_play": {
        "block_name": "start sound ()", "block_type": "Sound", "block_shape": "Stack Block", "op_code": "sound_play",
        "functionality": "Initiates playback of a specified sound without pausing the script, allowing other actions to proceed concurrently.",
        "inputs": {"SOUND_MENU": [1, "sound_sounds_menu"]}, "fields": {}, "shadow": False, "topLevel": True
    },
    "sound_stopallsounds": {
        "block_name": "stop all sounds", "block_type": "Sound", "block_shape": "Stack Block", "op_code": "sound_stopallsounds",
        "functionality": "Stops all currently playing sounds.",
        "inputs": {}, "fields": {}, "shadow": False, "topLevel": True
    },
    "sound_changeeffectby": {
        "block_name": "change () effect by ()", "block_type": "Sound", "block_shape": "Stack Block", "op_code": "sound_changeeffectby",
        "functionality": "Changes the project's sound effect by a specified amount.",
        "inputs": {"VALUE": [1, [4, "10"]]}, "fields": {"EFFECT": ["PITCH", None]}, "shadow": False, "topLevel": True
    },
    "sound_seteffectto": {
        "block_name": "set () effect to ()", "block_type": "Sound", "block_shape": "Stack Block", "op_code": "sound_seteffectto",
        "functionality": "Sets the sound effect to a specific value.",
        "inputs": {"VALUE": [1, [4, "100"]]}, "fields": {"EFFECT": ["PITCH", None]}, "shadow": False, "topLevel": True
    },
    "sound_cleareffects": {
        "block_name": "clear sound effects", "block_type": "Sound", "block_shape": "Stack Block", "op_code": "sound_cleareffects",
        "functionality": "Removes all sound effects applied to the sprite.",
        "inputs": {}, "fields": {}, "shadow": False, "topLevel": True
    },
    "sound_changevolumeby": {
        "block_name": "change volume by ()", "block_type": "Sound", "block_shape": "Stack Block", "op_code": "sound_changevolumeby",
        "functionality": "Changes the project's sound volume by a specified amount.",
        "inputs": {"VOLUME": [1, [4, "-10"]]}, "fields": {}, "shadow": False, "topLevel": True
    },
    "sound_setvolumeto": {
        "block_name": "set volume to () %", "block_type": "Sound", "block_shape": "Stack Block", "op_code": "sound_setvolumeto",
        "functionality": "Sets the sound volume to a specific percentage (0-100).",
        "inputs": {"VOLUME": [1, [4, "100"]]}, "fields": {}, "shadow": False, "topLevel": True
    },
    "sound_volume": {
        "block_name": "(volume)", "block_type": "Sound", "block_shape": "Reporter Block", "op_code": "sound_volume",
        "functionality": "Reports the current volume level of the sprite.",
        "inputs": {}, "fields": {}, "shadow": False, "topLevel": True
    },
}

# Example input with opcodes for the initial generation
initial_opcode_counts = [
    {"opcode":"event_whenflagclicked","count":1},
    {"opcode":"motion_gotoxy","count":1},
    {"opcode":"motion_glidesecstoxy","count":1},
    {"opcode":"motion_xposition","count":1},
    {"opcode":"motion_setx","count":1},
    {"opcode":"control_forever","count":1},
    {"opcode":"control_if","count":1},
    {"opcode":"control_stop","count":1},
    {"opcode":"operator_lt","count":1},
    {"opcode":"sensing_touchingobject","count":1}, # Changed from sensing_istouching
    {"opcode":"sensing_touchingobjectmenu","count":1},
    {"opcode":"event_broadcast","count":1},
    {"opcode":"data_setvariableto","count":2},
    {"opcode":"data_showvariable","count":2},
]

# Generate the initial blocks and get the opcode_occurrences
generated_output_json, initial_opcode_occurrences = generate_blocks_from_opcodes(initial_opcode_counts, all_block_definitions)

# Pseudo-code to interpret
pseudo_code_input = """
when green flag clicked
  go to x: (240) y: (-135)
  set [score v] to (1)
  set [speed v] to (1)
  show variable [score v]
  show variable [speed v]
  forever
    glide (2) seconds to x: (-240) y: (-135)
    if <((x position)) < (-235)> then
      set x to (240)
    end
    if <touching [Sprite1 v]?> then
      broadcast [Game Over v]
      stop [all v]
    end
  end
end
"""

# Interpret the pseudo-code and update the blocks, passing opcode_occurrences
final_generated_blocks = interpret_pseudo_code_and_update_blocks(generated_output_json, pseudo_code_input, all_block_definitions, initial_opcode_occurrences)

print(initial_opcode_occurrences)

#print(json.dumps(final_generated_blocks, indent=2))
# ```json
# {
#   "event_whenflagclicked_1": {
#     "block_name": "when green flag pressed",
#     "block_type": "Events",
#     "op_code": "event_whenflagclicked",
#     "block_shape": "Hat Block",
#     "functionality": "This Hat block initiates the script when the green flag is clicked, serving as the common starting point for most Scratch projects.",
#     "inputs": {},
#     "fields": {},
#     "shadow": false,
#     "topLevel": true,
#     "parent": null,
#     "next": "motion_gotoxy_1"
#   },
#   "motion_gotoxy_1": {
#     "block_name": "go to x: () y: ()",
#     "block_type": "Motion",
#     "op_code": "motion_gotoxy",
#     "functionality": "Moves the sprite to the specified X and Y coordinates on the stage.",
#     "inputs": {
#       "X": [
#         4,
#         "240"
#       ],
#       "Y": [
#         4,
#         "-135"
#       ]
#     },
#     "fields": {},
#     "shadow": false,
#     "topLevel": false,
#     "parent": null,
#     "next": "data_setvariableto_1"
#   },
#   "motion_glidesecstoxy_1": {
#     "block_name": "glide () secs to x: () y: ()",
#     "block_type": "Motion",
#     "op_code": "motion_glidesecstoxy",
#     "functionality": "Glides the sprite smoothly to the specified X and Y coordinates over a given number of seconds.",
#     "inputs": {
#       "SECS": [
#         4,
#         "2"
#       ],
#       "X": [
#         4,
#         "-240"
#       ],
#       "Y": [
#         4,
#         "-135"
#       ]
#     },
#     "fields": {},
#     "shadow": false,
#     "topLevel": false,
#     "parent": "control_forever_1",
#     "next": "control_if_1"
#   },
#   "motion_xposition_1": {
#     "block_name": "(x position)",
#     "block_type": "Motion",
#     "op_code": "motion_xposition",
#     "functionality": "Reports the current X-coordinate of the sprite.[NOTE: not used in stage/backdrops]",
#     "inputs": {},
#     "fields": {},
#     "shadow": true,
#     "topLevel": false,
#     "parent": "operator_lt_1",
#     "next": null
#   },
#   "motion_setx_1": {
#     "block_name": "set x to ()",
#     "block_type": "Motion",
#     "op_code": "motion_setx",
#     "functionality": "Sets the sprite's X-coordinate to a specific value, placing it at a precise horizontal position.",
#     "inputs": {
#       "X": [
#         4,
#         "240"
#       ]
#     },
#     "fields": {},
#     "shadow": false,
#     "topLevel": false,
#     "parent": "control_if_1",
#     "next": null
#   },
#   "control_forever_1": {
#     "block_name": "forever",
#     "block_type": "Control",
#     "op_code": "control_forever",
#     "functionality": "Continuously runs the blocks inside it.",
#     "inputs": {
#       "SUBSTACK": [
#         2,
#         "motion_glidesecstoxy_1"
#       ]
#     },
#     "fields": {},
#     "shadow": false,
#     "topLevel": false,
#     "parent": null,
#     "next": null
#   },
#   "control_if_1": {
#     "block_name": "if <> then",
#     "block_type": "Control",
#     "op_code": "control_if",
#     "functionality": "Executes the blocks inside it only if the specified boolean condition is true. [NOTE: it takes boolean blocks as input]",
#     "inputs": {
#       "CONDITION": [
#         2,
#         "operator_lt_1"
#       ],
#       "SUBSTACK": [
#         2,
#         "motion_setx_1"
#       ]
#     },
#     "fields": {},
#     "shadow": false,
#     "topLevel": false,
#     "parent": "control_forever_1",
#     "next": "control_if_2"
#   },
#   "control_stop_1": {
#     "block_name": "stop [v]",
#     "block_type": "Control",
#     "op_code": "control_stop",
#     "functionality": "Halts all scripts, only the current script, or other scripts within the same sprite. Its shape can dynamically change based on the selected option.",
#     "inputs": {},
#     "fields": {
#       "STOP_OPTION": [
#         "all",
#         null
#       ]
#     },
#     "shadow": false,
#     "topLevel": false,
#     "parent": "control_if_2",
#     "mutation": {
#       "tagName": "mutation",
#       "children": [],
#       "hasnext": "false"
#     },
#     "next": null
#   },
#   "operator_lt_1": {
#     "block_name": "<() < ()>",
#     "block_type": "operator",
#     "op_code": "operator_lt",
#     "functionality": "Checks if the first value is less than the second.",
#     "inputs": {
#       "OPERAND1": [
#         1,
#         "motion_xposition_1"
#       ],
#       "OPERAND2": [
#         4,
#         "-235"
#       ]
#     },
#     "fields": {},
#     "shadow": true,
#     "topLevel": false,
#     "parent": "control_if_1",
#     "next": null
#   },
#   "sensing_touchingobject_1": {
#     "block_name": "<touching [edge v]?>",
#     "block_type": "Sensing",
#     "op_code": "sensing_touchingobject",
#     "functionality": "Checks if its sprite is touching the mouse-pointer, edge, or another specified sprite.",
#     "inputs": {
#       "TOUCHINGOBJECTMENU": [
#         1,
#         "sensing_touchingobjectmenu_1"
#       ]
#     },
#     "fields": {},
#     "shadow": true,
#     "topLevel": false,
#     "parent": "control_if_2",
#     "next": null
#   },
#   "sensing_touchingobjectmenu_1": {
#     "block_name": "touching object menu",
#     "block_type": "Sensing",
#     "op_code": "sensing_touchingobjectmenu",
#     "functionality": "Menu for touching object block.",
#     "inputs": {},
#     "fields": {
#       "TOUCHINGOBJECTMENU": [
#         "Sprite1",
#         null
#       ]
#     },
#     "shadow": true,
#     "topLevel": false,
#     "parent": "sensing_touchingobject_1",
#     "next": null
#   },
#   "event_broadcast_1": {
#     "block_name": "broadcast ()",
#     "block_type": "Events",
#     "op_code": "event_broadcast",
#     "functionality": "Sends a broadcast message throughout the Scratch program, activating any 'when I receive ()' blocks that are set to listen for that message, enabling indirect communication.",
#     "inputs": {
#       "BROADCAST_INPUT": [
#         10,
#         "Game Over"
#       ]
#     },
#     "fields": {},
#     "shadow": false,
#     "topLevel": false,
#     "parent": "control_if_2",
#     "next": "control_stop_1"
#   },
#   "data_setvariableto_1": {
#     "block_name": "set [my variable v] to ()",
#     "block_type": "Data",
#     "op_code": "data_setvariableto",
#     "functionality": "Assigns a specific value (number, string, or boolean) to a variable.",
#     "inputs": {
#       "VALUE": [
#         4,
#         "1"
#       ]
#     },
#     "fields": {
#       "VARIABLE": [
#         "score",
#         "`var_score"
#       ]
#     },
#     "shadow": false,
#     "topLevel": false,
#     "parent": null,
#     "next": "data_setvariableto_2"
#   },
#   "data_setvariableto_2": {
#     "block_name": "set [my variable v] to ()",
#     "block_type": "Data",
#     "op_code": "data_setvariableto",
#     "functionality": "Assigns a specific value (number, string, or boolean) to a variable.",
#     "inputs": {
#       "VALUE": [
#         4,
#         "1"
#       ]
#     },
#     "fields": {
#       "VARIABLE": [
#         "speed",
#         "`var_speed"
#       ]
#     },
#     "shadow": false,
#     "topLevel": false,
#     "parent": null,
#     "next": "data_showvariable_1"
#   },
#   "data_showvariable_1": {
#     "block_name": "show variable [my variable v]",
#     "block_type": "Data",
#     "op_code": "data_showvariable",
#     "functionality": "Makes a variable's monitor visible on the stage.",
#     "inputs": {},
#     "fields": {
#       "VARIABLE": [
#         "score",
#         "`var_score"
#       ]
#     },
#     "shadow": false,
#     "topLevel": false,
#     "parent": null,
#     "next": "data_showvariable_2"
#   },
#   "data_showvariable_2": {
#     "block_name": "show variable [my variable v]",
#     "block_type": "Data",
#     "op_code": "data_showvariable",
#     "functionality": "Makes a variable's monitor visible on the stage.",
#     "inputs": {},
#     "fields": {
#       "VARIABLE": [
#         "speed",
#         "`var_speed"
#       ]
#     },
#     "shadow": false,
#     "topLevel": false,
#     "parent": null,
#     "next": "control_forever_1"
#   },
#   "control_if_2": {
#     "block_name": "if <> then",
#     "block_type": "Control",
#     "op_code": "control_if",
#     "functionality": "Executes the blocks inside it only if the specified boolean condition is true. [NOTE: it takes boolean blocks as input]",
#     "inputs": {
#       "CONDITION": [
#         2,
#         "sensing_touchingobject_1"
#       ],
#       "SUBSTACK": [
#         2,
#         "event_broadcast_1"
#       ]
#     },
#     "fields": {},
#     "shadow": false,
#     "topLevel": false,
#     "parent": "control_forever_1",
#     "next": null
#   }
# }