=== Instruction 1 ===
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 objects in the environment, specifically a bottom drawer and a plate.

The task consists of a series of steps: first, it pulls the bottom drawer, then picks up a tomato from the table, places it on the plate, picks up a second tomato, and finally places that tomato on the plate as well. After each action, it checks if the task is completed and prints appropriate messages. If the task ends at any step, it exits early. Finally, it ensures that the environment is properly shut down before concluding the task.
Similarity: {'ok': False, 'reason': 'LLM JSON parsing failed.'}
Differences: 1. **Purpose**: 
   - TASK describes a high-level instruction for a robot to perform a specific action involving object manipulation.
   - CODE_FUNC outlines a detailed implementation of a simulation task, including setup, execution, and cleanup.

2. **Structure**: 
   - TASK is presented in a PDDL format, defining a domain and problem with types, predicates, and actions.
   - CODE_FUNC is a narrative description of a function that executes a sequence of actions in a simulation.

3. **Detail Level**: 
   - TASK provides a formal representation of actions, preconditions, and effects in a planning domain.
   - CODE_FUNC describes the procedural steps taken to achieve the task without formal preconditions or effects.

4. **Execution Flow**: 
   - TASK does not specify the order of actions beyond the initial instruction.
   - CODE_FUNC explicitly details the sequence of actions taken (pulling the drawer, picking up tomatoes, placing them on the plate).

5. **Environment Interaction**: 
   - TASK defines the environment and objects in a declarative manner.
   - CODE_FUNC describes the interaction with the environment in a procedural manner, including checks for task completion.

6. **Error Handling**: 
   - TASK does not mention error handling or early exits.
   - CODE_FUNC includes checks for task completion and early exits if the task ends at any step.

7. **Output**: 
   - TASK does not specify any output or feedback mechanism.
   - CODE_FUNC mentions printing messages after actions to indicate progress or completion.

8. **Initialization**: 
   - TASK assumes an initial state defined in the PDDL problem.
   - CODE_FUNC includes steps to reset the environment and optionally initialize video recording.

9. **Focus**: 
   - TASK focuses on the logical representation of actions and their relationships.
   - CODE_FUNC focuses on the practical execution of those actions in a simulation context.

10. **Terminology**: 
    - TASK uses specific PDDL terminology (e.g., predicates, actions, preconditions).
    - CODE_FUNC uses more general programming and simulation terminology (e.g., function, simulation task, environment).

