Instruction:
You serve as an AI task planner.
1. Your task is to create a plan to achieve a goal by converting it into a sequence of actions. Each action should follow the format "[verb] <target1> <target2>", where 'verb' represents the action, and 'target1' and 'target2' are optional arguments.
2. You must describe your plan in natural language at the beginning. After that, you should list all the actions together.
Ensure that you response can be parsed by Python json.loads.

Here is an example plan to achieve a goal for reference:
Scene_Objects:['pot', 'tablelamp', 'scissors', 'food_ice_cream', 'chair', 'walllamp', 'cpuscreen', 'floor', 'ceiling', 'stamp', 'piano_bench', 'ceilinglamp', 'mat', 'window', 'mousepad', 'couch', 'pillow', 'wall', 'nightstand', 'photoframe', 'check', 'television', 'toothbrush_holder', 'curtain', 'diary', 'vacuum_cleaner', 'sink', 'home_office', 'light', 'dishwasher']
Task:Relax on sofa
response:
{
    "thoughts": walk to living room, walk to sofa, sit on sofa.,
    "actions": ['[WALK] <home_office>', '[WALK] <couch>', '[SIT] <couch>']
}

Input:
Scene_Objects:['pot', 'food_ice_cream', 'microwave', 'toilet', 'freezer', 'walllamp', 'drawing', 'knifeblock', 'food_egg', 'kitchen_cabinet', 'floor', 'ceiling', 'phone', 'stovefan', 'mat', 'toaster', 'shower', 'faucet', 'oil', 'food_kiwi', 'nightstand', 'wall', 'powersocket', 'oven', 'cup', 'photoframe', 'food_food', 'oven_mitts', 'tray', 'doorjamb', 'kitchen_counter', 'dishrack', 'cupboard', 'door', 'sink', 'light', 'dishwasher']
Task:Cook some food
response:

Walk into kitchen. Open fridge. Take food from fridge. Close fridge. Put food on kitchen counter. Prepare food. Turn on stove. Open kitchen cabinet. Take pot. Close cabinet. Put food in pot. Put pot on stove. Cook food.

[WALK] <dining_room>
[WALK] <freezer>
[FIND] <freezer>
[OPEN] <freezer>
[FIND] <food_food>
[GRAB] <food_food>
[FIND] <kitchen_counter>
[PUTBACK] <food_food> <kitchen_counter>
[CLOSE] <freezer>
[FIND] <kitchen_cabinet>
[OPEN] <kitchen_cabinet>
[FIND] <pot>
[GRAB] <pot>
[CLOSE] <kitchen_cabinet>
[FIND] <oven>
[PUTBACK] <pot> <oven>
[GRAB] <food_food>
[PUTBACK] <food_food> <oven>


Instruction:
You serve as an AI task planner.
1. Your task is to create a plan to achieve a goal by converting it into a sequence of actions. Each action should follow the format "[verb] <target1> <target2>", where 'verb' represents the action, and 'target1' and 'target2' are optional arguments.
2. You must describe your plan in natural language at the beginning. After that, you should list all the actions together.
Ensure that you response can be parsed by Python json.loads.

Here is an example plan to achieve a goal for reference:
Scene_Objects:['tablelamp', 'toilet', 'walllamp', 'orchid', 'knifeblock', 'wallshelf', 'floor', 'ceiling', 'character', 'video_game_console', 'bedroom', 'computer', 'button', 'table_cloth', 'tvstand', 'window', 'closetdrawer', 'couch', 'pillow', 'nightstand', 'wall', 'powersocket', 'box', 'video_game_controller', 'television', 'curtain', 'pencil', 'dresser', 'door', 'table']
Task:Play games
response:
{
    "thoughts": Turn on the television. Turn on the video game system. Insert desired game into gaming system. Follow directions on game to and push needed buttons on video  game remote controller.,
    "actions": ['[WALK] <home_office>', '[WALK] <television>', '[FIND] <television>', '[SWITCHON] <television>', '[FIND] <video_game_console>', '[SWITCHON] <video_game_console>', '[FIND] <video_game_controller>', '[GRAB] <video_game_controller>', '[FIND] <button>', '[PUSH] <button>', '[TURNTO] <television>', '[WATCH] <television>']
}

Input:
Scene_Objects:['pot', 'tea', 'chair', 'detergent', 'toothbrush', 'orchid', 'knifeblock', 'cpuscreen', 'kitchen_cabinet', 'floor', 'phone', 'bedroom', 'keyboard', 'ceilinglamp', 'faucet', 'window', 'dish_soap', 'food_jam', 'food_orange', 'pillow', 'wall', 'oven', 'bed', 'novel', 'coffe_maker', 'kitchen_counter', 'dishrack', 'cupboard', 'table', 'dishwasher']
Task:Wash dishes with dishwasher
response:

I walk to the kitchen. I open the dishwasher. I open the kitchen cabinet. I reach inside the cabinet and grab the box of dish soap. I add some soap to the open dishwasher. I put the box of dish soap back in the kitchen cabinet. I close the kitchen cabinet and then I close the dishwasher. I turn the dishwasher on and wait.

[WALK] <dining_room>
[WALK] <dishwasher>
[FIND] <dishwasher>
[OPEN] <dishwasher>
[FIND] <kitchen_cabinet>
[OPEN] <kitchen_cabinet>
[FIND] <dish_soap>
[GRAB] <dish_soap>
[PUTBACK] <dish_soap> <dishwasher>
[GRAB] <dish_soap>
[PUTIN] <dish_soap> <kitchen_cabinet>
[CLOSE] <kitchen_cabinet>
[CLOSE] <dishwasher>
[SWITCHON] <dishwasher>


Instruction:
You serve as an AI task planner.
1. Your task is to create a plan to achieve a goal by converting it into a sequence of actions. Each action should follow the format "[verb] <target1> <target2>", where 'verb' represents the action, and 'target1' and 'target2' are optional arguments.
2. You must describe your plan in natural language at the beginning. After that, you should list all the actions together.
Ensure that you response can be parsed by Python json.loads.

Here is an example plan to achieve a goal for reference:
Scene_Objects:['tablelamp', 'chair', 'walllamp', 'orchid', 'drawing', 'floor', 'ceiling', 'computer', 'button', 'toaster', 'ceilinglamp', 'tvstand', 'window', 'closetdrawer', 'couch', 'pillow', 'nightstand', 'wall', 'basket_for_clothes', 'food_food', 'check', 'television', 'tray', 'curtain', 'dresser', 'door', 'home_office', 'table', 'clothes_shirt', 'coffee']
Task:Watch TV
response:
{
    "thoughts": I walk to the living room. I reach for the remote. I push the on button on the remote. I sit down on the couch and watch television.,
    "actions": ['[WALK] <home_office>', '[WALK] <button>', '[FIND] <button>', '[PUSH] <button>', '[FIND] <couch>', '[SIT] <couch>', '[FIND] <television>', '[TURNTO] <television>', '[WATCH] <television>']
}

Input:
Scene_Objects:['tablelamp', 'chair', 'jelly', 'bathroom', 'knife', 'dvd_player', 'character', 'bedroom', 'thread', 'computer', 'toaster', 'shoe-shine_kit', 'deck_of_cards', 'shower', 'electric_shaver', 'homework', 'food_peanut_butter', 'form', 'powersocket', 'food_cheese', 'photoframe', 'bed', 'novel', 'light_bulb', 'food_food', 'curtain', 'coffee_pot', 'food_steak', 'door', 'light']
Task:Listen to music
response:

Go to the living room. Find the radio. Turn on the radio.

[WALK] <home_office>
[WALK] <stereo>
[FIND] <stereo>
[SWITCHON] <stereo>


Instruction:
You serve as an AI task planner.
1. Your task is to create a plan to achieve a goal by converting it into a sequence of actions. Each action should follow the format "[verb] <target1> <target2>", where 'verb' represents the action, and 'target1' and 'target2' are optional arguments.
2. You must describe your plan in natural language at the beginning. After that, you should list all the actions together.
Ensure that you response can be parsed by Python json.loads.

Here is an example plan to achieve a goal for reference:
Scene_Objects:['microwave', 'walllamp', 'orchid', 'ceiling', 'desk', 'computer', 'food_bacon', 'stovefan', 'ceilinglamp', 'plate', 'shower', 'faucet', 'window', 'form', 'dining_room', 'oven', 'basket_for_clothes', 'keys', 'novel', 'food_food', 'coffe_maker', 'food_rice', 'tray', 'doorjamb', 'cards', 'mouse', 'pajamas', 'home_office', 'light', 'bathroom_cabinet']
Task:Listen to music
response:
{
    "thoughts": Find the playback device you want to listen to. turn on. press play. enjoyu music.,
    "actions": ['[WALK] <bedroom>', '[WALK] <cd_player>', '[FIND] <cd_player>', '[SWITCHON] <cd_player>']
}

Input:
Scene_Objects:['scissors', 'mop', 'bathroom', 'food_egg', 'wallshelf', 'clothes_underwear', 'character', 'bookshelf', 'food_cake', 'button', 'bookmark', 'laptop', 'mat', 'iron', 'wall', 'powersocket', 'television', 'console', 'mouse', 'shoes', 'pajamas', 'cupboard', 'door', 'hairdryer', 'home_office', 'light', 'bathroom_cabinet', 'soap', 'laser_pointer', 'washing_machine']
Task:Wash clothes
response:

Walk to bathroom. Open washer. Put clothes in washer. Put soap in washer. Close washer. Turn washer on.


Instruction:
You serve as an AI task planner.
1. Your task is to create a plan to achieve a goal by converting it into a sequence of actions. Each action should follow the format "[verb] <target1> <target2>", where 'verb' represents the action, and 'target1' and 'target2' are optional arguments.
2. You must describe your plan in natural language at the beginning. After that, you should list all the actions together.
Ensure that you response can be parsed by Python json.loads.

Here is an example plan to achieve a goal for reference:
Scene_Objects:['tablelamp', 'chair', 'walllamp', 'ground_coffee', 'drawing', 'cpuscreen', 'hanger', 'floor', 'ceiling', 'desk', 'bookshelf', 'keyboard', 'computer', 'stovefan', 'ceilinglamp', 'mousepad', 'closetdrawer', 'dining_room', 'wall', 'nightstand', 'powersocket', 'check', 'television', 'doorjamb', 'mouse', 'pencil', 'dresser', 'sink', 'light', 'table']
Task:Work
response:
{
    "thoughts": I go to the home office to work on my project. I turn on the light and walk to my desk. I turn on the computer. Then I look through the documents. After I'm done, I turn off the computer.,
    "actions": ['[WALK] <home_office>', '[WALK] <light>', '[FIND] <light>', '[SWITCHON] <light>', '[WALK] <desk>', '[FIND] <computer>', '[SWITCHON] <computer>', '[FIND] <check>', '[TURNTO] <check>', '[LOOKAT] <check>', '[SWITCHOFF] <computer>']
}

Input:
Scene_Objects:['tablelamp', 'food_oatmeal', 'toilet', 'freezer', 'food_carrot', 'drawing', 'kitchen_cabinet', 'floor', 'ceiling', 'bathroom_counter', 'stamp', 'food_cake', 'computer', 'mat', 'shower', 'food_cereal', 'wall', 'nightstand', 'powersocket', 'food_vegetable', 'photoframe', 'newspaper', 'food_food', 'coffe_maker', 'doorjamb', 'pencil', 'door', 'bathroom_cabinet', 'light', 'scrabble']
Task:Put groceries in Fridge
response:

Walk to kitchen, find groceries in cabinet and move them to fridge and close fridge.

[WALK] <dining_room>
[WALK] <kitchen_cabinet>
[FIND] <kitchen_cabinet>
[FIND] <food_vegetable>
[GRAB] <food_vegetable>
[FIND] <freezer>
[OPEN] <freezer>
[PUTIN] <food_vegetable> <freezer>
[FIND] <food_carrot>
[GRAB] <food_carrot>
[PUTIN] <food_carrot> <freezer>
[FIND] <food_cereal>
[GRAB] <food_cereal>
[PUTIN] <food_cereal> <freezer>
[FIND] <food_oatmeal>
[GRAB] <food_oatmeal>
[PUTIN] <food_oatmeal> <freezer>
[FIND] <food_food>
[GRAB] <food_food>
[PUTIN] <food_food> <freezer>
[FIND] <freezer>
[CLOSE] <freezer>


Instruction:
You serve as an AI task planner.
1. Your task is to create a plan to achieve a goal by converting it into a sequence of actions. Each action should follow the format "[verb] <target1> <target2>", where 'verb' represents the action, and 'target1' and 'target2' are optional arguments.
2. You must describe your plan in natural language at the beginning. After that, you should list all the actions together.
Ensure that you response can be parsed by Python json.loads.

Here is an example plan to achieve a goal for reference:
Scene_Objects:['sheets', 'microwave', 'toilet', 'ground_coffee', 'blow_dryer', 'orchid', 'wallshelf', 'bathroom_counter', 'character', 'desk', 'bookshelf', 'alcohol', 'computer', 'ceilinglamp', 'laptop', 'faucet', 'pillow', 'wall_clock', 'powersocket', 'oven', 'cutting_board', 'cup', 'television', 'oven_mitts', 'after_shave', 'doorjamb', 'diary', 'towel_rack', 'cards', 'maindoor']
Task:Pet cat
response:
{
    "thoughts": Walk to living room. Find cat. Walk to cat. Pull cat.,
    "actions": ['[WALK] <home_office>', '[WALK] <cat>', '[FIND] <cat>', '[WALK] <cat>', '[PULL] <cat>']
}

Input:
Scene_Objects:['sheets', 'toilet', 'bathroom', 'bills', 'orchid', 'cpuscreen', 'floor', 'phone', 'character', 'bedroom', 'piano_bench', 'toaster', 'mat', 'ceilinglamp', 'window', 'foundation', 'electric_shaver', 'oil', 'closetdrawer', 'couch', 'broom', 'nightstand', 'wall', 'cup', 'bed', 'check', 'toothbrush_holder', 'sink', 'napkin', 'dishwasher']
Task:Go to sleep
response:

Enter bedroom, turn on the light, and shut door. Change into night clothes. Turn off light. Turn down comforter, climb into bed, lay head on pillow, and cover up with comforter. Close eyes and drift off to sleep.

[WALK] <bedroom>
[WALK] <bed>
[FIND] <bed>
[LIE] <bed>
[FIND] <sheets>
[PULL] <sheets>


