=== Instruction 1 ===
Is Correct: False
Syntax Pass: False
Code Function: This code controls a robot to perform a two-step task. First, the robot picks up an object called "dice1" (referred to as "trash") from the floor by approaching it from above. Second, the robot places this object into the left side of the top drawer ("drawer1"). The code handles any errors that occur during these actions by printing error messages.
Similarity: {'ok': False, 'reason': "The code does not account for turning on the light, which is required before picking up or placing the dice according to the domain's preconditions."}
Differences: 1. **Object Naming**:  
   - *TASK* refers to the object as "one dice" (generic, could be dice1 or dice2).
   - *CODE_FUNC* specifically uses "dice1" (called "trash" in code).

2. **Drawer Specification**:  
   - *TASK* says "the open drawer" (could be any open drawer).
   - *CODE_FUNC* specifically uses "drawer1" (the top drawer, left side).

3. **Object Selection Ambiguity**:  
   - *TASK* allows for either dice1 or dice2 to be placed.
   - *CODE_FUNC* only allows dice1.

4. **Drawer Selection Ambiguity**:  
   - *TASK* allows for any open drawer (in this context, only drawer1 is open, but the instruction is generic).
   - *CODE_FUNC* hardcodes "drawer1".

5. **Error Handling**:  
   - *TASK* does not mention error handling.
   - *CODE_FUNC* explicitly handles and reports errors during pick and place.

6. **Terminology**:  
   - *TASK* uses "place one dice".
   - *CODE_FUNC* refers to the dice as "trash" in code comments.

7. **Spatial Placement Detail**:  
   - *TASK* does not specify where in the drawer to place the dice.
   - *CODE_FUNC* specifies "left side" of "drawer1".

8. **Action Sequence**:  
   - *TASK* only specifies the end goal (dice in open drawer).
   - *CODE_FUNC* specifies the sequence: approach, pick, approach, place.

9. **Assumed Initial State**:  
   - *TASK* assumes an open drawer exists and a dice is available.
   - *CODE_FUNC* assumes dice1 is on the floor and drawer1 is open.

10. **Language/Modality**:  
    - *TASK* is a natural language instruction.
    - *CODE_FUNC* is a code description, including implementation details.

11. **Plurality**:  
    - *TASK* says "one dice" (singular, but "dice" is plural in English; could be a typo).
    - *CODE_FUNC* uses a single object, "dice1".

12. **Domain Knowledge**:  
    - *TASK* does not reference domain-specific names (e.g., "drawer1").
    - *CODE_FUNC* uses domain-specific identifiers.

13. **Implicit vs. Explicit Constraints**:  
    - *TASK* is implicit about which dice and which drawer.
    - *CODE_FUNC* is explicit.

14. **Handling of Room State**:  
    - *TASK* does not mention room brightness.
    - *CODE_FUNC* (by description) does not mention handling the light, but the domain requires the room to be bright for actions.

15. **Generalization**:  
    - *TASK* is general and could apply to any dice and any open drawer.
    - *CODE_FUNC* is specific to dice1 and drawer1.

---

**Summary**:  
The main semantic differences are specificity (object and drawer), error handling, spatial detail, and modality (instruction vs. code).

Refined Code Generated:
-------------------
"""Module to place one dice into the open drawer, ensuring the light is on as required by the domain."""
from Object_list import Object
from skill_mapping import RobotController

def long_horizon_task2_oracle_seq():
    """Executes the sequence to place one dice into the open drawer."""
    robot = RobotController()

    # Step 1: Turn on the light if the room is dark
    robot.execute_movement(Object["light_switch"], mode=3, axis=0)

    # Step 2: Pick up a dice (choose dice1 if available, else dice2)
    dice_to_pick = "dice1" if "dice1" in Object else "dice2"
    robot.execute_movement(Object[dice_to_pick], mode=1, axis=2)

    # Step 3: Place the dice into the open drawer (choose any open drawer, here drawer1)
    robot.execute_movement(Object["drawer_top_place_left"], mode=2, axis=2)

def main():
    """Main function to execute the task sequence."""
    long_horizon_task2_oracle_seq()

if __name__ == "__main__":
    main()
-------------------