In summary, the semantic differences between TASK and CODE_FUNC are significant, as they serve different purposes and are structured differently.

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 *
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
        plate_pos = positions['plate']

        # === Execute the Plan ===
        # Step 1: Pull the bottom drawer
        print("[Task] Pulling the bottom drawer.")
        obs, reward, done = pull(env, task, pull_distance=0.1, pull_axis='y')
        if done:
            print("[Task] Task ended after pulling the drawer!")
            return

        # Step 2: Pick the first tomato
        print("[Task] Picking tomato1 from the table.")
        obs, reward, done = pick(env, task, target_pos=positions['item1'], approach_distance=0.15)
        if done:
            print("[Task] Task ended after picking tomato1!")
            return

        # Step 3: Place the first tomato on the plate
        print("[Task] Placing tomato1 on the plate.")
        obs, reward, done = place(env, task, target_pos=plate_pos, approach_distance=0.15)
        if done:
            print("[Task] Task ended after placing tomato1!")
            return

        # Step 4: Pick the second tomato
        print("[Task] Picking tomato2 from the table.")
        obs, reward, done = pick(env, task, target_pos=positions['item2'], approach_distance=0.15)
        if done:
            print("[Task] Task ended after picking tomato2!")
            return

        # Step 5: Place the second tomato on the plate
        print("[Task] Placing tomato2 on the plate.")
        obs, reward, done = place(env, task, target_pos=plate_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 =====")
-------------------

=== Instruction 2 ===
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 various objects, including a plate and two tomatoes. 

The task consists of three main steps: first, it attempts to pull open a drawer that is not locked; if successful, it proceeds to place the first tomato onto the plate; if that is also successful, it then places the second tomato onto the plate. After completing these actions, the environment is shut down properly. The function prints messages indicating the success or failure of each step throughout the process.
Similarity: {'ok': False, 'reason': 'LLM JSON parsing failed.'}
Differences: 1. **Purpose**: 
   - TASK describes a specific sequence of actions to be performed in a PDDL (Planning Domain Definition Language) format, focusing on the manipulation of objects (tomatoes and a drawer).
   - CODE_FUNC describes a function that implements a simulation of the task, including setup, execution, and feedback.

2. **Format**: 
   - TASK is structured in a formal PDDL syntax, defining types, predicates, and actions.
   - CODE_FUNC is written in a programming language (likely Python or similar), outlining a procedural approach to executing the task.

3. **Components**: 
   - TASK includes definitions of types (e.g., drawer, gripper) and predicates (e.g., is-locked, is-open) that are essential for planning.
   - CODE_FUNC focuses on the procedural steps to execute the task, including environment setup and success/failure messaging.

4. **Execution**: 
   - TASK specifies the logical conditions and effects of actions in a planning context, which can be used by a planner to generate a sequence of actions.
   - CODE_FUNC executes the actions in a specific order, handling the simulation of the task in a runtime environment.

5. **Feedback Mechanism**: 
   - TASK does not include any feedback mechanism; it is purely declarative.
   - CODE_FUNC includes print statements to indicate the success or failure of each step, providing real-time feedback during execution.

6. **State Management**: 
   - TASK defines the initial state and the effects of actions in a declarative manner.
   - CODE_FUNC manages state through procedural code, resetting and updating the environment as actions are performed.

7. **Error Handling**: 
   - TASK does not account for error handling; it assumes actions will be executed as planned.
   - CODE_FUNC includes conditional checks to determine the success of actions and handle failures accordingly.

8. **Simulation vs. Planning**: 
   - TASK is focused on planning and defining the actions that can be taken within a domain.
   - CODE_FUNC is focused on simulating the execution of those plans in a controlled environment.

9. **Action Granularity**: 
   - TASK breaks down actions into detailed preconditions and effects, suitable for automated planning.
   - CODE_FUNC may abstract some of these details, focusing instead on the high-level steps necessary to complete the task.

10. **Environment Interaction**: 
    - TASK describes interactions in terms of predicates and actions without specifying how they are executed.
    - CODE_FUNC explicitly interacts with the environment, manipulating objects and checking conditions during runtime.

Refined Code Generated:
-------------------
import numpy as np
from env import setup_environment, shutdown_environment
from skill_code import *
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
        task.reset()

        # (Optional) Initialize video writers for capturing your simulation
        init_video_writers(task.get_observation())

        # 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
        plate_pos = positions['plate']
        bottom_drawer_pos = positions['bottom_anchor_pos']

        # Step 1: Pull open any drawer that is not locked
        print("[Task] Pulling open the drawer.")
        obs, _, done = pull(env, task, pull_distance=0.1, pull_axis='y', max_steps=100, threshold=0.01, timeout=10.0)
        if done:
            print("[Task] Drawer opened successfully!")
        else:
            print("[Task] Failed to open the drawer.")
            return

        # Step 2: Place the first tomato onto the plate
        print("[Task] Placing tomato1 onto the plate.")
        obs, _, done = place(env, task, target_pos=plate_pos, approach_distance=0.15, max_steps=100, threshold=0.01, approach_axis='z', timeout=10.0)
        if done:
            print("[Task] tomato1 placed successfully!")
        else:
            print("[Task] Failed to place tomato1.")
            return

        # Step 3: Place the second tomato onto the plate
        print("[Task] Placing tomato2 onto the plate.")
        obs, _, done = place(env, task, target_pos=plate_pos, approach_distance=0.15, max_steps=100, threshold=0.01, approach_axis='z', timeout=10.0)
        if done:
            print("[Task] tomato2 placed successfully!")
        else:
            print("[Task] Failed to place tomato2.")
            return

    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 that simulates a task in a virtual 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 needed for the task.

The task consists of three main steps: first, it pulls a drawer; second, it picks up three tomatoes from a table; and finally, it places the tomatoes on a plate. After each action, it checks if the task is completed and prints appropriate messages. If the task is completed at any step, it exits early. Finally, the environment is shut down to ensure proper cleanup. The function is executed when the script is run directly.
Similarity: {'ok': False, 'reason': 'LLM JSON parsing failed.'}
Differences: 1. **Nature of Content**: TASK is a detailed instruction set for a specific action sequence, while CODE_FUNC describes a function that simulates a task in a virtual environment.
2. **Structure**: TASK is structured in PDDL (Planning Domain Definition Language) format, defining types, predicates, and actions, whereas CODE_FUNC is a narrative description of a function's behavior and logic.
3. **Level of Detail**: TASK provides explicit details about the actions, preconditions, and effects in a formalized manner, while CODE_FUNC gives a high-level overview without specific implementation details.
4. **Execution Context**: TASK is designed for a planning system to execute actions based on defined predicates and actions, while CODE_FUNC describes a procedural simulation that may involve programming constructs.
5. **Focus**: TASK focuses on the logical representation of actions and their relationships, while CODE_FUNC emphasizes the procedural steps and flow of execution in a simulation context.
6. **Output**: TASK does not specify outputs or results of actions, while CODE_FUNC mentions printing messages and checking for task completion.
7. **Environment Interaction**: TASK defines interactions with objects in a planning context, while CODE_FUNC describes interactions in a simulated environment, including setup and cleanup processes.

Refined Code Generated:
-------------------
import numpy as np
from env import setup_environment, shutdown_environment
from skill_code import *
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 based on the provided object list
        plate_pos = positions['plate']

        # === Task Execution Plan ===
        # Step 1: Pull the drawer (assuming we are pulling the bottom drawer)
        print("[Task] Pulling the bottom drawer.")
        obs, reward, done = pull(env, task, pull_distance=0.2, pull_axis='y', max_steps=100, threshold=0.01, timeout=10.0)
        if done:
            print("[Task] Task ended after pulling the drawer!")
            return

        # Step 2: Pick up all tomatoes (assuming they are at the table)
        for item in ['item1', 'item2', 'item3']:
            print(f"[Task] Picking up {item}.")
            obs, reward, done = pick(env, task, target_pos=positions[item], approach_distance=0.15, max_steps=100, threshold=0.01, approach_axis='z', timeout=10.0)
            if done:
                print(f"[Task] Task ended after picking up {item}!")
                return

        # Step 3: Place all tomatoes on the plate
        print("[Task] Placing tomatoes on the plate.")
        obs, reward, done = place(env, task, target_pos=plate_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 4 ===
Is Correct: False
Syntax Pass: False
Code Function: The code defines a function to run a simulation task involving object manipulation in a virtual environment. It begins by setting up the environment and resetting the task to its initial state. The simulation can optionally record video of the task execution. 

The function retrieves the positions of specific objects, including two tomatoes and a plate. It then performs a series of steps: pulling a drawer to unlock a cabinet, picking up the first tomato, placing it on the plate, picking up the second tomato, and placing it on the plate as well. After each action, it checks if the task is completed and prints appropriate messages. 

Finally, the environment is shut down to ensure proper cleanup 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 describes a specific sequence of actions to be performed to achieve a goal (unlocking a cabinet and transferring tomatoes).
   - CODE_FUNC outlines a function that implements a simulation of the task described in TASK.

2. **Structure**: 
   - TASK is presented in a natural language format with a clear instruction.
   - CODE_FUNC is structured as a programming function with defined steps and logic.

3. **Detail Level**: 
   - TASK provides high-level instructions without implementation details.
   - CODE_FUNC includes specific implementation details, such as object retrieval, action execution, and state checking.

4. **Execution Context**: 
   - TASK is a conceptual description of what needs to be done.
   - CODE_FUNC is an executable piece of code that performs the actions described in TASK.

5. **Output**: 
   - TASK does not specify any output or feedback mechanism.
   - CODE_FUNC includes print statements to provide feedback on task completion and actions taken.

6. **Environment Interaction**: 
   - TASK assumes an environment where actions can be performed.
   - CODE_FUNC explicitly sets up and tears down the environment for the simulation.

7. **Action Sequence**: 
   - TASK lists actions in a specific order to achieve the goal.
   - CODE_FUNC may include additional steps for checking conditions and managing state that are not present in TASK.

8. **State Management**: 
   - TASK does not address how the state of the environment or objects is managed.
   - CODE_FUNC includes mechanisms for checking and updating the state of objects and the environment.

9. **Flexibility**: 
   - TASK is a static instruction set that does not account for variations or errors.
   - CODE_FUNC may include error handling or conditional logic to adapt to different scenarios during execution.

10. **Simulation Aspect**: 
    - TASK does not imply any simulation or virtual environment.
    - CODE_FUNC explicitly mentions running a simulation and the option to record video.

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 *  # Importing predefined skills
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
        tomato1_pos = positions['item1']
        tomato2_pos = positions['item2']
        plate_pos = positions['plate']
        bottom_drawer_pos = positions['bottom_anchor_pos']  # Assuming this is the drawer to pull

        # Step 1: Pull the drawer to unlock the cabinet
        print("[Task] Pulling the drawer to unlock the cabinet.")
        obs, reward, done = pull(env, task, pull_distance=0.1, pull_axis='y')  # Adjust distance and axis as needed
        if done:
            print("[Task] Task ended after pulling the drawer!")
            return

        # Step 2: Pick the first tomato
        print("[Task] Picking the first tomato.")
        obs, reward, done = pick(env, task, target_pos=tomato1_pos, approach_distance=0.15)
        if done:
            print("[Task] Task ended after picking the first tomato!")
            return

        # Step 3: Place the first tomato on the plate
        print("[Task] Placing the first tomato on the plate.")
        obs, reward, done = place(env, task, target_pos=plate_pos, approach_distance=0.15)
        if done:
            print("[Task] Task ended after placing the first tomato!")
            return

        # Step 4: Pick the second tomato
        print("[Task] Picking the second tomato.")
        obs, reward, done = pick(env, task, target_pos=tomato2_pos, approach_distance=0.15)
        if done:
            print("[Task] Task ended after picking the second tomato!")
            return

        # Step 5: Place the second tomato on the plate
        print("[Task] Placing the second tomato on the plate.")
        obs, reward, done = place(env, task, target_pos=plate_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 =====")

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

=== Instruction 5 ===
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 various objects, including a table, a plate, and two tomatoes.

The task consists of a series of steps: first, it pulls open a bottom drawer, then picks the first tomato from the table and places it onto the plate. Next, it picks the second tomato from the table and places it onto the plate as well. After each action, it checks if the task is completed and prints appropriate 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**: Describes a specific instruction for a robot to perform a sequence of actions involving object manipulation.
   - **CODE_FUNC**: Describes a function that implements a simulation of the task, including setup, execution, and shutdown.

2. **Content Type**:
   - **TASK**: Contains a natural language instruction and a PDDL (Planning Domain Definition Language) representation of the domain and problem.
   - **CODE_FUNC**: Contains a description of a programming function that outlines the steps to execute the task in a simulation environment.

3. **Level of Abstraction**:
   - **TASK**: High-level description of what needs to be done without implementation details.
   - **CODE_FUNC**: Low-level description that includes specific programming constructs and logic for executing the task.

4. **Execution Context**:
   - **TASK**: Implies a physical or simulated robot performing actions in a defined environment.
   - **CODE_FUNC**: Implies a software function that runs within a programming environment, potentially simulating the robot's actions.

5. **Action Sequence**:
   - **TASK**: Specifies a sequence of actions (open drawer, toss tomatoes) in a straightforward manner.
   - **CODE_FUNC**: Details a more complex sequence of actions, including checks for task completion and environment management.

6. **Output**:
   - **TASK**: Does not specify any output or feedback mechanism.
   - **CODE_FUNC**: Mentions printing messages and checking task completion, indicating a feedback mechanism.

7. **Initialization**:
   - **TASK**: Does not include any initialization steps or environment setup.
   - **CODE_FUNC**: Includes steps for initializing the environment and resetting the task state.

8. **Recording**:
   - **TASK**: Does not mention any form of recording or monitoring.
   - **CODE_FUNC**: Mentions optional video recording for the simulation.

9. **Shutdown Procedure**:
   - **TASK**: Does not include any shutdown or cleanup procedures.
   - **CODE_FUNC**: Specifies ensuring proper shutdown of the environment after task execution.

10. **Implementation Detail**:
    - **TASK**: Focuses on what actions to perform without detailing how they are implemented.
    - **CODE_FUNC**: Provides a detailed description of how the actions are implemented in code.

In summary, the semantic differences between TASK and CODE_FUNC are significant, as they serve different purposes and contexts within the realm of task execution and simulation.

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 *
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
        table_pos = positions['table']
        plate_pos = positions['plate']
        tomato1_pos = positions['item1']
        tomato2_pos = positions['item2']
        bottom_drawer_pos = positions['bottom_anchor_pos']

        # Step 1: Pull open the bottom drawer
        print("[Task] Pulling open the bottom drawer.")
        obs, reward, done = pull(env, task, pull_distance=0.1, pull_axis='y')
        if done:
            print("[Task] Task ended after pulling the drawer!")
            return

        # Step 2: Pick the first tomato from the table
        print("[Task] Picking tomato1 from the table.")
        obs, reward, done = pick(env, task, target_pos=tomato1_pos, approach_distance=0.15)
        if done:
            print("[Task] Task ended after picking tomato1!")
            return

        # Step 3: Place the first tomato onto the plate
        print("[Task] Placing tomato1 onto the plate.")
        obs, reward, done = place(env, task, target_pos=plate_pos, approach_distance=0.15)
        if done:
            print("[Task] Task ended after placing tomato1!")
            return

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

        # Step 5: Place the second tomato onto the plate
        print("[Task] Placing tomato2 onto the plate.")
        obs, reward, done = place(env, task, target_pos=plate_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 =====")
-------------------