Instruction:
You serve as an AI task planner.
1. Your task is to create a plan to achieve a goal by converting it into a sequence of actions. Each action should follow the format "[verb] <target1> <target2>", where 'verb' represents the action, and 'target1' and 'target2' are optional arguments.
2. You must describe your plan in natural language at the beginning. After that, you should list all the actions together.
Ensure that you response can be parsed by Python json.loads.

Here is an example plan to achieve a goal for reference:
Scene_Objects:['crayon', 'microwave', 'toilet', 'freezer', 'ground_coffee', 'longboard', 'shampoo', 'character', 'thread', 'food_bacon', 'piano_bench', 'balanceball', 'stereo', 'window', 'picture', 'mousepad', 'pillow', 'toy', 'basket_for_clothes', 'photoframe', 'novel', 'coffe_maker', 'oven_mitts', 'colander', 'doorjamb', 'shaving_cream', 'dresser', 'soap', 'washing_machine', 'creditcard']
Task:Wash clothes
response:
{
    "thoughts": walk to the bathroom, grab the basket for clothes, find soap, put in washing machine, turn on,
    "actions": ['[WALK] <bathroom>', '[WALK] <basket_for_clothes>', '[FIND] <basket_for_clothes>', '[GRAB] <basket_for_clothes>', '[WALK] <washing_machine>', '[OPEN] <washing_machine>', '[PUTBACK] <basket_for_clothes> <washing_machine>', '[FIND] <soap>', '[GRAB] <soap>', '[WALK] <washing_machine>', '[PUTBACK] <soap> <washing_machine>', '[CLOSE] <washing_machine>', '[SWITCHON] <washing_machine>']
}

Input:
Scene_Objects:['water_glass', 'tablelamp', 'toilet', 'chair', 'walllamp', 'detergent', 'cat', 'knife', 'cpuscreen', 'floor', 'ceiling', 'mail', 'toaster', 'ceilinglamp', 'stovefan', 'stereo', 'homework', 'couch', 'pillow', 'nightstand', 'wall', 'powersocket', 'tape', 'newspaper', 'photoframe', 'food_food', 'television', 'water', 'tray', 'bathroom_cabinet']
Task:Drink
response:

[WALK] <dining_room>
[WALK] <water>
[FIND] <water>
[GRAB] <water>
[FIND] <water_glass>
[POUR] <water> <water_glass>
[GRAB] <water_glass>
[DRINK] <water_glass>
[WALK] <home_office>
[WALK] <couch>
[FIND] <couch>
[SIT] <couch>


Instruction:
You serve as an AI task planner.
1. Your task is to create a plan to achieve a goal by converting it into a sequence of actions. Each action should follow the format "[verb] <target1> <target2>", where 'verb' represents the action, and 'target1' and 'target2' are optional arguments.
2. You must describe your plan in natural language at the beginning. After that, you should list all the actions together.
Ensure that you response can be parsed by Python json.loads.

Here is an example plan to achieve a goal for reference:
Scene_Objects:['tea', 'chair', 'freezer', 'cpuscreen', 'food_egg', 'hanger', 'floor', 'ceiling', 'phone', 'desk', 'bookshelf', 'keyboard', 'computer', 'clothes_jacket', 'stovefan', 'mousepad', 'wall', 'keys', 'check', 'oven_mitts', 'doorjamb', 'mouse', 'pencil', 'dresser', 'cupboard', 'door', 'clothes_scarf', 'napkin', 'home_office', 'light']
Task:Turn on light
response:
{
    "thoughts": turn on the light for room,
    "actions": ['[WALK] <home_office>', '[WALK] <light>', '[FIND] <light>', '[PLUGIN] <light>', '[SWITCHON] <light>', '[FIND] <chair>', '[SIT] <chair>']
}

Input:
Scene_Objects:['tablelamp', 'beer', 'toilet', 'freezer', 'bathroom', 'drawing', 'floor', 'ceiling', 'character', 'computer', 'table_cloth', 'mat', 'shower', 'window', 'food_orange', 'broom', 'nightstand', 'wall', 'powersocket', 'basket_for_clothes', 'photoframe', 'bed', 'food_food', 'doorjamb', 'hairbrush', 'controller', 'door', 'sink', 'napkin', 'light']
Task:Cook some food
response:

[WALK] <dining_room>
[WALK] <freezer>
[OPEN] <freezer>
[FIND] <food_food>


Instruction:
You serve as an AI task planner.
1. Your task is to create a plan to achieve a goal by converting it into a sequence of actions. Each action should follow the format "[verb] <target1> <target2>", where 'verb' represents the action, and 'target1' and 'target2' are optional arguments.
2. You must describe your plan in natural language at the beginning. After that, you should list all the actions together.
Ensure that you response can be parsed by Python json.loads.

Here is an example plan to achieve a goal for reference:
Scene_Objects:['sheets', 'tablelamp', 'microwave', 'toilet', 'bathroom', 'toothbrush', 'drawing', 'cpuscreen', 'hanger', 'bathroom_counter', 'phone', 'bedroom', 'computer', 'button', 'toaster', 'mat', 'stereo', 'foundation', 'window', 'couch', 'bench', 'oven', 'cup', 'check', 'television', 'tray', 'dresser', 'home_office', 'light', 'bathroom_cabinet']
Task:Listen to music
response:
{
    "thoughts": Walk into living room, look for radio, grab on button,
    "actions": ['[WALK] <home_office>', '[WALK] <stereo>', '[FIND] <stereo>', '[TURNTO] <stereo>', '[LOOKAT] <stereo>', '[FIND] <button>', '[GRAB] <button>']
}

Input:
Scene_Objects:['sheets', 'glue', 'chair', 'milk', 'toothbrush', 'orchid', 'drawing', 'bathroom_counter', 'floor', 'ceiling', 'phone', 'bookshelf', 'alcohol', 'mop_bucket', 'table_cloth', 'mat', 'faucet', 'homework', 'clothes_socks', 'closetdrawer', 'teeth', 'mousepad', 'wall', 'powersocket', 'doorjamb', 'shaving_cream', 'sink', 'bathroom_cabinet', 'light', 'hands_both']
Task:Wash hands
response:

I go to the bathroom, walk to the sink, turn on the faucet and then wash my hands under the water.

[WALK] <bathroom>
[WALK] <sink>
[FIND] <faucet>
[TURNTO] <faucet>
[FIND] <hands_both>
[WASH] <hands_both>


Instruction:
You serve as an AI task planner.
1. Your task is to create a plan to achieve a goal by converting it into a sequence of actions. Each action should follow the format "[verb] <target1> <target2>", where 'verb' represents the action, and 'target1' and 'target2' are optional arguments.
2. You must describe your plan in natural language at the beginning. After that, you should list all the actions together.
Ensure that you response can be parsed by Python json.loads.

Here is an example plan to achieve a goal for reference:
Scene_Objects:['walllamp', 'drawing', 'orchid', 'hanger', 'floor', 'ceiling', 'desk', 'remote_control', 'ceilinglamp', 'tvstand', 'mat', 'window', 'couch', 'clothes_pants', 'form', 'pillow', 'towel', 'wall', 'powersocket', 'bench', 'newspaper', 'television', 'curtain', 'doorjamb', 'mouse', 'hair', 'door', 'bathroom_cabinet', 'table', 'dishwasher']
Task:Watch TV
response:
{
    "thoughts": SIT ON THE COUCH, TURN TV ON WITH REMOTE, FIND A SHOW,
    "actions": ['[WALK] <home_office>', '[WALK] <couch>', '[FIND] <couch>', '[SIT] <couch>', '[FIND] <remote_control>', '[GRAB] <remote_control>', '[FIND] <television>', '[SWITCHON] <television>', '[PUTOBJBACK] <remote_control>', '[TURNTO] <television>', '[WATCH] <television>']
}

Input:
Scene_Objects:['glue', 'food_bread', 'filing_cabinet', 'scissors', 'knife', 'character', 'stamp', 'bookshelf', 'keyboard', 'bookmark', 'ceilinglamp', 'tvstand', 'shower', 'foundation', 'food_noodles', 'towel', 'tape', 'check', 'mouthwash', 'television', 'wooden_spoon', 'tray', 'kettle', 'kitchen_counter', 'cd', 'laundry_detergent', 'sink', 'light', 'soap', 'instrument_violin']
Task:Wash hands
response:

I walk to the kitchen and get the soap and wash my both hand using the soap and rinse my hands and use towel.

[WALK] <dining_room>
[WALK] <soap>
[FIND] <soap>
[GRAB] <soap>
[SCRUB] <soap>
[FIND] <towel>
[RINSE] <towel>


Instruction:
You serve as an AI task planner.
1. Your task is to create a plan to achieve a goal by converting it into a sequence of actions. Each action should follow the format "[verb] <target1> <target2>", where 'verb' represents the action, and 'target1' and 'target2' are optional arguments.
2. You must describe your plan in natural language at the beginning. After that, you should list all the actions together.
Ensure that you response can be parsed by Python json.loads.

Here is an example plan to achieve a goal for reference:
Scene_Objects:['tablelamp', 'tea', 'chair', 'walllamp', 'orchid', 'cpuscreen', 'wallshelf', 'hanger', 'floor', 'ceiling', 'phone', 'desk', 'keyboard', 'computer', 'toaster', 'ceilinglamp', 'tvstand', 'mat', 'mousepad', 'couch', 'pillow', 'wall', 'nightstand', 'television', 'doorjamb', 'mouse', 'vacuum_cleaner', 'dresser', 'door', 'home_office']
Task:Vacuum
response:
{
    "thoughts": Keep my keyboard vacuumed and free of debris.,
    "actions": ['[WALK] <home_office>', '[WALK] <computer>', '[FIND] <vacuum_cleaner>', '[SWITCHON] <vacuum_cleaner>', '[SWITCHOFF] <vacuum_cleaner>']
}

Input:
Scene_Objects:['sheets', 'filing_cabinet', 'tablelamp', 'food_ice_cream', 'chair', 'walllamp', 'knifeblock', 'hanger', 'floor', 'ceiling', 'food_bacon', 'toaster', 'ceilinglamp', 'oil', 'closetdrawer', 'couch', 'food_jam', 'pillow', 'wall', 'nightstand', 'newspaper', 'television', 'coin', 'lighter', 'laundry_detergent', 'napkin', 'home_office', 'dishwasher', 'soap', 'laser_pointer']
Task:Relax on sofa
response:

walk to living room, find sofa, sit in sofa

[WALK] <home_office>
[WALK] <couch>
[FIND] <couch>
[WALK] <couch>
[SIT] <couch>


Instruction:
You serve as an AI task planner.
1. Your task is to create a plan to achieve a goal by converting it into a sequence of actions. Each action should follow the format "[verb] <target1> <target2>", where 'verb' represents the action, and 'target1' and 'target2' are optional arguments.
2. You must describe your plan in natural language at the beginning. After that, you should list all the actions together.
Ensure that you response can be parsed by Python json.loads.

Here is an example plan to achieve a goal for reference:
Scene_Objects:['walllamp', 'drawing', 'orchid', 'wallshelf', 'knifeblock', 'knife', 'bathroom_counter', 'floor', 'ceiling', 'bookshelf', 'mat', 'tvstand', 'ceilinglamp', 'shower', 'window', 'couch', 'pillow', 'wall', 'powersocket', 'photoframe', 'light_bulb', 'television', 'curtain', 'doorjamb', 'cd', 'pajamas', 'door', 'table', 'light', 'dishwasher']
Task:Watch TV
response:
{
    "thoughts": Sitting on the couch watching my favorite television show.,
    "actions": ['[WALK] <home_office>', '[WALK] <couch>', '[FIND] <couch>', '[SIT] <couch>', '[FIND] <television>', '[TURNTO] <television>', '[WATCH] <television>']
}

Input:
Scene_Objects:['water_glass', 'blender', 'food_salt', 'chair', 'walllamp', 'nail_polish', 'bathroom', 'milk', 'drawing', 'wallshelf', 'clothes_underwear', 'bathroom_counter', 'floor', 'character', 'stamp', 'envelope', 'button', 'stovefan', 'ceilinglamp', 'mat', 'faucet', 'closetdrawer', 'form', 'coffe_maker', 'water', 'mouse', 'dresser', 'hairbrush', 'cupboard', 'table']
Task:Drink
response:

walk to kitchen, hold drinking glass, lift glass, pour water in drinking glass

[WALK] <dining_room>
[WALK]

[FIND]

[FIND] <water_glass>
[GRAB] <water_glass>
[FIND] <water>
[GRAB] <water>
[WALK] <water>
[POUR] <water> <water_glass>
[DRINK] <water_glass>


Instruction:
You serve as an AI task planner.
1. Your task is to create a plan to achieve a goal by converting it into a sequence of actions. Each action should follow the format "[verb] <target1> <target2>", where 'verb' represents the action, and 'target1' and 'target2' are optional arguments.
2. You must describe your plan in natural language at the beginning. After that, you should list all the actions together.
Ensure that you response can be parsed by Python json.loads.

Here is an example plan to achieve a goal for reference:
Scene_Objects:['filing_cabinet', 'freezer', 'walllamp', 'trashcan', 'drawing', 'orchid', 'bathroom_counter', 'floor', 'ceiling', 'desk', 'keyboard', 'computer', 'mat', 'tvstand', 'window', 'mousepad', 'couch', 'pillow', 'wall', 'powersocket', 'bench', 'bed', 'coin', 'curtain', 'dresser', 'cupboard', 'door', 'bathtub', 'sink', 'light']
Task:Wipe down baseboards please
response:
{
    "thoughts": Use a rag to get all the dust off the baseboards please.,
    "actions": ['[WALK] <home_office>', '[WALK] <rag>', '[FIND] <rag>', '[GRAB] <rag>', '[WALK] <wall>', '[PUTOBJBACK] <rag>']
}

Input:
Scene_Objects:['pot', 'microwave', 'chair', 'walllamp', 'detergent', 'knifeblock', 'wallshelf', 'cpuscreen', 'floor', 'ceiling', 'stovefan', 'toaster', 'faucet', 'dining_room', 'wall', 'pasta', 'oven', 'cup', 'food_cheese', 'keys', 'coffe_maker', 'water', 'tray', 'centerpiece', 'mouse', 'kitchen_counter', 'cupboard', 'sink', 'dishwasher', 'clothes_shirt']
Task:Drink
response:

Walk to kitchen, walk to cupboard, open cupboard, grab cup, walk to sink, pour water in cup, drink water.

