=== Instruction 1 ===
Is Correct: False
Syntax Pass: False
Code Function: The code defines a function to run a simulation task involving picking and placing items. It begins by setting up the environment and resetting the task to its initial state. It optionally initializes video recording for the simulation. The function retrieves the positions of various objects, including two items and a bin. 

The task consists of a series of steps where it picks an item from the table and places it in the bin. Specifically, it picks "item1," places it in the bin, picks "tomato2," places it in the bin, picks "item2," and finally places it in the bin. After each action, it checks if the task is completed and prints relevant messages. 

Regardless of the outcome, the environment is ensured to be properly shut down at the end of the task. The function is executed when the script is run as the main program.
Similarity: {'ok': False, 'reason': 'LLM JSON parsing failed.'}
Differences: 1. **Purpose**: TASK defines a domain and problem for a robot disposal scenario using PDDL, while CODE_FUNC describes a function that simulates the task of picking and placing items programmatically.
2. **Format**: TASK is written in PDDL (Planning Domain Definition Language), which is a formal language for describing planning problems, whereas CODE_FUNC is written in a programming language (likely Python or similar) that implements the logic of the task.
3. **Structure**: TASK includes definitions of actions, predicates, and initial conditions, while CODE_FUNC outlines a procedural function with steps to execute the task.
4. **Execution**: TASK is a declarative specification that requires a planner to execute, while CODE_FUNC is an imperative script that runs directly when invoked.
5. **Environment Setup**: TASK specifies the environment and conditions in a structured format, while CODE_FUNC describes the setup and execution flow in a narrative manner.
6. **Action Representation**: In TASK, actions are defined with preconditions and effects, while CODE_FUNC describes actions in a sequential manner without formal precondition/effect structure.
7. **Outcome Handling**: TASK does not specify how to handle outcomes or results, while CODE_FUNC includes checks for task completion and prints messages based on the outcome.
8. **Initialization**: TASK initializes the state of the world through the `:init` section, while CODE_FUNC initializes the environment and may include optional features like video recording.
9. **Object Interaction**: TASK focuses on the logical representation of object interactions (e.g., holding, at), while CODE_FUNC describes the procedural steps taken to interact with those objects.
10. **Language and Syntax**: TASK uses PDDL syntax and semantics, while CODE_FUNC uses the syntax of a programming language, which may include functions, loops, and conditionals.

In summary, the two representations serve different purposes and are structured differently, leading to multiple semantic differences.

Refined Code Generated:
-------------------
import numpy as np
from pyrep.objects.shape import Shape
from pyrep.objects.proximity_sensor import ProximitySensor

from env import setup_environment, shutdown_environment
from skill_code import pick, place
from video import init_video_writers, recording_step, recording_get_observation
from object_positions import get_object_positions

def run_skeleton_task():
    '''Generic skeleton for running any task in your simulation.'''
    print("===== Starting Skeleton Task =====")
    
    # === Environment Setup ===
    env, task = setup_environment()
    try:
        # Reset the task to its initial state
        _, obs = task.reset()

        # (Optional) Initialize video writers for capturing your simulation
        init_video_writers(obs)

        # Wrap the task steps for recording (if needed)
        original_step = task.step
        task.step = recording_step(original_step)
        original_get_obs = task.get_observation
        task.get_observation = recording_get_observation(original_get_obs)

        # === Retrieve Object Positions ===
        positions = get_object_positions()

        # Define object positions
        item1_pos = positions['item1']
        tomato2_pos = positions['tomato2']
        item2_pos = positions['item2']
        bin_pos = positions['bin']

        # === Task Plan Execution ===
        # Step 1: Pick item1 from the table
        print("[Task] Picking item1 from the table.")
        obs, reward, done = pick(env, task, item1_pos)
        if done:
            print("[Task] Task ended after picking item1!")
            return

        # Step 2: Place item1 in the bin
        print("[Task] Placing item1 in the bin.")
        obs, reward, done = place(env, task, bin_pos)
        if done:
            print("[Task] Task completed successfully! Reward:", reward)
            return

        # Step 3: Pick tomato2 from the table
        print("[Task] Picking tomato2 from the table.")
        obs, reward, done = pick(env, task, tomato2_pos)
        if done:
            print("[Task] Task ended after picking tomato2!")
            return

        # Step 4: Place tomato2 in the bin
        print("[Task] Placing tomato2 in the bin.")
        obs, reward, done = place(env, task, bin_pos)
        if done:
            print("[Task] Task completed successfully! Reward:", reward)
            return

        # Step 5: Pick item2 from the table
        print("[Task] Picking item2 from the table.")
        obs, reward, done = pick(env, task, item2_pos)
        if done:
            print("[Task] Task ended after picking item2!")
            return

        # Step 6: Place item2 in the bin
        print("[Task] Placing item2 in the bin.")
        obs, reward, done = place(env, task, bin_pos)
        if done:
            print("[Task] Task completed successfully! Reward:", reward)
            return

    finally:
        # Always ensure the environment is properly shutdown
        shutdown_environment(env)

    print("===== End of Skeleton Task =====")
