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', 'tablelamp', 'microwave', 'toilet', 'freezer', 'knifeblock', 'drawing', 'wallshelf', 'ceiling', 'phone', 'desk', 'keyboard', 'face', 'toaster', 'laptop', 'tvstand', 'shower', 'stereo', 'homework', 'oil', 'towel', 'oven', 'basket_for_clothes', 'tray', 'towel_rack', 'hair', 'cupboard', 'door', 'bathtub', 'clothes_shirt']
Task:Rain welcome
response:
{
    "thoughts": The robot would greet me and then hand me a towel.  It would make an appropriate quip about the weather while I dried off.  It would receive the wet towel when I was done.,
    "actions": ['[WALK] <bedroom>', '[WALK] <towel>', '[FIND] <towel>', '[GRAB] <towel>', '[FIND] <face>', '[WIPE] <face>', '[FIND] <hair>', '[WIPE] <hair>', '[PUTOBJBACK] <towel>']
}

Input:
Scene_Objects:['microwave', 'toilet', 'trashcan', 'toothbrush', 'wallshelf', 'bathroom_counter', 'floor', 'ceiling', 'character', 'keyboard', 'alcohol', 'stovefan', 'faucet', 'shower', 'mousepad', 'closetdrawer', 'pillow', 'wall', 'wall_clock', 'bench', 'photoframe', 'towel_rack', 'mouse', 'cupboard', 'conditioner', 'sink', 'clothes_scarf', 'bathroom_cabinet', 'home_office', 'tooth_paste']
Task:Wash teeth
response:

Upon entering the restroom, walk to the sink. Take a toothbrush and apply enough toothpaste so that 1/4 of the brush is covered (this is the appropriate amount). Proceed to "brush" your teeth using an up and down motion with the brush in your mouth. Brush for 2 minutes covering all areas of the teeth. Rinse with water and clean toothbrush with water too.

[WALK] <bathroom>
[WALK] <tooth_paste>
[FIND] <tooth_paste>
[SCRUB] <tooth_paste>
[FIND] <toothbrush>
[WASH] <toothbrush>
[FIND] <sink>
[RINSE] <sink>


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', 'food_bread', 'toilet', 'chair', 'freezer', 'bathroom', 'food_carrot', 'hanger', 'keyboard', 'envelope', 'mail', 'tvstand', 'clothes_pants', 'bowl', 'dining_room', 'oven', 'powersocket', 'bed', 'clothes_gloves', 'check', 'wine', 'curtain', 'food_onion', 'kettle', 'dresser', 'vase', 'home_office', 'light', 'clothes_skirt', 'dishwasher']
Task:Pick up phone
response:
{
    "thoughts": I hear the phone ringing in the living room. I walk to the living room and go to the phone. I pick it up and answer the phone.,
    "actions": ['[WALK] <home_office>', '[WALK] <phone>', '[FIND] <phone>', '[TURNTO] <phone>', '[LOOKAT] <phone>', '[GRAB] <phone>', '[SWITCHON] <phone>']
}

Input:
Scene_Objects:['pot', 'filing_cabinet', 'chair', 'walllamp', 'cpuscreen', 'floor', 'ceiling', 'desk', 'keyboard', 'computer', 'ceilinglamp', 'tvstand', 'laptop', 'shower', 'mousepad', 'closetdrawer', 'wall', 'powersocket', 'oven', 'cutting_board', 'coffe_maker', 'television', 'tray', 'doorjamb', 'mouse', 'hair', 'door', 'sink', 'home_office', 'table']
Task:Write an email
response:

I walk to the Home Office then find the computer and sit in the chair. I switch on the computer and start typing the email. I switch the computer off.