[WALK] <dining_room>
[WALK] <cupboard>
[FIND] <cupboard>
[OPEN] <cupboard>
[FIND] <cup>
[GRAB] <cup>
[WALK] <sink>
[WALK] <water>
[FIND] <water>
[GRAB] <water>
[POUR] <water> <cup>
[DRINK] <cup>


Instruction:
You serve as an AI task planner.
1. Your task is to create a plan to achieve a goal by converting it into a sequence of actions. Each action should follow the format "[verb] <target1> <target2>", where 'verb' represents the action, and 'target1' and 'target2' are optional arguments.
2. You must describe your plan in natural language at the beginning. After that, you should list all the actions together.
Ensure that you response can be parsed by Python json.loads.

Here is an example plan to achieve a goal for reference:
Scene_Objects:['filing_cabinet', 'scissors', 'walllamp', 'orchid', 'needle', 'clothes_underwear', 'dvd_player', 'character', 'desk', 'mop_bucket', 'table_cloth', 'brush', 'ceilinglamp', 'mat', 'stereo', 'dining_room', 'nightstand', 'powersocket', 'toy', 'shelf', 'check', 'toothbrush_holder', 'mouse', 'chessboard', 'dresser', 'laundry_detergent', 'home_office', 'bathroom_cabinet', 'teeth', 'creditcard']
Task:Put toys away
response:
{
    "thoughts": Pick up all the toys on the floor and put them in their correct storage bin or shelf.,
    "actions": ['[WALK] <bedroom>', '[WALK] <toy>', '[FIND] <toy>', '[GRAB] <toy>', '[WALK] <filing_cabinet>', '[OPEN] <filing_cabinet>', '[PUTBACK] <toy> <filing_cabinet>', '[FIND] <toy>', '[GRAB] <toy>', '[WALK] <filing_cabinet>', '[PUTBACK] <toy> <filing_cabinet>', '[FIND] <toy>', '[GRAB] <toy>', '[WALK] <filing_cabinet>', '[PUTBACK] <toy> <filing_cabinet>', '[CLOSE] <filing_cabinet>']
}

Input:
Scene_Objects:['sheets', 'pot', 'crayon', 'toilet', 'chair', 'freezer', 'milk', 'drawing', 'wallshelf', 'floor', 'ceiling', 'desk', 'brush', 'mat', 'shower', 'nightstand', 'wall', 'powersocket', 'tape', 'food_cheese', 'photoframe', 'food_food', 'check', 'doorjamb', 'cupboard', 'controller', 'door', 'clothes_scarf', 'light', 'table']
Task:Put groceries in Fridge
response:

I pick up groceries. I open fridge. I put groceries in the fridge.

[WALK] <dining_room>
[WALK] <food_food>
[FIND] <food_food>
[GRAB] <food_food>
[FIND] <freezer>
[OPEN] <freezer>
[DROP] <food_food>


Instruction:
You serve as an AI task planner.
1. Your task is to create a plan to achieve a goal by converting it into a sequence of actions. Each action should follow the format "[verb] <target1> <target2>", where 'verb' represents the action, and 'target1' and 'target2' are optional arguments.
2. You must describe your plan in natural language at the beginning. After that, you should list all the actions together.
Ensure that you response can be parsed by Python json.loads.

Here is an example plan to achieve a goal for reference:
Scene_Objects:['beer', 'walllamp', 'drawing', 'orchid', 'food_egg', 'hanger', 'floor', 'ceiling', 'phone', 'desk', 'remote_control', 'toaster', 'ceilinglamp', 'tvstand', 'mat', 'faucet', 'window', 'couch', 'candle', 'pillow', 'wall', 'nightstand', 'powersocket', 'keys', 'television', 'curtain', 'doorjamb', 'door', 'sink', 'table']
Task:Watch movie
response:
{
    "thoughts": Sit down on couch in front of TV.  Use remote to turn on the TV,
    "actions": ['[WALK] <home_office>', '[WALK] <couch>', '[FIND] <couch>', '[SIT] <couch>', '[FIND] <remote_control>', '[GRAB] <remote_control>', '[FIND] <television>', '[SWITCHON] <television>', '[TURNTO] <television>', '[WATCH] <television>']
}

Input:
Scene_Objects:['sheets', 'scissors', 'toilet', 'band-aids', 'food_carrot', 'dough', 'orchid', 'wallshelf', 'hanger', 'floor', 'ceiling', 'folder', 'bedroom', 'shoe-shine_kit', 'closetdrawer', 'food_orange', 'nightstand', 'wall', 'powersocket', 'coin', 'shaving_cream', 'pencil', 'cupboard', 'sink', 'napkin', 'instrument_guitar', 'bathroom_cabinet', 'soap', 'scrabble', 'washing_machine']
Task:Wash clothes
response:

I go to the bedroom to find and grab basket of clothes. I then go to the bathroom and find the washing machine. I put clothes inside the washing machine and put washing powder. I switch on the washing machine.


Instruction:
You serve as an AI task planner.
1. Your task is to create a plan to achieve a goal by converting it into a sequence of actions. Each action should follow the format "[verb] <target1> <target2>", where 'verb' represents the action, and 'target1' and 'target2' are optional arguments.
2. You must describe your plan in natural language at the beginning. After that, you should list all the actions together.
Ensure that you response can be parsed by Python json.loads.

Here is an example plan to achieve a goal for reference:
Scene_Objects:['fork', 'water_glass', 'pot', 'freezer', 'walllamp', 'bathroom', 'food_butter', 'food_carrot', 'milk', 'knifeblock', 'knife', 'floor', 'ceiling', 'mail', 'computer', 'stovefan', 'ceilinglamp', 'brush', 'faucet', 'wall', 'nightstand', 'cutting_board', 'cup', 'photoframe', 'water', 'pencil', 'kitchen_counter', 'cupboard', 'sink', 'soap']
Task:Drink
response:
{
    "thoughts": I enter the kitchen and grab a waterglass from the cupboard. I open the fridge and grap some water. I pour the water into the cup and drink it.,
    "actions": ['[WALK] <dining_room>', '[WALK] <cupboard>', '[FIND] <cupboard>', '[OPEN] <cupboard>', '[FIND] <water_glass>', '[GRAB] <water_glass>', '[WALK] <freezer>', '[OPEN] <freezer>', '[WALK] <water>', '[FIND] <water>', '[GRAB] <water>', '[POUR] <water> <water_glass>', '[DRINK] <water_glass>']
}

Input:
Scene_Objects:['food_ice_cream', 'microwave', 'toilet', 'chair', 'knifeblock', 'hanger', 'floor', 'toaster', 'stovefan', 'shoe-shine_kit', 'faucet', 'homework', 'food_noodles', 'mousepad', 'couch', 'wall', 'nightstand', 'powersocket', 'cup', 'newspaper', 'coffee_filter', 'food_rice', 'console', 'mouse', 'kitchen_counter', 'dishrack', 'comb', 'cupboard', 'door', 'sink']
Task:Drink
response:

go to the kitchen, walk to the cabinet, pic up a glass. carry the glass to the sink. turn on the water and fill up the glass. drink the water.

[WALK] <dining_room>
[WALK] <sink>
[FIND] <cup>
[GRAB] <cup>
[WALK] <water>
[FIND] <water>
[GRAB] <water>
[POUR] <water> <cup>
[DRINK] <cup>


Instruction:
You serve as an AI task planner.
1. Your task is to create a plan to achieve a goal by converting it into a sequence of actions. Each action should follow the format "[verb] <target1> <target2>", where 'verb' represents the action, and 'target1' and 'target2' are optional arguments.
2. You must describe your plan in natural language at the beginning. After that, you should list all the actions together.
Ensure that you response can be parsed by Python json.loads.

Here is an example plan to achieve a goal for reference:
Scene_Objects:['toilet', 'drawing', 'wallshelf', 'bathroom_counter', 'floor', 'ceiling', 'desk', 'bookshelf', 'table_cloth', 'bookmark', 'mat', 'shower', 'faucet', 'closetdrawer', 'dining_room', 'wall', 'powersocket', 'oven', 'keys', 'coffe_maker', 'television', 'tray', 'doorjamb', 'pencil', 'kitchen_counter', 'door', 'hairdryer', 'bathroom_cabinet', 'light', 'home_office']
Task:Turn on light
response:
{
    "thoughts": I open the room door and press the light button on,
    "actions": ['[WALK] <home_office>', '[WALK] <light>', '[FIND] <light>', '[SWITCHON] <light>']
}

Input:
Scene_Objects:['food_pizza', 'chair', 'freezer', 'walllamp', 'orchid', 'cpuscreen', 'wallshelf', 'floor', 'ceiling', 'desk', 'keyboard', 'computer', 'mat', 'ceilinglamp', 'tvstand', 'shower', 'faucet', 'mousepad', 'closetdrawer', 'couch', 'pillow', 'wall', 'check', 'television', 'doorjamb', 'mouse', 'dresser', 'door', 'light', 'table']
Task:Write an email
response:

I go to the home office to find the computer. I turn switch computer on , i open the email. i write the email and  send it.

[WALK] <home_office>
[WALK] <computer>
[FIND] <computer>
[SWITCHON] <computer>


Instruction:
You serve as an AI task planner.
1. Your task is to create a plan to achieve a goal by converting it into a sequence of actions. Each action should follow the format "[verb] <target1> <target2>", where 'verb' represents the action, and 'target1' and 'target2' are optional arguments.
2. You must describe your plan in natural language at the beginning. After that, you should list all the actions together.
Ensure that you response can be parsed by Python json.loads.

Here is an example plan to achieve a goal for reference:
Scene_Objects:['pot', 'freezer', 'ceilingfan', 'dough', 'milk', 'knifeblock', 'bills', 'floor', 'ceiling', 'bedroom', 'keyboard', 'bookshelf', 'computer', 'mop_bucket', 'ceilinglamp', 'microphone', 'wall', 'bench', 'powersocket', 'clothes_gloves', 'light_bulb', 'food_food', 'coffe_maker', 'tray', 'curtain', 'shaving_cream', 'controller', 'door', 'maindoor', 'dirt']
Task:Put groceries in Fridge
response:
{
    "thoughts": Go to kitchen and put groceries in fridge,
    "actions": ['[WALK] <dining_room>', '[WALK] <food_food>', '[FIND] <food_food>', '[GRAB] <food_food>', '[WALK] <freezer>', '[OPEN] <freezer>', '[PUTIN] <food_food> <freezer>', '[CLOSE] <freezer>']
}

Input:
Scene_Objects:['tablelamp', 'toilet', 'chair', 'freezer', 'walllamp', 'detergent', 'floor', 'ceiling', 'keyboard', 'food_cake', 'computer', 'stovefan', 'ceilinglamp', 'faucet', 'shower', 'stereo', 'couch', 'dustpan', 'pillow', 'wall', 'nightstand', 'cup', 'photoframe', 'television', 'doorjamb', 'kitchen_counter', 'food_steak', 'bathroom_cabinet', 'light', 'dishwasher']
Task:Relax on sofa
response:

I sit on the sofa. I put my legs on the sofa and recline.

[WALK] <home_office>
[WALK] <couch>
[FIND] <couch>
[SIT] <couch>
[LIE] <couch>


Instruction:
You serve as an AI task planner.
1. Your task is to create a plan to achieve a goal by converting it into a sequence of actions. Each action should follow the format "[verb] <target1> <target2>", where 'verb' represents the action, and 'target1' and 'target2' are optional arguments.
2. You must describe your plan in natural language at the beginning. After that, you should list all the actions together.
Ensure that you response can be parsed by Python json.loads.

Here is an example plan to achieve a goal for reference:
Scene_Objects:['pot', 'filing_cabinet', 'crayon', 'microwave', 'walllamp', 'knifeblock', 'floor', 'ceiling', 'character', 'bedroom', 'bookshelf', 'purse', 'toaster', 'faucet', 'shower', 'homework', 'pillow', 'wall', 'oven', 'water', 'doorjamb', 'mouse', 'kitchen_counter', 'cupboard', 'sink', 'bathtub', 'bathroom_cabinet', 'home_office', 'soap', 'teeth']
Task:Wash hands
response:
{
    "thoughts": walk to kitchen, turn on water, find soap, apply to hand, lather, rinse, dry hands,
    "actions": ['[WALK] <dining_room>', '[WALK] <sink>', '[FIND] <sink>', '[FIND] <faucet>', '[SWITCHON] <faucet>', '[FIND] <soap>', '[GRAB] <soap>', '[SCRUB] <soap>', '[PUTOBJBACK] <soap>', '[FIND] <water>', '[RINSE] <water>']
}

Input:
Scene_Objects:['scissors', 'chair', 'ground_coffee', 'bathroom', 'drawing', 'wallshelf', 'floor', 'ceiling', 'phone', 'keyboard', 'mat', 'tvstand', 'plate', 'pillow', 'wall', 'nightstand', 'bed', 'coffe_maker', 'television', 'coffee_filter', 'razor', 'tray', 'kitchen_counter', 'cupboard', 'hairdryer', 'home_office', 'light', 'dishwasher', 'table', 'dirt']
Task:Make coffee
response:

[WALK] <dining_room>
[WALK] <coffe_maker>
[FIND] <coffe_maker>
[PLUGIN] <coffe_maker>
[OPEN] <coffe_maker>
[FIND] <coffee_filter>
[GRAB] <coffee_filter>
[PUTBACK] <coffee_filter> <coffe_maker>
[FIND] <ground_coffee>
[GRAB] <ground_coffee>
[PUTBACK] <ground_coffee> <coffe_maker>
[CLOSE] <coffe_maker>
[SWITCHON] <coffe_maker>


Instruction:
You serve as an AI task planner.
1. Your task is to create a plan to achieve a goal by converting it into a sequence of actions. Each action should follow the format "[verb] <target1> <target2>", where 'verb' represents the action, and 'target1' and 'target2' are optional arguments.
2. You must describe your plan in natural language at the beginning. After that, you should list all the actions together.
Ensure that you response can be parsed by Python json.loads.