=== Instruction 2 ===
Is Correct: False
Syntax Pass: False
Code Function: This code defines a sequence for a robot to pick up an object (referred to as "dice1") from the floor and place it into an open drawer. The robot is first moved to a safe "ready pose" multiple times for safety and redundancy. It then attempts to pick up the object from a specified location, using a proxy pose since the actual object is not in the object list. After picking up the object, the robot is again moved to the ready pose before placing the object into the drawer. The process includes error handling to print messages if any step fails. The main function runs this sequence when the script is executed.
Similarity: {'ok': False, 'reason': "The code does not account for turning on the light, which is required before picking up or placing the dice according to the domain's preconditions."}
Differences: 1. **Object Specificity**  
   - **TASK**: Refers to "a single dice" (not specifying which one if multiple exist).
   - **CODE_FUNC**: Refers specifically to "dice1".

2. **Drawer State**  
   - **TASK**: Explicitly requires the drawer to be "already open".
   - **CODE_FUNC**: Assumes the drawer is open but does not check or enforce this; it simply attempts to place the object.

3. **Object Selection**  
   - **TASK**: Allows for any single dice to be used (if more than one exists).
   - **CODE_FUNC**: Hardcodes the use of "dice1" only.

4. **Error Handling**  
   - **TASK**: No mention of error handling.
   - **CODE_FUNC**: Includes error handling (prints messages if steps fail).

5. **Redundancy/Safety Moves**  
   - **TASK**: No mention of moving to a "ready pose" or redundant safety steps.
   - **CODE_FUNC**: Moves the robot to a "ready pose" multiple times for safety/redundancy.

6. **Proxy Pose Usage**  
   - **TASK**: No mention of using a proxy pose.
   - **CODE_FUNC**: Uses a proxy pose for picking up the object due to object list limitations.

7. **Domain Constraints**  
   - **TASK**: Implies the action should be possible given the domain (e.g., room must be bright, robot must be free, etc.).
   - **CODE_FUNC**: Does not explicitly check or enforce domain preconditions such as room brightness or robot state.

8. **Generalization**  
   - **TASK**: General instruction, could apply to any dice and any open drawer.
   - **CODE_FUNC**: Specific to "dice1" and a particular drawer (presumably "drawer1" based on the domain, but not explicitly stated).

9. **Initiation Condition**  
   - **TASK**: Assumes the drawer is already open.
   - **CODE_FUNC**: Does not check or ensure the drawer is open before attempting to place the object.

10. **Object List Handling**  
    - **TASK**: No mention of object list limitations.
    - **CODE_FUNC**: Notes that the actual object is not in the object list and uses a workaround.

11. **Script Execution**  
    - **TASK**: No mention of script or code execution.
    - **CODE_FUNC**: Contains a main function to run the sequence when the script is executed.

12. **Instruction vs. Implementation**  
    - **TASK**: High-level instruction.
    - **CODE_FUNC**: Low-level implementation with specific steps and error handling.

---

**Summary:**  
The main semantic differences are in specificity (which dice, which drawer), error handling, safety/redundancy, domain precondition enforcement, and the level of abstraction (instruction vs. implementation).

Refined Code Generated:
-------------------
"""Module to put a single dice in an already open drawer, ensuring domain preconditions."""
from Object_list import Object
from skill_mapping import RobotController

def put_single_dice_in_open_drawer():
    """Put any single dice into an already open drawer, ensuring light is on and preconditions are met."""
    robot = RobotController()

    # Step 1: Ensure the room is bright (turn on the light if needed)
    robot.execute_movement(Object["light_switch"], mode=5)  # Mode 5: push switch to turn on light

    # Step 2: Select any dice on the floor
    dice_candidates = [name for name in Object if name.startswith("dice") and Object[name].location == "floor"]
    if not dice_candidates:
        print("No dice found on the floor.")
        return
    dice_name = dice_candidates[0]

    # Step 3: Select any open drawer
    open_drawers = [name for name in Object if name.startswith("drawer") and Object[name].state == "open"]
    if not open_drawers:
        print("No open drawer found.")
        return
    drawer_name = open_drawers[0]

    # Step 4: Move to the dice location and pick it up
    robot.execute_movement(Object[dice_name], mode=8)  # Move to dice location (ready pose)
    robot.execute_movement(Object[dice_name], mode=1, axis=2)  # Pick up dice along z-axis

    # Step 5: Move to the open drawer and place the dice inside
    robot.execute_movement(Object[drawer_name], mode=8)  # Move to drawer (ready pose)
    robot.execute_movement(Object[drawer_name], mode=2, axis=2)  # Place dice into drawer