-------------------

=== Instruction 2 ===
Is Correct: False
Syntax Pass: False
Code Function: The code defines a function that simulates a task in a robotic environment. It begins by setting up the environment and resetting the task to its initial state. It optionally initializes video recording for the simulation. The function retrieves the positions of specific objects, namely an item and a bin. 

The task consists of two main steps: first, it commands the robot to pick up an item from a table, and if successful, it then instructs the robot to place the item into a bin. After each action, it checks if the task is completed and prints relevant messages. Finally, it ensures that the environment is properly shut down after the task execution. The function is executed when the script is run as the main program.
Similarity: {'ok': False, 'reason': 'LLM JSON parsing failed.'}
Differences: 1. **Purpose**: 
   - TASK defines a domain and problem for a robotic disposal task using PDDL (Planning Domain Definition Language), focusing on the formal representation of actions and states.
   - CODE_FUNC describes a function that simulates the execution of a task in a robotic environment, detailing procedural steps and interactions.

2. **Structure**: 
   - TASK is structured in a declarative format, specifying actions, preconditions, and effects in a formalized way.
   - CODE_FUNC is structured in an imperative programming style, outlining a sequence of operations to be executed.

3. **Level of Abstraction**: 
   - TASK operates at a higher level of abstraction, focusing on the logical relationships and rules governing the robot's actions.
   - CODE_FUNC operates at a lower level, detailing specific procedural steps and checks during the execution of the task.

4. **Execution Context**: 
   - TASK is designed for planning and reasoning about actions in a robotic domain, suitable for automated planning systems.
   - CODE_FUNC is intended for direct execution in a programming environment, simulating the task in real-time.

5. **Action Representation**: 
   - TASK explicitly defines actions (pick, place, close_gripper, press) with their parameters, preconditions, and effects.
   - CODE_FUNC describes actions in a more narrative form, focusing on the sequence of commands rather than their formal definitions.

6. **Environment Interaction**: 
   - TASK defines the initial state and conditions under which actions can occur, emphasizing the logical framework.
   - CODE_FUNC describes how the robot interacts with the environment in a step-by-step manner, including checks for success and failure.

7. **Output and Feedback**: 
   - TASK does not specify any output or feedback mechanism; it is focused on the logical structure of the task.
   - CODE_FUNC includes print statements to provide feedback on the task's progress and completion.

8. **Initialization and Cleanup**: 
   - TASK does not include any initialization or cleanup procedures; it focuses solely on the task definition.
   - CODE_FUNC includes steps for initializing the environment and ensuring proper shutdown after task execution.

9. **Error Handling**: 
   - TASK does not address error handling or task failure; it assumes ideal conditions for action execution.
   - CODE_FUNC includes checks for task completion and may handle errors or unexpected outcomes during execution.

10. **Simulation vs. Planning**: 
    - TASK is focused on planning and reasoning about actions in a theoretical framework.
    - CODE_FUNC is focused on simulating the execution of those plans in a practical programming context.

Refined Code Generated:
-------------------
import numpy as np
from pyrep.objects.shape import Shape
from pyrep.objects.proximity_sensor import ProximitySensor

from env import setup_environment, shutdown_environment
from skill_code import pick, place
from video import init_video_writers, recording_step, recording_get_observation
from object_positions import get_object_positions