Here is an example plan to achieve a goal for reference:
Scene_Objects:['dry_pasta', 'microwave', 'walllamp', 'bathroom', 'trashcan', 'milk', 'floor', 'ceiling', 'desk', 'keyboard', 'button', 'mop_bucket', 'toaster', 'stereo', 'window', 'wall', 'powersocket', 'bench', 'newspaper', 'coffe_maker', 'tray', 'curtain', 'food_sugar', 'kitchen_counter', 'vacuum_cleaner', 'cupboard', 'coffee_cup', 'dishwasher', 'light', 'clothes_shirt']
Task:Make coffee
response:
{
    "thoughts": walk to kitchen, look at the coffee maker, open the coffee maker, find milk, suger and water, mix that all, put into coffee maker, switch on the coffee maker, wait for few mins, push the coffee button in coffee maker, we get coffee in coffee cup, drink coffee,
    "actions": ['[WALK] <dining_room>', '[WALK] <coffe_maker>', '[FIND] <coffe_maker>', '[TURNTO] <coffe_maker>', '[LOOKAT] <coffe_maker>', '[OPEN] <coffe_maker>', '[FIND] <milk>', '[GRAB] <milk>', '[PUTBACK] <milk> <coffe_maker>', '[FIND] <food_sugar>', '[FIND] <coffee_cup>', '[GRAB] <coffee_cup>', '[PUTBACK] <coffee_cup> <coffe_maker>', '[SWITCHON] <coffe_maker>', '[FIND] <button>', '[PUSH] <button>', '[GRAB] <coffee_cup>', '[DRINK] <coffee_cup>']
}

Input:
Scene_Objects:['sheets', 'pot', 'blender', 'chair', 'bathroom', 'hanger', 'floor', 'tea_bag', 'food_cake', 'food_bacon', 'piano_bench', 'mat', 'plate', 'dish_soap', 'mousepad', 'closetdrawer', 'couch', 'clothes_socks', 'wall', 'powersocket', 'coffe_maker', 'curtain', 'console', 'kitchen_counter', 'cupboard', 'door', 'sink', 'napkin', 'dishwasher', 'colander']
Task:Wash dishes with dishwasher
response:

I walk to the kitchen. I search and find dishwasher. I search dishes. I put dishes inside the dishwasher. I put dish soap in dishwasher. I switch on dishwasher and wait for dishes to be washed.

[WALK] <dining_room>
[WALK] <dishwasher>
[FIND] <dishwasher>
[FIND] <plate>
[GRAB] <plate>
[OPEN] <dishwasher>
[PUTBACK] <plate> <dishwasher>
[FIND] <dish_soap>
[GRAB] <dish_soap>
[PUTBACK] <dish_soap> <dishwasher>
[CLOSE] <dishwasher>
[SWITCHON] <dishwasher>


Instruction:
You serve as an AI task planner.
1. Your task is to create a plan to achieve a goal by converting it into a sequence of actions. Each action should follow the format "[verb] <target1> <target2>", where 'verb' represents the action, and 'target1' and 'target2' are optional arguments.
2. You must describe your plan in natural language at the beginning. After that, you should list all the actions together.
Ensure that you response can be parsed by Python json.loads.

Here is an example plan to achieve a goal for reference:
Scene_Objects:['sponge', 'band-aids', 'toothbrush', 'orchid', 'phone', 'desk', 'keyboard', 'bookshelf', 'computer', 'toaster', 'faucet', 'picture', 'shower', 'mousepad', 'candle', 'food_orange', 'oven', 'basket_for_clothes', 'bed', 'check', 'food_food', 'television', 'tray', 'after_shave', 'headset', 'comb', 'dresser', 'laundry_detergent', 'napkin', 'bathroom_cabinet']
Task:Sit in chair
response:
{
    "thoughts": I sit in a chair to rest and eat.,
    "actions": ['[WALK] <dining_room>', '[WALK] <chair>', '[FIND] <chair>', '[PULL] <chair>', '[SIT] <chair>']
}

Input:
Scene_Objects:['tablelamp', 'microwave', 'walllamp', 'food_carrot', 'orchid', 'floor', 'ceiling', 'shampoo', 'bedroom', 'remote_control', 'computer', 'button', 'ceilinglamp', 'tvstand', 'shower', 'window', 'closetdrawer', 'couch', 'pillow', 'nightstand', 'wall', 'pasta', 'oven', 'novel', 'television', 'curtain', 'pencil', 'dresser', 'sink', 'table']
Task:Change TV channel
response:

walk to living room, look at the television, switch on the television, grab the remote control, press the channel button in remote control, now the tv channel is changed

[WALK] <home_office>
[WALK] <television>
[FIND] <television>
[TURNTO] <television>
[LOOKAT] <television>
[SWITCHON] <television>
[FIND] <remote_control>
[GRAB] <remote_control>
[FIND] <button>
[GRAB] <button>


Instruction:
You serve as an AI task planner.
1. Your task is to create a plan to achieve a goal by converting it into a sequence of actions. Each action should follow the format "[verb] <target1> <target2>", where 'verb' represents the action, and 'target1' and 'target2' are optional arguments.
2. You must describe your plan in natural language at the beginning. After that, you should list all the actions together.
Ensure that you response can be parsed by Python json.loads.

Here is an example plan to achieve a goal for reference:
Scene_Objects:['pot', 'toilet', 'chair', 'freezer', 'detergent', 'orchid', 'food_egg', 'bathroom_counter', 'floor', 'ceiling', 'character', 'bedroom', 'purse', 'toaster', 'mat', 'faucet', 'iron', 'mousepad', 'wall', 'powersocket', 'cup', 'coffe_maker', 'water', 'shaving_cream', 'kitchen_counter', 'cupboard', 'food_steak', 'sink', 'clothes_scarf', 'colander']
Task:Drink
response:
{
    "thoughts": I go in the kitchen and get the glass near the sink. I open the faucet, then I pour water in it, turn off the faucet and drink it.,
    "actions": ['[WALK] <dining_room>', '[WALK] <sink>', '[FIND] <cup>', '[GRAB] <cup>', '[FIND] <faucet>', '[SWITCHON] <faucet>', '[FIND] <water>', '[PUTBACK] <cup> <sink>', '[GRAB] <cup>', '[SWITCHOFF] <faucet>', '[DRINK] <cup>']
}

Input:
Scene_Objects:['food_salt', 'microwave', 'walllamp', 'bathroom', 'wallshelf', 'clothes_underwear', 'floor', 'ceiling', 'phone', 'computer', 'tvstand', 'shoe-shine_kit', 'faucet', 'window', 'mousepad', 'couch', 'wall', 'oven', 'newspaper', 'coffe_maker', 'food_food', 'doorjamb', 'kitchen_counter', 'shoes', 'cupboard', 'clothes_dress', 'door', 'sink', 'bathroom_cabinet', 'light']
Task:Pick up phone
response:

Walk to living room. Go near telephone. take the receiver and then talk to other person on that side.


Instruction:
You serve as an AI task planner.
1. Your task is to create a plan to achieve a goal by converting it into a sequence of actions. Each action should follow the format "[verb] <target1> <target2>", where 'verb' represents the action, and 'target1' and 'target2' are optional arguments.
2. You must describe your plan in natural language at the beginning. After that, you should list all the actions together.
Ensure that you response can be parsed by Python json.loads.

Here is an example plan to achieve a goal for reference:
Scene_Objects:['tablelamp', 'crayon', 'chair', 'walllamp', 'toothbrush', 'wallshelf', 'dvd_player', 'keyboard', 'bookshelf', 'computer', 'alcohol', 'mousepad', 'couch', 'form', 'pillow', 'bowl', 'nightstand', 'wall_clock', 'bench', 'oven', 'powersocket', 'clothes_gloves', 'doorjamb', 'mouse', 'kitchen_counter', 'dresser', 'hairdryer', 'bathtub', 'home_office', 'table']
Task:Write an email
response:
{
    "thoughts": I go to my bed room and sit on the chair and in front of me is my desktop computer and start writing an email.,
    "actions": ['[WALK] <bathroom>', '[WALK] <chair>', '[FIND] <chair>', '[SIT] <chair>', '[FIND] <computer>', '[SWITCHON] <computer>', '[TURNTO] <computer>', '[LOOKAT] <computer>', '[FIND] <keyboard>', '[TYPE] <keyboard>']
}

Input:
Scene_Objects:['filing_cabinet', 'toilet', 'band-aids', 'freezer', 'food_carrot', 'toothbrush', 'orchid', 'floor', 'mail', 'button', 'faucet', 'foundation', 'oil', 'pillow', 'towel', 'food_food', 'toothbrush_holder', 'doorjamb', 'lighter', 'kettle', 'headset', 'cd', 'dresser', 'hairbrush', 'controller', 'napkin', 'light', 'dishwasher', 'tooth_paste', 'teeth']
Task:Brush teeth
response:

walk to bathroom, look at the toothbrush holder, take toothbrush from the toothbrush holder, find the toothpaste, squeeze the toothpaste into toothbrush, now brush teeth

[WALK] <bathroom>
[WALK] <toothbrush_holder>
[FIND] <toothbrush_holder>
[TURNTO] <toothbrush_holder>
[LOOKAT] <toothbrush_holder>
[FIND] <toothbrush>
[TURNTO] <toothbrush>
[LOOKAT] <toothbrush>
[FIND] <tooth_paste>
[SQUEEZE] <tooth_paste>


Instruction:
You serve as an AI task planner.
1. Your task is to create a plan to achieve a goal by converting it into a sequence of actions. Each action should follow the format "[verb] <target1> <target2>", where 'verb' represents the action, and 'target1' and 'target2' are optional arguments.
2. You must describe your plan in natural language at the beginning. After that, you should list all the actions together.
Ensure that you response can be parsed by Python json.loads.

Here is an example plan to achieve a goal for reference:
Scene_Objects:['sheets', 'microwave', 'toilet', 'chair', 'dog', 'cpuscreen', 'keyboard', 'ceilinglamp', 'plate', 'laptop', 'faucet', 'window', 'stereo', 'oil', 'food_noodles', 'mousepad', 'dining_room', 'nightstand', 'food_food', 'check', 'wine', 'curtain', 'after_shave', 'comb', 'dresser', 'napkin', 'home_office', 'table', 'bathroom_cabinet', 'light']
Task:Listen to music
response:
{
    "thoughts": I reach out arm. I put hand on radio. I turn on radio. I pick a station.,
    "actions": ['[WALK] <bedroom>', '[WALK] <stereo>', '[TOUCH] <stereo>', '[TURNTO] <stereo>']
}

Input:
Scene_Objects:['sheets', 'detergent', 'orchid', 'wallshelf', 'floor', 'ceiling', 'tea_bag', 'stovefan', 'toaster', 'faucet', 'shower', 'foundation', 'tooth_paste', 'closetdrawer', 'candle', 'nightstand', 'cup', 'coffe_maker', 'food_food', 'television', 'coffee_filter', 'tray', 'curtain', 'rag', 'clothes_scarf', 'table', 'soap', 'instrument_violin', 'dirt', 'hands_both']
Task:Wash hands
response:

[WALK] <bathroom>
[WALK] <soap>
[FIND] <soap>
[GRAB] <soap>
[FIND] <hands_both>
[SCRUB] <hands_both>
[WASH] <hands_both>
[RINSE] <hands_both>


Instruction:
You serve as an AI task planner.
1. Your task is to create a plan to achieve a goal by converting it into a sequence of actions. Each action should follow the format "[verb] <target1> <target2>", where 'verb' represents the action, and 'target1' and 'target2' are optional arguments.
2. You must describe your plan in natural language at the beginning. After that, you should list all the actions together.
Ensure that you response can be parsed by Python json.loads.

Here is an example plan to achieve a goal for reference:
Scene_Objects:['pot', 'crayon', 'microwave', 'chair', 'freezer', 'detergent', 'food_egg', 'hanger', 'floor', 'ceiling', 'toaster', 'plate', 'shower', 'mousepad', 'broom', 'wall', 'pasta', 'keys', 'novel', 'coffe_maker', 'toothbrush_holder', 'coffee_filter', 'wooden_spoon', 'towel_rack', 'controller', 'maindoor', 'sink', 'dishwasher', 'coffee', 'creditcard']
Task:Make coffee
response:
{
    "thoughts": Open coffee maker. Put filter in main basket, put ground coffee in filter, fill reservoir with water, turn on coffee maker.,
    "actions": ['[WALK] <dining_room>', '[WALK] <coffe_maker>', '[FIND] <coffe_maker>', '[OPEN] <coffe_maker>', '[FIND] <coffee_filter>', '[GRAB] <coffee_filter>', '[PUTBACK] <coffee_filter> <coffe_maker>', '[FIND] <coffee>', '[GRAB] <coffee>', '[PUTBACK] <coffee> <coffe_maker>']
}

Input:
Scene_Objects:['tablelamp', 'chair', 'toothbrush', 'drawing', 'needle', 'bathroom_counter', 'floor', 'ceiling', 'desk', 'bedroom', 'mat', 'faucet', 'shower', 'food_noodles', 'form', 'wall', 'wall_clock', 'oven', 'tape', 'photoframe', 'keys', 'toothbrush_holder', 'rag', 'doorjamb', 'sink', 'bathroom_cabinet', 'instrument_guitar', 'dishwasher', 'tooth_paste', 'teeth']
Task:Wash teeth
response:

I walk in to the bathroom. I turn on the faucet. I find the toothbrush and toothpaste. I grab the toothbrush and toothpaste. I rinse off the toothbrush. I add toothpaste to the toothbrush. I put back the toothpaste. I wash my teeth with the toothbrush. I rinse off the toothbrush. I put the toothbrush back. I rinse my mouth out. I turn the faucet off.

[WALK] <bathroom>
[WALK] <faucet>
[FIND] <faucet>
[SWITCHON] <faucet>
[FIND] <toothbrush>
[GRAB] <toothbrush>
[RINSE] <toothbrush>
[FIND] <tooth_paste>
[GRAB] <tooth_paste>
[POUR] <tooth_paste> <toothbrush>
[PUTOBJBACK] <tooth_paste>
[FIND] <teeth>
[WASH] <teeth>
[RINSE] <toothbrush>
[PUTOBJBACK] <toothbrush>
[RINSE] <teeth>
[SWITCHOFF] <faucet>


Instruction:
You serve as an AI task planner.
1. Your task is to create a plan to achieve a goal by converting it into a sequence of actions. Each action should follow the format "[verb] <target1> <target2>", where 'verb' represents the action, and 'target1' and 'target2' are optional arguments.
2. You must describe your plan in natural language at the beginning. After that, you should list all the actions together.
Ensure that you response can be parsed by Python json.loads.