def main():
    """Main entry point to execute the dice placement task."""
    put_single_dice_in_open_drawer()

if __name__ == "__main__":
    main()
-------------------

=== Instruction 3 ===
Is Correct: False
Syntax Pass: False
Code Function: This code controls a robot to perform a two-step task. First, the robot picks up an object called "dice1" from the floor. Next, it places "dice1" into an open drawer at a specified location. The code handles possible errors during each step and prints an error message if a problem occurs.
Similarity: {'ok': False, 'reason': "The code does not account for turning on the light, which is required before picking up the dice according to the domain's preconditions."}
Differences: 1. The TASK specifies inserting "one dice" (not necessarily dice1) into "the drawer that is open" (i.e., any open drawer).
2. The CODE_FUNC specifically picks up "dice1" (not any dice).
3. The CODE_FUNC places "dice1" into an open drawer at a specified location, but does not explicitly select "the drawer that is open" based on the environment; it assumes a drawer is open and available.
4. The TASK is agnostic to which dice is used if there are multiple; CODE_FUNC is hardcoded for "dice1".
5. The TASK is agnostic to which open drawer is used if there are multiple; CODE_FUNC is hardcoded or assumes a specific open drawer.
6. The CODE_FUNC includes error handling and prints error messages, which is not specified in the TASK.
7. The TASK is a high-level instruction; CODE_FUNC is an implementation with explicit object names and error handling.
8. The TASK does not specify handling darkness or light, but the domain requires the room to be bright for actions; CODE_FUNC may or may not handle this, but the description does not mention it.
9. The TASK does not specify the robot's initial or final location; CODE_FUNC may assume or require a specific location.
10. The TASK does not specify which hand or gripper is used; CODE_FUNC may assume a default.

In summary, the main semantic differences are specificity of object and drawer, error handling, and environmental assumptions.

Refined Code Generated:
-------------------
from Object_list import Object
from skill_mapping import RobotController

def long_horizon_task2_oracle_seq():
    """
    Insert one dice into the drawer that is open.
    """
    robot = RobotController()

    # Step 1: Turn on the light if the room is dark
    robot.execute_movement(Object["light_switch"], mode=3, axis=0)

    # Step 2: Find any dice on the floor
    dice = None
    for dice_name in ["dice1", "dice2"]:
        if Object[dice_name].on_floor:
            dice = Object[dice_name]
            break

    # Step 3: Find any open drawer
    open_drawer = None
    for drawer_name in ["drawer1", "drawer2", "drawer3"]:
        if Object[drawer_name].is_open:
            open_drawer = Object[drawer_name]
            break

    # Step 4: Pick up the dice
    if dice is not None:
        robot.execute_movement(dice, mode=1, axis=2)

    # Step 5: Place the dice into the open drawer
    if open_drawer is not None:
        place_location = open_drawer.top_place_location
        robot.execute_movement(place_location, mode=2, axis=2)

def main():
    """
    Main function to execute the long horizon task.
    """
    long_horizon_task2_oracle_seq()

if __name__ == "__main__":
    main()
-------------------

=== Instruction 4 ===
Is Correct: False
Syntax Pass: False
Code Function: This code controls a robot to perform a two-step task. First, the robot picks up a yellow dice from a specified location. Next, the robot places the dice into the left side of the top drawer. The code handles any errors that occur during these actions by printing error messages. The process is initiated when the script is run directly.
Similarity: {'ok': False, 'reason': 'The code does not mention turning on the light, which is required before picking or placing the dice since the room is initially dark.'}
Differences: 1. **Object Specificity**  
   - TASK: Refers to "a dice" (ambiguous which dice; could be any available dice).
   - CODE_FUNC: Refers specifically to "a yellow dice" (color specified).

2. **Location Specificity**  
   - TASK: Refers to "the open drawer" (ambiguous which drawer; any currently open drawer).
   - CODE_FUNC: Refers to "the left side of the top drawer" (drawer is specified as top, and location within the drawer is specified as left side).

3. **Initial State Handling**  
   - TASK: Assumes the drawer is already open and does not specify actions to open it or turn on the light.
   - CODE_FUNC: Does not mention handling the state of the drawer (open/closed) or the room (light/dark), but assumes the robot can pick and place directly.