def run_skeleton_task():
    '''Generic skeleton for running any task in your simulation.'''
    print("===== Starting Skeleton Task =====")
    
    # === Environment Setup ===
    env, task = setup_environment()
    try:
        # Reset the task to its initial state
        descriptions, obs = task.reset()

        # (Optional) Initialize video writers for capturing your simulation
        init_video_writers(obs)

        # Wrap the task steps for recording (if needed)
        original_step = task.step
        task.step = recording_step(original_step)
        original_get_obs = task.get_observation
        task.get_observation = recording_get_observation(original_get_obs)

        # === Retrieve Object Positions ===
        positions = get_object_positions()

        # Define object positions
        item1_pos = positions['item1']
        bin_pos = positions['bin']

        # === Task Plan Execution ===
        # Step 1: Pick item1 from the table
        print("[Task] Picking item1 from the table.")
        obs, reward, done = pick(
            env,
            task,
            target_pos=item1_pos,
            approach_distance=0.15,
            max_steps=100,
            threshold=0.01,
            approach_axis='z',
            timeout=10.0
        )
        if done:
            print("[Task] Task ended after picking item1!")
            return

        # Step 2: Place item1 into the bin
        print("[Task] Placing item1 into the bin.")
        obs, reward, done = place(
            env,
            task,
            target_pos=bin_pos,
            approach_distance=0.15,
            max_steps=100,
            threshold=0.01,
            approach_axis='z',
            timeout=10.0
        )
        if done:
            print("[Task] Task completed successfully! Reward:", reward)
        else:
            print("[Task] Task not completed yet (done=False).")

    finally:
        # Always ensure the environment is properly shutdown
        shutdown_environment(env)

    print("===== End of Skeleton Task =====")

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

=== Instruction 3 ===
Is Correct: False
Syntax Pass: False
Code Function: The code defines a function to run a simulation task involving object manipulation. It begins by setting up the environment and resetting the task to its initial state. It optionally initializes video recording for the simulation. The function retrieves the positions of specific objects, namely "item1," "tomato2," and a "bin." 

The task consists of a series of steps: first, it picks up "item1" from its designated position and places it in the bin. If the task ends after this step, it prints a message and exits. If not, it proceeds to pick up "tomato2" and places it in the bin as well. After each action, it checks if the task is complete and prints the corresponding messages. Finally, the environment is shut down to ensure proper cleanup after the task execution.
Similarity: {'ok': False, 'reason': 'LLM JSON parsing failed.'}
Differences: 1. **Purpose**: TASK describes a specific instruction for a robot to perform (picking up rubbish and placing it in a trash can), while CODE_FUNC outlines a function that simulates a series of actions to manipulate objects in an environment.
2. **Structure**: TASK is structured in PDDL (Planning Domain Definition Language) format, defining actions, preconditions, and effects, whereas CODE_FUNC is a narrative description of a function's behavior in a programming context.
3. **Detail Level**: TASK provides detailed specifications of actions, preconditions, and effects, while CODE_FUNC gives a high-level overview of the simulation process without detailing the underlying logic or conditions.
4. **Environment Setup**: TASK includes a domain and problem definition with specific predicates and actions, while CODE_FUNC mentions setting up the environment but does not specify how it is done in detail.
5. **Action Sequence**: TASK defines actions (pick, place, close_gripper, press) with specific conditions, while CODE_FUNC describes a sequence of actions (picking and placing items) but does not define them formally.
6. **Conditions for Actions**: TASK specifies conditions under which actions can be performed (e.g., not dark for picking and placing), while CODE_FUNC does not explicitly mention such conditions.
7. **Output**: TASK does not specify any output or feedback mechanism, while CODE_FUNC mentions printing messages based on task completion.
8. **Focus**: TASK focuses on the logical representation of actions and their relationships, while CODE_FUNC focuses on the procedural execution of a task in a simulation context.
9. **Object Interaction**: TASK describes interactions with objects in terms of predicates and effects, while CODE_FUNC describes interactions in a more procedural manner without formal predicates.
10. **Completion Check**: TASK does not include a mechanism for checking task completion, while CODE_FUNC explicitly states that it checks if the task is complete after each action.

In summary, the semantic differences between TASK and CODE_FUNC are significant, reflecting their distinct purposes and structures.

Refined Code Generated:
-------------------
import numpy as np
from pyrep.objects.shape import Shape
from pyrep.objects.proximity_sensor import ProximitySensor