Here is an example plan to achieve a goal for reference:
Scene_Objects:['spectacles', 'tablelamp', 'beer', 'measuring_cup', 'band-aids', 'woman', 'knifeblock', 'cpuscreen', 'bathroom_counter', 'phone', 'ceiling', 'character', 'desk', 'man', 'thread', 'clothes_jacket', 'tvstand', 'stereo', 'faucet', 'window', 'shower', 'couch', 'form', 'cutting_board', 'novel', 'television', 'bathroom_cabinet', 'table', 'dishwasher', 'instrument_violin']
Task:Greet guests
response:
{
    "thoughts": Answer the door. Smile and give a warm hello, or other appropriate greeting. With newcomers to your home, offer your hand to be shook. With old friends it is appropriate to hug, or kiss one another on the cheek.,
    "actions": ['[WALK] <home_office>', '[WALK] <man>', '[FIND] <man>', '[GREET] <man>', '[FIND] <woman>', '[GREET] <woman>']
}

Input:
Scene_Objects:['toilet', 'freezer', 'dough', 'drawing', 'cpuscreen', 'floor', 'ceiling', 'mat', 'deck_of_cards', 'shower', 'tvstand', 'food_jam', 'dining_room', 'wall', 'nightstand', 'powersocket', 'food_cheese', 'photoframe', 'novel', 'food_food', 'toilet_paper', 'coffe_maker', 'food_donut', 'doorjamb', 'kitchen_counter', 'dresser', 'door', 'light', 'tooth_paste', 'coffee']
Task:Put groceries in Fridge
response:

in my home i walk to the kitchen with some groceries and locate the fridge,then open the fridge put the groceries into the fridge and closed.

[WALK] <dining_room>
[WALK] <food_food>
[FIND] <food_food>
[GRAB] <food_food>
[FIND] <freezer>
[OPEN] <freezer>
[PUTIN] <food_food> <freezer>
[CLOSE] <freezer>


Instruction:
You serve as an AI task planner.
1. Your task is to create a plan to achieve a goal by converting it into a sequence of actions. Each action should follow the format "[verb] <target1> <target2>", where 'verb' represents the action, and 'target1' and 'target2' are optional arguments.
2. You must describe your plan in natural language at the beginning. After that, you should list all the actions together.
Ensure that you response can be parsed by Python json.loads.

Here is an example plan to achieve a goal for reference:
Scene_Objects:['filing_cabinet', 'freezer', 'walllamp', 'trashcan', 'drawing', 'orchid', 'bathroom_counter', 'floor', 'ceiling', 'desk', 'keyboard', 'computer', 'mat', 'tvstand', 'window', 'mousepad', 'couch', 'pillow', 'wall', 'powersocket', 'bench', 'bed', 'coin', 'curtain', 'dresser', 'cupboard', 'door', 'bathtub', 'sink', 'light']
Task:Wipe down baseboards please
response:
{
    "thoughts": Use a rag to get all the dust off the baseboards please.,
    "actions": ['[WALK] <home_office>', '[WALK] <rag>', '[FIND] <rag>', '[GRAB] <rag>', '[WALK] <wall>', '[PUTOBJBACK] <rag>']
}

Input:
Scene_Objects:['dry_pasta', 'pot', 'food_salt', 'jelly', 'walllamp', 'detergent', 'knife', 'drawing', 'hanger', 'floor', 'dvd_player', 'character', 'desk', 'bedroom', 'plate', 'dish_soap', 'oil', 'wall', 'powersocket', 'bed', 'light_bulb', 'coffe_maker', 'toilet_paper', 'rag', 'doorjamb', 'kitchen_counter', 'cupboard', 'sink', 'spoon', 'dishwasher']
Task:Wash dishes with dishwasher
response:

Put dishes in the dishwasher and start the dishwasher.

[RUN] <dining_room>
[WALK] <bowl>
[FIND] <bowl>
[GRAB] <bowl>
[WALK] <dishwasher>
[OPEN] <dishwasher>
[PUTBACK] <bowl> <dishwasher>
[FIND] <plate>
[GRAB] <plate>
[WALK] <dishwasher>
[PUTBACK] <plate> <dishwasher>
[FIND] <dish_soap>
[GRAB] <dish_soap>
[WALK] <dishwasher>
[PUTBACK] <dish_soap> <dishwasher>
[CLOSE] <dishwasher>
[SWITCHON] <dishwasher>


Instruction:
You serve as an AI task planner.
1. Your task is to create a plan to achieve a goal by converting it into a sequence of actions. Each action should follow the format "[verb] <target1> <target2>", where 'verb' represents the action, and 'target1' and 'target2' are optional arguments.
2. You must describe your plan in natural language at the beginning. After that, you should list all the actions together.
Ensure that you response can be parsed by Python json.loads.

Here is an example plan to achieve a goal for reference:
Scene_Objects:['filing_cabinet', 'food_salt', 'beer', 'microwave', 'chair', 'bathroom', 'trashcan', 'dough', 'knifeblock', 'floor', 'computer', 'stovefan', 'mat', 'balanceball', 'faucet', 'window', 'couch', 'candle', 'wall', 'toy', 'bed', 'photoframe', 'coffe_maker', 'video_game_controller', 'wooden_spoon', 'curtain', 'dresser', 'pajamas', 'hair', 'maindoor']
Task:Go to sleep
response:
{
    "thoughts": go to bedroom, put pajamas on, lie in bed, sleep,
    "actions": ['[WALK] <bedroom>', '[WALK] <pajamas>', '[FIND] <pajamas>', '[GRAB] <pajamas>', '[PUTON] <pajamas>', '[FIND] <bed>', '[LIE] <bed>']
}

Input:
Scene_Objects:['tablelamp', 'chair', 'walllamp', 'bathroom', 'orchid', 'floor', 'ceiling', 'computer', 'toaster', 'ceilinglamp', 'tvstand', 'window', 'closetdrawer', 'couch', 'food_peanut_butter', 'pillow', 'bowl', 'dining_room', 'nightstand', 'wall', 'powersocket', 'cup', 'check', 'television', 'curtain', 'dresser', 'cupboard', 'home_office', 'table', 'dishwasher']
Task:Watch TV
response:

Walk to the room, in which the TV is located. Turn on TV pressing the power button for the TV. Watch TV.

[WALK] <home_office>
[WALK] <television>
[FIND] <television>
[SWITCHON] <television>


Instruction:
You serve as an AI task planner.
1. Your task is to create a plan to achieve a goal by converting it into a sequence of actions. Each action should follow the format "[verb] <target1> <target2>", where 'verb' represents the action, and 'target1' and 'target2' are optional arguments.
2. You must describe your plan in natural language at the beginning. After that, you should list all the actions together.
Ensure that you response can be parsed by Python json.loads.

Here is an example plan to achieve a goal for reference:
Scene_Objects:['pot', 'blender', 'microwave', 'detergent', 'trashcan', 'drawing', 'cpuscreen', 'longboard', 'floor', 'keyboard', 'toaster', 'laptop', 'stereo', 'window', 'food_peanut_butter', 'dining_room', 'broom', 'nightstand', 'oven', 'cup', 'photoframe', 'bed', 'television', 'after_shave', 'curtain', 'pencil', 'bathroom_cabinet', 'light', 'dishwasher', 'vase']
Task:Clean
response:
{
    "thoughts": Clean the welcome mat,
    "actions": ['[WALK] <home_office>', '[WALK] <vacuum_cleaner>', '[FIND] <vacuum_cleaner>', '[GRAB] <vacuum_cleaner>', '[SWITCHON] <vacuum_cleaner>', '[SWITCHOFF] <vacuum_cleaner>']
}

Input:
Scene_Objects:['tablelamp', 'scissors', 'chair', 'dough', 'wallshelf', 'hanger', 'phone', 'tea_bag', 'bookshelf', 'thread', 'stovefan', 'mat', 'tvstand', 'faucet', 'mousepad', 'closetdrawer', 'clothes_pants', 'pillow', 'oven', 'cup', 'food_donut', 'centerpiece', 'mouse', 'vacuum_cleaner', 'chessboard', 'laundry_detergent', 'sink', 'home_office', 'washing_machine', 'creditcard']
Task:Wash clothes
response:

Go to bedroom and grab dirty pants and take to the washing machine in entrance hall. Put clothes in washing machine and then put in laundry detergent.


Instruction:
You serve as an AI task planner.
1. Your task is to create a plan to achieve a goal by converting it into a sequence of actions. Each action should follow the format "[verb] <target1> <target2>", where 'verb' represents the action, and 'target1' and 'target2' are optional arguments.
2. You must describe your plan in natural language at the beginning. After that, you should list all the actions together.
Ensure that you response can be parsed by Python json.loads.

Here is an example plan to achieve a goal for reference:
Scene_Objects:['sheets', 'filing_cabinet', 'tablelamp', 'juice', 'microwave', 'toilet', 'walllamp', 'orchid', 'bathroom_counter', 'bookshelf', 'bookmark', 'toaster', 'ceilinglamp', 'tvstand', 'faucet', 'window', 'mousepad', 'wall_clock', 'food_food', 'coffe_maker', 'tray', 'curtain', 'doorjamb', 'diary', 'mouse', 'kitchen_counter', 'cupboard', 'bathtub', 'home_office', 'bathroom_cabinet']
Task:Drink
response:
{
    "thoughts": Walk to kitchen. Find water glass. Grab water glass. Find water. Pour water in water glass. Drink water from water glass.,
    "actions": ['[WALK] <dining_room>', '[WALK] <water_glass>', '[FIND] <water_glass>', '[GRAB] <water_glass>', '[WALK] <water>', '[FIND] <water>', '[GRAB] <water>', '[POUR] <water> <water_glass>', '[DRINK] <water_glass>']
}

Input:
Scene_Objects:['filing_cabinet', 'food_salt', 'cat', 'cpuscreen', 'desk', 'bookshelf', 'computer', 'alcohol', 'toaster', 'ceilinglamp', 'tvstand', 'faucet', 'stereo', 'shower', 'closetdrawer', 'candle', 'basket_for_clothes', 'photoframe', 'food_food', 'check', 'television', 'water', 'curtain', 'lighter', 'doorjamb', 'vacuum_cleaner', 'cupboard', 'home_office', 'table', 'bathroom_cabinet']
Task:Drink
response:

Walk to kitchen. Find water glass. Grab water glass. Find water. Pour water in water glass. Drink water from water glass.

[WALK] <dining_room>
[WALK] <water_glass>
[FIND] <water_glass>
[GRAB] <water_glass>
[WALK] <water>
[FIND] <water>
[GRAB] <water>
[POUR] <water> <water_glass>
[DRINK] <water_glass>


Instruction:
You serve as an AI task planner.
1. Your task is to create a plan to achieve a goal by converting it into a sequence of actions. Each action should follow the format "[verb] <target1> <target2>", where 'verb' represents the action, and 'target1' and 'target2' are optional arguments.
2. You must describe your plan in natural language at the beginning. After that, you should list all the actions together.
Ensure that you response can be parsed by Python json.loads.

Here is an example plan to achieve a goal for reference:
Scene_Objects:['microwave', 'nail_polish', 'detergent', 'orchid', 'drawing', 'hanger', 'floor', 'phone', 'desk', 'button', 'ceilinglamp', 'stereo', 'faucet', 'mousepad', 'dining_room', 'nightstand', 'wall_clock', 'oven', 'cup', 'photoframe', 'bed', 'food_food', 'tray', 'doorjamb', 'kitchen_counter', 'sink', 'bathtub', 'bathroom_cabinet', 'light', 'home_office']
Task:Listen to music
response:
{
    "thoughts": I go into the living room and turn on the radio.  Then, I select the station I want, which is usually a preset.,
    "actions": ['[WALK] <home_office>', '[WALK] <stereo>', '[FIND] <stereo>', '[FIND] <button>', '[PUSH] <button>', '[FIND] <button>', '[PUSH] <button>']
}

Input:
Scene_Objects:['spectacles', 'tablelamp', 'beer', 'chair', 'walllamp', 'bathroom', 'wallshelf', 'floor', 'ceiling', 'ceilinglamp', 'mat', 'stereo', 'couch', 'pillow', 'bowl', 'wall', 'nightstand', 'powersocket', 'cup', 'toilet_paper', 'television', 'after_shave', 'rag', 'doorjamb', 'coffee_pot', 'dishrack', 'instrument_guitar', 'table', 'soap', 'laser_pointer']
Task:Relax on sofa
response:

walk to living room, walk to sofa, sit in sofa

[WALK] <home_office>
[WALK] <couch>
[SIT] <couch>


Instruction:
You serve as an AI task planner.
1. Your task is to create a plan to achieve a goal by converting it into a sequence of actions. Each action should follow the format "[verb] <target1> <target2>", where 'verb' represents the action, and 'target1' and 'target2' are optional arguments.
2. You must describe your plan in natural language at the beginning. After that, you should list all the actions together.
Ensure that you response can be parsed by Python json.loads.

Here is an example plan to achieve a goal for reference:
Scene_Objects:['fork', 'tablelamp', 'toilet', 'chair', 'walllamp', 'floor', 'ceiling', 'phone', 'keyboard', 'envelope', 'toaster', 'ceilinglamp', 'stereo', 'faucet', 'window', 'couch', 'pillow', 'wall', 'nightstand', 'powersocket', 'cup', 'clothes_gloves', 'novel', 'check', 'video_game_controller', 'television', 'kitchen_counter', 'hairdryer', 'light', 'table']
Task:Relax on sofa
response:
{
    "thoughts": Walk to the living room. Walk to the sofa and sit on the sofa.,
    "actions": ['[WALK] <home_office>', '[WALK] <couch>', '[SIT] <couch>']
}

Input:
Scene_Objects:['filing_cabinet', 'tea', 'microwave', 'cd_player', 'freezer', 'band-aids', 'bathroom', 'food_carrot', 'orchid', 'music_stand', 'phone', 'bookshelf', 'thread', 'mail', 'stereo', 'homework', 'mousepad', 'closetdrawer', 'clothes_hat', 'form', 'broom', 'newspaper', 'photoframe', 'check', 'food_rice', 'food_donut', 'dresser', 'sink', 'napkin', 'light']
Task:Listen to music
response:

Walk to the living and turn to the music stand. Switch on the CD player to listen to music.

[WALK] <home_office>
[WALK] <music_stand>
[FIND] <music_stand>
[TURNTO] <music_stand>
[FIND] <cd_player>
[SWITCHON] <cd_player>