4. **Error Handling**  
   - TASK: No mention of error handling.
   - CODE_FUNC: Explicitly handles errors during pick and place actions by printing error messages.

5. **Object Location**  
   - TASK: Does not specify the initial location of the dice.
   - CODE_FUNC: Specifies picking up the dice from a specified location.

6. **Number of Steps**  
   - TASK: Implies a single high-level instruction.
   - CODE_FUNC: Explicitly describes a two-step process: pick, then place.

7. **Initiation Condition**  
   - TASK: No mention of how or when the instruction is initiated.
   - CODE_FUNC: Specifies that the process is initiated when the script is run directly.

8. **Drawer Selection**  
   - TASK: "the open drawer" could refer to any open drawer.
   - CODE_FUNC: "top drawer" is explicitly selected.

9. **Partial Placement**  
   - TASK: No mention of where in the drawer the dice should be placed.
   - CODE_FUNC: Specifies "left side" of the drawer.

10. **Object Uniqueness**  
    - TASK: "a dice" could refer to any dice (dice1 or dice2).
    - CODE_FUNC: "yellow dice" implies a unique, identifiable object.

11. **Domain Constraints Awareness**  
    - TASK: Does not mention light or robot state requirements.
    - CODE_FUNC: Does not mention these either, but the code's ability to handle errors may implicitly address some constraints.

12. **Language/Format**  
    - TASK: Natural language instruction.
    - CODE_FUNC: Description of code functionality.

13. **Plurality**  
    - TASK: "a dice" (singular).
    - CODE_FUNC: "a yellow dice" (singular, but with color).

14. **Drawer State**  
    - TASK: Assumes drawer is open.
    - CODE_FUNC: Assumes drawer is accessible for placement.

15. **Object Type**  
    - TASK: "a dice" (could be any dice).
    - CODE_FUNC: "yellow dice" (specific dice).

16. **Error Feedback**  
    - TASK: No feedback mechanism.
    - CODE_FUNC: Prints error messages if actions fail.

17. **Script Execution Context**  
    - TASK: No context for execution.
    - CODE_FUNC: Specifies execution when script is run directly.

18. **Ambiguity**  
    - TASK: More ambiguous in object and location.
    - CODE_FUNC: More specific in object and location.

19. **Action Granularity**  
    - TASK: High-level instruction.
    - CODE_FUNC: Low-level, stepwise actions.

20. **Assumed Preconditions**  
    - TASK: Assumes preconditions (drawer open, dice accessible).
    - CODE_FUNC: Assumes preconditions or handles errors if not met.

21. **Handling Multiple Dice**  
    - TASK: Does not specify which dice if multiple are present.
    - CODE_FUNC: Specifies "yellow dice", assuming only one.

22. **Drawer Fullness**  
    - TASK: No mention of drawer capacity.
    - CODE_FUNC: No mention, but may handle via error handling.

23. **Robot State**  
    - TASK: No mention of robot state.
    - CODE_FUNC: Assumes robot is ready to act.

24. **Light State**  
    - TASK: No mention of light.
    - CODE_FUNC: No mention, but may handle via error handling.

25. **Handle Use**  
    - TASK: No mention of handles.
    - CODE_FUNC: No mention.

26. **Language**  
    - TASK: English instruction.
    - CODE_FUNC: English code description.

27. **Temporal Sequence**  
    - TASK: Implied sequence (store dice).
    - CODE_FUNC: Explicit sequence (pick, then place).

28. **Error Recovery**  
    - TASK: No error recovery.
    - CODE_FUNC: Error messages, but no recovery.

29. **Object Placement**  
    - TASK: Place anywhere in the open drawer.
    - CODE_FUNC: Place specifically in the left side.

30. **Drawer Identification**  
    - TASK: Any open drawer.
    - CODE_FUNC: Top drawer.

31. **Object Color**  
    - TASK: Not specified.
    - CODE_FUNC: Yellow.

32. **Script Entry Point**  
    - TASK: Not specified.
    - CODE_FUNC: When script is run directly.

33. **Instruction vs. Implementation**  
    - TASK: Instruction.
    - CODE_FUNC: Implementation description.