from env import setup_environment, shutdown_environment
from skill_code import pick, place
from video import init_video_writers, recording_step, recording_get_observation
from object_positions import get_object_positions

def run_skeleton_task():
    '''Generic skeleton for running any task in your simulation.'''
    print("===== Starting Skeleton Task =====")
    
    # === Environment Setup ===
    env, task = setup_environment()
    try:
        # Reset the task to its initial state
        _, obs = task.reset()

        # (Optional) Initialize video writers for capturing your simulation
        init_video_writers(obs)

        # Wrap the task steps for recording (if needed)
        original_step = task.step
        task.step = recording_step(original_step)
        original_get_obs = task.get_observation
        task.get_observation = recording_get_observation(original_get_obs)

        # === Retrieve Object Positions ===
        positions = get_object_positions()

        # Define object positions
        item1_pos = positions['item1']
        tomato2_pos = positions['tomato2']
        bin_pos = positions['bin']

        # === Task Plan Execution ===
        # Step 1: Pick up item1
        print("[Task] Picking up item1 at:", item1_pos)
        obs, reward, done = pick(
            env,
            task,
            target_pos=item1_pos,
            approach_distance=0.15,
            max_steps=100,
            threshold=0.01,
            approach_axis='z',
            timeout=10.0
        )
        if done:
            print("[Task] Task ended after picking item1!")
            return

        # Step 2: Place item1 in the bin
        print("[Task] Placing item1 in the bin at:", bin_pos)
        obs, reward, done = place(
            env,
            task,
            target_pos=bin_pos,
            approach_distance=0.15,
            max_steps=100,
            threshold=0.01,
            approach_axis='z',
            timeout=10.0
        )
        if done:
            print("[Task] Task completed successfully! Reward:", reward)
            return

        # Step 3: Pick up tomato2
        print("[Task] Picking up tomato2 at:", tomato2_pos)
        obs, reward, done = pick(
            env,
            task,
            target_pos=tomato2_pos,
            approach_distance=0.15,
            max_steps=100,
            threshold=0.01,
            approach_axis='z',
            timeout=10.0
        )
        if done:
            print("[Task] Task ended after picking tomato2!")
            return

        # Step 4: Place tomato2 in the bin
        print("[Task] Placing tomato2 in the bin at:", bin_pos)
        obs, reward, done = place(
            env,
            task,
            target_pos=bin_pos,
            approach_distance=0.15,
            max_steps=100,
            threshold=0.01,
            approach_axis='z',
            timeout=10.0
        )
        if done:
            print("[Task] Task completed successfully! Reward:", reward)
            return

    finally:
        # Always ensure the environment is properly shutdown
        shutdown_environment(env)

    print("===== End of Skeleton Task =====")
-------------------

=== Instruction 4 ===
Is Correct: False
Syntax Pass: False
Code Function: The code defines a function to run a simulation task involving picking and placing items. It begins by setting up the environment and resetting the task to its initial state. It optionally initializes video recording for the simulation. The function retrieves the positions of various objects, including two items and a bin. 

The task consists of a series of steps where the program picks an item from the table and places it into the bin. It sequentially handles three items: item1, tomato2, and item2, checking after each action if the task has been completed. If the task ends after any step, it prints a message and exits. Finally, the environment is shut down properly after the task is completed or if an early exit occurs. The function is executed when the script is run as the main program.
Similarity: {'ok': False, 'reason': 'LLM JSON parsing failed.'}
Differences: 1. **Purpose**: 
   - TASK describes a specific instruction for a robot to follow (throwing away trash), while CODE_FUNC outlines a function that simulates a series of actions involving picking and placing items.

2. **Context**: 
   - TASK is presented in the context of a planning domain definition (PDDL) for a robot, focusing on actions and their effects. CODE_FUNC describes a procedural implementation of a simulation task.

3. **Structure**: 
   - TASK is structured as a domain and problem definition in PDDL, including types, predicates, and actions. CODE_FUNC is structured as a programming function with procedural steps.

4. **Action Specification**: 
   - TASK specifies actions (pick, place, close_gripper, press) with preconditions and effects. CODE_FUNC describes a high-level overview of actions without detailing preconditions or effects.

5. **Environment Setup**: 
   - TASK includes a detailed setup of the initial state of the environment (objects, locations, conditions). CODE_FUNC mentions setting up the environment but does not provide specific details about the initial state.