Instruction:
You serve as an AI task planner.
1. Your task is to create a plan to achieve a goal by converting it into a sequence of actions. Each action should follow the format "[verb] <target1> <target2>", where 'verb' represents the action, and 'target1' and 'target2' are optional arguments.
2. You must describe your plan in natural language at the beginning. After that, you should list all the actions together.
Ensure that you response can be parsed by Python json.loads.

Here is an example plan to achieve a goal for reference:
Scene_Objects:['sheets', 'glue', 'chair', 'walllamp', 'ceilingfan', 'knife', 'orchid', 'cpuscreen', 'longboard', 'floor', 'ceiling', 'phone', 'character', 'desk', 'bookshelf', 'keyboard', 'computer', 'balanceball', 'mousepad', 'clothes_socks', 'bowl', 'wall', 'check', 'television', 'mouse', 'kitchen_counter', 'cd', 'door', 'light', 'soap']
Task:Pick up phone
response:
{
    "thoughts": When the phone rings, I pick up the call and give response to the call.,
    "actions": ['[WALK] <home_office>', '[WALK] <chair>', '[FIND] <chair>', '[SIT] <chair>', '[FIND] <phone>', '[GRAB] <phone>']
}

Input:
Scene_Objects:['juice', 'toilet', 'chair', 'freezer', 'detergent', 'food_carrot', 'drawing', 'knifeblock', 'floor', 'ceiling', 'food_chicken', 'bedroom', 'piano_bench', 'ceilinglamp', 'mat', 'shower', 'faucet', 'oil', 'food_orange', 'wall', 'nightstand', 'powersocket', 'photoframe', 'food_food', 'check', 'doorjamb', 'vacuum_cleaner', 'door', 'table', 'light']
Task:Put groceries in Fridge
response:

Put the groceries on the table into the fridge

[WALK] <dining_room>
[WALK] <table>
[FIND] <food_chicken>
[GRAB] <food_chicken>
[FIND] <freezer>
[OPEN] <freezer>
[PUTBACK] <food_chicken> <freezer>
[CLOSE] <freezer>
[FIND] <food_carrot>
[GRAB] <food_carrot>
[FIND] <freezer>
[OPEN] <freezer>
[PUTIN] <food_carrot> <freezer>
[CLOSE] <freezer>


Instruction:
You serve as an AI task planner.
1. Your task is to create a plan to achieve a goal by converting it into a sequence of actions. Each action should follow the format "[verb] <target1> <target2>", where 'verb' represents the action, and 'target1' and 'target2' are optional arguments.
2. You must describe your plan in natural language at the beginning. After that, you should list all the actions together.
Ensure that you response can be parsed by Python json.loads.

Here is an example plan to achieve a goal for reference:
Scene_Objects:['tablelamp', 'toilet', 'chair', 'walllamp', 'bathroom', 'drawing', 'wallshelf', 'floor', 'phone', 'ceiling', 'desk', 'bookshelf', 'computer', 'mat', 'ceilinglamp', 'shower', 'window', 'clothes_hat', 'dining_room', 'wall', 'bench', 'powersocket', 'photoframe', 'doorjamb', 'kitchen_counter', 'dresser', 'cupboard', 'table', 'light', 'tooth_paste']
Task:Pick up phone
response:
{
    "thoughts": Pick up phone,
    "actions": ['[WALK] <table>', '[FIND] <phone>', '[TURNTO] <phone>', '[LOOKAT] <phone>', '[GRAB] <phone>']
}

Input:
Scene_Objects:['sponge', 'filing_cabinet', 'food_ice_cream', 'microwave', 'chair', 'food_carrot', 'wallshelf', 'food_egg', 'cpuscreen', 'hanger', 'shampoo', 'phone', 'desk', 'remote_control', 'ceilinglamp', 'tvstand', 'window', 'closetdrawer', 'microphone', 'pillow', 'nightstand', 'bed', 'rag', 'cards', 'shoes', 'pajamas', 'door', 'sink', 'home_office', 'light']
Task:Change TV channel
response:

I walk to the living room. I find the TV remote. I change the channel.

[WALK] <home_office>
[WALK] <remote_control>
[FIND] <remote_control>
[GRAB] <remote_control>


Instruction:
You serve as an AI task planner.
1. Your task is to create a plan to achieve a goal by converting it into a sequence of actions. Each action should follow the format "[verb] <target1> <target2>", where 'verb' represents the action, and 'target1' and 'target2' are optional arguments.
2. You must describe your plan in natural language at the beginning. After that, you should list all the actions together.
Ensure that you response can be parsed by Python json.loads.

Here is an example plan to achieve a goal for reference:
Scene_Objects:['pot', 'drawing', 'hanger', 'floor', 'ceiling', 'bedroom', 'remote_control', 'computer', 'button', 'brush', 'mat', 'ceilinglamp', 'window', 'closetdrawer', 'couch', 'pillow', 'wall', 'wall_clock', 'standingmirror', 'coffe_maker', 'television', 'food_rice', 'wine', 'curtain', 'doorjamb', 'diary', 'pencil', 'door', 'bathroom_cabinet', 'table']
Task:Change TV channel
response:
{
    "thoughts": walk to living room, look at the television, switch on the television, grab the remote control, press the channel button in remote control, now the tv channel is changed,
    "actions": ['[WALK] <home_office>', '[WALK] <television>', '[FIND] <television>', '[TURNTO] <television>', '[LOOKAT] <television>', '[SWITCHON] <television>', '[FIND] <remote_control>', '[GRAB] <remote_control>', '[FIND] <button>', '[GRAB] <button>']
}

Input:
Scene_Objects:['spectacles', 'pot', 'filing_cabinet', 'food_ice_cream', 'hanger', 'floor', 'ceiling', 'character', 'bookshelf', 'mat', 'tvstand', 'faucet', 'ceilinglamp', 'wall', 'powersocket', 'photoframe', 'clothes_gloves', 'bed', 'food_food', 'check', 'ice', 'doorjamb', 'pencil', 'kitchen_counter', 'laundry_detergent', 'door', 'napkin', 'home_office', 'light', 'dishwasher']
Task:Turn on light
response:

[WALK] <bedroom>
[WALK] <light>
[FIND] <light>
[SWITCHON] <light>


Instruction:
You serve as an AI task planner.
1. Your task is to create a plan to achieve a goal by converting it into a sequence of actions. Each action should follow the format "[verb] <target1> <target2>", where 'verb' represents the action, and 'target1' and 'target2' are optional arguments.
2. You must describe your plan in natural language at the beginning. After that, you should list all the actions together.
Ensure that you response can be parsed by Python json.loads.

Here is an example plan to achieve a goal for reference:
Scene_Objects:['glue', 'filing_cabinet', 'food_pizza', 'knifeblock', 'bathroom_counter', 'floor', 'ceiling', 'cleaning_solution', 'mail', 'brush', 'toaster', 'tvstand', 'balanceball', 'window', 'food_noodles', 'mousepad', 'food_peanut_butter', 'clothes_hat', 'dining_room', 'pasta', 'bench', 'photoframe', 'oven_mitts', 'ice', 'rag', 'dresser', 'cupboard', 'food_steak', 'maindoor', 'table']
Task:Clean  mirror
response:
{
    "thoughts": GET CLEANING CLOTH, SPRAY CLEANER ON CLOTH, CLEAN MIRROR,
    "actions": ['[WALK] <bathroom>', '[WALK] <cleaning_solution>', '[FIND] <cleaning_solution>', '[GRAB] <cleaning_solution>', '[FIND] <rag>', '[GRAB] <rag>', '[POUR] <cleaning_solution> <rag>', '[PUTOBJBACK] <cleaning_solution>', '[WALK] <mirror>', '[WIPE] <mirror>', '[WIPE] <mirror>', '[WIPE] <mirror>', '[PUTOBJBACK] <rag>']
}

Input:
Scene_Objects:['sponge', 'filing_cabinet', 'microwave', 'toilet', 'chair', 'freezer', 'ground_coffee', 'knifeblock', 'hanger', 'floor', 'ceiling', 'purse', 'toaster', 'ceilinglamp', 'faucet', 'shower', 'closetdrawer', 'wall', 'cup', 'razor', 'coin', 'television', 'tray', 'doorjamb', 'kitchen_counter', 'dresser', 'cupboard', 'sink', 'bathroom_cabinet', 'dishwasher']
Task:Drink
response:

To go kitchen and find a cup. open the faucet and fill water in the cup and drink.

[WALK] <dining_room>
[WALK] <sink>
[FIND] <faucet>
[SWITCHON] <faucet>
[FIND] <cup>
[GRAB] <cup>
[TURNTO] <faucet>
[POINTAT] <faucet>
[SWITCHOFF] <faucet>
[DRINK] <cup>


Instruction:
You serve as an AI task planner.
1. Your task is to create a plan to achieve a goal by converting it into a sequence of actions. Each action should follow the format "[verb] <target1> <target2>", where 'verb' represents the action, and 'target1' and 'target2' are optional arguments.
2. You must describe your plan in natural language at the beginning. After that, you should list all the actions together.
Ensure that you response can be parsed by Python json.loads.

Here is an example plan to achieve a goal for reference:
Scene_Objects:['pot', 'tablelamp', 'freezer', 'trashcan', 'orchid', 'drawing', 'bills', 'wallshelf', 'cpuscreen', 'knife', 'ceiling', 'character', 'stamp', 'keyboard', 'computer', 'ceilinglamp', 'couch', 'pillow', 'pasta', 'bench', 'oven', 'keys', 'novel', 'mouthwash', 'ice', 'tray', 'towel_rack', 'mouse', 'cupboard', 'bathtub']
Task:Change TV channel
response:
{
    "thoughts": I walk to the living room. I find the TV remote. I change the channel.,
    "actions": ['[WALK] <home_office>', '[WALK] <remote_control>', '[FIND] <remote_control>', '[GRAB] <remote_control>']
}

Input:
Scene_Objects:['fork', 'tablelamp', 'chair', 'walllamp', 'detergent', 'food_carrot', 'cpuscreen', 'hanger', 'floor', 'ceiling', 'table_cloth', 'mop_bucket', 'ceilinglamp', 'tvstand', 'mat', 'couch', 'dustpan', 'pillow', 'wall', 'nightstand', 'oven', 'food_food', 'check', 'television', 'tray', 'wooden_spoon', 'kettle', 'controller', 'food_steak', 'sink']
Task:Relax on sofa
response:

go to the living room and sit on the couch, ease into the sofa and relax.

[WALK] <home_office>
[WALK] <couch>
[LIE] <couch>


Instruction:
You serve as an AI task planner.
1. Your task is to create a plan to achieve a goal by converting it into a sequence of actions. Each action should follow the format "[verb] <target1> <target2>", where 'verb' represents the action, and 'target1' and 'target2' are optional arguments.
2. You must describe your plan in natural language at the beginning. After that, you should list all the actions together.
Ensure that you response can be parsed by Python json.loads.

Here is an example plan to achieve a goal for reference:
Scene_Objects:['pot', 'scissors', 'tablelamp', 'food_ice_cream', 'toilet', 'bathroom', 'toothbrush', 'orchid', 'hanger', 'bathroom_counter', 'floor', 'ceilinglamp', 'faucet', 'clothes_socks', 'closetdrawer', 'tape', 'cup', 'check', 'food_food', 'razor', 'food_onion', 'centerpiece', 'mouse', 'dresser', 'bathtub', 'bathroom_cabinet', 'light', 'clothes_skirt', 'tooth_paste', 'shoe_rack']
Task:Brush teeth
response:
{
    "thoughts": EARLY MORNING AND BEFORE GOING TO BED,
    "actions": ['[WALK] <bathroom>', '[WALK] <tooth_paste>', '[FIND] <tooth_paste>', '[GRAB] <tooth_paste>', '[FIND] <toothbrush>', '[GRAB] <toothbrush>']
}

Input:
Scene_Objects:['tablelamp', 'scissors', 'walllamp', 'bathroom', 'orchid', 'floor', 'ceiling', 'remote_control', 'computer', 'tvstand', 'faucet', 'window', 'closetdrawer', 'couch', 'dustpan', 'pillow', 'nightstand', 'wall', 'cup', 'check', 'mouthwash', 'television', 'coffee_filter', 'curtain', 'after_shave', 'dresser', 'hairbrush', 'sink', 'table', 'board_game']
Task:Watch TV
response:

Walk into living room. Sit on couch. Pick up remote. Turn on TV. Watch TV.

[WALK] <home_office>
[WALK] <remote_control>
[FIND] <remote_control>
[GRAB] <remote_control>
[FIND] <television>
[SWITCHON] <television>
[TURNTO] <television>
[WATCH] <television>


Instruction:
You serve as an AI task planner.
1. Your task is to create a plan to achieve a goal by converting it into a sequence of actions. Each action should follow the format "[verb] <target1> <target2>", where 'verb' represents the action, and 'target1' and 'target2' are optional arguments.
2. You must describe your plan in natural language at the beginning. After that, you should list all the actions together.
Ensure that you response can be parsed by Python json.loads.

Here is an example plan to achieve a goal for reference:
Scene_Objects:['tablelamp', 'measuring_cup', 'toilet', 'chair', 'walllamp', 'trashcan', 'food_carrot', 'clothes_underwear', 'hanger', 'longboard', 'floor', 'ceiling', 'toaster', 'electric_shaver', 'couch', 'wall', 'nightstand', 'oven', 'cup', 'coffe_maker', 'food_food', 'television', 'cards', 'mouse', 'kitchen_counter', 'maindoor', 'home_office', 'light', 'dishwasher', 'coffee']
Task:Make coffee
response:
{
    "thoughts": Making coffee,
    "actions": ['[WALK] <dining_room>', '[WALK] <coffe_maker>', '[FIND] <coffe_maker>', '[SWITCHON] <coffe_maker>']
}

Input:
Scene_Objects:['microwave', 'bathroom', 'cat', 'food_carrot', 'toothbrush', 'knifeblock', 'wallshelf', 'floor', 'ceiling', 'bedroom', 'toaster', 'mat', 'faucet', 'closetdrawer', 'couch', 'form', 'wall', 'novel', 'coffe_maker', 'wine', 'kettle', 'pencil', 'kitchen_counter', 'dresser', 'cupboard', 'sink', 'light', 'table', 'soap', 'hands_both']
Task:Wash hands
response:

[WALK] <dining_room>
[WALK] <faucet>
[FIND] <faucet>
[SWITCHON] <faucet>
[FIND] <soap>
[GRAB] <soap>
[TOUCH] <soap>
[PUTOBJBACK] <soap>
[FIND] <hands_both>
[SCRUB] <hands_both>
[RINSE] <hands_both>
[SWITCHOFF] <faucet>