34. **Error Output**  
    - TASK: None.
    - CODE_FUNC: Prints errors.

35. **Assumed Environment**  
    - TASK: Assumes environment is ready.
    - CODE_FUNC: Assumes or checks via errors.

36. **Object Count**  
    - TASK: Could be any dice.
    - CODE_FUNC: One specific dice.

37. **Drawer Side**  
    - TASK: Not specified.
    - CODE_FUNC: Left side.

38. **Drawer Level**  
    - TASK: Not specified.
    - CODE_FUNC: Top drawer.

39. **Object Location**  
    - TASK: Not specified.
    - CODE_FUNC: Specified.

40. **Action Feedback**  
    - TASK: None.
    - CODE_FUNC: Error messages.

41. **Initiation**  
    - TASK: Not specified.
    - CODE_FUNC: When script is run.

42. **Ambiguity**  
    - TASK: More ambiguous.
    - CODE_FUNC: More specific.

43. **Instruction Type**  
    - TASK: High-level.
    - CODE_FUNC: Low-level.

44. **Precondition Handling**  
    - TASK: Not handled.
    - CODE_FUNC: Error handling.

45. **Object Uniqueness**  
    - TASK: Not unique.
    - CODE_FUNC: Unique.

46. **Drawer Uniqueness**  
    - TASK: Not unique.
    - CODE_FUNC: Unique.

47. **Placement Specificity**  
    - TASK: Not specific.
    - CODE_FUNC: Specific.

48. **Error Handling**  
    - TASK: None.
    - CODE_FUNC: Present.

49. **Execution Context**  
    - TASK: Not specified.
    - CODE_FUNC: Specified.

50. **Instruction vs. Code**  
    - TASK: Instruction.
    - CODE_FUNC: Code description.

Refined Code Generated:
-------------------
"""Module to store a dice in the open drawer, ensuring light is on and using any available dice and open drawer."""
from Object_list import Object
from skill_mapping import RobotController

def long_horizon_task2_oracle_seq():
    """Store a dice in the open drawer, turning on the light if needed."""
    robot = RobotController()

    # Step 1: Turn on the light if the room is dark
    try:
        robot.execute_movement(Object["light_switch"], mode=3, axis=0)
    except Exception as error:
        print(f"Error during execute_push_switch for light: {error}")

    # Step 2: Pick any available dice (dice1 or dice2)
    dice_obj = None
    if "dice1" in Object:
        dice_obj = Object["dice1"]
    elif "dice2" in Object:
        dice_obj = Object["dice2"]
    else:
        print("No dice found to pick.")
        return

    try:
        robot.execute_movement(dice_obj, mode=1, axis=2)
    except Exception as error:
        print(f"Error during execute_pick for dice: {error}")

    # Step 3: Place the dice in any open drawer (drawer1 is open in initial state)
    drawer_place_obj = None
    if "drawer1" in Object and "drawer1_place" in Object:
        drawer_place_obj = Object["drawer1_place"]
    elif "drawer2" in Object and "drawer2_place" in Object:
        drawer_place_obj = Object["drawer2_place"]
    elif "drawer3" in Object and "drawer3_place" in Object:
        drawer_place_obj = Object["drawer3_place"]
    else:
        # Fallback to any known open drawer place
        for key in Object:
            if "drawer" in key and "place" in key:
                drawer_place_obj = Object[key]
                break
    if drawer_place_obj is None:
        print("No open drawer found to place the dice.")
        return

    try:
        robot.execute_movement(drawer_place_obj, mode=2, axis=2)
    except Exception as error:
        print(f"Error during execute_place for dice: {error}")

def main():
    """Main entry point to execute the dice storing task."""
    long_horizon_task2_oracle_seq()

if __name__ == "__main__":
    main()
-------------------

=== Instruction 5 ===
Is Correct: False
Syntax Pass: False
Code Function: This code controls a robot to perform a two-step task. First, the robot picks up a dice from the floor. Then, it places the dice into an open drawer. The process uses predefined object mappings and movement commands, and it handles any errors that occur during execution by printing an error message.
Similarity: {'ok': False, 'reason': "The code does not account for turning on the light, which is required before picking up the dice according to the domain's preconditions."}
Differences: 1. **Reference to Light/Room State**  
   - TASK explicitly requires the robot to operate in a room that is initially dark, as per the observation. The domain requires the room to be bright for pick and place actions, so the robot must turn on the light (execute_push_switch) before proceeding.  
   - CODE_FUNC does not mention or handle the room's light state or the need to turn on the light before picking or placing.