[WALK] <home_office>
[WALK] <computer>
[FIND] <computer>
[FIND] <chair>
[SIT] <chair>
[SWITCHON] <computer>
[TURNTO] <computer>
[LOOKAT] <computer>
[FIND] <keyboard>
[TYPE] <keyboard>
[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:['filing_cabinet', 'detergent', 'bills', 'orchid', 'floor', 'ceiling', 'phone', 'bedroom', 'mat', 'laptop', 'shower', 'faucet', 'ceilinglamp', 'mousepad', 'microphone', 'form', 'pillow', 'broom', 'wall', 'newspaper', 'after_shave', 'doorjamb', 'cd', 'comb', 'controller', 'door', 'bathroom_cabinet', 'light', 'table', 'creditcard']
Task:Turn on light
response:
{
    "thoughts": I walk to wall. I put my hand on the switch. I push the button. I turn on the lights.,
    "actions": ['[WALK] <light>', '[FIND] <light>', '[SWITCHON] <light>']
}

Input:
Scene_Objects:['filing_cabinet', 'tablelamp', 'microwave', 'chair', 'walllamp', 'drawing', 'cpuscreen', 'bedroom', 'computer', 'toaster', 'mat', 'oil', 'couch', 'dining_room', 'oven', 'powersocket', 'photoframe', 'coffe_maker', 'television', 'food_rice', 'tray', 'curtain', 'mouse', 'dresser', 'bathtub', 'home_office', 'table', 'bathroom_cabinet', 'coffee', 'shoe_rack']
Task:Browse internet
response:

I pick up my phone. I touch it to navigate to the web browser. I can swipe and tap the screen to visit different websites. Then I read or watch the content within those websites.

[WALK] <home_office>
[WALK] <phone>
[FIND] <phone>
[GRAB] <phone>
[TOUCH] <phone>
[TURNTO] <phone>
[LOOKAT] <phone>


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', 'trashcan', 'food_carrot', 'drawing', 'knifeblock', 'hanger', 'floor', 'tea_bag', 'ceilinglamp', 'tvstand', 'shower', 'window', 'homework', 'couch', 'dustpan', 'food_orange', 'dining_room', 'wall', 'nightstand', 'photoframe', 'clothes_gloves', 'coffe_maker', 'check', 'television', 'mouse', 'pencil', 'table', 'laser_pointer']
Task:Relax on sofa
response:
{
    "thoughts": Walk to the living room, turn to the sofa. Sit on the sofa and relax.,
    "actions": ['[WALK] <home_office>', '[WALK] <couch>', '[FIND] <couch>', '[TURNTO] <couch>', '[SIT] <couch>']
}

Input:
Scene_Objects:['blender', 'chair', 'nail_polish', 'knife', 'cpuscreen', 'bathroom_counter', 'table_cloth', 'stovefan', 'tvstand', 'stereo', 'faucet', 'window', 'mousepad', 'dining_room', 'broom', 'nightstand', 'wall_clock', 'wall', 'oven', 'bed', 'newspaper', 'food_food', 'video_game_controller', 'wine', 'after_shave', 'curtain', 'towel_rack', 'bathtub', 'light', 'table']
Task:Listen to music
response:

[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:['pot', 'tablelamp', 'jelly', 'bathroom', 'detergent', 'dough', 'orchid', 'floor', 'bedroom', 'mat', 'dish_soap', 'mousepad', 'dining_room', 'wall', 'nightstand', 'oven', 'food_cheese', 'photoframe', 'coffe_maker', 'food_food', 'ice', 'tray', 'kitchen_counter', 'headset', 'dishrack', 'dresser', 'cupboard', 'door', 'home_office', 'dishwasher']
Task:Wash dishes with dishwasher
response:
{
    "thoughts": I go to the dishwasher and put dish soap. I close the dishwasher and turn it on.,
    "actions": ['[WALK] <dining_room>', '[WALK] <dishwasher>', '[FIND] <dishwasher>', '[OPEN] <dishwasher>', '[FIND] <dish_soap>', '[GRAB] <dish_soap>', '[PUTBACK] <dish_soap> <dishwasher>', '[GRAB] <dish_soap>', '[PUTBACK] <dish_soap> <dishwasher>', '[CLOSE] <dishwasher>', '[SWITCHON] <dishwasher>']
}

Input:
Scene_Objects:['microwave', 'toilet', 'chair', 'walllamp', 'bathroom', 'drawing', 'cpuscreen', 'wallshelf', 'floor', 'ceiling', 'desk', 'keyboard', 'bookshelf', 'computer', 'ceilinglamp', 'tvstand', 'window', 'mousepad', 'dustpan', 'pillow', 'wall', 'wall_clock', 'powersocket', 'television', 'tray', 'doorjamb', 'mouse', 'dresser', 'cupboard', 'table']
Task:Browse internet
response:

[WALK] <home_office>
[WALK] <desk>
[FIND] <computer>
[SWITCHON] <computer>
[FIND] <chair>
[SIT] <chair>
[FIND] <mouse>
[TOUCH] <mouse>
[TURNTO] <computer>
[LOOKAT] <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:['sheets', 'chair', 'walllamp', 'detergent', 'knifeblock', 'orchid', 'cpuscreen', 'drawing', 'bathroom_counter', 'phone', 'folder', 'man', 'keyboard', 'mop_bucket', 'tvstand', 'faucet', 'picture', 'plate', 'mousepad', 'bench', 'oven', 'powersocket', 'photoframe', 'food_food', 'check', 'food_onion', 'clothes_scarf', 'spoon', 'light', 'dishwasher']
Task:Greet guests
response:
{
    "thoughts": When someone knocks I n the door walk through the hallway and greet them.,
    "actions": ['[RUN] <home_office>', '[WALK] <man>', '[FIND] <man>', '[GREET] <man>', '[FIND] <man>', '[GREET] <man>']
}

Input:
Scene_Objects:['filing_cabinet', 'tablelamp', 'toilet', 'freezer', 'orchid', 'drawing', 'wallshelf', 'floor', 'phone', 'bedroom', 'bookshelf', 'stovefan', 'mat', 'shower', 'window', 'mousepad', 'pillow', 'nightstand', 'wall', 'oven', 'wall_clock', 'bed', 'novel', 'curtain', 'towel_rack', 'cupboard', 'door', 'sink', 'light', 'laser_pointer']
Task:Read book
response:

Go to the bedroom. Grab the book out of the nightstand. Lay down in bed. Open the book. Read the book.

[WALK] <bedroom>
[WALK] <nightstand>
[FIND] <nightstand>
[OPEN] <nightstand>
[FIND] <novel>
[GRAB] <novel>
[FIND] <bed>
[TURNTO] <bed>
[SIT] <bed>
[READ] <novel>


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:['juice', 'walllamp', 'cat', 'drawing', 'orchid', 'wallshelf', 'bathroom_counter', 'floor', 'ceiling', 'desk', 'thread', 'computer', 'stovefan', 'mat', 'tvstand', 'toaster', 'couch', 'pillow', 'wall', 'photoframe', 'check', 'television', 'doorjamb', 'laundry_detergent', 'conditioner', 'sink', 'door', 'bathroom_cabinet', 'table', 'dishwasher']
Task:Do homework
response:
{
    "thoughts": Sit on the couch in the Living room and pick u some papers,
    "actions": ['[WALK] <home_office>', '[WALK] <couch>', '[FIND] <couch>', '[SIT] <couch>', '[FIND] <check>', '[GRAB] <check>', '[DROP] <check>']
}

Input:
Scene_Objects:['food_pizza', 'mop', 'chair', 'bathroom', 'drawing', 'wallshelf', 'character', 'bedroom', 'keyboard', 'computer', 'mat', 'ceilinglamp', 'shower', 'faucet', 'floor_lamp', 'mousepad', 'closetdrawer', 'nightstand', 'wall', 'oven', 'bench', 'photoframe', 'bed', 'coffe_maker', 'food_food', 'check', 'conditioner', 'light', 'table', 'tooth_paste']
Task:Turn on light
response:

walk to living room, find lamp, switch on.

[WALK] <home_office>
[WALK] <floor_lamp>
[FIND] <floor_lamp>


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', '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:
{
    "thoughts": 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.,
    "actions": ['[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>']
}

Input:
Scene_Objects:['fork', 'toilet', 'freezer', 'detergent', 'drawing', 'knife', 'wallshelf', 'dvd_player', 'character', 'bookshelf', 'plate', 'shower', 'tvstand', 'dish_soap', 'closetdrawer', 'pillow', 'food_kiwi', 'nightstand', 'powersocket', 'cutting_board', 'photoframe', 'wooden_spoon', 'dishrack', 'dresser', 'cupboard', 'door', 'sink', 'spoon', 'light', 'dishwasher']
Task:Wash dishes with dishwasher
response:

put forks, spoons, plates, knife in dishwasher, add dish soap, turn diswaser on

[WALK] <dining_room>
[WALK] <dishwasher>
[FIND] <dishwasher>
[OPEN] <dishwasher>
[FIND] <dish_soap>
[GRAB] <dish_soap>
[PUTBACK] <dish_soap> <dishwasher>
[FIND] <fork>
[GRAB] <fork>
[FIND] <dishrack>
[PUTBACK] <fork> <dishrack>
[FIND] <plate>
[GRAB] <plate>
[PUTBACK] <plate> <dishrack>
[FIND] <spoon>
[GRAB] <spoon>
[PUTBACK] <spoon> <dishrack>
[FIND] <knife>
[GRAB] <knife>
[PUTBACK] <knife> <dishrack>
[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:['microwave', 'chair', 'freezer', 'walllamp', 'bathroom', 'floor', 'ceiling', 'keyboard', 'stovefan', 'electric_shaver', 'clothes_socks', 'form', 'wall', 'nightstand', 'oven', 'cutting_board', 'coffe_maker', 'food_food', 'oven_mitts', 'food_donut', 'tray', 'doorjamb', 'kettle', 'mouse', 'kitchen_counter', 'laundry_detergent', 'home_office', 'table', 'bathroom_cabinet', 'instrument_guitar']
Task:Put groceries in Fridge
response:
{
    "thoughts": go to the kitchen and put the groceries in the fridge,
    "actions": ['[WALK] <dining_room>', '[WALK] <freezer>', '[FIND] <freezer>', '[OPEN] <freezer>', '[FIND] <food_food>', '[GRAB] <food_food>', '[PUTIN] <food_food> <freezer>']
}

Input:
Scene_Objects:['sheets', 'food_ice_cream', 'microwave', 'toilet', 'freezer', 'bathroom', 'trashcan', 'drawing', 'wallshelf', 'bathroom_counter', 'floor', 'ceiling', 'phone', 'desk', 'bookshelf', 'computer', 'toaster', 'mat', 'shower', 'faucet', 'wall', 'nightstand', 'oven', 'food_food', 'video_game_controller', 'doorjamb', 'kitchen_counter', 'cupboard', 'door', 'sink']
Task:Cook some food
response:

Walk Into Kitchen. Open Refrigerator. Grab Food. Walk to Microwave. Insert food into microwave. Cook until warm.

[WALK] <dining_room>
[WALK] <freezer>
[OPEN] <freezer>
[FIND] <food_food>
[CLOSE] <freezer>
[WALK] <microwave>
[SWITCHON] <microwave>
[SWITCHOFF] <microwave>


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', 'drawing', 'orchid', 'cpuscreen', 'wallshelf', 'hanger', 'floor', 'ceiling', 'phone', 'desk', 'keyboard', 'computer', 'mat', 'ceilinglamp', 'tvstand', 'mousepad', 'couch', 'pillow', 'wall', 'nightstand', 'oven', 'cup', 'television', 'tray', 'doorjamb', 'mouse', 'dresser', 'door']
Task:Watch youtube
response:
{
    "thoughts": Go to youtube.Com watch videos,
    "actions": ['[WALK] <home_office>', '[WALK] <chair>', '[FIND] <chair>', '[SIT] <chair>', '[FIND] <computer>', '[SWITCHON] <computer>', '[FIND] <keyboard>', '[TYPE] <keyboard>', '[TURNTO] <computer>', '[LOOKAT] <computer>']
}

Input:
Scene_Objects:['microwave', 'chair', 'jelly', 'walllamp', 'orchid', 'wallshelf', 'cpuscreen', 'bathroom_counter', 'floor', 'ceiling', 'desk', 'keyboard', 'bookshelf', 'envelope', 'computer', 'stovefan', 'ceilinglamp', 'tvstand', 'faucet', 'picture', 'mousepad', 'wall', 'powersocket', 'television', 'tray', 'doorjamb', 'towel_rack', 'mouse', 'bathroom_cabinet', 'table']
Task:Work
response:

Go into the office and sit down at the desk in front of the computer. Turn on the computer and look at it while clicking with the mouse and typing with the keyboard.

[WALK] <home_office>
[WALK] <chair>
[FIND] <chair>
[SIT] <chair>
[FIND] <computer>
[SWITCHON] <computer>
[TURNTO] <computer>
[LOOKAT] <computer>
[FIND] <keyboard>
[TYPE] <keyboard>


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', 'chair', 'freezer', 'ground_coffee', 'walllamp', 'trashcan', 'cpuscreen', 'bathroom_counter', 'floor', 'ceiling', 'character', 'food_bacon', 'toaster', 'tvstand', 'window', 'oil', 'couch', 'wall', 'nightstand', 'newspaper', 'coffe_maker', 'television', 'coffee_filter', 'water', 'food_donut', 'kitchen_counter', 'cupboard', 'bathroom_cabinet', 'dishwasher', 'dirt']
Task:Make coffee
response:
{
    "thoughts": Walk to Kitchen and find coffee maker, find coffee filter and place it in coffee maker. Find ground coffee and water. put both in coffee maker. Close the coffee maker and switch it on.,
    "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] <ground_coffee>', '[GRAB] <ground_coffee>', '[PUTBACK] <ground_coffee> <coffe_maker>', '[WALK] <water>', '[FIND] <water>', '[GRAB] <water>', '[POUR] <water> <coffe_maker>', '[CLOSE] <coffe_maker>', '[SWITCHON] <coffe_maker>']
}

Input:
Scene_Objects:['chair', 'walllamp', 'blow_dryer', 'cpuscreen', 'floor', 'ceiling', 'character', 'desk', 'bedroom', 'keyboard', 'thread', 'computer', 'table_cloth', 'ceilinglamp', 'tvstand', 'mat', 'foundation', 'mousepad', 'wall', 'powersocket', 'television', 'doorjamb', 'kettle', 'mouse', 'kitchen_counter', 'cupboard', 'sink', 'bathroom_cabinet', 'table', 'light']
Task:Work
response:

I go to my home office, sit on the chair and turn on the computer. I open my email account to look for all the information I need.I pull up my online task on the computer to look at what the assigned task is.

[WALK] <home_office>
[WALK] <chair>
[FIND] <chair>
[SIT] <chair>
[FIND] <computer>
[SWITCHON] <computer>
[TURNTO] <computer>
[LOOKAT] <computer>
[FIND] <mouse>
[GRAB] <mouse>
[FIND] <keyboard>
[TYPE] <keyboard>
[TURNTO] <computer>
[LOOKAT] <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', 'filing_cabinet', 'microwave', 'chair', 'freezer', 'bathroom', 'drawing', 'cpuscreen', 'wallshelf', 'bathroom_counter', 'ceiling', 'desk', 'computer', 'stovefan', 'mat', 'ceilinglamp', 'homework', 'mousepad', 'closetdrawer', 'pillow', 'dining_room', 'wall_clock', 'oven', 'tape', 'photoframe', 'dresser', 'cupboard', 'bathtub', 'light', 'dirt']
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:['filing_cabinet', 'chair', 'walllamp', 'trashcan', 'drawing', 'wallshelf', 'cpuscreen', 'hanger', 'bathroom_counter', 'floor', 'ceiling', 'character', 'bedroom', 'tea_bag', 'food_bacon', 'mop_bucket', 'tvstand', 'electric_shaver', 'dining_room', 'wall', 'photoframe', 'television', 'doorjamb', 'kitchen_counter', 'sink', 'bathroom_cabinet', 'light', 'table', 'home_office', 'colander']
Task:Turn on light
response:

push any ligth button to turn it on, for example in the living room

[WALK] <home_office>
[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:['dry_pasta', 'pot', 'microwave', 'walllamp', 'toothbrush', 'drawing', 'knifeblock', 'wallshelf', 'keyboard', 'food_cake', 'ceilinglamp', 'tvstand', 'shower', 'stereo', 'oil', 'tooth_paste', 'couch', 'closetdrawer', 'dining_room', 'toy', 'basket_for_clothes', 'light_bulb', 'check', 'centerpiece', 'kettle', 'mouse', 'kitchen_counter', 'shoes', 'light', 'board_game']
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:['jelly', 'freezer', 'walllamp', 'bathroom', 'bills', 'needle', 'drawing', 'character', 'table_cloth', 'toaster', 'picture', 'floor_lamp', 'window', 'mousepad', 'microphone', 'food_kiwi', 'wall', 'wall_clock', 'newspaper', 'bed', 'television', 'tray', 'cupboard', 'controller', 'door', 'sink', 'bathtub', 'bathroom_cabinet', 'light', 'home_office']
Task:Turn on light
response:

I go to bedroom and locate a lamp. This lamp can be turned on by touch, as it has capacitive sensing. So I do it.

[WALK] <bedroom>
[WALK] <floor_lamp>
[FIND] <floor_lamp>
[TOUCH] <floor_lamp>
[SWITCHON] <floor_lamp>


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', 'chair', 'drawing', 'orchid', 'wallshelf', 'bathroom_counter', 'floor', 'ceiling', 'character', 'desk', 'computer', 'stovefan', 'tvstand', 'faucet', 'shower', 'pillow', 'wall', 'cup', 'bed', 'coffe_maker', 'television', 'tray', 'lighter', 'dresser', 'cupboard', 'door', 'sink', 'bathroom_cabinet', 'soap', 'hands_both']
Task:Wash hands
response:
{
    "thoughts": Walk to the sink, turn on the faucet, put soap on hands, rub hands together under the water, rinse off hands, turn off faucet, dry hands,
    "actions": ['[WALK] <bathroom>', '[WALK] <sink>', '[FIND] <sink>', '[WALK] <sink>', '[FIND] <soap>', '[FIND] <faucet>', '[SWITCHON] <faucet>', '[FIND] <hands_both>', '[WASH] <hands_both>', '[RINSE] <hands_both>', '[SWITCHOFF] <faucet>']
}

Input:
Scene_Objects:['filing_cabinet', 'microwave', 'chair', 'walllamp', 'detergent', 'cpuscreen', 'floor', 'ceiling', 'phone', 'desk', 'keyboard', 'computer', 'ceilinglamp', 'tvstand', 'mousepad', 'closetdrawer', 'dining_room', 'wall', 'nightstand', 'powersocket', 'photoframe', 'bed', 'coffe_maker', 'television', 'doorjamb', 'mouse', 'pencil', 'bathtub', 'home_office', 'table']
Task:Browse internet
response:

For browsing internet walk to home office. Find Computer. Walk to Computer. Find Chair. Sit in a chair and switch on computer. Connect with internet and browse the net.

[WALK] <home_office>
[WALK] <computer>
[FIND] <computer>
[WALK] <computer>
[FIND] <chair>
[SIT] <chair>
[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:['tablelamp', 'chair', 'ground_coffee', 'orchid', 'drawing', 'cpuscreen', 'floor', 'ceiling', 'phone', 'desk', 'keyboard', 'computer', 'mail', 'bookmark', 'toaster', 'mat', 'ceilinglamp', 'tvstand', 'laptop', 'mousepad', 'dining_room', 'wall', 'nightstand', 'oven', 'cup', 'bed', 'television', 'coffee_filter', 'mouse', 'door']
Task:Answer emails
response:
{
    "thoughts": Open email application.  Open new emails.  Respond accordingly,
    "actions": ['[WALK] <home_office>', '[WALK] <chair>', '[FIND] <chair>', '[SIT] <chair>', '[FIND] <laptop>', '[SWITCHON] <laptop>', '[TURNTO] <laptop>', '[LOOKAT] <laptop>', '[FIND] <mail>', '[GRAB] <mail>', '[READ] <mail>', '[FIND] <keyboard>', '[TYPE] <keyboard>', '[SWITCHOFF] <laptop>']
}

Input:
Scene_Objects:['tablelamp', 'freezer', 'bathroom', 'bathroom_counter', 'floor', 'ceiling', 'phone', 'stovefan', 'toaster', 'tvstand', 'faucet', 'mousepad', 'towel', 'wall', 'wall_clock', 'bench', 'powersocket', 'nightstand', 'bed', 'toilet_paper', 'television', 'wine', 'curtain', 'doorjamb', 'dresser', 'sink', 'bathtub', 'bathroom_cabinet', 'clothes_skirt', 'soap']
Task:Wash hands
response:

I walk into the bathroom. Walk to the sink. Turn on tap. Get soap. Wash and rinse hands. Turn off tap. Dry hands.

[WALK] <bathroom>
[WALK] <sink>
[FIND] <sink>
[TURNTO] <sink>
[LOOKAT] <sink>
[WALK] <sink>
[FIND] <faucet>
[SWITCHON] <faucet>
[FIND] <soap>
[GRAB] <soap>
[RINSE] <soap>
[SWITCHOFF] <faucet>
[FIND] <towel>
[GRAB] <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:['sheets', 'tablelamp', 'toilet', 'walllamp', 'detergent', 'food_carrot', 'orchid', 'floor', 'ceiling', 'phone', 'bedroom', 'keyboard', 'ceilinglamp', 'tvstand', 'stereo', 'faucet', 'mousepad', 'dining_room', 'wall', 'powersocket', 'food_food', 'food_donut', 'towel_rack', 'mouse', 'shoes', 'dishrack', 'sink', 'spoon', 'light', 'coffee']
Task:Go to toilet
response:
{
    "thoughts": Walk to bathroom, find toilet.,
    "actions": ['[WALK] <bathroom>', '[WALK] <toilet>', '[FIND] <toilet>']
}

Input:
Scene_Objects:['microwave', 'toilet', 'freezer', 'walllamp', 'bathroom', 'trashcan', 'drawing', 'cpuscreen', 'floor', 'ceiling', 'bedroom', 'bookshelf', 'stovefan', 'mat', 'ceilinglamp', 'shower', 'dining_room', 'wall', 'oven', 'powersocket', 'food_food', 'coffe_maker', 'television', 'tray', 'doorjamb', 'kitchen_counter', 'cupboard', 'door', 'bathtub', 'bathroom_cabinet']
Task:Put groceries in Fridge
response:

go to the kitchen and put the groceries in the fridge

[WALK] <dining_room>
[WALK] <freezer>
[FIND] <freezer>
[OPEN] <freezer>
[FIND] <food_food>
[GRAB] <food_food>
[PUTIN] <food_food> <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', 'chair', 'walllamp', 'drawing', 'wallshelf', 'cpuscreen', 'hanger', 'bathroom_counter', 'floor', 'ceiling', 'desk', 'keyboard', 'remote_control', 'computer', 'mat', 'tvstand', 'ceilinglamp', 'shower', 'oil', 'closetdrawer', 'couch', 'pillow', 'wall', 'love_seat', 'photoframe', 'television', 'doorjamb', 'dresser', 'door', 'clothes_scarf']
Task:Watch TV
response:
{
    "thoughts": Sit and watch the television,
    "actions": ['[WALK] <home_office>', '[WALK] <remote_control>', '[FIND] <remote_control>', '[GRAB] <remote_control>', '[FIND] <love_seat>', '[SIT] <love_seat>', '[FIND] <television>', '[SWITCHON] <television>', '[TURNTO] <television>', '[WATCH] <television>']
}

Input:
Scene_Objects:['filing_cabinet', 'tablelamp', 'beer', 'microwave', 'toilet', 'jelly', 'freezer', 'cpuscreen', 'floor', 'phone', 'ceiling', 'keyboard', 'toaster', 'ceilinglamp', 'tvstand', 'faucet', 'shower', 'foundation', 'clothes_socks', 'couch', 'pillow', 'wall', 'wall_clock', 'cup', 'photoframe', 'tray', 'curtain', 'kitchen_counter', 'sink', 'clothes_scarf']
Task:Go to toilet
response:


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', 'chair', 'walllamp', 'drawing', 'needle', 'wallshelf', 'bills', 'hanger', 'floor', 'ceiling', 'desk', 'remote_control', 'computer', 'stovefan', 'mat', 'tvstand', 'ceilinglamp', 'closetdrawer', 'couch', 'form', 'pillow', 'wall', 'basket_for_clothes', 'photoframe', 'check', 'television', 'doorjamb', 'kitchen_counter', 'dresser', 'tooth_paste']
Task:Watch TV
response:
{
    "thoughts": I enter the living room and sit on the couch. I grab the remote and 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', 'water_glass', 'microwave', 'toilet', 'freezer', 'trashcan', 'drawing', 'hanger', 'bathroom_counter', 'floor', 'ceiling', 'phone', 'character', 'desk', 'stovefan', 'mat', 'shower', 'closetdrawer', 'couch', 'wall', 'powersocket', 'oven', 'food_food', 'check', 'doorjamb', 'kitchen_counter', 'dresser', 'cupboard', 'door', 'light']
Task:Drink
response:

walk to kitchen ,find fridge ,open fridge ,find water  glass , drink from water glass

[WALK] <dining_room>
[WALK] <freezer>
[FIND] <freezer>
[OPEN] <freezer>
[FIND] <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:['measuring_cup', 'detergent', 'orchid', 'clothes_underwear', 'floor', 'character', 'button', 'stovefan', 'ceilinglamp', 'toaster', 'homework', 'mousepad', 'couch', 'dustpan', 'microphone', 'form', 'towel', 'powersocket', 'basket_for_clothes', 'bed', 'light_bulb', 'oven_mitts', 'tray', 'kitchen_counter', 'cupboard', 'laundry_detergent', 'sink', 'bathroom_cabinet', 'colander', 'washing_machine']
Task:Wash clothes
response:
{
    "thoughts": Walk to laundry room. Find laundry basket. Grab laundry basket. Find washing machine. Walk to washing machine. Open washing machine. Find detergent. Grab detergent. Put in detergent. Put in clothes. Close washing machine. Turn on machine.,
    "actions": ['[WALK] <bathroom>', '[WALK] <basket_for_clothes>', '[FIND] <basket_for_clothes>', '[GRAB] <basket_for_clothes>', '[FIND] <washing_machine>', '[WALK] <washing_machine>', '[OPEN] <washing_machine>', '[FIND] <laundry_detergent>', '[GRAB] <laundry_detergent>', '[POUR] <laundry_detergent> <washing_machine>', '[PUTOBJBACK] <laundry_detergent>', '[PUTBACK] <basket_for_clothes> <washing_machine>', '[CLOSE] <washing_machine>', '[SWITCHON] <washing_machine>']
}

Input:
Scene_Objects:['filing_cabinet', 'microwave', 'toilet', 'chair', 'freezer', 'trashcan', 'drawing', 'cpuscreen', 'floor', 'character', 'bedroom', 'keyboard', 'table_cloth', 'toaster', 'stovefan', 'faucet', 'shower', 'window', 'mousepad', 'closetdrawer', 'wall', 'oven', 'lighter', 'towel_rack', 'kitchen_counter', 'cupboard', 'sink', 'bathroom_cabinet', 'light', 'home_office']
Task:Go to toilet
response:

Travel through the house and locate the bathroom, and proceed to the toilet.

[WALK] <bathroom>
[WALK] <toilet>
[FIND] <toilet>


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', 'measuring_cup', 'walllamp', 'bathroom', 'drawing', 'wallshelf', 'floor', 'ceiling', 'bookshelf', 'bookmark', 'mat', 'tvstand', 'ceilinglamp', 'window', 'couch', 'pillow', 'wall', 'bench', 'cup', 'photoframe', 'novel', 'check', 'coffe_maker', 'television', 'tray', 'curtain', 'doorjamb', 'bathroom_cabinet', 'light', 'table']
Task:Read book
response:
{
    "thoughts": I go to the book case, I select a book, I go back and sit down, then I read.,
    "actions": ['[WALK] <filing_cabinet>', '[FIND] <novel>', '[GRAB] <novel>', '[WALK] <couch>', '[READ] <novel>']
}

Input:
Scene_Objects:['fork', 'freezer', 'walllamp', 'drawing', 'orchid', 'needle', 'floor', 'phone', 'ceiling', 'character', 'keyboard', 'food_cake', 'computer', 'stovefan', 'mat', 'plate', 'window', 'closetdrawer', 'wall', 'powersocket', 'tape', 'television', 'tray', 'curtain', 'towel_rack', 'sink', 'spoon', 'bathtub', 'table', 'bathroom_cabinet']
Task:Set up table
response:

Place your plate on the placemat. The forks will be placed on the left side of the plate and the knife and spoon on the right and place the spoon to the right of the knife. If you want to set out food, place them above the plate.

[WALK] <table>
[FIND] <plate>
[GRAB] <plate>
[DROP] <plate>
[FIND] <fork>
[GRAB] <fork>
[DROP] <fork>
[FIND] <spoon>
[GRAB] <spoon>
[DROP] <spoon>


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', 'drawing', 'orchid', 'cpuscreen', 'wallshelf', 'hanger', 'floor', 'ceiling', 'phone', 'desk', 'keyboard', 'bookshelf', 'computer', 'mat', 'ceilinglamp', 'tvstand', 'mousepad', 'couch', 'pillow', 'wall', 'nightstand', 'oven', 'powersocket', 'television', 'doorjamb', 'mouse', 'dresser', 'door', 'light', 'table']
Task:Draft home
response:
{
    "thoughts": Using mathematics and CAD software design a home,
    "actions": ['[WALK] <home_office>', '[WALK] <chair>', '[FIND] <chair>', '[SIT] <chair>', '[FIND] <computer>', '[SWITCHON] <computer>', '[FIND] <mouse>', '[GRAB] <mouse>', '[TURNTO] <computer>', '[POINTAT] <computer>', '[PUTOBJBACK] <mouse>', '[FIND] <keyboard>', '[TYPE] <keyboard>', '[FIND] <drawing>', '[TURNTO] <drawing>', '[LOOKAT] <drawing>']
}

Input:
Scene_Objects:['filing_cabinet', 'microwave', 'toilet', 'chair', 'freezer', 'trashcan', 'drawing', 'orchid', 'floor', 'ceiling', 'bedroom', 'clothes_jacket', 'mat', 'ceilinglamp', 'shower', 'window', 'closetdrawer', 'couch', 'dining_room', 'wall', 'powersocket', 'food_food', 'television', 'doorjamb', 'kitchen_counter', 'dresser', 'cupboard', 'door', 'bathtub', 'board_game']
Task:Put groceries in Fridge
response:

Walk to kitchen. Open fridge. Put groceries in fridge.

[WALK] <freezer>
[OPEN] <freezer>
[FIND] <food_food>
[GRAB] <food_food>
[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:['glue', 'pot', 'tablelamp', 'chair', 'walllamp', 'drawing', 'orchid', 'cpuscreen', 'wallshelf', 'hanger', 'floor', 'phone', 'ceiling', 'desk', 'keyboard', 'computer', 'mat', 'ceilinglamp', 'tvstand', 'mousepad', 'couch', 'pillow', 'wall', 'nightstand', 'oven', 'powersocket', 'novel', 'check', 'television', 'tray', 'doorjamb', 'towel_rack', 'mouse', 'dresser', 'door', 'light']
Task:Work
response:
{
    "thoughts": I sit at my desk and work on the computer.,
    "actions": ['[WALK] <home_office>', '[WALK] <desk>', '[FIND] <chair>', '[SIT] <chair>', '[FIND] <computer>', '[SWITCHON] <computer>', '[TURNTO] <computer>', '[LOOKAT] <computer>', '[FIND] <check>', '[GRAB] <check>', '[READ] <check>', '[FIND] <keyboard>', '[TYPE] <keyboard>']
}

Input:
Scene_Objects:['sheets', 'filing_cabinet', 'toilet', 'chair', 'freezer', 'drawing', 'floor', 'ceiling', 'keyboard', 'computer', 'stovefan', 'toaster', 'tvstand', 'faucet', 'shower', 'window', 'wall', 'oven', 'powersocket', 'cup', 'coffe_maker', 'coffee_filter', 'tray', 'curtain', 'kitchen_counter', 'cupboard', 'sink', 'light', 'dirt', 'coffee']
Task:Make coffee
response:

Enter kitchen, find coffee maker, find coffee filter, pick up coffee filter, put it in coffee maker, find coffee, pour coffee into filter, turn on.

[WALK] <dining_room>
[WALK] <coffe_maker>
[FIND] <coffe_maker>
[FIND] <coffee_filter>
[GRAB] <coffee_filter>
[OPEN] <coffe_maker>
[PUTBACK] <coffee_filter> <coffe_maker>
[WALK] <coffee>
[FIND] <coffee>
[GRAB] <coffee>
[POUR] <coffee> <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:['toilet', 'cat', 'floor', 'character', 'stamp', 'table_cloth', 'piano_bench', 'mat', 'window', 'couch', 'food_jam', 'pillow', 'wall', 'nightstand', 'bench', 'toy', 'cup', 'mouthwash', 'television', 'coffee_filter', 'tray', 'curtain', 'doorjamb', 'towel_rack', 'clothes_dress', 'door', 'food_steak', 'bathtub', 'bag', 'table']
Task:Pet cat
response:
{
    "thoughts": I see my cat on the couch so I walk over, sit down and pet the cat.,
    "actions": ['[WALK] <home_office>', '[WALK] <cat>', '[FIND] <cat>', '[TURNTO] <cat>', '[LOOKAT] <cat>', '[FIND] <couch>', '[SIT] <couch>', '[TOUCH] <cat>']
}

Input:
Scene_Objects:['ground_coffee', 'cpuscreen', 'hanger', 'bathroom_counter', 'floor', 'ceiling', 'phone', 'bedroom', 'bookshelf', 'keyboard', 'toaster', 'mat', 'faucet', 'electric_shaver', 'towel', 'pillow', 'wall', 'wall_clock', 'bench', 'bed', 'coffe_maker', 'curtain', 'doorjamb', 'dresser', 'sink', 'bag', 'bathroom_cabinet', 'table', 'soap', 'hands_both']
Task:Wash hands
response:

Go to bathroom, turn on faucet, wet hands, apply soap, rub hands, rinse hands, turn off faucet, dry hands

[WALK] <bathroom>
[WALK] <faucet>
[FIND] <faucet>
[SWITCHON] <faucet>
[FIND] <hands_both>
[RINSE] <hands_both>
[FIND] <soap>
[GRAB] <soap>
[SCRUB] <hands_both>
[RINSE] <hands_both>
[SWITCHOFF] <faucet>
[FIND] <towel>
[GRAB] <towel>
[WIPE] <hands_both>
[PUTOBJBACK] <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:['food_bread', 'filing_cabinet', 'toilet', 'freezer', 'dough', 'drawing', 'hanger', 'floor', 'ceiling', 'mat', 'shoe-shine_kit', 'shower', 'clothes_hat', 'bowl', 'nightstand', 'wall', 'powersocket', 'wall_clock', 'photoframe', 'light_bulb', 'food_food', 'coffe_maker', 'razor', 'coffee_filter', 'doorjamb', 'hairbrush', 'door', 'home_office', 'light', 'soap']
Task:Put away groceries
response:
{
    "thoughts": Place groceries in refrigerator from shopping at the grocery store.,
    "actions": ['[WALK] <dining_room>', '[WALK] <freezer>', '[FIND] <freezer>', '[OPEN] <freezer>', '[FIND] <food_food>', '[GRAB] <food_food>', '[PUTIN] <food_food> <freezer>', '[CLOSE] <freezer>']
}

Input:
Scene_Objects:['pot', 'chair', 'walllamp', 'detergent', 'cpuscreen', 'wallshelf', 'floor', 'ceiling', 'phone', 'desk', 'keyboard', 'bookshelf', 'computer', 'brush', 'ceilinglamp', 'tvstand', 'plate', 'mousepad', 'closetdrawer', 'dustpan', 'pillow', 'wall', 'powersocket', 'television', 'tray', 'doorjamb', 'centerpiece', 'mouse', 'shoes', 'table']
Task:Write an email
response:

walk to living room, look at computer, find chair, sit in chair, grab keyboard, grab mouse, type using keyboard and mouse

[WALK] <home_office>
[WALK] <computer>
[FIND] <computer>
[TURNTO] <computer>
[LOOKAT] <computer>
[WALK] <computer>
[FIND] <chair>
[SIT] <chair>
[FIND] <keyboard>
[GRAB] <keyboard>
[FIND] <mouse>
[GRAB] <mouse>
[TYPE] <keyboard>


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', 'blender', 'crayon', 'walllamp', 'ceilingfan', 'dough', 'drawing', 'orchid', 'cpuscreen', 'floor', 'ceiling', 'desk', 'bookshelf', 'keyboard', 'computer', 'toaster', 'mat', 'stovefan', 'wall', 'powersocket', 'oven', 'bench', 'cutting_board', 'food_rice', 'doorjamb', 'cd', 'door', 'light', 'vase', 'creditcard']
Task:Turn on light
response:
{
    "thoughts": I enter the bedroom and find the light. Then I turn it on.,
    "actions": ['[WALK] <bedroom>', '[WALK] <light>', '[FIND] <light>', '[SWITCHON] <light>']
}

Input:
Scene_Objects:['microwave', 'toilet', 'freezer', 'trashcan', 'drawing', 'wallshelf', 'hanger', 'floor', 'ceiling', 'character', 'bookshelf', 'stovefan', 'mat', 'shower', 'window', 'closetdrawer', 'clothes_hat', 'pillow', 'dining_room', 'wall', 'wall_clock', 'photoframe', 'food_food', 'tray', 'curtain', 'doorjamb', 'kitchen_counter', 'cupboard', 'door', 'home_office']
Task:Put groceries in Fridge
response:

[WALK] <dining_room>
[WALK] <freezer>
[FIND] <freezer>
[OPEN] <freezer>
[FIND] <food_food>
[GRAB] <food_food>
[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:['pot', 'food_salt', 'chair', 'freezer', 'walllamp', 'detergent', 'orchid', 'phone', 'bookshelf', 'computer', 'toaster', 'tvstand', 'stereo', 'closetdrawer', 'food_peanut_butter', 'clothes_pants', 'form', 'wall', 'oven', 'cup', 'bed', 'mouthwash', 'rag', 'towel_rack', 'kitchen_counter', 'pajamas', 'food_steak', 'door', 'napkin', '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:['pot', 'tablelamp', 'microwave', 'toothbrush', 'drawing', 'orchid', 'wallshelf', 'kitchen_cabinet', 'floor', 'ceiling', 'desk', 'bedroom', 'stovefan', 'toaster', 'ceilinglamp', 'faucet', 'shower', 'mousepad', 'pillow', 'wall', 'pasta', 'oven', 'coffe_maker', 'water', 'tray', 'towel_rack', 'kitchen_counter', 'headset', 'sauce_pan', 'cupboard']
Task:Cook some food
response:

[WALK] <dining_room>
[WALK] <kitchen_cabinet>
[FIND] <kitchen_cabinet>
[OPEN] <kitchen_cabinet>
[FIND] <pasta>
[GRAB] <pasta>
[FIND] <water>
[GRAB] <water>
[FIND] <sauce_pan>
[POUR] <water> <sauce_pan>
[FIND] <oven>
[SWITCHON] <oven>
[PUTBACK] <pasta> <sauce_pan>
[FIND] <sauce_pan>
[GRAB] <sauce_pan>
[PUTBACK] <sauce_pan> <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:['microwave', 'walllamp', 'cpuscreen', 'clothes_underwear', 'hanger', 'phone', 'bedroom', 'bookshelf', 'electric_shaver', 'window', 'towel', 'wall', 'nightstand', 'oven', 'powersocket', 'basket_for_clothes', 'newspaper', 'check', 'oven_mitts', 'after_shave', 'towel_rack', 'mouse', 'kettle', 'dresser', 'laundry_detergent', 'bag', 'table', 'dishwasher', 'washing_machine', 'shoe_rack']
Task:Wash clothes
response:
{
    "thoughts": Pick up my dirty clothes, load the washer, add detergent, turn on washer,
    "actions": ['[WALK] <bedroom>', '[WALK] <basket_for_clothes>', '[GRAB] <basket_for_clothes>', '[WALK] <home_office>', '[WALK] <washing_machine>', '[OPEN] <washing_machine>', '[PUTBACK] <basket_for_clothes> <washing_machine>', '[FIND] <laundry_detergent>', '[GRAB] <laundry_detergent>', '[PUTBACK] <laundry_detergent> <washing_machine>', '[RUN] <washing_machine>']
}

Input:
Scene_Objects:['food_salt', 'microwave', 'toilet', 'chair', 'freezer', 'walllamp', 'needle', 'floor', 'ceiling', 'computer', 'toaster', 'stovefan', 'mat', 'faucet', 'shower', 'pillow', 'wall', 'oven', 'cup', 'photoframe', 'toilet_paper', 'coffe_maker', 'doorjamb', 'towel_rack', 'kitchen_counter', 'cupboard', 'sink', 'home_office', 'light', 'creditcard']
Task:Go to toilet
response:

[WALK] <bathroom>
[WALK] <toilet>
[FIND] <toilet>


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', 'band-aids', 'walllamp', 'drawing', 'food_egg', 'bathroom_counter', 'ceiling', 'stamp', 'desk', 'cleaning_solution', 'computer', 'stovefan', 'deck_of_cards', 'faucet', 'tvstand', 'window', 'couch', 'wall', 'nightstand', 'coffe_maker', 'television', 'mirror', 'after_shave', 'paper_towel', 'clothes_dress', 'sink', 'bag', 'bathroom_cabinet', 'dishwasher', 'laser_pointer']
Task:Clean mirror
response:
{
    "thoughts": First spray the mirrors with Windex or window type spray.  Take paper towels and wipe until sparkly clean.  If they have streaks, repeat the process.,
    "actions": ['[WALK] <bathroom>', '[WALK] <bathroom_cabinet>', '[OPEN] <bathroom_cabinet>', '[FIND] <paper_towel>', '[GRAB] <paper_towel>', '[CLOSE] <bathroom_cabinet>', '[WALK] <mirror>', '[FIND] <cleaning_solution>', '[RINSE] <cleaning_solution>', '[WIPE] <mirror>']
}

Input:
Scene_Objects:['filing_cabinet', 'microwave', 'freezer', 'hanger', 'bathroom_counter', 'floor', 'ceiling', 'character', 'food_cake', 'stovefan', 'faucet', 'closetdrawer', 'couch', 'form', 'dining_room', 'wall', 'nightstand', 'photoframe', 'television', 'tray', 'doorjamb', 'cards', 'kitchen_counter', 'dresser', 'sink', 'bathtub', 'bathroom_cabinet', 'home_office', 'light', 'teeth']
Task:Wash teeth
response:

Walk to bathroom.  Find mouthwash or turn on water.  Put mouthwash or water in mouth.  Swish around for 30 seconds.  Spit mouthwash out.

[WALK] <bathroom>
[WALK] <faucet>
[FIND] <faucet>
[SWITCHON] <faucet>
[FIND] <teeth>
[RINSE] <teeth>


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', 'tablelamp', 'toilet', 'chair', 'freezer', 'blow_dryer', 'bathroom', 'trashcan', 'drawing', 'wallshelf', 'cpuscreen', 'floor', 'ceiling', 'desk', 'tea_bag', 'bookshelf', 'ceilinglamp', 'dining_room', 'wall', 'oven', 'photoframe', 'bed', 'novel', 'check', 'tray', 'doorjamb', 'towel_rack', 'console', 'pencil', 'light']
Task:Read book
response:
{
    "thoughts": Walk to the Living Room. Look at the Cabinet. Find a Textbook. Grab the textbook. Open the Textbook. Read the textbook.,
    "actions": ['[WALK] <home_office>', '[WALK] <filing_cabinet>', '[FIND] <filing_cabinet>', '[TURNTO] <filing_cabinet>', '[LOOKAT] <filing_cabinet>', '[FIND] <novel>', '[GRAB] <novel>', '[READ] <novel>']
}

Input:
Scene_Objects:['microwave', 'chair', 'drawing', 'orchid', 'wallshelf', 'bathroom_counter', 'floor', 'ceiling', 'character', 'desk', 'computer', 'stovefan', 'tvstand', 'faucet', 'shower', 'pillow', 'wall', 'cup', 'bed', 'coffe_maker', 'television', 'tray', 'lighter', 'dresser', 'cupboard', 'door', 'sink', 'bathroom_cabinet', 'soap', 'hands_both']
Task:Wash hands
response:

Walk to the sink, turn on the faucet, put soap on hands, rub hands together under the water, rinse off hands, turn off faucet, dry hands

[WALK] <bathroom>
[WALK] <sink>
[FIND] <sink>
[WALK] <sink>
[FIND] <soap>
[FIND] <faucet>
[SWITCHON] <faucet>
[FIND] <hands_both>
[WASH] <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:['filing_cabinet', 'toilet', 'chair', 'ground_coffee', 'detergent', 'drawing', 'clothes_underwear', 'hanger', 'floor', 'bookshelf', 'envelope', 'mat', 'shower', 'faucet', 'homework', 'mousepad', 'wall', 'toy', 'photoframe', 'check', 'coffee_filter', 'food_onion', 'shaving_cream', 'cards', 'mouse', 'dresser', 'hairbrush', 'door', 'soap', 'scrabble']
Task:Clean
response:
{
    "thoughts": Enter inside kid's room, begin picking up toys from the floor and putting them in a toy box, leave once once.,
    "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:['filing_cabinet', 'microwave', 'toilet', 'chair', 'freezer', 'bathroom', 'orchid', 'floor', 'bedroom', 'bookshelf', 'toaster', 'tvstand', 'faucet', 'shower', 'stereo', 'closetdrawer', 'couch', 'broom', 'wall', 'wall_clock', 'photoframe', 'bed', 'television', 'mouse', 'kitchen_counter', 'comb', 'dresser', 'sink', 'spoon', 'clothes_skirt']
Task:Go to toilet
response:

I walk into the bath room and go to the toilet

[WALK] <bathroom>
[WALK] <toilet>
[FIND] <toilet>
[SIT] <toilet>


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', 'mop', 'chair', 'blow_dryer', 'orchid', 'cpuscreen', 'floor', 'phone', 'folder', 'desk', 'bookshelf', 'remote_control', 'computer', 'toaster', 'stovefan', 'mousepad', 'couch', 'pillow', 'wall', 'wall_clock', 'photoframe', 'novel', 'television', 'coin', 'coffee_filter', 'doorjamb', 'shoes', 'cupboard', 'sink', 'light']
Task:Watch TV
response:
{
    "thoughts": I walk to the living room and sit on the couch.  I grab the TV remote.  I press the power button on the TV remote and the TV turns on.  I grab the surround sound remote.  I press the power button on the surround sound remote and the system turns on.,
    "actions": ['[WALK] <home_office>', '[WALK] <remote_control>', '[FIND] <remote_control>', '[GRAB] <remote_control>', '[PUSH] <remote_control>', '[FIND] <remote_control>', '[PUSH] <remote_control>']
}

Input:
Scene_Objects:['microwave', 'toilet', 'freezer', 'walllamp', 'bathroom', 'trashcan', 'orchid', 'floor', 'toaster', 'mat', 'faucet', 'shower', 'pillow', 'wall', 'nightstand', 'bench', 'toy', 'coffe_maker', 'television', 'curtain', 'after_shave', 'doorjamb', 'towel_rack', 'kitchen_counter', 'chessboard', 'sink', 'home_office', 'bathroom_cabinet', 'table', 'instrument_violin']
Task:Go to toilet
response:

Walk to the bathroom.  Find the toilet.  Lift the top of the toilet.  Sit on the toilet.

[WALK] <bathroom>
[WALK] <toilet>
[FIND] <toilet>
[OPEN] <toilet>
[SIT] <toilet>


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', 'bathroom', 'orchid', 'cpuscreen', 'floor', 'ceiling', 'desk', 'keyboard', 'computer', 'food_bacon', 'bookmark', 'mat', 'ceilinglamp', 'tvstand', 'deck_of_cards', 'mousepad', 'closetdrawer', 'pillow', 'wall', 'nightstand', 'cup', 'television', 'doorjamb', 'mouse', 'kitchen_counter', 'vacuum_cleaner', 'door', 'light', 'table']
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:['toilet', 'chair', 'walllamp', 'bathroom', 'drawing', 'wallshelf', 'hanger', 'floor', 'ceiling', 'character', 'bedroom', 'bookshelf', 'keyboard', 'computer', 'stovefan', 'mat', 'toaster', 'ceilinglamp', 'window', 'floor_lamp', 'couch', 'coffe_maker', 'curtain', 'doorjamb', 'kitchen_counter', 'comb', 'door', 'bathtub', 'bathroom_cabinet', 'coffee']
Task:Turn on light
response:

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


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', 'toilet', 'freezer', 'detergent', 'drawing', 'knife', 'wallshelf', 'dvd_player', 'character', 'bookshelf', 'plate', 'shower', 'tvstand', 'dish_soap', 'closetdrawer', 'pillow', 'food_kiwi', 'nightstand', 'powersocket', 'cutting_board', 'photoframe', 'wooden_spoon', 'dishrack', 'dresser', 'cupboard', 'door', 'sink', 'spoon', 'light', 'dishwasher']
Task:Wash dishes with dishwasher
response:
{
    "thoughts": put forks, spoons, plates, knife in dishwasher, add dish soap, turn diswaser on,
    "actions": ['[WALK] <dining_room>', '[WALK] <dishwasher>', '[FIND] <dishwasher>', '[OPEN] <dishwasher>', '[FIND] <dish_soap>', '[GRAB] <dish_soap>', '[PUTBACK] <dish_soap> <dishwasher>', '[FIND] <fork>', '[GRAB] <fork>', '[FIND] <dishrack>', '[PUTBACK] <fork> <dishrack>', '[FIND] <plate>', '[GRAB] <plate>', '[PUTBACK] <plate> <dishrack>', '[FIND] <spoon>', '[GRAB] <spoon>', '[PUTBACK] <spoon> <dishrack>', '[FIND] <knife>', '[GRAB] <knife>', '[PUTBACK] <knife> <dishrack>', '[CLOSE] <dishwasher>', '[SWITCHON] <dishwasher>']
}

Input:
Scene_Objects:['water_glass', 'filing_cabinet', 'microwave', 'toilet', 'freezer', 'trashcan', 'drawing', 'floor', 'ceiling', 'desk', 'toaster', 'stovefan', 'mat', 'faucet', 'shower', 'window', 'tvstand', 'wall', 'oven', 'box', 'food_food', 'coffe_maker', 'water', 'tray', 'doorjamb', 'kitchen_counter', 'cupboard', 'door', 'sink', 'bathtub']
Task:Drink
response:

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.

[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>


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', 'microwave', 'chair', 'walllamp', 'trashcan', 'drawing', 'cpuscreen', 'floor', 'ceiling', 'phone', 'desk', 'keyboard', 'computer', 'ceilinglamp', 'tvstand', 'mousepad', 'couch', 'dining_room', 'wall', 'powersocket', 'oven', 'television', 'tray', 'doorjamb', 'towel_rack', 'mouse', 'dresser', 'door', 'bathroom_cabinet', 'table']
Task:Turn on computer
response:
{
    "thoughts": Push power button.,
    "actions": ['[WALK] <home_office>', '[WALK] <computer>', '[SWITCHON] <computer>']
}

Input:
Scene_Objects:['filing_cabinet', 'tablelamp', 'juice', 'microwave', 'chair', 'trashcan', 'drawing', 'cpuscreen', 'wallshelf', 'floor', 'ceiling', 'computer', 'table_cloth', 'tvstand', 'shower', 'mousepad', 'dining_room', 'wall', 'nightstand', 'powersocket', 'photoframe', 'food_food', 'television', 'tray', 'doorjamb', 'cupboard', 'sink', 'bathroom_cabinet', 'light', 'board_game']
Task:Turn on light
response:

walk into living room, walk to light, turn on light switch.

[WALK] <home_office>
[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:['juice', 'nail_polish', 'wallshelf', 'clothes_underwear', 'bathroom_counter', 'floor', 'ceiling', 'computer', 'piano_bench', 'stovefan', 'mat', 'plate', 'faucet', 'picture', 'tvstand', 'dish_soap', 'food_noodles', 'pillow', 'food_kiwi', 'wall', 'wall_clock', 'oven', 'tape', 'shelf', 'coin', 'tray', 'curtain', 'sink', 'napkin', 'bathroom_cabinet']
Task:Wash dishes by hand
response:
{
    "thoughts": Make some dish water, grab a dish rag, put dishes in dish water and wash.,
    "actions": ['[RUN] <sink>', '[FIND] <dish_soap>', '[GRAB] <dish_soap>', '[FIND] <plate>', '[PUTBACK] <dish_soap> <plate>', '[RINSE] <dish_soap>', '[FIND] <plate>', '[WASH] <plate>']
}

Input:
Scene_Objects:['filing_cabinet', 'measuring_cup', 'ground_coffee', 'walllamp', 'trashcan', 'drawing', 'wallshelf', 'hanger', 'floor', 'ceiling', 'keyboard', 'stovefan', 'toaster', 'mat', 'faucet', 'shower', 'wall', 'nightstand', 'oven', 'coffe_maker', 'coffee_filter', 'water', 'tray', 'kitchen_counter', 'cd', 'cupboard', 'controller', 'hairdryer', 'sink', 'home_office']
Task:Make coffee
response:

Walk to Kitchen and find coffee maker, find coffee filter and place it in coffee maker. Find ground coffee and water. put both in coffee maker. Close the coffee maker and switch it on.

[WALK] <dining_room>
[WALK] <coffe_maker>
[FIND] <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>
[WALK] <water>
[FIND] <water>
[GRAB] <water>
[POUR] <water> <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', 'food_bread', 'walllamp', 'bathroom', 'cpuscreen', 'kitchen_cabinet', 'floor', 'tea_bag', 'toaster', 'mat', 'stereo', 'balanceball', 'dish_soap', 'towel', 'wall', 'oven', 'bed', 'light_bulb', 'novel', 'coffe_maker', 'check', 'coin', 'food_donut', 'tray', 'doorjamb', 'towel_rack', 'sink', 'dishwasher', 'vase', 'clothes_shirt']
Task:Wash dishes with dishwasher
response:
{
    "thoughts": 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.,
    "actions": ['[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>']
}

Input:
Scene_Objects:['pot', 'walllamp', 'cat', 'drawing', 'wallshelf', 'cpuscreen', 'floor', 'phone', 'desk', 'bookshelf', 'stovefan', 'mat', 'tvstand', 'ceilinglamp', 'toaster', 'window', 'oil', 'closetdrawer', 'couch', 'form', 'pillow', 'wall', 'wall_clock', 'coffe_maker', 'television', 'curtain', 'mouse', 'home_office', 'table', 'coffee']
Task:Pet cat
response:

I walk into the living room. I see my cat on the couch. I go sit next to the cat on the couch. I pet the cat on the back.

[WALK] <home_office>
[WALK] <cat>
[FIND] <cat>
[TURNTO] <cat>
[LOOKAT] <cat>
[FIND] <couch>
[SIT] <couch>
[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:['blender', 'chair', 'walllamp', 'bathroom', 'drawing', 'bathroom_counter', 'shampoo', 'floor', 'ceiling', 'toaster', 'mat', 'ceilinglamp', 'plate', 'stovefan', 'dish_soap', 'broom', 'wall', 'bench', 'food_food', 'coffe_maker', 'tray', 'wooden_spoon', 'towel_rack', 'kitchen_counter', 'cupboard', 'hair', 'sink', 'table', 'dishwasher', 'instrument_violin']
Task:Wash dishes with dishwasher
response:
{
    "thoughts": I go the in kitchen then grab the plate on the table. I put the plate and dish soap in the dishwasher. Finally, I turn on the dishwasher.,
    "actions": ['[WALK] <dining_room>', '[WALK] <table>', '[FIND] <plate>', '[GRAB] <plate>', '[WALK] <dishwasher>', '[OPEN] <dishwasher>', '[PUTBACK] <plate> <dishwasher>', '[FIND] <dish_soap>', '[GRAB] <dish_soap>', '[PUTBACK] <dish_soap> <dishwasher>', '[CLOSE] <dishwasher>', '[SWITCHON] <dishwasher>']
}

Input:
Scene_Objects:['sheets', 'filing_cabinet', 'scissors', 'tablelamp', 'microwave', 'chair', 'bathroom', 'trashcan', 'drawing', 'clothes_underwear', 'phone', 'bookshelf', 'envelope', 'computer', 'ceilinglamp', 'tvstand', 'faucet', 'closetdrawer', 'candle', 'clothes_pants', 'wall', 'photoframe', 'curtain', 'mouse', 'cupboard', 'clothes_dress', 'soap', 'tooth_paste', 'clothes_shirt', 'washing_machine']
Task:Wash clothes
response:

I need to get the dirty clothes basket.  Walk to bathroom.  Put all the clothes in washing machine.  Add soap.  Turn on 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:['pot', 'tablelamp', 'chair', 'walllamp', 'drawing', 'orchid', 'cpuscreen', 'wallshelf', 'hanger', 'floor', 'phone', 'ceiling', 'desk', 'keyboard', 'computer', 'mat', 'ceilinglamp', 'tvstand', 'mousepad', 'couch', 'pillow', 'wall', 'nightstand', 'oven', 'powersocket', 'television', 'tray', 'doorjamb', 'towel_rack', 'mouse', 'dresser', 'door', 'light']
Task:Work
response:
{
    "thoughts": Using desktop computer in home office,
    "actions": ['[WALK] <home_office>', '[WALK] <desk>', '[FIND] <desk>', '[WALK] <desk>', '[FIND] <computer>', '[SWITCHON] <computer>', '[FIND] <chair>', '[PULL] <chair>', '[SIT] <chair>', '[FIND] <mouse>', '[GRAB] <mouse>', '[FIND] <keyboard>', '[TYPE] <keyboard>', '[TURNTO] <computer>', '[LOOKAT] <computer>']
}

Input:
Scene_Objects:['food_ice_cream', 'toilet', 'freezer', 'trashcan', 'drawing', 'floor', 'phone', 'ceiling', 'character', 'bedroom', 'desk', 'keyboard', 'toaster', 'mat', 'faucet', 'window', 'wall', 'wall_clock', 'powersocket', 'box', 'cup', 'bed', 'video_game_controller', 'television', 'doorjamb', 'console', 'kitchen_counter', 'door', 'light', 'teeth']
Task:Pick up phone
response:

I walk over to the phone and pick it up.


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', 'microwave', 'chair', 'blow_dryer', 'cat', 'drawing', 'hanger', 'floor', 'ceiling', 'phone', 'keyboard', 'computer', 'ceilinglamp', 'balanceball', 'shower', 'window', 'couch', 'wall', 'powersocket', 'food_food', 'television', 'oven_mitts', 'doorjamb', 'dresser', 'cupboard', 'door', 'clothes_scarf', 'light', 'table', 'dishwasher']
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:['tablelamp', 'chair', 'freezer', 'walllamp', 'bathroom', 'cat', 'trashcan', 'drawing', 'wallshelf', 'floor', 'desk', 'mat', 'tvstand', 'ceilinglamp', 'window', 'couch', 'pillow', 'wall', 'wall_clock', 'bench', 'cup', 'food_food', 'television', 'curtain', 'towel_rack', 'mouse', 'sink', 'bathroom_cabinet', 'table', 'scrabble']
Task:Pet cat
response:

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.

[WALK] <home_office>
[WALK] <cat>
[FIND] <cat>
[WALK] <couch>
[SIT] <couch>
[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:['pot', 'walllamp', 'trashcan', 'drawing', 'knifeblock', 'cpuscreen', 'floor', 'ceiling', 'toaster', 'laptop', 'plate', 'stovefan', 'shower', 'dish_soap', 'wall', 'bench', 'oven', 'powersocket', 'photoframe', 'food_food', 'coffe_maker', 'tray', 'kettle', 'pencil', 'kitchen_counter', 'cupboard', 'home_office', 'table', 'dishwasher', 'coffee']
Task:Wash dishes with dishwasher
response:
{
    "thoughts": Put the dishes on dinner table in the dishwasher and wash them,
    "actions": ['[WALK] <dining_room>', '[WALK] <table>', '[FIND] <plate>', '[GRAB] <plate>', '[WALK] <dishwasher>', '[OPEN] <dishwasher>', '[PUTBACK] <plate> <dishwasher>', '[WALK] <table>', '[FIND] <pot>', '[GRAB] <pot>', '[WALK] <dishwasher>', '[PUTBACK] <pot> <dishwasher>', '[CLOSE] <dishwasher>', '[FIND] <dish_soap>', '[GRAB] <dish_soap>', '[OPEN] <dishwasher>', '[PUTBACK] <dish_soap> <dishwasher>', '[CLOSE] <dishwasher>', '[SWITCHON] <dishwasher>']
}

Input:
Scene_Objects:['filing_cabinet', 'tablelamp', 'toilet', 'chair', 'freezer', 'blow_dryer', 'bathroom', 'trashcan', 'drawing', 'wallshelf', 'cpuscreen', 'floor', 'ceiling', 'desk', 'tea_bag', 'bookshelf', 'ceilinglamp', 'dining_room', 'wall', 'oven', 'photoframe', 'bed', 'novel', 'check', 'tray', 'doorjamb', 'towel_rack', 'console', 'pencil', 'light']
Task:Read book
response:

Walk to the Living Room. Look at the Cabinet. Find a Textbook. Grab the textbook. Open the Textbook. Read the textbook.

[WALK] <home_office>
[WALK] <filing_cabinet>
[FIND] <filing_cabinet>
[TURNTO] <filing_cabinet>
[LOOKAT] <filing_cabinet>
[FIND] <novel>
[GRAB] <novel>
[READ] <novel>


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', 'chair', 'walllamp', 'drawing', 'orchid', 'cpuscreen', 'wallshelf', 'hanger', 'floor', 'ceiling', 'phone', 'desk', 'keyboard', 'computer', 'mat', 'ceilinglamp', 'tvstand', 'mousepad', 'couch', 'pillow', 'wall', 'nightstand', 'oven', 'television', 'doorjamb', 'mouse', 'dresser', 'door', 'sink']
Task:Use computer
response:
{
    "thoughts": Browse the internet,
    "actions": ['[WALK] <home_office>', '[WALK] <chair>', '[FIND] <chair>', '[SIT] <chair>', '[FIND] <computer>', '[SWITCHON] <computer>', '[TURNTO] <computer>', '[LOOKAT] <computer>', '[FIND] <keyboard>', '[TYPE] <keyboard>']
}

Input:
Scene_Objects:['filing_cabinet', 'tablelamp', 'freezer', 'bathroom', 'nail_polish', 'toothbrush', 'drawing', 'cpuscreen', 'food_egg', 'wallshelf', 'bathroom_counter', 'floor', 'ceiling', 'stovefan', 'ceilinglamp', 'faucet', 'picture', 'powersocket', 'oven', 'bed', 'photoframe', 'curtain', 'doorjamb', 'mouse', 'kitchen_counter', 'food_steak', 'sink', 'door', 'table', 'instrument_violin']
Task:Pick up phone
response:

walk to living room, walk to the phone reach for the phone and pick up the phone.

[WALK] <home_office>
[WALK] <phone>
[FIND] <phone>
[TOUCH] <phone>
[GRAB] <phone>


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', 'dry_pasta', 'food_ice_cream', 'toilet', 'freezer', 'knifeblock', 'wallshelf', 'folder', 'desk', 'stamp', 'bedroom', 'computer', 'toaster', 'mat', 'floor_lamp', 'dustpan', 'pillow', 'dining_room', 'broom', 'wall', 'nightstand', 'check', 'curtain', 'console', 'dresser', 'door', 'sink', 'bathroom_cabinet', 'light', 'dishwasher']
Task:Turn on light
response:
{
    "thoughts": I go home and it's dark so I can not see anything,
    "actions": ['[WALK] <home_office>', '[WALK] <floor_lamp>', '[FIND] <floor_lamp>', '[SWITCHON] <floor_lamp>']
}

Input:
Scene_Objects:['tablelamp', 'microwave', 'walllamp', 'nail_polish', 'trashcan', 'drawing', 'orchid', 'floor', 'desk', 'computer', 'food_bacon', 'stovefan', 'mat', 'tvstand', 'ceilinglamp', 'faucet', 'window', 'mousepad', 'couch', 'pillow', 'wall', 'bench', 'coffe_maker', 'television', 'curtain', 'mouse', 'bathtub', 'home_office', 'table', 'bathroom_cabinet']
Task:Relax on sofa
response:

Open coffee maker. Put filter in main basket, put ground coffee in filter, fill reservoir with water, turn on coffee maker.

[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:['food_bread', 'filing_cabinet', 'tablelamp', 'food_salt', 'toilet', 'chair', 'bathroom', 'trashcan', 'drawing', 'floor', 'character', 'desk', 'purse', 'computer', 'table_cloth', 'stovefan', 'ceilinglamp', 'tvstand', 'shower', 'foundation', 'couch', 'pillow', 'nightstand', 'powersocket', 'novel', 'tray', 'mouse', 'bathroom_cabinet', 'soap', 'teeth']
Task:Pet cat
response:
{
    "thoughts": First I need to find the cat in the living room. Then I walk over to the cat and pet it gently.,
    "actions": ['[WALK] <home_office>', '[WALK] <cat>', '[FIND] <cat>', '[WALK] <cat>', '[TOUCH] <cat>']
}

Input:
Scene_Objects:['chair', 'walllamp', 'detergent', 'drawing', 'orchid', 'food_egg', 'clothes_underwear', 'cpuscreen', 'bathroom_counter', 'floor', 'ceiling', 'folder', 'remote_control', 'computer', 'mat', 'ceilinglamp', 'tvstand', 'shower', 'window', 'couch', 'food_peanut_butter', 'pillow', 'wall', 'bench', 'box', 'television', 'curtain', 'towel_rack', 'table', 'light']
Task:Change TV channel
response:

[WALK] <home_office>
[WALK] <television>
[FIND] <television>
[SWITCHON] <television>
[FIND] <couch>
[SIT] <couch>
[FIND] <remote_control>
[GRAB] <remote_control>
[TURNTO] <television>
[POINTAT] <television>
[DROP] <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:['toilet', 'freezer', 'walllamp', 'food_butter', 'drawing', 'orchid', 'floor', 'ceiling', 'desk', 'remote_control', 'ceilinglamp', 'tvstand', 'mat', 'stereo', 'faucet', 'window', 'mousepad', 'pillow', 'wall', 'powersocket', 'bed', 'coffee_table', 'television', 'doorjamb', 'pencil', 'dresser', 'clothes_dress', 'door', 'table', 'dishwasher']
Task:Change TV channel
response:
{
    "thoughts": Walk to the living room and look at the coffee table. Grab the remote control and turn to the television and point the remote control. Put back the remote control.,
    "actions": ['[WALK] <home_office>', '[WALK] <coffee_table>', '[FIND] <coffee_table>', '[TURNTO] <coffee_table>', '[LOOKAT] <coffee_table>', '[FIND] <remote_control>', '[GRAB] <remote_control>', '[FIND] <television>', '[TURNTO] <television>', '[POINTAT] <television>', '[PUTOBJBACK] <remote_control>']
}

Input:
Scene_Objects:['scissors', 'walllamp', 'drawing', 'cpuscreen', 'hanger', 'floor', 'ceiling', 'desk', 'bedroom', 'computer', 'mat', 'ceilinglamp', 'tvstand', 'faucet', 'shower', 'couch', 'pillow', 'wall', 'television', 'wine', 'tray', 'curtain', 'doorjamb', 'towel_rack', 'pencil', 'cupboard', 'controller', 'sink', 'table', 'light']
Task:Change TV channel
response:

Walk to the living room. Find remote control. Grab remote control. Walk to television. Look at television. Switch on remote control.

[WALK] <home_office>
[WALK] <remote_control>
[FIND] <remote_control>
[GRAB] <remote_control>
[WALK] <television>
[TURNTO] <television>
[LOOKAT] <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:['sheets', 'tablelamp', 'scissors', 'chair', 'freezer', 'knifeblock', 'clothes_underwear', 'bookshelf', 'mop_bucket', 'stovefan', 'shower', 'window', 'couch', 'dining_room', 'nightstand', 'wall_clock', 'powersocket', 'photoframe', 'keys', 'bed', 'towel_rack', 'cd', 'dresser', 'cupboard', 'sink', 'napkin', 'bathroom_cabinet', 'home_office', 'dishwasher', 'board_game']
Task:Pet cat
response:
{
    "thoughts": Find the cat.  Pet the cat.,
    "actions": ['[WALK] <home_office>', '[WALK] <cat>', '[FIND] <cat>', '[TOUCH] <cat>']
}

Input:
Scene_Objects:['filing_cabinet', 'tablelamp', 'tea', 'microwave', 'toilet', 'freezer', 'bathroom', 'trashcan', 'drawing', 'cpuscreen', 'floor', 'ceiling', 'folder', 'bookshelf', 'computer', 'toaster', 'mat', 'shower', 'closetdrawer', 'pillow', 'wall', 'nightstand', 'bench', 'cup', 'food_food', 'doorjamb', 'kitchen_counter', 'cupboard', 'door', 'napkin']
Task:Put groceries in Fridge
response:

Find groceries. Grab groceries. Walk to refrigerator. Open refrigerator door. Place groceries into refrigerator. Close refrigerator door.

[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:['pot', 'microwave', 'chair', 'milk', 'bathroom_counter', 'floor', 'bookshelf', 'table_cloth', 'toaster', 'tvstand', 'shower', 'foundation', 'pillow', 'wall', 'nightstand', 'powersocket', 'cutting_board', 'cup', 'coffe_maker', 'food_onion', 'kitchen_counter', 'dishrack', 'cupboard', 'clothes_dress', 'sink', 'bag', 'table', 'dishwasher', 'dirt', 'shoe_rack']
Task:Wash dishes by hand
response:
{
    "thoughts": walk to kitchen , find dish washer , wash the dishe rack , put dishes in dish washer , switch on dish washer,
    "actions": ['[WALK] <dining_room>', '[WALK] <dishwasher>', '[FIND] <dishwasher>', '[FIND] <dishrack>', '[FIND] <dishrack>', '[GRAB] <dishrack>', '[FIND] <dishwasher>', '[OPEN] <dishwasher>', '[PUTBACK] <dishrack> <dishwasher>', '[SWITCHON] <dishwasher>']
}

Input:
Scene_Objects:['food_bread', 'filing_cabinet', 'microwave', 'walllamp', 'drawing', 'orchid', 'wallshelf', 'bathroom_counter', 'phone', 'desk', 'bookshelf', 'toaster', 'ceilinglamp', 'shower', 'faucet', 'couch', 'dining_room', 'nightstand', 'wall_clock', 'oven', 'wall', 'bed', 'water', 'tray', 'towel_rack', 'kitchen_counter', 'bathtub', 'bathroom_cabinet', 'table', 'hands_both']
Task:Wash hands
response:

walk to bathroom, look at the water, wash hands

[WALK] <bathroom>
[WALK] <water>
[FIND] <water>
[TURNTO] <water>
[LOOKAT] <water>
[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:['pot', 'microwave', 'chair', 'freezer', 'wallshelf', 'cpuscreen', 'floor', 'phone', 'desk', 'remote_control', 'computer', 'button', 'toaster', 'mat', 'shower', 'food_peanut_butter', 'food_kiwi', 'nightstand', 'oven', 'photoframe', 'television', 'oven_mitts', 'tray', 'kettle', 'cards', 'pencil', 'kitchen_counter', 'towel_rack', 'bathtub', 'table']
Task:Change TV channel
response:
{
    "thoughts": Walk into living room. Find television remote control. Pick up remote control. Press button.,
    "actions": ['[WALK] <home_office>', '[WALK] <remote_control>', '[FIND] <remote_control>', '[GRAB] <remote_control>', '[FIND] <button>', '[PUSH] <button>']
}

Input:
Scene_Objects:['microwave', 'chair', 'orchid', 'cpuscreen', 'hanger', 'floor', 'ceiling', 'character', 'desk', 'bedroom', 'keyboard', 'bookshelf', 'computer', 'ceilinglamp', 'mousepad', 'bowl', 'wall', 'newspaper', 'bed', 'novel', 'curtain', 'doorjamb', 'mouse', 'dresser', 'cupboard', 'door', 'sink', 'bathroom_cabinet', 'light', 'table']
Task:Browse internet
response:

go to the room, sit in the chair, turn on the computer, look for the news

[WALK] <bedroom>
[WALK] <chair>
[FIND] <chair>
[SIT] <chair>
[FIND] <computer>
[SWITCHON] <computer>
[FIND] <newspaper>


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', 'microwave', 'chair', 'freezer', 'bathroom', 'drawing', 'orchid', 'floor', 'ceiling', 'desk', 'ceilinglamp', 'tvstand', 'stereo', 'picture', 'mat', 'closetdrawer', 'couch', 'dining_room', 'wall_clock', 'bench', 'food_food', 'coffe_maker', 'tray', 'doorjamb', 'towel_rack', 'mouse', 'dresser', 'cupboard', 'home_office', 'instrument_guitar']
Task:Turn on light
response:
{
    "thoughts": I walk into the living room and then I walk to the light switch in there and turn the lights on,
    "actions": ['[WALK] <home_office>', '[WALK] <floor_lamp>', '[SWITCHON] <floor_lamp>']
}

Input:
Scene_Objects:['sheets', 'pot', 'tablelamp', 'microwave', 'toilet', 'trashcan', 'hanger', 'bathroom_counter', 'bedroom', 'keyboard', 'stovefan', 'tvstand', 'mousepad', 'closetdrawer', 'pillow', 'nightstand', 'wall', 'oven', 'wall_clock', 'coffe_maker', 'television', 'oven_mitts', 'curtain', 'lighter', 'kitchen_counter', 'bathtub', 'bathroom_cabinet', 'light', 'instrument_guitar', 'teeth']
Task:Set up table
response:

Walk into kitchen, find plate, drop plate on table in living room, walk into kitchen, find cup, bring cup to table in living room, walk into kitchen find fork, bring fork to table in living room

[WALK] <dining_room>
[WALK] <plate>
[FIND] <plate>
[GRAB] <plate>
[WALK] <home_office>
[DROP] <plate>
[WALK] <dining_room>
[WALK] <cup>
[FIND] <cup>
[GRAB] <cup>
[WALK] <home_office>
[DROP] <cup>
[WALK] <dining_room>
[WALK] <fork>
[FIND] <fork>
[GRAB] <fork>
[WALK] <home_office>
[DROP] <fork>


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', 'freezer', 'drawing', 'wallshelf', 'cpuscreen', 'hanger', 'floor', 'ceiling', 'dvd_player', 'character', 'keyboard', 'bookshelf', 'computer', 'stovefan', 'toaster', 'window', 'mousepad', 'closetdrawer', 'clothes_pants', 'pillow', 'wall', 'nightstand', 'wall_clock', 'television', 'tray', 'curtain', 'mouse', 'kitchen_counter', 'dresser', 'clothes_shirt']
Task:Organize closet
response:
{
    "thoughts": Organize the hanging clothes in my closet by color and type and get rid of clothes I don't wear.,
    "actions": ['[WALK] <bedroom>', '[WALK] <dresser>', '[OPEN] <dresser>', '[FIND] <clothes_pants>', '[GRAB] <clothes_pants>', '[PULL] <clothes_pants>', '[PUTIN] <clothes_pants> <dresser>', '[FIND] <clothes_pants>', '[GRAB] <clothes_pants>', '[PULL] <clothes_pants>', '[PUTIN] <clothes_pants> <dresser>', '[FIND] <clothes_shirt>', '[GRAB] <clothes_shirt>', '[PUSH] <clothes_shirt>', '[PUTIN] <clothes_shirt> <dresser>', '[FIND] <clothes_shirt>', '[GRAB] <clothes_shirt>', '[PUSH] <clothes_shirt>', '[PUTIN] <clothes_shirt> <dresser>', '[FIND] <clothes_shirt>', '[GRAB] <clothes_shirt>', '[CLOSE] <dresser>', '[WALK] <basket_for_clothes>', '[PUTBACK] <clothes_shirt> <basket_for_clothes>']
}

Input:
Scene_Objects:['sheets', 'tablelamp', 'microwave', 'chair', 'bathroom', 'orchid', 'drawing', 'bathroom_counter', 'floor', 'phone', 'character', 'computer', 'toaster', 'mat', 'tvstand', 'couch', 'clothes_hat', 'pillow', 'wall', 'wall_clock', 'bench', 'powersocket', 'cup', 'bed', 'food_food', 'television', 'mouse', 'pencil', 'bathroom_cabinet', 'table']
Task:Set up table
response:

walk to entrance hall. find a table. pull table. walk to living rook. push table.

[WALK] <home_office>
[WALK]

[FIND]

[PULL]

[WALK] <home_office>
[WALK]

[PUSH]


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', 'chair', 'walllamp', 'drawing', 'wallshelf', 'hanger', 'floor', 'ceiling', 'shampoo', 'desk', 'bookshelf', 'remote_control', 'computer', 'mat', 'tvstand', 'ceilinglamp', 'closetdrawer', 'couch', 'pillow', 'food_kiwi', 'wall', 'nightstand', 'oven', 'photoframe', 'television', 'doorjamb', 'headset', 'dresser', 'bathroom_cabinet', 'soap']
Task:Change TV channel
response:
{
    "thoughts": I find the remote then I push the button to switch it to the tv channel i want to watch,
    "actions": ['[WALK] <home_office>', '[WALK] <remote_control>', '[FIND] <remote_control>', '[GRAB] <remote_control>', '[FIND] <television>', '[TURNTO] <television>', '[POINTAT] <television>', '[PUSH] <remote_control>']
}

Input:
Scene_Objects:['fork', 'tablelamp', 'chair', 'walllamp', 'wallshelf', 'hanger', 'floor', 'phone', 'ceiling', 'character', 'bedroom', 'bookshelf', 'computer', 'stovefan', 'toaster', 'plate', 'dish_soap', 'mousepad', 'closetdrawer', 'oven', 'powersocket', 'bed', 'photoframe', 'check', 'water', 'cards', 'hairbrush', 'sink', 'bathroom_cabinet', 'light']
Task:Wash dishes by hand
response:

walk to kitchen, fins soap, arrange dishes, wash dishes

[WALK] <dining_room>
[WALK] <plate>
[FIND] <plate>
[FIND] <dish_soap>
[FIND] <water>
[GRAB] <plate>
[GRAB] <dish_soap>
[WASH] <plate>
[RINSE] <plate>
[DROP] <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:['tablelamp', 'chair', 'walllamp', 'orchid', 'clothes_underwear', 'floor', 'ceiling', 'character', 'bedroom', 'remote_control', 'computer', 'ceilinglamp', 'tvstand', 'window', 'closetdrawer', 'couch', 'pillow', 'wall', 'nightstand', 'powersocket', 'food_food', 'television', 'wooden_spoon', 'curtain', 'diary', 'dresser', 'cupboard', 'clothes_dress', 'table', 'light']
Task:Watch TV
response:
{
    "thoughts": You walk to the living room and sit on the sofa. You grab the remote control, look at it and point at the television, you watch television.,
    "actions": ['[WALK] <home_office>', '[WALK] <couch>', '[FIND] <couch>', '[SIT] <couch>', '[FIND] <remote_control>', '[GRAB] <remote_control>', '[TURNTO] <remote_control>', '[LOOKAT] <remote_control>', '[FIND] <television>', '[TURNTO] <television>', '[POINTAT] <television>', '[WATCH] <television>']
}

Input:
Scene_Objects:['dry_pasta', 'filing_cabinet', 'tablelamp', 'freezer', 'trashcan', 'dough', 'cpuscreen', 'ceiling', 'bedroom', 'keyboard', 'toaster', 'mat', 'plate', 'shower', 'faucet', 'dish_soap', 'mousepad', 'closetdrawer', 'dining_room', 'wall_clock', 'bench', 'food_food', 'tray', 'doorjamb', 'kitchen_counter', 'clothes_dress', 'sink', 'home_office', 'dishwasher', 'coffee']
Task:Wash dishes with dishwasher
response:

Walk to the  kitchen. Open the dishwasher. Put plates into the dishwasher. Put dish soap into the dishwasher. Close the dishwasher. Turn on the dishwasher.

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