Instruction:
You serve as an AI task planner.
1. Your task is to create a plan to achieve a goal by converting it into a sequence of actions. Each action should follow the format "[verb] <target1> <target2>", where 'verb' represents the action, and 'target1' and 'target2' are optional arguments.
2. You must describe your plan in natural language at the beginning. After that, you should list all the actions together.
Ensure that you response can be parsed by Python json.loads.

Here is an example plan to achieve a goal for reference:
Scene_Objects:['pot', 'chair', 'freezer', 'walllamp', 'bathroom', 'food_butter', 'knifeblock', 'floor', 'ceiling', 'character', 'desk', 'food_cake', 'computer', 'bookmark', 'toaster', 'stovefan', 'mat', 'faucet', 'food_kiwi', 'wall', 'oven', 'powersocket', 'food_vegetable', 'bed', 'food_food', 'oven_mitts', 'tray', 'towel_rack', 'kitchen_counter', 'cupboard']
Task:Cook some food
response:
{
    "thoughts": I prepare meals and cook them on the stove.,
    "actions": ['[WALK] <dining_room>', '[WALK] <freezer>', '[OPEN] <freezer>', '[FIND] <food_vegetable>', '[GRAB] <food_vegetable>', '[CLOSE] <freezer>', '[FIND] <oven>', '[SWITCHON] <oven>', '[SWITCHOFF] <oven>']
}

Input:
Scene_Objects:['chair', 'walllamp', 'orchid', 'cpuscreen', 'floor', 'ceiling', 'desk', 'keyboard', 'computer', 'mat', 'ceilinglamp', 'tvstand', 'shower', 'homework', 'foundation', 'mousepad', 'closetdrawer', 'pillow', 'wall', 'bed', 'novel', 'check', 'television', 'doorjamb', 'mouse', 'door', 'sink', 'light', 'table', 'dishwasher']
Task:Work
response:

[WALK] <home_office>
[WALK] <computer>
[FIND] <computer>
[SWITCHON] <computer>
[FIND] <keyboard>
[FIND] <mouse>
[FIND] <check>
[FIND] <homework>
[GRAB] <homework>
[FIND] <homework>
[READ] <homework>
[SWITCHOFF] <computer>


Instruction:
You serve as an AI task planner.
1. Your task is to create a plan to achieve a goal by converting it into a sequence of actions. Each action should follow the format "[verb] <target1> <target2>", where 'verb' represents the action, and 'target1' and 'target2' are optional arguments.
2. You must describe your plan in natural language at the beginning. After that, you should list all the actions together.
Ensure that you response can be parsed by Python json.loads.

Here is an example plan to achieve a goal for reference:
Scene_Objects:['chair', 'walllamp', 'drawing', 'cpuscreen', 'wallshelf', 'bathroom_counter', 'floor', 'ceiling', 'desk', 'keyboard', 'computer', 'toaster', 'ceilinglamp', 'tvstand', 'stovefan', 'mousepad', 'wall', 'wall_clock', 'powersocket', 'nightstand', 'tape', 'newspaper', 'bed', 'television', 'doorjamb', 'mouse', 'sink', 'home_office', 'table', 'light']
Task:Work
response:
{
    "thoughts": Walk to home office. Sit on chair. Switch on computer. type in keyboard.,
    "actions": ['[WALK] <home_office>', '[WALK] <chair>', '[FIND] <chair>', '[SIT] <chair>', '[FIND] <computer>', '[SWITCHON] <computer>', '[FIND] <keyboard>', '[TYPE] <keyboard>']
}

Input:
Scene_Objects:['pot', 'toilet', 'jelly', 'freezer', 'walllamp', 'knifeblock', 'drawing', 'floor', 'ceiling', 'food_cake', 'stovefan', 'toaster', 'plate', 'mat', 'shower', 'food_kiwi', 'wall', 'nightstand', 'oven', 'powersocket', 'photoframe', 'food_food', 'tray', 'food_onion', 'doorjamb', 'kitchen_counter', 'sauce_pan', 'cupboard', 'door', 'food_steak', 'spoon', 'light', 'dishwasher']
Task:Cook some food
response:

I pull a sauce pan from the cupboard. I turn the stove on. I take my ingredients from the pantry and fridge. I put the ingredients in the pan and I mix them with a spoon. I cook until the food is finished and transfer my food to a plate.

[WALK] <dining_room>
[WALK] <food_food>
[FIND] <food_food>
[FIND] <pot>
[GRAB] <pot>
[FIND] <spoon>
[GRAB] <spoon>
[FIND] <sauce_pan>
[PUTBACK] <spoon> <sauce_pan>
[FIND] <freezer>
[OPEN] <freezer>
[FIND] <plate>
[PUTBACK] <pot> <plate>


Instruction:
You serve as an AI task planner.
1. Your task is to create a plan to achieve a goal by converting it into a sequence of actions. Each action should follow the format "[verb] <target1> <target2>", where 'verb' represents the action, and 'target1' and 'target2' are optional arguments.
2. You must describe your plan in natural language at the beginning. After that, you should list all the actions together.
Ensure that you response can be parsed by Python json.loads.

Here is an example plan to achieve a goal for reference:
Scene_Objects:['filing_cabinet', 'toilet', 'walllamp', 'ground_coffee', 'trashcan', 'desk', 'bedroom', 'purse', 'mop_bucket', 'shower', 'picture', 'homework', 'mousepad', 'form', 'wall', 'oven', 'bed', 'keys', 'video_game_controller', 'wine', 'food_onion', 'after_shave', 'console', 'mouse', 'cd', 'comb', 'dresser', 'door', 'clothes_skirt', 'dirt']
Task:Pet cat
response:
{
    "thoughts": Find the cat; pet the cat by touching it,
    "actions": ['[WALK] <home_office>', '[WALK] <cat>', '[FIND] <cat>', '[TOUCH] <cat>']
}

Input:
Scene_Objects:['pot', 'microwave', 'chair', 'freezer', 'walllamp', 'floor', 'character', 'bookshelf', 'computer', 'toaster', 'mat', 'plate', 'window', 'food_noodles', 'food_orange', 'wall', 'oven', 'photoframe', 'keys', 'bed', 'coffe_maker', 'toothbrush_holder', 'doorjamb', 'kitchen_counter', 'comb', 'cupboard', 'clothes_dress', 'napkin', 'home_office', 'dishwasher']
Task:Wash dishes with dishwasher
response:

In the kitchen, open up the dishwasher. Take plates from the sink and put them in the dishwasher one by one. Close the dishwasher. Program it. Push start.

[WALK] <dining_room>
[WALK] <dishwasher>
[FIND] <dishwasher>
[OPEN] <dishwasher>
[FIND] <plate>
[GRAB] <plate>
[PUTBACK] <plate> <dishwasher>
[FIND] <plate>
[GRAB] <plate>
[PUTBACK] <plate> <dishwasher>
[FIND] <plate>
[GRAB] <plate>
[PUTBACK] <plate> <dishwasher>
[CLOSE] <dishwasher>
[SWITCHON] <dishwasher>


Instruction:
You serve as an AI task planner.
1. Your task is to create a plan to achieve a goal by converting it into a sequence of actions. Each action should follow the format "[verb] <target1> <target2>", where 'verb' represents the action, and 'target1' and 'target2' are optional arguments.
2. You must describe your plan in natural language at the beginning. After that, you should list all the actions together.
Ensure that you response can be parsed by Python json.loads.

Here is an example plan to achieve a goal for reference:
Scene_Objects:['toilet', 'chair', 'walllamp', 'knifeblock', 'orchid', 'cpuscreen', 'floor', 'ceiling', 'desk', 'keyboard', 'computer', 'alcohol', 'table_cloth', 'stovefan', 'ceilinglamp', 'mat', 'iron', 'faucet', 'mousepad', 'bowl', 'wall', 'nightstand', 'oven', 'mouse', 'cupboard', 'door', 'clothes_scarf', 'bathroom_cabinet', 'table', 'instrument_guitar']
Task:Work
response:
{
    "thoughts": For doing homework walk to home office. Walk to computer. Switch on Computer. Sit in a chair and do homework in computer.,
    "actions": ['[WALK] <home_office>', '[WALK] <computer>', '[FIND] <computer>', '[WALK] <computer>', '[FIND] <chair>', '[SIT] <chair>', '[SWITCHON] <computer>']
}

Input:
Scene_Objects:['tablelamp', 'microwave', 'chair', 'walllamp', 'orchid', 'floor', 'ceiling', 'computer', 'ceilinglamp', 'tvstand', 'window', 'closetdrawer', 'couch', 'microphone', 'form', 'pillow', 'wall', 'nightstand', 'oven', 'cup', 'coffe_maker', 'television', 'curtain', 'vacuum_cleaner', 'dishrack', 'dresser', 'hairbrush', 'door', 'table', 'soap']
Task:Watch TV
response:

I walk to the living room. I grab the remote control. I walk to the sofa. I sit down, and press the on button on the remote.

[WALK] <home_office>
[WALK] <remote_control>
[FIND] <remote_control>
[GRAB] <remote_control>
[WALK] <couch>
[SIT] <couch>
[TOUCH] <remote_control>
[FIND] <television>
[SWITCHON] <television>


Instruction:
You serve as an AI task planner.
1. Your task is to create a plan to achieve a goal by converting it into a sequence of actions. Each action should follow the format "[verb] <target1> <target2>", where 'verb' represents the action, and 'target1' and 'target2' are optional arguments.
2. You must describe your plan in natural language at the beginning. After that, you should list all the actions together.
Ensure that you response can be parsed by Python json.loads.

Here is an example plan to achieve a goal for reference:
Scene_Objects:['blender', 'toilet', 'chair', 'walllamp', 'bathroom', 'detergent', 'orchid', 'knifeblock', 'ceiling', 'bedroom', 'bookshelf', 'food_bacon', 'table_cloth', 'toaster', 'laptop', 'ceilinglamp', 'floor_lamp', 'mousepad', 'couch', 'clothes_pants', 'towel', 'dining_room', 'basket_for_clothes', 'check', 'pencil', 'chessboard', 'food_steak', 'napkin', 'spoon', 'table']
Task:Turn off light
response:
{
    "thoughts": Walk to the lamp.  Find the switch.  Click the switch off.,
    "actions": ['[WALK] <bedroom>', '[WALK] <floor_lamp>', '[SWITCHOFF] <floor_lamp>']
}

Input:
Scene_Objects:['sponge', 'food_pizza', 'filing_cabinet', 'toilet', 'wallshelf', 'cpuscreen', 'hanger', 'floor', 'folder', 'keyboard', 'faucet', 'iron', 'mousepad', 'pillow', 'dining_room', 'tape', 'cutting_board', 'cup', 'food_food', 'video_game_controller', 'food_rice', 'food_donut', 'rag', 'kettle', 'mouse', 'kitchen_counter', 'controller', 'food_steak', 'sink', 'dishwasher']
Task:Listen to music
response:

I walk to the living room. I find a radio there and switch it on to listen to music.

[WALK] <home_office>
[WALK] <stereo>
[FIND] <stereo>
[SWITCHON] <stereo>


Instruction:
You serve as an AI task planner.
1. Your task is to create a plan to achieve a goal by converting it into a sequence of actions. Each action should follow the format "[verb] <target1> <target2>", where 'verb' represents the action, and 'target1' and 'target2' are optional arguments.
2. You must describe your plan in natural language at the beginning. After that, you should list all the actions together.
Ensure that you response can be parsed by Python json.loads.

Here is an example plan to achieve a goal for reference:
Scene_Objects:['filing_cabinet', 'food_salt', 'jelly', 'walllamp', 'trashcan', 'hanger', 'longboard', 'floor', 'desk', 'mail', 'toaster', 'plate', 'shower', 'balanceball', 'couch', 'wall', 'oven', 'box', 'cup', 'bed', 'coffe_maker', 'tray', 'rag', 'doorjamb', 'kitchen_counter', 'cupboard', 'sink', 'dishwasher', 'vase', 'laser_pointer']
Task:Wash dishes with dishwasher
response:
{
    "thoughts": Walk to Kitchen, find dishwasher. Find vessels to be washed. Open dishwasher, put vessels in dish washer, close dish washer and switch it on.,
    "actions": ['[WALK] <dining_room>', '[WALK] <dishwasher>', '[FIND] <dishwasher>', '[OPEN] <dishwasher>', '[FIND] <cup>', '[GRAB] <cup>', '[PUTBACK] <cup> <dishwasher>', '[FIND] <plate>', '[GRAB] <plate>', '[GRAB] <cup>', '[PUTBACK] <cup> <plate>', '[GRAB] <cup>', '[PUTBACK] <cup> <dishwasher>', '[CLOSE] <dishwasher>', '[SWITCHON] <dishwasher>']
}

Input:
Scene_Objects:['food_salt', 'crayon', 'microwave', 'food_carrot', 'orchid', 'knifeblock', 'bills', 'floor', 'bedroom', 'stamp', 'envelope', 'clothes_jacket', 'bookmark', 'toaster', 'faucet', 'towel', 'dining_room', 'wall', 'coffe_maker', 'food_food', 'video_game_controller', 'tray', 'lighter', 'diary', 'kitchen_counter', 'cupboard', 'sink', 'soap', 'scrabble', 'hands_both']
Task:Wash hands
response:

I have had my lunch and walked towards the sink and applied soap to my hands and washed cleanly.

[WALK] <dining_room>
[WALK] <sink>
[FIND] <soap>
[GRAB] <soap>
[FIND] <hands_both>
[WASH] <hands_both>
[FIND] <towel>
[GRAB] <towel>
[WIPE] <hands_both>


Instruction:
You serve as an AI task planner.
1. Your task is to create a plan to achieve a goal by converting it into a sequence of actions. Each action should follow the format "[verb] <target1> <target2>", where 'verb' represents the action, and 'target1' and 'target2' are optional arguments.
2. You must describe your plan in natural language at the beginning. After that, you should list all the actions together.
Ensure that you response can be parsed by Python json.loads.