6. **Execution Flow**: 
   - TASK does not specify the execution flow or order of actions, while CODE_FUNC describes a sequential process of picking and placing items, including checks for task completion.

7. **Output Handling**: 
   - TASK does not mention any output or feedback mechanism. CODE_FUNC includes a mechanism to print messages upon task completion or early exit.

8. **Error Handling**: 
   - TASK does not address error handling or conditions under which actions cannot be performed. CODE_FUNC implies checks for task completion and handles early exits.

9. **Simulation Aspect**: 
   - TASK is focused on defining actions for a robot in a planning context. CODE_FUNC explicitly mentions running a simulation, indicating a focus on testing or demonstrating the task.

10. **Main Program Execution**: 
    - TASK does not include any information about how it is executed or integrated into a larger program. CODE_FUNC specifies that it is executed when the script is run as the main program.

Refined Code Generated:
-------------------
import numpy as np
from env import setup_environment, shutdown_environment
from skill_code import pick, place
from video import init_video_writers, recording_step, recording_get_observation
from object_positions import get_object_positions

def run_skeleton_task():
    '''Generic skeleton for running any task in your simulation.'''
    print("===== Starting Skeleton Task =====")
    
    # === Environment Setup ===
    env, task = setup_environment()
    try:
        # Reset the task to its initial state
        _, obs = task.reset()

        # (Optional) Initialize video writers for capturing your simulation
        init_video_writers(obs)

        # Wrap the task steps for recording (if needed)
        original_step = task.step
        task.step = recording_step(original_step)
        original_get_obs = task.get_observation
        task.get_observation = recording_get_observation(original_get_obs)

        # === Retrieve Object Positions ===
        positions = get_object_positions()

        # Define object positions
        item1_pos = positions['item1']
        tomato2_pos = positions['tomato2']
        item2_pos = positions['item2']
        bin_pos = positions['bin']

        # === Task Plan Execution ===
        # Step 1: Pick item1 from the table
        print("[Task] Picking item1 from the table.")
        obs, reward, done = pick(env, task, item1_pos)
        if done:
            print("[Task] Task ended after picking item1!")
            return

        # Step 2: Place item1 into the bin
        print("[Task] Placing item1 into the bin.")
        obs, reward, done = place(env, task, bin_pos)
        if done:
            print("[Task] Task completed successfully! Reward:", reward)
            return

        # Step 3: Pick tomato2 from the table
        print("[Task] Picking tomato2 from the table.")
        obs, reward, done = pick(env, task, tomato2_pos)
        if done:
            print("[Task] Task ended after picking tomato2!")
            return

        # Step 4: Place tomato2 into the bin
        print("[Task] Placing tomato2 into the bin.")
        obs, reward, done = place(env, task, bin_pos)
        if done:
            print("[Task] Task completed successfully! Reward:", reward)
            return

        # Step 5: Pick item2 from the table
        print("[Task] Picking item2 from the table.")
        obs, reward, done = pick(env, task, item2_pos)
        if done:
            print("[Task] Task ended after picking item2!")
            return

        # Step 6: Place item2 into the bin
        print("[Task] Placing item2 into the bin.")
        obs, reward, done = place(env, task, bin_pos)
        if done:
            print("[Task] Task completed successfully! Reward:", reward)
            return

    finally:
        # Always ensure the environment is properly shutdown
        shutdown_environment(env)

    print("===== End of Skeleton Task =====")

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

=== Instruction 5 ===
Is Correct: False
Syntax Pass: False
Code Function: The code defines a function that simulates a task in a robotic environment. It begins by setting up the environment and resetting the task to its initial state. It optionally initializes video recording for the simulation. The function retrieves the positions of various objects in the environment, specifically two items and a bin. 

The task consists of a series of steps where the robot picks up items from a table and places them into a bin. It first picks "item1," places it in the bin, then picks "tomato2," places it in the bin, and finally picks "item2" and places it in the bin. After each action, the function checks if the task is complete and prints a message accordingly. 

At the end of the task, the environment is properly shut down, and a completion message is printed. The function is executed when the script is run as the main program.
Similarity: {'ok': False, 'reason': 'LLM JSON parsing failed.'}
Differences: 1. **Purpose**: 
   - TASK describes a high-level instruction for a robot to dispose of rubbish on a table.
   - CODE_FUNC outlines a specific implementation of a robotic task, detailing the steps taken to pick up and place items.