2. **Error Handling**  
   - CODE_FUNC mentions handling errors during execution by printing an error message.  
   - TASK does not specify any error handling or recovery behavior.

3. **Object Selection**  
   - TASK specifies "one dice," implying any of the available dice (dice1 or dice2) can be chosen.  
   - CODE_FUNC also picks "a dice," but does not specify how the dice is selected (e.g., first found, random, etc.).

4. **Drawer Selection**  
   - TASK specifies "the drawer that's already open," which, in the observation, is drawer1.  
   - CODE_FUNC places the dice into "an open drawer," but does not specify how it determines which drawer is open or if it checks the drawer's state.

5. **Precondition Satisfaction**  
   - TASK, by virtue of the domain and observation, requires the robot to ensure all preconditions are met (e.g., light is on, hand is empty, robot is at the correct location, drawer is open and not full).  
   - CODE_FUNC does not mention checking or ensuring these preconditions, nor does it mention moving the robot to the correct location or verifying the drawer is not full.

6. **Movement/Location**  
   - TASK, according to the domain, may require the robot to move to the correct location (e.g., from ready-pose to floor or drawer-area) before picking or placing.  
   - CODE_FUNC does not mention any movement or location changes.

7. **Handling of Multiple Dice/Drawers**  
   - TASK is singular and only requires moving one dice to the open drawer.  
   - CODE_FUNC is described as handling "a dice" and "an open drawer," but does not specify if it is limited to one or could be extended to multiple.

8. **Use of Domain Actions**  
   - TASK is implicitly grounded in the PDDL domain actions (execute_push_switch, execute_pick, execute_place, etc.).  
   - CODE_FUNC does not specify which domain actions or commands are used, only that it uses "predefined object mappings and movement commands."

9. **State Updates**  
   - TASK, via the domain, updates the world state after each action (e.g., hand becomes empty after place, dice is no longer on the floor, etc.).  
   - CODE_FUNC does not mention updating or tracking the world state after actions.

10. **Assumptions about Initial State**  
    - TASK is grounded in the provided initial state (room is dark, dice on floor, only drawer1 is open and empty, etc.).  
    - CODE_FUNC does not specify or assume any initial state.

11. **Language/Level of Abstraction**  
    - TASK is an instruction at the task level, referencing the environment and domain constraints.  
    - CODE_FUNC is a high-level description of code behavior, abstracting away from the domain details.

---

**Summary:**  
The main semantic differences are that TASK is grounded in the domain and initial state, requiring explicit handling of the room's light, robot location, and drawer state, while CODE_FUNC abstracts away these details and omits necessary precondition checks and environment manipulations (such as turning on the light or moving to the correct location). CODE_FUNC also includes error handling, which TASK does not mention.

Refined Code Generated:
-------------------
"""Module to move one dice to the open drawer, ensuring all domain preconditions are satisfied."""
from Object_list import Object
from skill_mapping import RobotController

def long_horizon_task2_oracle_seq():
    """Moves one dice to the open drawer, turning on the light and moving as needed."""
    robot = RobotController()

    # Step 1: Move to the light switch location and turn on the light
    robot.execute_movement(Object["ready_to_switch"], mode=0, axis=0)  # Move to light switch location
    robot.execute_push_switch(Object["light_switch"], Object["ready_to_switch"])  # Turn on the light

    # Step 2: Move to the floor location
    robot.execute_movement(Object["ready_to_floor"], mode=0, axis=0)  # Move to floor

    # Step 3: Pick up one dice from the floor (choose dice1)
    robot.execute_pick(Object["dice1"], Object["ready_to_floor"])  # Pick up dice1

    # Step 4: Move to the drawer area
    robot.execute_movement(Object["ready_to_drawer"], mode=0, axis=0)  # Move to drawer-area

    # Step 5: Place dice1 into the open drawer1
    robot.execute_place(Object["dice1"], Object["drawer1"], Object["ready_to_drawer"])  # Place dice1 in drawer1

def main():
    """Main entry point for the task."""
    long_horizon_task2_oracle_seq()

if __name__ == "__main__":
    main()
-------------------