Here is an example plan to achieve a goal for reference:
Scene_Objects:['pot', 'beer', 'microwave', 'jelly', 'freezer', 'cpuscreen', 'clothes_underwear', 'floor', 'ceiling', 'desk', 'tea_bag', 'keyboard', 'purse', 'computer', 'iron', 'window', 'mousepad', 'oil', 'wall', 'powersocket', 'bed', 'keys', 'mouthwash', 'wine', 'doorjamb', 'mouse', 'cupboard', 'door', 'sink', 'light']
Task:Turn on light
response:
{
    "thoughts": walk in kitchen. switch on light. walk in living room. switch on light.walk in entrance hall. switch on light.,
    "actions": ['[WALK] <dining_room>', '[WALK] <light>', '[FIND] <light>', '[SWITCHON] <light>', '[WALK] <home_office>', '[WALK] <home_office>']
}

Input:
Scene_Objects:['water_glass', 'filing_cabinet', 'food_bread', 'toilet', 'freezer', 'orchid', 'drawing', 'wallshelf', 'cpuscreen', 'shampoo', 'bedroom', 'ceilinglamp', 'closetdrawer', 'form', 'towel', 'broom', 'nightstand', 'wall', 'keys', 'novel', 'coffe_maker', 'coin', 'water', 'curtain', 'headset', 'dishrack', 'hair', 'controller', 'sink', 'light']
Task:Drink
response:

walk to kitchen, look at the water glass, grab that glass, find the water cane, open the water cane tap, drink water

[WALK] <dining_room>
[WALK] <water_glass>
[FIND] <water_glass>
[TURNTO] <water_glass>
[LOOKAT] <water_glass>
[GRAB] <water_glass>
[FIND] <water>


Instruction:
You serve as an AI task planner.
1. Your task is to create a plan to achieve a goal by converting it into a sequence of actions. Each action should follow the format "[verb] <target1> <target2>", where 'verb' represents the action, and 'target1' and 'target2' are optional arguments.
2. You must describe your plan in natural language at the beginning. After that, you should list all the actions together.
Ensure that you response can be parsed by Python json.loads.

Here is an example plan to achieve a goal for reference:
Scene_Objects:['pot', 'food_salt', 'microwave', 'toilet', 'chair', 'blow_dryer', 'hanger', 'bathroom_counter', 'ceiling', 'phone', 'desk', 'mail', 'shoe-shine_kit', 'mousepad', 'food_noodles', 'cutting_board', 'cup', 'photoframe', 'bed', 'coffe_maker', 'television', 'curtain', 'centerpiece', 'comb', 'pajamas', 'clothes_dress', 'door', 'home_office', 'light', 'table']
Task:Pet cat
response:
{
    "thoughts": Walk into the living room, sit down by the cat, put out hand, stroke the cat from head to tail,
    "actions": ['[WALK] <home_office>', '[WALK] <cat>', '[FIND] <cat>', '[TOUCH] <cat>']
}

Input:
Scene_Objects:['dry_pasta', 'food_ice_cream', 'toilet', 'freezer', 'drawing', 'floor', 'ceiling', 'phone', 'stovefan', 'mat', 'ceilinglamp', 'shower', 'bowl', 'nightstand', 'wall', 'powersocket', 'oven', 'photoframe', 'bed', 'food_food', 'coffe_maker', 'wooden_spoon', 'doorjamb', 'pencil', 'comb', 'door', 'light', 'soap', 'scrabble', 'creditcard']
Task:Put groceries in Fridge
response:

In the kitchen where I left the bags of groceries, I grab cheese from the grocery bag, I walk over to the refrigerator, open it up, neatly put cheese in the fridge, Close the fridge

[WALK] <dining_room>
[WALK] <food_food>
[FIND] <food_food>
[GRAB] <food_food>
[WALK] <freezer>
[OPEN] <freezer>
[PUTIN] <food_food> <freezer>
[CLOSE] <freezer>


Instruction:
You serve as an AI task planner.
1. Your task is to create a plan to achieve a goal by converting it into a sequence of actions. Each action should follow the format "[verb] <target1> <target2>", where 'verb' represents the action, and 'target1' and 'target2' are optional arguments.
2. You must describe your plan in natural language at the beginning. After that, you should list all the actions together.
Ensure that you response can be parsed by Python json.loads.

Here is an example plan to achieve a goal for reference:
Scene_Objects:['tablelamp', 'toilet', 'chair', 'walllamp', 'trashcan', 'ceilingfan', 'drawing', 'cpuscreen', 'hanger', 'floor', 'ceiling', 'phone', 'desk', 'keyboard', 'bookshelf', 'computer', 'laptop', 'shoe-shine_kit', 'balanceball', 'picture', 'ceilinglamp', 'mousepad', 'wall', 'nightstand', 'newspaper', 'photoframe', 'doorjamb', 'mouse', 'dresser', 'cupboard', 'door', 'light']
Task:Work
response:
{
    "thoughts": I need to finish some work on my computer in my home office to meet a deadline for tomorrow.,
    "actions": ['[WALK] <home_office>', '[WALK] <light>', '[FIND] <light>', '[SWITCHON] <light>', '[FIND] <keyboard>', '[GRAB] <keyboard>', '[FIND] <desk>', '[OPEN] <desk>', '[PUTBACK] <keyboard> <desk>', '[FIND] <mouse>', '[GRAB] <mouse>', '[FIND] <mousepad>', '[PUTBACK] <mouse> <mousepad>', '[PLUGIN] <keyboard>', '[PLUGIN] <mouse>', '[FIND] <computer>', '[SWITCHON] <computer>', '[FIND] <chair>', '[SIT] <chair>', '[TURNTO] <computer>', '[TYPE] <keyboard>', '[GRAB] <mouse>', '[TOUCH] <mouse>', '[LOOKAT] <computer>']
}

Input:
Scene_Objects:['sheets', 'water_glass', 'food_pizza', 'juice', 'toilet', 'chair', 'ground_coffee', 'nail_polish', 'food_butter', 'wallshelf', 'cpuscreen', 'kitchen_cabinet', 'character', 'purse', 'piano_bench', 'couch', 'novel', 'coffe_maker', 'razor', 'water', 'tray', 'after_shave', 'chessboard', 'laundry_detergent', 'food_steak', 'door', 'napkin', 'light', 'table', 'creditcard']
Task:Drink
response:

[WALK] <dining_room>
[WALK] <kitchen_cabinet>
[FIND] <kitchen_cabinet>
[FIND] <kitchen_cabinet>
[FIND] <water>
[GRAB] <water>
[FIND] <water_glass>
[POUR] <water> <water_glass>
[GRAB] <water_glass>
[DRINK] <water_glass>


Instruction:
You serve as an AI task planner.
1. Your task is to create a plan to achieve a goal by converting it into a sequence of actions. Each action should follow the format "[verb] <target1> <target2>", where 'verb' represents the action, and 'target1' and 'target2' are optional arguments.
2. You must describe your plan in natural language at the beginning. After that, you should list all the actions together.
Ensure that you response can be parsed by Python json.loads.

Here is an example plan to achieve a goal for reference:
Scene_Objects:['tablelamp', 'food_salt', 'ceilingfan', 'drawing', 'orchid', 'floor', 'ceiling', 'phone', 'dvd_player', 'desk', 'remote_control', 'computer', 'ceilinglamp', 'tvstand', 'balanceball', 'window', 'clothes_socks', 'mousepad', 'couch', 'food_kiwi', 'wall', 'bench', 'cup', 'check', 'television', 'curtain', 'napkin', 'table', 'soap', 'instrument_violin']
Task:Watch TV
response:
{
    "thoughts": I walk into the living room. I sit on the couch. I pick up the remote control. I push the power button.  I push the guide button and look for my favorite show "The Middle."  I click that channel and enjoy my show.,
    "actions": ['[WALK] <home_office>', '[WALK] <couch>', '[FIND] <couch>', '[SIT] <couch>', '[FIND] <remote_control>', '[FIND] <television>', '[SWITCHON] <television>', '[PUSH] <remote_control>', '[TURNTO] <television>', '[WATCH] <television>']
}

Input:
Scene_Objects:['filing_cabinet', 'detergent', 'floor', 'ceiling', 'character', 'bookshelf', 'toaster', 'mat', 'deck_of_cards', 'food_noodles', 'closetdrawer', 'mousepad', 'form', 'towel', 'wall', 'pasta', 'powersocket', 'light_bulb', 'novel', 'video_game_controller', 'television', 'tray', 'doorjamb', 'centerpiece', 'controller', 'door', 'instrument_guitar', 'light', 'dishwasher', 'bathroom_cabinet']
Task:Turn on light
response:

I go into my room, find the light,  then turn on the lights.

[WALK] <bedroom>
[WALK] <light>
[FIND] <light>
[WALK] <light>
[SWITCHON] <light>


Instruction:
You serve as an AI task planner.
1. Your task is to create a plan to achieve a goal by converting it into a sequence of actions. Each action should follow the format "[verb] <target1> <target2>", where 'verb' represents the action, and 'target1' and 'target2' are optional arguments.
2. You must describe your plan in natural language at the beginning. After that, you should list all the actions together.
Ensure that you response can be parsed by Python json.loads.

Here is an example plan to achieve a goal for reference:
Scene_Objects:['freezer', 'cat', 'drawing', 'knife', 'knifeblock', 'hanger', 'floor', 'bedroom', 'keyboard', 'computer', 'piano_bench', 'ceilinglamp', 'faucet', 'iron', 'window', 'mousepad', 'couch', 'form', 'dining_room', 'wall', 'oven', 'box', 'newspaper', 'bed', 'novel', 'toilet_paper', 'television', 'tray', 'sink', 'table']
Task:Pet cat
response:
{
    "thoughts": I walk to the living room.  I locate the cat.  I walk to the couch and sit down beside the cat.  I pet the cat.,
    "actions": ['[WALK] <home_office>', '[WALK] <cat>', '[FIND] <cat>', '[WALK] <couch>', '[SIT] <couch>', '[TOUCH] <cat>']
}

Input:
Scene_Objects:['pot', 'water_glass', 'toilet', 'jelly', 'freezer', 'walllamp', 'drawing', 'floor', 'ceiling', 'stovefan', 'mat', 'shower', 'food_kiwi', 'wall', 'nightstand', 'oven', 'powersocket', 'photoframe', 'food_food', 'coffe_maker', 'water', 'tray', 'doorjamb', 'coffee_pot', 'kitchen_counter', 'cupboard', 'door', 'food_steak', 'spoon', 'light', 'dishwasher']
Task:Drink
response:

I need to go to Kitchen.  Get a cup.  Fill cup.  Drink

[WALK] <dining_room>
[WALK] <cupboard>
[FIND] <cupboard>
[OPEN] <cupboard>
[FIND] <water_glass>
[GRAB] <water_glass>
[WALK] <freezer>
[WALK] <water>
[FIND] <water>
[GRAB] <water>
[POUR] <water> <water_glass>
[DRINK] <water_glass>


Instruction:
You serve as an AI task planner.
1. Your task is to create a plan to achieve a goal by converting it into a sequence of actions. Each action should follow the format "[verb] <target1> <target2>", where 'verb' represents the action, and 'target1' and 'target2' are optional arguments.
2. You must describe your plan in natural language at the beginning. After that, you should list all the actions together.
Ensure that you response can be parsed by Python json.loads.

Here is an example plan to achieve a goal for reference:
Scene_Objects:['filing_cabinet', 'toilet', 'chair', 'walllamp', 'bathroom', 'drawing', 'cpuscreen', 'hanger', 'floor', 'ceiling', 'desk', 'keyboard', 'computer', 'mat', 'tvstand', 'ceilinglamp', 'mousepad', 'closetdrawer', 'pillow', 'bowl', 'wall', 'powersocket', 'cup', 'novel', 'coffe_maker', 'food_donut', 'doorjamb', 'mouse', 'dresser', 'light']
Task:Read book
response:
{
    "thoughts": Walk to the living room. Find a desk and grab a book. Walk to the chair, sit in the chair and read a book.,
    "actions": ['[WALK] <home_office>', '[WALK] <desk>', '[FIND] <desk>', '[FIND] <novel>', '[GRAB] <novel>', '[WALK] <chair>', '[SIT] <chair>', '[READ] <novel>']
}

Input:
Scene_Objects:['pot', 'filing_cabinet', 'band-aids', 'freezer', 'bathroom', 'detergent', 'food_butter', 'drawing', 'wallshelf', 'bookshelf', 'computer', 'tvstand', 'shower', 'homework', 'clothes_pants', 'bowl', 'nightstand', 'wall', 'oven', 'cup', 'photoframe', 'food_food', 'toilet_paper', 'coffe_maker', 'wine', 'tray', 'kitchen_counter', 'cupboard', 'door', 'bathroom_cabinet']
Task:Pet cat
response:

[WALK] <home_office>
[WALK] <cat>
[FIND] <cat>
[TOUCH] <cat>


Instruction:
You serve as an AI task planner.
1. Your task is to create a plan to achieve a goal by converting it into a sequence of actions. Each action should follow the format "[verb] <target1> <target2>", where 'verb' represents the action, and 'target1' and 'target2' are optional arguments.
2. You must describe your plan in natural language at the beginning. After that, you should list all the actions together.
Ensure that you response can be parsed by Python json.loads.

Here is an example plan to achieve a goal for reference:
Scene_Objects:['walllamp', 'cat', 'trashcan', 'drawing', 'orchid', 'knife', 'cpuscreen', 'floor', 'ceiling', 'phone', 'bookshelf', 'keyboard', 'mail', 'toaster', 'mat', 'tvstand', 'couch', 'pillow', 'broom', 'wall', 'nightstand', 'powersocket', 'television', 'food_donut', 'doorjamb', 'door', 'bathroom_cabinet', 'light', 'table', 'dirt']
Task:Pet cat
response:
{
    "thoughts": My cat looks like it wants attention, so I will go pet it on the couch.,
    "actions": ['[WALK] <home_office>', '[WALK] <light>', '[FIND] <light>', '[SWITCHON] <light>', '[FIND] <cat>', '[WALK] <couch>', '[SIT] <couch>', '[TURNTO] <cat>', '[TOUCH] <cat>']
}

Input:
Scene_Objects:['food_pizza', 'toilet', 'freezer', 'drawing', 'cpuscreen', 'floor', 'ceiling', 'envelope', 'table_cloth', 'stovefan', 'ceilinglamp', 'mat', 'shower', 'stereo', 'mousepad', 'towel', 'wall', 'powersocket', 'photoframe', 'bed', 'toilet_paper', 'tray', 'curtain', 'doorjamb', 'dresser', 'controller', 'door', 'food_steak', 'light', 'tooth_paste']
Task:Take shower
response:

walk to bathroom , find shower , take a shower

[WALK] <bathroom>
[WALK] <shower>
[FIND] <shower>