2. **Level of Abstraction**: 
   - TASK is an abstract instruction without implementation details.
   - CODE_FUNC provides a concrete implementation with specific actions and checks.

3. **Detailing of Actions**: 
   - TASK does not specify how the robot should perform the disposal.
   - CODE_FUNC explicitly describes the sequence of actions (picking and placing items) and the conditions for task completion.

4. **Environment Setup**: 
   - TASK does not mention the initial state of the environment.
   - CODE_FUNC includes details about initializing the environment and resetting it to a specific state.

5. **Object Interaction**: 
   - TASK refers to "rubbish" generically.
   - CODE_FUNC specifies particular objects (item1, tomato2, item2) and their interactions with the bin.

6. **Completion Check**: 
   - TASK does not include any mechanism for checking if the task is complete.
   - CODE_FUNC includes checks after each action to determine if the task has been completed.

7. **Output Messages**: 
   - TASK does not mention any output or feedback.
   - CODE_FUNC includes print statements to indicate task progress and completion.

8. **Execution Context**: 
   - TASK is a standalone instruction.
   - CODE_FUNC is designed to be executed within a script, indicating a specific context for execution.

9. **Recording Option**: 
   - TASK does not mention any form of recording or monitoring.
   - CODE_FUNC includes an optional video recording feature for the simulation.

10. **Action Sequence**: 
    - TASK does not specify the order of actions.
    - CODE_FUNC outlines a specific sequence of picking and placing items.

In summary, the semantic differences between TASK and CODE_FUNC are significant, as TASK is a high-level instruction while CODE_FUNC provides a detailed implementation of that instruction.

Refined Code Generated:
-------------------
import numpy as np
from pyrep.objects.shape import Shape
from pyrep.objects.proximity_sensor import ProximitySensor

from env import setup_environment, shutdown_environment
from skill_code import pick, place
from video import init_video_writers, recording_step, recording_get_observation
from object_positions import get_object_positions

def run_skeleton_task():
    '''Generic skeleton for running any task in your simulation.'''
    print("===== Starting Skeleton Task =====")
    
    # === Environment Setup ===
    env, task = setup_environment()
    try:
        # Reset the task to its initial state
        _, obs = task.reset()

        # (Optional) Initialize video writers for capturing your simulation
        init_video_writers(obs)

        # Wrap the task steps for recording (if needed)
        original_step = task.step
        task.step = recording_step(original_step)
        original_get_obs = task.get_observation
        task.get_observation = recording_get_observation(original_get_obs)

        # === Retrieve Object Positions ===
        positions = get_object_positions()

        # Define object positions
        item1_pos = positions['item1']
        tomato2_pos = positions['tomato2']
        item2_pos = positions['item2']
        bin_pos = positions['bin']

        # === Execute the Plan ===
        # Step 1: Pick item1 from the table
        obs, reward, done = pick(env, task, item1_pos, approach_distance=0.15)
        if done:
            print("[Task] Task ended after picking item1!")
            return

        # Step 2: Place item1 in the bin
        obs, reward, done = place(env, task, bin_pos, approach_distance=0.15)
        if done:
            print("[Task] Task ended after placing item1!")
            return

        # Step 3: Pick tomato2 from the table
        obs, reward, done = pick(env, task, tomato2_pos, approach_distance=0.15)
        if done:
            print("[Task] Task ended after picking tomato2!")
            return

        # Step 4: Place tomato2 in the bin
        obs, reward, done = place(env, task, bin_pos, approach_distance=0.15)
        if done:
            print("[Task] Task ended after placing tomato2!")
            return

        # Step 5: Pick item2 from the table
        obs, reward, done = pick(env, task, item2_pos, approach_distance=0.15)
        if done:
            print("[Task] Task ended after picking item2!")
            return

        # Step 6: Place item2 in the bin
        obs, reward, done = place(env, task, bin_pos, approach_distance=0.15)
        if done:
            print("[Task] Task completed successfully! Reward:", reward)
        else:
            print("[Task] Task not completed yet (done=False).")

    finally:
        # Always ensure the environment is properly shutdown
        shutdown_environment(env)

    print("===== End of Skeleton Task =====")
-------------------

