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:['scissors', 'freezer', 'walllamp', 'knifeblock', 'wallshelf', 'clothes_underwear', 'ceiling', 'bookshelf', 'keyboard', 'ceilinglamp', 'plate', 'stereo', 'clothes_socks', 'clothes_pants', 'pillow', 'bowl', 'powersocket', 'cutting_board', 'basket_for_clothes', 'razor', 'coin', 'wine', 'curtain', 'pencil', 'kitchen_counter', 'cd', 'dresser', 'laundry_detergent', 'clothes_shirt', 'washing_machine']
Task:Wash clothes
response:
{
    "thoughts": I go to the bathroom and open the washing machine there. I take my laundry basket and put each item of laundry into the machine. Then I take the laundry detergent and pour some into the machine. Finally I close the machine and switch it on.,
    "actions": ['[WALK] <bathroom>', '[WALK] <washing_machine>', '[FIND] <washing_machine>', '[OPEN] <washing_machine>', '[FIND] <basket_for_clothes>', '[GRAB] <basket_for_clothes>', '[FIND] <clothes_pants>', '[GRAB] <clothes_pants>', '[PUTBACK] <clothes_pants> <washing_machine>', '[FIND] <clothes_shirt>', '[GRAB] <clothes_shirt>', '[PUTBACK] <clothes_shirt> <washing_machine>', '[FIND] <clothes_underwear>', '[GRAB] <clothes_underwear>', '[PUTBACK] <clothes_underwear> <washing_machine>', '[FIND] <clothes_socks>', '[GRAB] <clothes_socks>', '[PUTBACK] <clothes_socks> <washing_machine>', '[PUTOBJBACK] <basket_for_clothes>', '[FIND] <laundry_detergent>', '[GRAB] <laundry_detergent>', '[POUR] <laundry_detergent> <washing_machine>', '[CLOSE] <washing_machine>', '[SWITCHON] <washing_machine>']
}

Input:
Scene_Objects:['bathroom', 'drawing', 'orchid', 'knifeblock', 'floor', 'ceiling', 'bedroom', 'bookshelf', 'computer', 'tvstand', 'window', 'mousepad', 'couch', 'pillow', 'wall', 'powersocket', 'bench', 'cup', 'television', 'doorjamb', 'mouse', 'shoes', 'door', 'sink', 'napkin', 'clothes_scarf', 'table', 'light', 'dishwasher', 'colander']
Task:Relax on sofa
response:

walk to living room ,find sofa ,sit on sofa

[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:['pot', 'toilet', 'chair', 'freezer', 'walllamp', 'dough', 'woman', 'knifeblock', 'bathroom_counter', 'floor', 'character', 'desk', 'tea_bag', 'bookshelf', 'computer', 'stovefan', 'ceilinglamp', 'wall', 'child', 'coffe_maker', 'video_game_controller', 'television', 'towel_rack', 'kettle', 'kitchen_counter', 'dresser', 'door', 'bathtub', 'instrument_violin', 'clothes_shirt']
Task:Greet guests
response:
{
    "thoughts": Go to the kitchen, greet your family members,
    "actions": ['[WALK] <dining_room>', '[WALK] <child>', '[FIND] <child>', '[GREET] <child>', '[FIND] <woman>', '[GREET] <woman>', '[FIND] <chair>', '[SIT] <chair>']
}

Input:
Scene_Objects:['beer', 'bathroom', 'orchid', 'knifeblock', 'food_egg', 'clothes_underwear', 'shampoo', 'bedroom', 'tvstand', 'shoe-shine_kit', 'pillow', 'dining_room', 'bench', 'powersocket', 'coffe_maker', 'video_game_controller', 'television', 'food_rice', 'tray', 'after_shave', 'food_onion', 'doorjamb', 'diary', 'towel_rack', 'mouse', 'comb', 'cupboard', 'bathroom_cabinet', 'light', 'tooth_paste']
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:['fork', 'pot', 'tea', 'walllamp', 'cat', 'trashcan', 'food_butter', 'drawing', 'orchid', 'wallshelf', 'floor', 'ceiling', 'bedroom', 'computer', 'shower', 'closetdrawer', 'couch', 'dining_room', 'oven', 'bench', 'bed', 'food_food', 'television', 'food_onion', 'doorjamb', 'cupboard', 'sink', 'bathtub', 'soap', 'laser_pointer']
Task:Walk to room
response:
{
    "thoughts": Leave the living room and enter the hall,
    "actions": ['[WALK] <home_office>', '[WALK] <home_office>']
}

Input:
Scene_Objects:['toilet', 'chair', 'freezer', 'blow_dryer', 'bathroom', 'trashcan', 'drawing', 'floor', 'bedroom', 'keyboard', 'stovefan', 'tvstand', 'homework', 'window', 'microphone', 'food_orange', 'pillow', 'dining_room', 'powersocket', 'bench', 'newspaper', 'bed', 'coffe_maker', 'food_food', 'tray', 'pencil', 'kitchen_counter', 'spoon', 'home_office', 'bathroom_cabinet']
Task:Pick up phone
response:

Enter the Home office, then walk to the phone, pickup the phone.

[WALK] <home_office>
[WALK] <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', 'scissors', 'walllamp', 'needle', 'wallshelf', 'cpuscreen', 'hanger', 'bedroom', 'keyboard', 'bookmark', 'stovefan', 'shower', 'oil', 'dining_room', 'wall', 'powersocket', 'bench', 'love_seat', 'standingmirror', 'novel', 'coffe_maker', 'check', 'after_shave', 'towel_rack', 'mouse', 'pencil', 'kitchen_counter', 'maindoor', 'bathtub', 'soap']
Task:Read book
response:
{
    "thoughts": Obtain a book from the book shelf. Sit in the easy chair.  Read the book.  Mark the stopping point with a bookmark.  Put the book back on the book shelf.,
    "actions": ['[WALK] <home_office>', '[WALK] <novel>', '[FIND] <novel>', '[GRAB] <novel>', '[FIND] <love_seat>', '[SIT] <love_seat>', '[READ] <novel>', '[FIND] <bookmark>', '[GRAB] <bookmark>', '[PUTBACK] <bookmark> <novel>', '[PUTOBJBACK] <novel>']
}

Input:
Scene_Objects:['pot', 'chair', 'freezer', 'walllamp', 'bathroom', 'clothes_underwear', 'floor', 'ceiling', 'thread', 'computer', 'bookmark', 'toaster', 'stovefan', 'couch', 'wall', 'powersocket', 'cup', 'food_food', 'razor', 'water', 'tray', 'centerpiece', 'pencil', 'kitchen_counter', 'chessboard', 'cupboard', 'clothes_scarf', 'light', 'table', 'dishwasher']
Task:Drink
response:

Feeling tired after hard work I opened the fridge and grabbed cool water and drank from the glass.

[WALK] <dining_room>
[WALK] <freezer>
[FIND] <freezer>
[OPEN] <freezer>
[FIND] <cup>
[GRAB] <cup>
[CLOSE] <freezer>
[FIND] <water>
[GRAB] <water>
[FIND] <cup>
[POUR] <water> <cup>
[FIND] <cup>
[DRINK] <cup>


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

Here is an example plan to achieve a goal for reference:
Scene_Objects:['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:['walllamp', 'orchid', 'drawing', 'wallshelf', 'clothes_underwear', 'floor', 'ceiling', 'folder', 'bookshelf', 'remote_control', 'mat', 'tvstand', 'ceilinglamp', 'shower', 'window', 'couch', 'pillow', 'dining_room', 'wall', 'powersocket', 'photoframe', 'food_food', 'television', 'toothbrush_holder', 'curtain', 'doorjamb', 'towel_rack', 'door', 'light', 'table']
Task:Watch TV
response:

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

[WALK] <home_office>
[WALK] <television>
[FIND] <television>
[WALK] <television>
[SWITCHON] <television>
[FIND] <couch>
[WALK] <couch>
[SIT] <couch>
[FIND] <remote_control>
[GRAB] <remote_control>
[TURNTO] <television>
[LOOKAT] <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:['trashcan', 'drawing', 'orchid', 'wallshelf', 'floor', 'ceiling', 'shampoo', 'tea_bag', 'keyboard', 'food_bacon', 'stovefan', 'tvstand', 'faucet', 'couch', 'microphone', 'pillow', 'wall', 'nightstand', 'powersocket', 'photoframe', 'television', 'oven_mitts', 'doorjamb', 'mouse', 'door', 'bathtub', 'sink', 'table', 'light', 'dishwasher']
Task:Relax on sofa
response:
{
    "thoughts": Go to the living room. Find the sofa. Sit on the sofa. Close your eyes. Breath calmly. Relax,
    "actions": ['[WALK] <home_office>', '[WALK] <couch>', '[FIND] <couch>', '[SIT] <couch>']
}

Input:
Scene_Objects:['pot', 'food_bread', 'tablelamp', 'juice', 'cd_player', 'band-aids', 'walllamp', 'cpuscreen', 'bathroom_counter', 'ceiling', 'desk', 'stovefan', 'stereo', 'homework', 'food_orange', 'nightstand', 'bench', 'bed', 'newspaper', 'photoframe', 'coffe_maker', 'check', 'food_onion', 'curtain', 'doorjamb', 'dresser', 'door', 'sink', 'bathtub', 'light']
Task:Listen to music
response:

I walk in the living room, then I go the the stereo and the cd player and turn them on.

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


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

Here is an example plan to achieve a goal for reference:
Scene_Objects:['glue', 'shoe_rack', 'food_salt', 'beer', 'measuring_cup', 'microwave', 'trashcan', 'food_carrot', 'orchid', 'drawing', 'bookshelf', 'envelope', 'alcohol', 'ceilinglamp', 'plate', 'food_jam', 'pillow', 'oven', 'newspaper', 'photoframe', 'coffe_maker', 'food_food', 'tray', 'lighter', 'doorjamb', 'coffee_pot', 'towel_rack', 'cupboard', 'hairdryer', 'creditcard']
Task:Pet cat
response:
{
    "thoughts": find a cat, touch it gently,
    "actions": ['[WALK] <home_office>', '[WALK] <cat>', '[FIND] <cat>', '[TOUCH] <cat>']
}

Input:
Scene_Objects:['pot', 'microwave', 'toilet', 'freezer', 'walllamp', 'trashcan', 'knifeblock', 'kitchen_cabinet', 'floor', 'ceiling', 'bathroom_counter', 'bookshelf', 'deck_of_cards', 'faucet', 'mousepad', 'pillow', 'wall', 'oven', 'box', 'cup', 'toilet_paper', 'rag', 'kitchen_counter', 'cupboard', 'sink', 'bag', 'bathroom_cabinet', 'bathtub', 'table', 'home_office']
Task:Drink
response:

I walk the kitchen and walk up to the kitchen cabinet. I open the cabinet and take out a cup. I walk to sink and I turn the faucet on using the cold water handle. I put my cup under the running water until it is full. I turn off the cold water handle and bring the cup to my mouth and take a drink.

[WALK] <dining_room>
[WALK] <kitchen_cabinet>
[FIND] <kitchen_cabinet>
[OPEN] <kitchen_cabinet>
[FIND] <cup>
[GRAB] <cup>
[FIND] <faucet>
[SWITCHON] <faucet>
[WALK] <sink>
[FIND] <faucet>
[PUSH] <faucet>
[PUTBACK] <cup> <sink>
[GRAB] <cup>
[SWITCHOFF] <faucet>
[DRINK] <cup>


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

Here is an example plan to achieve a goal for reference:
Scene_Objects:['food_salt', 'toilet', 'drawing', 'cpuscreen', 'bathroom_counter', 'floor', 'desk', 'bedroom', 'keyboard', 'tvstand', 'stereo', 'balanceball', 'picture', 'mousepad', 'couch', 'clothes_hat', 'pillow', 'dining_room', 'wall', 'nightstand', 'bench', 'photoframe', 'bed', 'toilet_paper', 'coffe_maker', 'cards', 'mouse', 'kitchen_counter', 'cd', 'vase']
Task:Go to toilet
response:
{
    "thoughts": Walk to the bathroom.  Find the toilet.  Lift the top of the toilet.  Sit on the toilet.,
    "actions": ['[WALK] <bathroom>', '[WALK] <toilet>', '[FIND] <toilet>', '[OPEN] <toilet>', '[SIT] <toilet>']
}

Input:
Scene_Objects:['filing_cabinet', 'toilet', 'walllamp', 'trashcan', 'drawing', 'cpuscreen', 'bathroom_counter', 'floor', 'phone', 'character', 'bedroom', 'desk', 'bookshelf', 'computer', 'mat', 'tvstand', 'window', 'pillow', 'wall', 'powersocket', 'tray', 'towel_rack', 'mouse', 'kitchen_counter', 'cupboard', 'laundry_detergent', 'bathtub', 'light', 'teeth', 'shoe_rack']
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:['sheets', 'fork', 'filing_cabinet', 'toilet', 'detergent', 'food_butter', 'orchid', 'needle', 'bills', 'stereo', 'window', 'dining_room', 'bench', 'oven', 'bed', 'novel', 'check', 'coffee_filter', 'tray', 'wooden_spoon', 'centerpiece', 'headset', 'conditioner', 'food_steak', 'napkin', 'home_office', 'soap', 'scrabble', 'dirt', 'coffee']
Task:File documents
response:
{
    "thoughts": I file all of my paperwork (including bills, receipts, documents, device instructions, etc.) in my black paperwork case that has many different files in order to organize.  I place each piece of paper in its' corresponding subject (as indicated by printed words on each tab).,
    "actions": ['[WALK] <home_office>', '[WALK] <bills>', '[FIND] <bills>', '[GRAB] <bills>', '[WALK] <filing_cabinet>', '[OPEN] <filing_cabinet>', '[PUTIN] <bills> <filing_cabinet>', '[FIND] <check>', '[GRAB] <check>', '[WALK] <filing_cabinet>', '[PUTIN] <check> <filing_cabinet>', '[FIND] <check>', '[GRAB] <check>', '[WALK] <filing_cabinet>', '[PUTIN] <check> <filing_cabinet>']
}

Input:
Scene_Objects:['water_glass', 'tablelamp', 'juice', 'food_ice_cream', 'measuring_cup', 'chair', 'freezer', 'nail_polish', 'detergent', 'food_carrot', 'toothbrush', 'drawing', 'floor', 'ceiling', 'phone', 'character', 'bedroom', 'bookmark', 'toaster', 'couch', 'wall', 'keys', 'toilet_paper', 'television', 'kitchen_counter', 'headset', 'cupboard', 'door', 'home_office', '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:['fork', 'microwave', 'freezer', 'knife', 'food_egg', 'wallshelf', 'kitchen_cabinet', 'ceiling', 'character', 'desk', 'tea_bag', 'toaster', 'stovefan', 'plate', 'faucet', 'shower', 'mat', 'wall', 'oven', 'bench', 'coffe_maker', 'drinking_glass', 'tray', 'kitchen_counter', 'cupboard', 'door', 'sink', 'spoon', 'napkin', 'dishwasher']
Task:Unload dishwasher
response:
{
    "thoughts": Open the dishwasher door. Take out all of the dishes and silverware. Put the dishes and silverware in their drawers and cabinets. Close the dishwasher door.,
    "actions": ['[WALK] <dining_room>', '[WALK] <dishwasher>', '[FIND] <dishwasher>', '[OPEN] <dishwasher>', '[FIND] <drinking_glass>', '[GRAB] <drinking_glass>', '[FIND] <cupboard>', '[OPEN] <cupboard>', '[PUTBACK] <drinking_glass> <cupboard>', '[FIND] <fork>', '[GRAB] <fork>', '[FIND] <kitchen_cabinet>', '[OPEN] <kitchen_cabinet>', '[PUTIN] <fork> <kitchen_cabinet>', '[FIND] <knife>', '[GRAB] <knife>', '[PUTIN] <knife> <kitchen_cabinet>', '[FIND] <spoon>', '[GRAB] <spoon>', '[PUTIN] <spoon> <kitchen_cabinet>', '[FIND] <plate>', '[GRAB] <plate>', '[PUTIN] <plate> <kitchen_cabinet>', '[CLOSE] <kitchen_cabinet>', '[CLOSE] <dishwasher>']
}

Input:
Scene_Objects:['tablelamp', 'toilet', 'walllamp', 'drawing', 'orchid', 'wallshelf', 'floor', 'ceiling', 'bookshelf', 'remote_control', 'mat', 'tvstand', 'ceilinglamp', 'shower', 'window', 'clothes_socks', 'couch', 'pillow', 'dining_room', 'wall', 'powersocket', 'photoframe', 'television', 'curtain', 'doorjamb', 'mouse', 'conditioner', 'door', 'table', 'light']
Task:Relax on sofa
response:

For relaxing walk to living room. Find the sofa to relax. Arrange the sofa to relax. Sit on the sofa to relaxing.

[WALK] <home_office>
[WALK] <couch>
[FIND] <couch>
[FIND] <conditioner>
[FIND] <remote_control>
[FIND] <television>
[SWITCHON] <television>
[LIE] <couch>


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

Here is an example plan to achieve a goal for reference:
Scene_Objects:['sponge', 'toilet', 'jelly', 'freezer', 'walllamp', 'bathroom', 'hanger', 'folder', 'bedroom', 'desk', 'tvstand', 'window', 'food_jam', 'microphone', 'dining_room', 'wall_clock', 'powersocket', 'bench', 'shelf', 'bed', 'video_game_controller', 'food_donut', 'water', 'doorjamb', 'cards', 'towel_rack', 'mouse', 'sink', 'colander', 'hands_both']
Task:Wash hands
response:
{
    "thoughts": walk to bathroom, look at the water, wash hands,
    "actions": ['[WALK] <bathroom>', '[WALK] <water>', '[FIND] <water>', '[TURNTO] <water>', '[LOOKAT] <water>', '[FIND] <hands_both>', '[WASH] <hands_both>']
}

Input:
Scene_Objects:['measuring_cup', 'chair', 'walllamp', 'trashcan', 'orchid', 'drawing', 'knifeblock', 'hanger', 'bathroom_counter', 'ceiling', 'bedroom', 'bookshelf', 'clothes_jacket', 'faucet', 'couch', 'clothes_pants', 'form', 'wall', 'cutting_board', 'photoframe', 'check', 'food_food', 'curtain', 'doorjamb', 'towel_rack', 'clothes_dress', 'door', 'sink', 'bathroom_cabinet', 'washing_machine']
Task:Wash clothes
response:

Walk to bathroom, open cabinet and collect clothes and put them into washing machine and wash clothes


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', 'toilet', 'chair', 'walllamp', 'orchid', 'cpuscreen', 'floor', 'ceiling', 'phone', 'desk', 'keyboard', 'computer', 'stovefan', 'mat', 'ceilinglamp', 'tvstand', 'mousepad', 'closetdrawer', 'pillow', 'bowl', 'wall', 'television', 'doorjamb', 'mouse', 'door', 'bathroom_cabinet', 'light', 'table', 'board_game']
Task:Write an email
response:
{
    "thoughts": Turn on PC and log onto email account. Type email and send it. Switch off computer.,
    "actions": ['[WALK] <home_office>', '[WALK] <computer>', '[SWITCHON] <computer>', '[FIND] <keyboard>', '[TYPE] <keyboard>', '[TURNTO] <computer>', '[LOOKAT] <computer>', '[SWITCHOFF] <computer>']
}

Input:
Scene_Objects:['tablelamp', 'toilet', 'chair', 'walllamp', 'bathroom', 'drawing', 'wallshelf', 'floor', 'phone', 'ceiling', 'desk', 'bookshelf', 'computer', 'mat', 'ceilinglamp', 'shower', 'window', 'clothes_hat', 'dining_room', 'wall', 'bench', 'powersocket', 'photoframe', 'doorjamb', 'kitchen_counter', 'dresser', 'cupboard', 'table', 'light', 'tooth_paste']
Task:Pick up phone
response:

[WALK] <table>
[FIND] <phone>
[TURNTO] <phone>
[LOOKAT] <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:['pot', 'filing_cabinet', 'measuring_cup', 'mop', 'microwave', 'toilet', 'bathroom', 'drawing', 'orchid', 'floor', 'ceiling', 'bedroom', 'computer', 'piano_bench', 'ceilinglamp', 'plate', 'deck_of_cards', 'mat', 'mousepad', 'couch', 'pillow', 'wall', 'bed', 'novel', 'television', 'doorjamb', 'door', 'coffee_cup', 'table', 'light']
Task:Relax on sofa
response:
{
    "thoughts": you walk to the living room, open the door, find a comfy sofa, sit on it, read a book or sip a cup of coffee and relax.,
    "actions": ['[WALK] <home_office>', '[WALK] <couch>', '[FIND] <couch>', '[FIND] <coffee_cup>', '[GRAB] <coffee_cup>', '[SIT] <couch>', '[FIND] <novel>', '[GRAB] <novel>', '[READ] <novel>', '[DRINK] <coffee_cup>']
}

Input:
Scene_Objects:['food_salt', 'trashcan', 'toothbrush', 'drawing', 'knifeblock', 'wallshelf', 'bathroom_counter', 'ceiling', 'phone', 'bedroom', 'stovefan', 'tvstand', 'food_peanut_butter', 'nightstand', 'wall', 'oven', 'powersocket', 'coffe_maker', 'toothbrush_holder', 'after_shave', 'curtain', 'coffee_pot', 'kitchen_counter', 'vacuum_cleaner', 'cupboard', 'bathtub', 'sink', 'home_office', 'dishwasher', 'tooth_paste']
Task:Brush teeth
response:

today morning i went to bathroom and took my toothbrush and paste from tooth brush holder and brushed and cleaned my teeth well


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', 'juice', 'toilet', 'chair', 'trashcan', 'ceilingfan', 'drawing', 'cpuscreen', 'hanger', 'floor', 'ceiling', 'phone', 'desk', 'keyboard', 'bookshelf', 'computer', 'toaster', 'ceilinglamp', 'stovefan', 'balanceball', 'mat', 'mousepad', 'oil', 'wall', 'nightstand', 'photoframe', 'doorjamb', 'mouse', 'light', 'dishwasher']
Task:Work
response:
{
    "thoughts": Go to office, sit at desk, turn on computer, enter password, open application and begin work,
    "actions": ['[WALK] <home_office>', '[WALK] <computer>', '[FIND] <computer>', '[SWITCHON] <computer>', '[FIND] <keyboard>', '[TYPE] <keyboard>', '[FIND] <mouse>', '[PUSH] <mouse>', '[TURNTO] <computer>', '[LOOKAT] <computer>']
}

Input:
Scene_Objects:['pot', 'tablelamp', 'blender', 'microwave', 'toilet', 'detergent', 'drawing', 'wallshelf', 'bathroom_counter', 'floor', 'character', 'keyboard', 'computer', 'brush', 'mat', 'laptop', 'faucet', 'ceilinglamp', 'window', 'dustpan', 'pillow', 'wall', 'nightstand', 'powersocket', 'bed', 'towel_rack', 'mouse', 'kitchen_counter', 'pajamas', 'dishwasher']
Task:Go to sleep
response:

go to bedroom, put pajamas on, lie in bed, sleep

[WALK] <bedroom>
[WALK] <pajamas>
[FIND] <pajamas>
[GRAB] <pajamas>
[PUTON] <pajamas>
[FIND] <bed>
[LIE] <bed>


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_salt', 'walllamp', 'detergent', 'orchid', 'drawing', 'cpuscreen', 'keyboard', 'envelope', 'computer', 'stovefan', 'faucet', 'electric_shaver', 'couch', 'candle', 'microphone', 'broom', 'nightstand', 'oven', 'bench', 'tape', 'cup', 'light_bulb', 'food_rice', 'wine', 'wooden_spoon', 'hair', 'maindoor', 'table', 'dishwasher', 'vase']
Task:Dust
response:
{
    "thoughts": Get a broom or duster with long handle. Dust blades of ceiling fan.,
    "actions": ['[WALK] <bedroom>', '[WALK] <duster>', '[FIND] <duster>', '[GRAB] <duster>', '[PUTOBJBACK] <duster>']
}

Input:
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:

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.

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


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', 'freezer', 'blow_dryer', 'walllamp', 'nail_polish', 'bathroom', 'toothbrush', 'drawing', 'hanger', 'floor', 'shampoo', 'character', 'desk', 'bookshelf', 'purse', 'envelope', 'mat', 'ceilinglamp', 'window', 'towel', 'wall', 'powersocket', 'toy', 'cup', 'food_food', 'coffe_maker', 'sink', 'duster']
Task:Dust
response:
{
    "thoughts": Apply duster to shelves and clean them until dust is gone,
    "actions": ['[WALK] <home_office>', '[WALK] <duster>', '[FIND] <duster>', '[GRAB] <duster>', '[FIND] <filing_cabinet>', '[WIPE] <filing_cabinet>', '[PUTOBJBACK] <duster>']
}

Input:
Scene_Objects:['filing_cabinet', 'microwave', 'chair', 'knife', 'knifeblock', 'orchid', 'drawing', 'floor', 'phone', 'character', 'bedroom', 'remote_control', 'computer', 'button', 'mat', 'tvstand', 'faucet', 'shower', 'oil', 'dining_room', 'powersocket', 'newspaper', 'ice', 'tray', 'doorjamb', 'towel_rack', 'dresser', 'door', 'home_office', 'table']
Task:Change TV channel
response:

I pick up the remote. I press button on remote.

[WALK] <bedroom>
[WALK] <remote_control>
[FIND] <remote_control>
[GRAB] <remote_control>
[FIND] <button>
[PUSH] <button>


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

Here is an example plan to achieve a goal for reference:
Scene_Objects:['bathroom', 'drawing', 'cpuscreen', 'bathroom_counter', 'floor', 'ceiling', 'phone', 'character', 'bookshelf', 'piano_bench', 'stovefan', 'ceilinglamp', 'faucet', 'electric_shaver', 'window', 'teeth', 'food_orange', 'pillow', 'wall', 'powersocket', 'food_food', 'tray', 'curtain', 'dresser', 'hair', 'controller', 'sink', 'bathroom_cabinet', 'soap', 'hands_both']
Task:Wash hands
response:
{
    "thoughts": I walk in to the bathroom. I find the soap. I find the faucet. I turn on the faucet. I wash my hands. I put the soap back. I rinse my hands. I turn the faucet off.,
    "actions": ['[WALK] <bathroom>', '[WALK] <faucet>', '[FIND] <faucet>', '[SWITCHON] <faucet>', '[FIND] <soap>', '[GRAB] <soap>', '[FIND] <hands_both>', '[WASH] <hands_both>', '[PUTOBJBACK] <soap>', '[RINSE] <hands_both>', '[SWITCHOFF] <faucet>']
}

Input:
Scene_Objects:['microwave', 'walllamp', 'orchid', 'ceiling', 'desk', 'computer', 'food_bacon', 'stovefan', 'ceilinglamp', 'plate', 'shower', 'faucet', 'window', 'form', 'dining_room', 'oven', 'basket_for_clothes', 'keys', 'novel', 'food_food', 'coffe_maker', 'food_rice', 'tray', 'doorjamb', 'cards', 'mouse', 'pajamas', 'home_office', 'light', 'bathroom_cabinet']
Task:Listen to music
response:

Find the playback device you want to listen to. turn on. press play. enjoyu music.

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


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

Here is an example plan to achieve a goal for reference:
Scene_Objects:['food_salt', 'microwave', 'detergent', 'cpuscreen', 'hanger', 'bathroom_counter', 'floor', 'ceiling', 'desk', 'shoe-shine_kit', 'faucet', 'clothes_socks', 'closetdrawer', 'mousepad', 'dining_room', 'broom', 'wall', 'nightstand', 'photoframe', 'television', 'water', 'tray', 'cards', 'paper_towel', 'door', 'sink', 'bathroom_cabinet', 'home_office', 'soap', 'hands_both']
Task:Wash hands
response:
{
    "thoughts": I walk into the bathroom. I turn on the water. I put soap on my hands. I rinse my hands. I turn off the water. I dry my hands.,
    "actions": ['[WALK] <bathroom>', '[WALK] <sink>', '[FIND] <water>', '[TURNTO] <water>', '[FIND] <soap>', '[GRAB] <soap>', '[FIND] <hands_both>', '[SCRUB] <hands_both>', '[RINSE] <hands_both>', '[TURNTO] <water>', '[FIND] <paper_towel>', '[GRAB] <paper_towel>']
}

Input:
Scene_Objects:['walllamp', 'orchid', 'knifeblock', 'wallshelf', 'floor', 'ceiling', 'phone', 'bookshelf', 'remote_control', 'button', 'mat', 'tvstand', 'ceilinglamp', 'shower', 'window', 'wall', 'nightstand', 'powersocket', 'bench', 'photoframe', 'television', 'curtain', 'doorjamb', 'mouse', 'pencil', 'dresser', 'cupboard', 'hair', 'light', 'table']
Task:Change TV channel
response:

Go to the living room, Switch on the television. Find the remote and press the change channel button, change the channel

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


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

Here is an example plan to achieve a goal for reference:
Scene_Objects:['dry_pasta', 'food_pizza', 'filing_cabinet', 'scissors', 'chair', 'ceilingfan', 'dough', 'drawing', 'orchid', 'floor', 'ceiling', 'phone', 'bookshelf', 'remote_control', 'stovefan', 'ceilinglamp', 'tvstand', 'balanceball', 'window', 'couch', 'food_orange', 'wall', 'powersocket', 'coffee_table', 'television', 'coin', 'wooden_spoon', 'curtain', 'maindoor', 'table']
Task:Watch TV
response:
{
    "thoughts": I walk into the living room and sit on the couch. I pick up the remote to turn on the television. I put down the remote on the coffee table and look at the television.,
    "actions": ['[WALK] <home_office>', '[WALK] <couch>', '[FIND] <couch>', '[SIT] <couch>', '[FIND] <remote_control>', '[GRAB] <remote_control>', '[FIND] <television>', '[SWITCHON] <television>', '[FIND] <coffee_table>', '[PUTBACK] <remote_control> <coffee_table>', '[TURNTO] <television>', '[LOOKAT] <television>']
}

Input:
Scene_Objects:['chair', 'walllamp', 'orchid', 'drawing', 'wallshelf', 'floor', 'ceiling', 'folder', 'bookshelf', 'remote_control', 'stovefan', 'mat', 'tvstand', 'ceilinglamp', 'shower', 'window', 'couch', 'pillow', 'wall', 'powersocket', 'photoframe', 'television', 'tray', 'curtain', 'doorjamb', 'door', 'bathroom_cabinet', 'light', 'table', 'tooth_paste']
Task:Watch TV
response:

I get home from work and decide to watch tv. I go to the living room and turn on the tv. I sit on the couch and use the remote to switch the channels to find what I want to watch.

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


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

Here is an example plan to achieve a goal for reference:
Scene_Objects:['dry_pasta', 'drawing', 'orchid', 'bathroom_counter', 'floor', 'ceiling', 'phone', 'table_cloth', 'stovefan', 'mat', 'faucet', 'foundation', 'mousepad', 'towel', 'wall', 'wall_clock', 'oven', 'nightstand', 'toy', 'hands_both', 'tray', 'doorjamb', 'towel_rack', 'shaving_cream', 'door', 'sink', 'spoon', 'bathroom_cabinet', 'light', 'teeth']
Task:Wash teeth
response:
{
    "thoughts": I need to rinse my dentures off and put them back in my mouth.,
    "actions": ['[WALK] <bathroom>', '[WALK] <light>', '[FIND] <light>', '[SWITCHON] <light>', '[WALK] <sink>', '[FIND] <faucet>', '[SWITCHON] <faucet>', '[FIND] <teeth>', '[GRAB] <teeth>', '[WASH] <teeth>', '[PUTOBJBACK] <teeth>', '[SWITCHOFF] <faucet>', '[FIND] <towel>', '[GRAB] <towel>', '[FIND] <hands_both>', '[SCRUB] <hands_both>', '[PUTOBJBACK] <towel>', '[SWITCHOFF] <light>']
}

Input:
Scene_Objects:['sheets', 'tablelamp', 'microwave', 'toilet', 'chair', 'walllamp', 'trashcan', 'bathroom_counter', 'floor', 'ceiling', 'keyboard', 'table_cloth', 'tvstand', 'faucet', 'stereo', 'window', 'couch', 'form', 'wall', 'powersocket', 'light_bulb', 'razor', 'vacuum_cleaner', 'controller', 'door', 'home_office', 'light', 'dishwasher', 'bathroom_cabinet', 'colander']
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:['blender', 'chair', 'blow_dryer', 'bathroom', 'drawing', 'cpuscreen', 'hanger', 'floor', 'ceiling', 'phone', 'folder', 'desk', 'stamp', 'keyboard', 'computer', 'food_bacon', 'mousepad', 'closetdrawer', 'wall', 'powersocket', 'coffe_maker', 'wooden_spoon', 'towel_rack', 'mouse', 'kitchen_counter', 'vacuum_cleaner', 'dresser', 'controller', 'light', 'soap']
Task:Vacuum
response:
{
    "thoughts": Plug in vacuum. Walk around with vacuum, covering all of the floor. Unplug vacuum.,
    "actions": ['[WALK] <bedroom>', '[WALK] <dresser>', '[OPEN] <dresser>', '[FIND] <vacuum_cleaner>', '[GRAB] <vacuum_cleaner>', '[PULL] <vacuum_cleaner>', '[PLUGIN] <vacuum_cleaner>', '[SWITCHON] <vacuum_cleaner>', '[PULL] <vacuum_cleaner>', '[PUSH] <vacuum_cleaner>', '[PULL] <vacuum_cleaner>', '[PUSH] <vacuum_cleaner>', '[PULL] <vacuum_cleaner>', '[PUSH] <vacuum_cleaner>', '[SWITCHOFF] <vacuum_cleaner>', '[PLUGOUT] <vacuum_cleaner>', '[WALK] <dresser>', '[PUTIN] <vacuum_cleaner> <dresser>', '[CLOSE] <dresser>']
}

Input:
Scene_Objects:['fork', 'spectacles', 'chair', 'freezer', 'walllamp', 'knife', 'wallshelf', 'floor', 'alcohol', 'bookmark', 'toaster', 'plate', 'candle', 'wall', 'nightstand', 'novel', 'coffe_maker', 'food_food', 'television', 'water', 'curtain', 'after_shave', 'diary', 'kitchen_counter', 'dresser', 'cupboard', 'bathtub', 'spoon', 'table', 'dishwasher']
Task:Wash dishes with dishwasher
response:

first i will take all the dishes to the dish washer and with the help of dishwasher and water i will clean all the dishes

[WALK] <dining_room>
[WALK] <dishwasher>
[FIND] <dishwasher>
[OPEN] <dishwasher>
[FIND] <fork>
[GRAB] <fork>
[PUTBACK] <fork> <dishwasher>
[FIND] <plate>
[GRAB] <plate>
[PUTBACK] <plate> <dishwasher>
[FIND] <spoon>
[GRAB] <spoon>
[PUTBACK] <spoon> <dishwasher>
[FIND] <water>
[TURNTO] <water>
[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:['fork', 'sheets', 'food_salt', 'tea', 'blow_dryer', 'wallshelf', 'ceiling', 'character', 'food_cake', 'computer', 'tvstand', 'window', 'mousepad', 'cutting_board', 'basket_for_clothes', 'cup', 'newspaper', 'light_bulb', 'novel', 'photoframe', 'coin', 'food_donut', 'rag', 'cards', 'kitchen_counter', 'vacuum_cleaner', 'pajamas', 'maindoor', 'bag', 'creditcard']
Task:Clean
response:
{
    "thoughts": Clean the welcome mat,
    "actions": ['[WALK] <home_office>', '[WALK] <vacuum_cleaner>', '[FIND] <vacuum_cleaner>', '[GRAB] <vacuum_cleaner>', '[SWITCHON] <vacuum_cleaner>', '[SWITCHOFF] <vacuum_cleaner>']
}

Input:
Scene_Objects:['fork', 'crayon', 'microwave', 'chair', 'cloth_napkin', 'freezer', 'walllamp', 'drawing', 'knife', 'floor', 'phone', 'character', 'food_cake', 'mat', 'ceilinglamp', 'plate', 'window', 'mousepad', 'microphone', 'pillow', 'wall', 'nightstand', 'bench', 'cup', 'video_game_controller', 'doorjamb', 'controller', 'door', 'table', 'teeth']
Task:Set up table
response:

Walk to dining room, walk to dining table, arrange chairs, set napkin, set plate, set knife, set fork and glass on table.

[WALK] <dining_room>
[WALK]

[FIND] <chair>
[PULL] <chair>
[FIND] <cloth_napkin>
[GRAB] <cloth_napkin>
[PUTBACK] <cloth_napkin>

[FIND] <plate>
[GRAB] <plate>
[PUTBACK] <plate>

[FIND] <knife>
[GRAB] <knife>
[PUTBACK] <knife>

[FIND] <fork>
[GRAB] <fork>
[PUTBACK] <fork>

[FIND] <cup>
[GRAB] <cup>
[PUTBACK] <cup>


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

Here is an example plan to achieve a goal for reference:
Scene_Objects:['glue', 'pot', 'filing_cabinet', 'tablelamp', 'mop', 'microwave', 'chair', 'dog', 'toothbrush', 'knifeblock', 'hanger', 'ceiling', 'bedroom', 'man', 'keyboard', 'ceilinglamp', 'stereo', 'shower', 'couch', 'food_jam', 'pillow', 'pasta', 'powersocket', 'coffe_maker', 'kettle', 'pencil', 'napkin', 'table', 'scrabble', 'creditcard']
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:['fork', 'microwave', 'nail_polish', 'drawing', 'cpuscreen', 'wallshelf', 'bathroom_counter', 'bedroom', 'bookshelf', 'keyboard', 'stovefan', 'ceilinglamp', 'mat', 'window', 'couch', 'dining_room', 'wall', 'tape', 'cup', 'bed', 'mouthwash', 'after_shave', 'dishrack', 'cupboard', 'door', 'sink', 'table', 'light', 'tooth_paste', 'clothes_shirt']
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:['milk', 'drawing', 'wallshelf', 'hanger', 'floor', 'ceiling', 'phone', 'character', 'bedroom', 'desk', 'brush', 'mat', 'ceilinglamp', 'closetdrawer', 'couch', 'dustpan', 'pillow', 'wall', 'powersocket', 'cup', 'photoframe', 'coffee_filter', 'food_rice', 'doorjamb', 'towel_rack', 'dresser', 'clothes_dress', 'door', 'light', 'table']
Task:Change clothes
response:
{
    "thoughts": Switch your clothes.,
    "actions": ['[WALK] <bedroom>', '[WALK] <dresser>', '[OPEN] <dresser>', '[FIND] <clothes_dress>', '[GRAB] <clothes_dress>', '[PUTON] <clothes_dress>', '[CLOSE] <dresser>']
}

Input:
Scene_Objects:['fork', 'pot', 'filing_cabinet', 'tablelamp', 'microwave', 'chair', 'bathroom', 'drawing', 'cpuscreen', 'floor', 'phone', 'desk', 'bedroom', 'ceilinglamp', 'shoe-shine_kit', 'faucet', 'clothes_pants', 'dining_room', 'wall', 'tape', 'basket_for_clothes', 'bed', 'coffe_maker', 'chessboard', 'clothes_dress', 'door', 'home_office', 'light', 'soap', 'washing_machine']
Task:Wash clothes
response:

Walk to Bathroom. Find basket for clothes. Lift clothes dress from basket. Find washing machine. Walk to washing machine. Put clothes in washing machine. Put soap in washing machine. Switch on washing machine.


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

Here is an example plan to achieve a goal for reference:
Scene_Objects:['chair', 'walllamp', 'drawing', 'wallshelf', 'hanger', 'floor', 'ceiling', 'desk', 'computer', 'stovefan', 'mat', 'tvstand', 'ceilinglamp', 'shower', 'toaster', 'closetdrawer', 'couch', 'food_jam', 'pillow', 'wall', 'cup', 'photoframe', 'coffee_table', 'novel', 'television', 'doorjamb', 'shoes', 'comb', 'dresser', 'instrument_violin']
Task:Watch TV
response:
{
    "thoughts": I sit down on the couch, get the tv remote, click the on button, and change the channel to the show i want to watch,
    "actions": ['[WALK] <home_office>', '[WALK] <remote_control>', '[FIND] <remote_control>', '[GRAB] <remote_control>', '[WALK] <couch>', '[SIT] <couch>', '[FIND] <television>', '[SWITCHON] <television>', '[FIND] <coffee_table>', '[PUTBACK] <remote_control> <coffee_table>', '[TURNTO] <television>', '[WATCH] <television>']
}

Input:
Scene_Objects:['blender', 'mop', 'walllamp', 'trashcan', 'wallshelf', 'floor', 'ceiling', 'folder', 'bedroom', 'tvstand', 'shower', 'foundation', 'window', 'mousepad', 'wall', 'powersocket', 'photoframe', 'light_bulb', 'food_food', 'coffe_maker', 'television', 'food_donut', 'curtain', 'centerpiece', 'towel_rack', 'kitchen_counter', 'cupboard', 'door', 'light', 'dishwasher']
Task:Take shower
response:

Walk to the bathroom and wash with the shower.

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


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', 'toothbrush', 'drawing', 'needle', 'bathroom_counter', 'floor', 'ceiling', 'desk', 'bedroom', 'mat', 'faucet', 'shower', 'food_noodles', 'form', 'wall', 'wall_clock', 'oven', 'tape', 'photoframe', 'keys', 'toothbrush_holder', 'rag', 'doorjamb', 'sink', 'bathroom_cabinet', 'instrument_guitar', 'dishwasher', 'tooth_paste', 'teeth']
Task:Wash teeth
response:
{
    "thoughts": I walk in to the bathroom. I turn on the faucet. I find the toothbrush and toothpaste. I grab the toothbrush and toothpaste. I rinse off the toothbrush. I add toothpaste to the toothbrush. I put back the toothpaste. I wash my teeth with the toothbrush. I rinse off the toothbrush. I put the toothbrush back. I rinse my mouth out. I turn the faucet off.,
    "actions": ['[WALK] <bathroom>', '[WALK] <faucet>', '[FIND] <faucet>', '[SWITCHON] <faucet>', '[FIND] <toothbrush>', '[GRAB] <toothbrush>', '[RINSE] <toothbrush>', '[FIND] <tooth_paste>', '[GRAB] <tooth_paste>', '[POUR] <tooth_paste> <toothbrush>', '[PUTOBJBACK] <tooth_paste>', '[FIND] <teeth>', '[WASH] <teeth>', '[RINSE] <toothbrush>', '[PUTOBJBACK] <toothbrush>', '[RINSE] <teeth>', '[SWITCHOFF] <faucet>']
}

Input:
Scene_Objects:['toilet', 'detergent', 'knifeblock', 'knife', 'bills', 'clothes_underwear', 'shampoo', 'desk', 'piano_bench', 'toaster', 'ceilinglamp', 'window', 'food_peanut_butter', 'clothes_pants', 'clothes_hat', 'basket_for_clothes', 'bed', 'coffe_maker', 'tray', 'doorjamb', 'cards', 'mouse', 'dresser', 'clothes_dress', 'bathtub', 'table', 'dishwasher', 'soap', '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:['microwave', 'toilet', 'walllamp', 'bathroom', 'detergent', 'trashcan', 'woman', 'knifeblock', 'needle', 'cpuscreen', 'desk', 'man', 'keyboard', 'bedroom', 'computer', 'stovefan', 'mat', 'ceilinglamp', 'nightstand', 'oven', 'cup', 'food_food', 'check', 'doorjamb', 'mouse', 'kitchen_counter', 'bathtub', 'bathroom_cabinet', 'table', 'light']
Task:Greet guests
response:
{
    "thoughts": Answer the door. Smile and give a warm hello, or other appropriate greeting. With newcomers to your home, offer your hand to be shook. With old friends it is appropriate to hug, or kiss one another on the cheek.,
    "actions": ['[WALK] <home_office>', '[WALK] <man>', '[FIND] <man>', '[GREET] <man>', '[FIND] <woman>', '[GREET] <woman>']
}

Input:
Scene_Objects:['spectacles', 'tablelamp', 'food_salt', 'microwave', 'toilet', 'freezer', 'walllamp', 'blow_dryer', 'bathroom', 'orchid', 'knifeblock', 'drawing', 'desk', 'bedroom', 'bookshelf', 'mat', 'foundation', 'oil', 'pillow', 'dining_room', 'bench', 'oven', 'novel', 'mouthwash', 'television', 'kitchen_counter', 'shoes', 'controller', 'bathtub', 'home_office']
Task:Write an email
response:

Find the computer.  Turn on the computer.  Open the e-mail program.  Create a new message.  Write the message.

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


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

Here is an example plan to achieve a goal for reference:
Scene_Objects:['sponge', 'food_pizza', 'filing_cabinet', 'toilet', 'wallshelf', 'cpuscreen', 'hanger', 'floor', 'folder', 'keyboard', 'faucet', 'iron', 'mousepad', 'pillow', 'dining_room', 'tape', 'cutting_board', 'cup', 'food_food', 'video_game_controller', 'food_rice', 'food_donut', 'rag', 'kettle', 'mouse', 'kitchen_counter', 'controller', 'food_steak', 'sink', 'dishwasher']
Task:Listen to music
response:
{
    "thoughts": I walk to the living room. I find a radio there and switch it on to listen to music.,
    "actions": ['[WALK] <home_office>', '[WALK] <stereo>', '[FIND] <stereo>', '[SWITCHON] <stereo>']
}

Input:
Scene_Objects:['microwave', 'chair', 'detergent', 'wallshelf', 'floor', 'ceiling', 'phone', 'bedroom', 'desk', 'alcohol', 'table_cloth', 'toaster', 'tvstand', 'shower', 'faucet', 'mousepad', 'clothes_hat', 'powersocket', 'oven', 'bench', 'box', 'photoframe', 'novel', 'coffe_maker', 'toilet_paper', 'doorjamb', 'mouse', 'cupboard', 'napkin', 'bathroom_cabinet']
Task:Pet cat
response:

I go looking for the cat in the living room where he usually sleeps. Once I find the cat I just pet him for a few minutes.

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


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

Here is an example plan to achieve a goal for reference:
Scene_Objects:['tablelamp', 'chair', 'walllamp', 'orchid', 'drawing', 'cpuscreen', 'wallshelf', 'hanger', 'floor', 'ceiling', 'phone', 'desk', 'keyboard', 'computer', 'ceilinglamp', 'tvstand', 'mat', 'mousepad', 'couch', 'pillow', 'wall', 'nightstand', 'television', 'fax_machine', 'doorjamb', 'mouse', 'dresser', 'door', 'teeth', 'printing_paper']
Task:Print out papers
response:
{
    "thoughts": Turn on printer and fill with blank paper. Use computer to click on printing option. Take printed page out of print.,
    "actions": ['[WALK] <home_office>', '[WALK] <fax_machine>', '[FIND] <fax_machine>', '[SWITCHON] <fax_machine>', '[FIND] <printing_paper>', '[GRAB] <printing_paper>', '[PUTBACK] <printing_paper> <fax_machine>', '[FIND] <computer>', '[FIND] <mouse>', '[GRAB] <mouse>', '[GRAB] <printing_paper>']
}

Input:
Scene_Objects:['pot', 'tablelamp', 'microwave', 'walllamp', 'knifeblock', 'cpuscreen', 'floor', 'ceiling', 'desk', 'toaster', 'plate', 'faucet', 'stereo', 'mousepad', 'couch', 'pillow', 'dining_room', 'wall', 'coffe_maker', 'check', 'doorjamb', 'mouse', 'kitchen_counter', 'dishrack', 'cupboard', 'sink', 'bathtub', 'dishwasher', 'clothes_skirt', 'laser_pointer']
Task:Wash dishes with dishwasher
response:

Take a dish and put it in the dishwasher to be washed

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


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

Here is an example plan to achieve a goal for reference:
Scene_Objects:['dry_pasta', 'sheets', 'ground_coffee', 'walllamp', 'trashcan', 'drawing', 'orchid', 'needle', 'hanger', 'floor', 'ceiling', 'desk', 'computer', 'toaster', 'ceilinglamp', 'couch', 'pillow', 'wall', 'nightstand', 'check', 'food_food', 'television', 'food_onion', 'doorjamb', 'pencil', 'door', 'home_office', 'table', 'light', 'coffee']
Task:Relax on sofa
response:
{
    "thoughts": Walk to the living room. Walk to the sofa and sit on the sofa.,
    "actions": ['[WALK] <home_office>', '[WALK] <couch>', '[SIT] <couch>']
}

Input:
Scene_Objects:['chair', 'walllamp', 'drawing', 'orchid', 'wallshelf', 'knifeblock', 'floor', 'ceiling', 'desk', 'bookshelf', 'remote_control', 'mat', 'tvstand', 'ceilinglamp', 'shower', 'window', 'mousepad', 'couch', 'pillow', 'wall', 'powersocket', 'bench', 'photoframe', 'television', 'curtain', 'doorjamb', 'coffee_pot', 'door', 'table', 'light']
Task:Watch TV
response:

I walk into my living room, find the remote and sit on my sofa. I look at the remote and switch on the television. I look at the Television.

[WALK] <home_office>
[WALK] <remote_control>
[FIND] <remote_control>
[FIND] <couch>
[SIT] <couch>
[TURNTO] <remote_control>
[LOOKAT] <remote_control>
[FIND] <television>
[SWITCHON] <television>
[TURNTO] <television>
[LOOKAT] <television>


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

Here is an example plan to achieve a goal for reference:
Scene_Objects:['tablelamp', 'jelly', 'drawing', 'floor', 'bedroom', 'table_cloth', 'stovefan', 'mat', 'plate', 'window', 'couch', 'wall', 'nightstand', 'wall_clock', 'cutting_board', 'bed', 'novel', 'tray', 'curtain', 'doorjamb', 'diary', 'mouse', 'pencil', 'cd', 'clothes_dress', 'bathroom_cabinet', 'table', 'light', 'vase', 'laser_pointer']
Task:Read book
response:
{
    "thoughts": I would go lie down in my bed and open the book and start reading.,
    "actions": ['[WALK] <bedroom>', '[WALK] <bed>', '[FIND] <bed>', '[LIE] <bed>', '[FIND] <novel>', '[GRAB] <novel>', '[READ] <novel>']
}

Input:
Scene_Objects:['pot', 'filing_cabinet', 'walllamp', 'bathroom', 'orchid', 'drawing', 'wallshelf', 'floor', 'ceiling', 'bookshelf', 'remote_control', 'mat', 'tvstand', 'ceilinglamp', 'shower', 'window', 'couch', 'pillow', 'wall', 'powersocket', 'oven', 'photoframe', 'bed', 'television', 'curtain', 'doorjamb', 'pencil', 'door', 'light', 'table']
Task:Change TV channel
response:

I push my body to be near to the table in front of me, without stand up. I move my right hand to near the TV remote control on the table. I take the TV remote control. I look the number on the remote control. I touch number 3 button. I put back the remote control to the table. I put my body back to the sofa

[WALK] <home_office>
[WALK] <television>
[FIND] <television>
[PLUGIN] <television>
[FIND] <couch>
[SIT] <couch>
[FIND] <remote_control>
[TURNTO] <remote_control>
[LOOKAT] <remote_control>
[GRAB] <remote_control>
[TOUCH] <remote_control>
[PUTOBJBACK] <remote_control>
[TURNTO] <television>
[WATCH] <television>


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

Here is an example plan to achieve a goal for reference:
Scene_Objects:['chair', 'walllamp', 'bathroom', 'detergent', 'food_butter', 'orchid', 'wallshelf', 'floor', 'ceiling', 'character', 'bedroom', 'button', 'table_cloth', 'stovefan', 'mat', 'brush', 'stereo', 'picture', 'mousepad', 'couch', 'clothes_pants', 'food_jam', 'powersocket', 'oven', 'newspaper', 'cards', 'shoes', 'controller', 'clothes_skirt', 'board_game']
Task:Listen to music
response:
{
    "thoughts": I go into the living room and turn on the radio.  Then, I select the station I want, which is usually a preset.,
    "actions": ['[WALK] <home_office>', '[WALK] <stereo>', '[FIND] <stereo>', '[FIND] <button>', '[PUSH] <button>', '[FIND] <button>', '[PUSH] <button>']
}

Input:
Scene_Objects:['filing_cabinet', 'bathroom', 'detergent', 'trashcan', 'drawing', 'orchid', 'floor', 'ceiling', 'bedroom', 'tea_bag', 'bookshelf', 'tvstand', 'faucet', 'mousepad', 'couch', 'pillow', 'wall', 'photoframe', 'check', 'food_food', 'coffe_maker', 'doorjamb', 'dresser', 'door', 'sink', 'napkin', 'bathroom_cabinet', 'table', 'light', 'home_office']
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:['pot', 'beer', 'mop', 'chair', 'freezer', 'orchid', 'floor', 'ceiling', 'character', 'bedroom', 'desk', 'keyboard', 'toaster', 'shower', 'window', 'food_orange', 'wall', 'oven', 'cup', 'photoframe', 'food_food', 'curtain', 'towel_rack', 'kitchen_counter', 'cupboard', 'door', 'spoon', 'table', 'light', 'coffee']
Task:Put groceries in Fridge
response:
{
    "thoughts": I take the groceries out of the grocery bags, throw away grocery bags, categorize the food so that I know where it goes in the fridge, open the fridge, and place each item in the fridge before closing the fridge.,
    "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:['microwave', 'freezer', 'walllamp', 'bathroom', 'orchid', 'wallshelf', 'bathroom_counter', 'floor', 'ceiling', 'dvd_player', 'character', 'bookshelf', 'toaster', 'mat', 'tvstand', 'ceilinglamp', 'shower', 'window', 'laptop', 'couch', 'wall', 'powersocket', 'photoframe', 'television', 'curtain', 'doorjamb', 'lighter', 'dresser', 'sink', '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', 'microwave', 'dog', 'chair', 'bathroom', 'drawing', 'floor', 'ceiling', 'bedroom', 'bookshelf', 'purse', 'mat', 'ceilinglamp', 'shower', 'candle', 'wall', 'bed', 'clothes_gloves', 'food_food', 'water', 'food_rice', 'wooden_spoon', 'curtain', 'console', 'dishrack', 'pajamas', 'light', 'clothes_skirt', 'soap', 'dirt']
Task:Take shower
response:
{
    "thoughts": go to a bathroom, open the shower, let water wash your body,
    "actions": ['[WALK] <bathroom>', '[WALK] <shower>', '[FIND] <soap>', '[SCRUB] <soap>', '[FIND] <water>', '[RINSE] <water>']
}

Input:
Scene_Objects:['pot', 'tea', 'microwave', 'chair', 'freezer', 'band-aids', 'orchid', 'drawing', 'floor', 'ceiling', 'shampoo', 'alcohol', 'toaster', 'shower', 'mousepad', 'oil', 'couch', 'wall', 'nightstand', 'bench', 'cutting_board', 'tape', 'cup', 'food_donut', 'tray', 'curtain', 'towel_rack', 'kitchen_counter', 'dresser', 'cupboard']
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:['microwave', 'toilet', 'dog', 'freezer', 'walllamp', 'bathroom', 'trashcan', 'drawing', 'knifeblock', 'cpuscreen', 'phone', 'bookshelf', 'table_cloth', 'bookmark', 'toaster', 'mat', 'faucet', 'oven', 'cup', 'photoframe', 'check', 'television', 'towel_rack', 'kitchen_counter', 'chessboard', 'cupboard', 'door', 'sink', 'light', 'tooth_paste']
Task:Pet dog
response:
{
    "thoughts": Pet my dog in hall,
    "actions": ['[WALK] <home_office>', '[WALK] <dog>', '[TURNTO] <dog>', '[LOOKAT] <dog>', '[TOUCH] <dog>']
}

Input:
Scene_Objects:['sheets', 'microwave', 'dog', 'chair', 'walllamp', 'detergent', 'knifeblock', 'needle', 'character', 'bookmark', 'mat', 'ceilinglamp', 'faucet', 'pillow', 'powersocket', 'oven', 'tape', 'cutting_board', 'coffe_maker', 'doorjamb', 'mouse', 'kitchen_counter', 'shoes', 'cupboard', 'sink', 'bathroom_cabinet', 'table', 'dishwasher', 'clothes_shirt', 'dirt']
Task:Change TV channel
response:

I pull up my online classes on the computer to look at what the assigned reading is. I get my textbook, notebook, and mechanical pencil. As I'm reading, I take notes over important points. I then use those notes to complete the assignment for the week. Frequently that involves writing a post on an online discussion board that answers a question related to things from the reading.

[WALK] <home_office>
[WALK] <remote_control>
[GRAB] <remote_control>
[TURNTO] <remote_control>
[POINTAT] <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:['filing_cabinet', 'tablelamp', 'microwave', 'toilet', 'dog', 'chair', 'walllamp', 'drawing', 'cpuscreen', 'wallshelf', 'hanger', 'floor', 'desk', 'envelope', 'mat', 'tvstand', 'ceilinglamp', 'shower', 'window', 'mousepad', 'couch', 'pillow', 'wall', 'nightstand', 'television', 'oven_mitts', 'curtain', 'controller', 'home_office', 'table']
Task:Relax on sofa
response:
{
    "thoughts": I walk into the living room. I cross the room to the couch. I sit down and relax.,
    "actions": ['[WALK] <home_office>', '[WALK] <couch>', '[SIT] <couch>']
}

Input:
Scene_Objects:['pot', 'filing_cabinet', 'ground_coffee', 'walllamp', 'nail_polish', 'floor', 'ceiling', 'bedroom', 'bookshelf', 'toaster', 'stovefan', 'iron', 'couch', 'form', 'wall', 'nightstand', 'photoframe', 'coffe_maker', 'food_food', 'television', 'coffee_filter', 'water', 'doorjamb', 'kitchen_counter', 'dresser', 'cupboard', 'hairdryer', 'bathtub', 'dishwasher', 'dirt']
Task:Make coffee
response:

I walk into the kitchen. I find the coffee maker and open it. I find the coffee filter, grab it and put it into the coffee maker. I find ground coffee, grab it and put it into the coffee maker. I find some water, then I pour it into the coffee maker. I close the coffee maker, I plug it in and I 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>
[PLUGIN] <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:['sponge', 'walllamp', 'ground_coffee', 'trashcan', 'drawing', 'orchid', 'hanger', 'floor', 'ceiling', 'bookshelf', 'remote_control', 'button', 'ceilinglamp', 'tvstand', 'mat', 'shower', 'foundation', 'couch', 'microphone', 'wall', 'powersocket', 'oven', 'bed', 'television', 'wooden_spoon', 'doorjamb', 'lighter', 'dresser', 'door', 'table']
Task:Change TV channel
response:
{
    "thoughts": I go to the living room where the TV is located. I plug in the TV to the outlet. I search for the remote control. I point the remote control directly to the TV, turn it on and push the number of the channel that I want.,
    "actions": ['[WALK] <home_office>', '[WALK] <television>', '[FIND] <television>', '[PLUGIN] <television>', '[FIND] <remote_control>', '[TURNTO] <television>', '[POINTAT] <television>', '[SWITCHON] <television>', '[FIND] <button>', '[PUSH] <button>']
}

Input:
Scene_Objects:['spectacles', 'scissors', 'food_ice_cream', 'chair', 'orchid', 'drawing', 'bills', 'knifeblock', 'floor', 'character', 'alcohol', 'mat', 'window', 'couch', 'microphone', 'pillow', 'dining_room', 'wall', 'pasta', 'clothes_gloves', 'check', 'coffe_maker', 'curtain', 'doorjamb', 'kitchen_counter', 'cupboard', 'table', 'dishwasher', 'colander', 'coffee']
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:['food_pizza', 'chair', 'freezer', 'walllamp', 'bathroom', 'orchid', 'cpuscreen', 'hanger', 'floor', 'ceiling', 'phone', 'desk', 'keyboard', 'computer', 'mop_bucket', 'ceilinglamp', 'mat', 'electric_shaver', 'mousepad', 'wall', 'powersocket', 'photoframe', 'food_food', 'coffe_maker', 'mouse', 'pencil', 'controller', 'door', 'table', 'teeth']
Task:Work
response:
{
    "thoughts": walk to home office ,find computer ,switch on computer and work,
    "actions": ['[WALK] <home_office>', '[WALK] <computer>', '[FIND] <computer>', '[SWITCHON] <computer>']
}

Input:
Scene_Objects:['filing_cabinet', 'crayon', 'freezer', 'walllamp', 'knifeblock', 'orchid', 'floor', 'ceiling', 'stamp', 'table_cloth', 'toaster', 'ceilinglamp', 'plate', 'shower', 'dish_soap', 'wall', 'nightstand', 'basket_for_clothes', 'keys', 'light_bulb', 'coffe_maker', 'novel', 'television', 'curtain', 'kitchen_counter', 'dishrack', 'cupboard', 'home_office', 'dishwasher', 'scrabble']
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>


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:['pot', 'filing_cabinet', 'measuring_cup', 'chair', 'freezer', 'drawing', 'floor', 'ceiling', 'character', 'toaster', 'plate', 'shower', 'floor_lamp', 'window', 'couch', 'food_peanut_butter', 'pillow', 'dining_room', 'wall', 'oven', 'toilet_paper', 'curtain', 'doorjamb', 'towel_rack', 'shoes', 'cd', 'laundry_detergent', 'door', 'light', 'table']
Task:Turn on light
response:

walk to wall, find light switch, turn on lights

[WALK] <home_office>
[WALK] <light>
[FIND] <light>
[PLUGIN] <light>
[FIND] <floor_lamp>
[SWITCHON] <floor_lamp>
[WALK] <bedroom>
[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:['pot', 'food_bread', 'microwave', 'detergent', 'knifeblock', 'floor', 'ceiling', 'character', 'computer', 'toaster', 'ceilinglamp', 'faucet', 'shower', 'wall', 'cup', 'check', 'mouthwash', 'water', 'wine', 'after_shave', 'curtain', 'food_onion', 'mouse', 'kitchen_counter', 'vacuum_cleaner', 'cupboard', 'conditioner', 'sink', 'napkin', 'bathroom_cabinet']
Task:Drink
response:
{
    "thoughts": I go in the kitchen and get the glass near the sink. I open the faucet, then I pour water in it, turn off the faucet and drink it.,
    "actions": ['[WALK] <dining_room>', '[WALK] <sink>', '[FIND] <cup>', '[GRAB] <cup>', '[FIND] <faucet>', '[SWITCHON] <faucet>', '[FIND] <water>', '[PUTBACK] <cup> <sink>', '[GRAB] <cup>', '[SWITCHOFF] <faucet>', '[DRINK] <cup>']
}

Input:
Scene_Objects:['sponge', 'dry_pasta', 'tablelamp', 'walllamp', 'detergent', 'milk', 'orchid', 'floor', 'ceiling', 'button', 'toaster', 'faucet', 'wall', 'box', 'basket_for_clothes', 'keys', 'coffe_maker', 'food_food', 'curtain', 'food_sugar', 'kitchen_counter', 'dresser', 'cupboard', 'controller', 'bathtub', 'sink', 'home_office', 'coffee_cup', 'dishwasher', 'clothes_skirt']
Task:Make coffee
response:

walk to kitchen, look at the coffee maker, open the coffee maker, find milk, suger and water, mix that all, put into coffee maker, switch on the coffee maker, wait for few mins, push the coffee button in coffee maker, we get coffee in coffee cup, drink coffee

[WALK] <dining_room>
[WALK] <coffe_maker>
[FIND] <coffe_maker>
[TURNTO] <coffe_maker>
[LOOKAT] <coffe_maker>
[OPEN] <coffe_maker>
[FIND] <milk>
[GRAB] <milk>
[PUTBACK] <milk> <coffe_maker>
[FIND] <food_sugar>
[FIND] <coffee_cup>
[GRAB] <coffee_cup>
[PUTBACK] <coffee_cup> <coffe_maker>
[SWITCHON] <coffe_maker>
[FIND] <button>
[PUSH] <button>
[GRAB] <coffee_cup>
[DRINK] <coffee_cup>


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

Here is an example plan to achieve a goal for reference:
Scene_Objects:['tablelamp', 'toilet', 'bathroom', 'orchid', 'cpuscreen', 'wallshelf', 'floor', 'phone', 'character', 'bedroom', 'toaster', 'ceilinglamp', 'stovefan', 'wall_clock', 'powersocket', 'bed', 'food_food', 'television', 'wooden_spoon', 'kitchen_counter', 'dresser', 'cupboard', 'door', 'sink', 'hairdryer', 'home_office', 'light', 'clothes_skirt', 'bathtub', 'bathroom_cabinet']
Task:Read book
response:
{
    "thoughts": pick up your book and read it,
    "actions": ['[WALK] <bedroom>', '[WALK] <novel>', '[GRAB] <novel>', '[READ] <novel>']
}

Input:
Scene_Objects:['food_pizza', 'dog', 'bathroom', 'trashcan', 'drawing', 'orchid', 'wallshelf', 'floor', 'ceiling', 'character', 'desk', 'shower', 'electric_shaver', 'window', 'couch', 'pillow', 'wall', 'nightstand', 'newspaper', 'bed', 'food_food', 'doorjamb', 'towel_rack', 'mouse', 'kitchen_counter', 'cupboard', 'door', 'bathroom_cabinet', 'table', 'light']
Task:Relax on sofa
response:

I walk to the living room and find the sofa. I sit on the sofa and get comfortable.

[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:['fork', 'tablelamp', 'chair', 'walllamp', 'detergent', 'food_carrot', 'cpuscreen', 'hanger', 'floor', 'ceiling', 'table_cloth', 'mop_bucket', 'ceilinglamp', 'tvstand', 'mat', 'couch', 'dustpan', 'pillow', 'wall', 'nightstand', 'oven', 'food_food', 'check', 'television', 'tray', 'wooden_spoon', 'kettle', 'controller', 'food_steak', 'sink']
Task:Relax on sofa
response:
{
    "thoughts": go to the living room and sit on the couch, ease into the sofa and relax.,
    "actions": ['[WALK] <home_office>', '[WALK] <couch>', '[LIE] <couch>']
}

Input:
Scene_Objects:['sheets', 'tablelamp', 'bathroom', 'cat', 'knifeblock', 'drawing', 'wallshelf', 'phone', 'ceiling', 'character', 'keyboard', 'toaster', 'mat', 'tvstand', 'electric_shaver', 'clothes_pants', 'pillow', 'dining_room', 'wall', 'photoframe', 'novel', 'food_food', 'curtain', 'doorjamb', 'dishrack', 'pajamas', 'door', 'bathtub', 'spoon', 'table']
Task:Pick up phone
response:

walk to phone, grab phone, pick up phone, put to ear

[WALK] <home_office>
[WALK] <phone>
[FIND] <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:['food_pizza', 'tablelamp', 'jelly', 'ceilingfan', 'knifeblock', 'cpuscreen', 'bathroom_counter', 'floor', 'bookshelf', 'computer', 'clothes_jacket', 'piano_bench', 'stovefan', 'toaster', 'tvstand', 'ceilinglamp', 'balanceball', 'stereo', 'brush', 'food_jam', 'clothes_hat', 'nightstand', 'pasta', 'powersocket', 'bench', 'bed', 'oven_mitts', 'tray', 'towel_rack', 'home_office']
Task:Listen to music
response:
{
    "thoughts": I walk to the radio.  I switch on the radio and listen,
    "actions": ['[WALK] <home_office>', '[WALK] <stereo>', '[SWITCHON] <stereo>']
}

Input:
Scene_Objects:['filing_cabinet', 'toilet', 'freezer', 'walllamp', 'drawing', 'wallshelf', 'floor', 'phone', 'ceiling', 'keyboard', 'computer', 'toaster', 'mat', 'tvstand', 'couch', 'dustpan', 'dining_room', 'wall', 'nightstand', 'powersocket', 'oven', 'newspaper', 'novel', 'doorjamb', 'mouse', 'pencil', 'cupboard', 'bathtub', 'bathroom_cabinet', 'light']
Task:Turn on light
response:

I walk into the kitchen, I find the light switch, and then i switch on the lights in the kitchen.

[WALK] <dining_room>
[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:['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:['filing_cabinet', 'food_salt', 'chair', 'bathroom', 'knifeblock', 'orchid', 'cpuscreen', 'bathroom_counter', 'floor', 'phone', 'character', 'bedroom', 'desk', 'stovefan', 'ceilinglamp', 'mat', 'faucet', 'homework', 'mousepad', 'form', 'powersocket', 'bench', 'light_bulb', 'check', 'television', 'tray', 'curtain', 'chessboard', 'cupboard', 'home_office']
Task:Pick up phone
response:

I walk to the home office, find where the phone is and lift the reciever.

[WALK] <home_office>
[WALK] <phone>
[FIND] <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:['tablelamp', 'toilet', 'walllamp', 'drawing', 'wallshelf', 'floor', 'phone', 'character', 'bedroom', 'alcohol', 'computer', 'table_cloth', 'stovefan', 'ceilinglamp', 'mat', 'foundation', 'food_noodles', 'wall', 'nightstand', 'bench', 'oven', 'food_food', 'television', 'curtain', 'rag', 'pencil', 'door', 'clothes_scarf', 'home_office', 'table']
Task:Play games
response:
{
    "thoughts": I either bring out monopoly, uno, chess, checkers or playing cards and lay them out on the dining room table. We then play the games for a couple of hours.,
    "actions": ['[WALK] <home_office>', '[WALK] <board_game>', '[FIND] <board_game>', '[GRAB] <board_game>', '[WALK] <dining_room>', '[WALK] <table>', '[PUTBACK] <board_game> <table>']
}

Input:
Scene_Objects:['food_pizza', 'chair', 'walllamp', 'orchid', 'wallshelf', 'clothes_underwear', 'floor', 'ceiling', 'bookshelf', 'remote_control', 'button', 'toaster', 'mat', 'tvstand', 'ceilinglamp', 'shower', 'window', 'wall', 'powersocket', 'oven', 'bench', 'photoframe', 'television', 'curtain', 'food_onion', 'doorjamb', 'towel_rack', 'bathroom_cabinet', 'light', 'home_office']
Task:Watch TV
response:

Walk to living room.  Find remote control.  Find television.  Point remote at television.  Press "on" button.  Watch.

[WALK] <home_office>
[WALK] <television>
[FIND] <television>
[FIND] <remote_control>
[TURNTO] <television>
[POINTAT] <television>
[FIND] <button>
[PUSH] <button>
[TURNTO] <television>
[WATCH] <television>


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

Here is an example plan to achieve a goal for reference:
Scene_Objects:['sheets', 'toilet', 'dog', 'band-aids', 'walllamp', 'ground_coffee', 'food_carrot', 'drawing', 'bathroom_counter', 'floor', 'phone', 'food_cake', 'computer', 'toaster', 'mat', 'faucet', 'window', 'couch', 'candle', 'pillow', 'wall', 'television', 'curtain', 'doorjamb', 'towel_rack', 'dresser', 'bathroom_cabinet', 'table', 'light', 'scrabble']
Task:Relax on sofa
response:
{
    "thoughts": I walk to the living room and stand in front of the sofa. Then I turn and sit on the sofa and lean my back against the pillow and my feet on the floor.,
    "actions": ['[WALK] <home_office>', '[WALK] <couch>', '[FIND] <couch>', '[TURNTO] <couch>', '[SIT] <couch>']
}

Input:
Scene_Objects:['tablelamp', 'crayon', 'detergent', 'trashcan', 'orchid', 'wallshelf', 'bathroom_counter', 'ceiling', 'keyboard', 'stovefan', 'tvstand', 'shower', 'window', 'mousepad', 'dining_room', 'wall', 'basket_for_clothes', 'television', 'centerpiece', 'kitchen_counter', 'comb', 'dresser', 'cupboard', 'clothes_dress', 'laundry_detergent', 'door', 'sink', 'table', 'clothes_shirt', 'washing_machine']
Task:Wash clothes
response:

Walk to the kitchen. Find the washing machine. Open the washing machine. Find the basket for clothes. Find the clothes_dress. Grab the clothes_dress. Put the clothes_dress into the washing machine. Find the clothes_shirt. Grab the clothes_shirt. Put the clothes_shirt into the washing machine. Close the washing machine. Switch on the washing machine.


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

Here is an example plan to achieve a goal for reference:
Scene_Objects:['tablelamp', 'toilet', 'chair', 'walllamp', 'drawing', 'orchid', 'cpuscreen', 'hanger', 'floor', 'ceiling', 'desk', 'keyboard', 'computer', 'ceilinglamp', 'mat', 'mousepad', 'closetdrawer', 'wall', 'nightstand', 'powersocket', 'check', 'television', 'wine', 'doorjamb', 'mouse', 'kitchen_counter', 'dresser', 'light', 'table', 'clothes_skirt']
Task:Write an email
response:
{
    "thoughts": enter office, find computer, turn it on,,
    "actions": ['[WALK] <home_office>', '[WALK] <computer>', '[FIND] <computer>', '[SWITCHON] <computer>', '[FIND] <keyboard>', '[TOUCH] <keyboard>', '[TYPE] <keyboard>']
}

Input:
Scene_Objects:['sheets', 'freezer', 'detergent', 'trashcan', 'cpuscreen', 'bathroom_counter', 'floor', 'ceiling', 'phone', 'bedroom', 'desk', 'bookshelf', 'mail', 'toaster', 'ceilinglamp', 'faucet', 'window', 'pillow', 'dining_room', 'wall', 'powersocket', 'oven', 'novel', 'television', 'wooden_spoon', 'curtain', 'doorjamb', 'pencil', 'vacuum_cleaner', 'light']
Task:Turn on light
response:

[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:['jelly', 'trashcan', 'food_carrot', 'drawing', 'food_egg', 'bathroom_counter', 'ceiling', 'keyboard', 'bookshelf', 'mop_bucket', 'tvstand', 'iron', 'oil', 'food_noodles', 'mousepad', 'dustpan', 'towel', 'nightstand', 'cup', 'light_bulb', 'razor', 'food_donut', 'rag', 'shaving_cream', 'towel_rack', 'pencil', 'kitchen_counter', 'bag', 'bathroom_cabinet', 'dishwasher']
Task:Listen to music
response:
{
    "thoughts": I pull up my online classes on the computer to look at what the assigned reading is. I get my textbook, notebook, and mechanical pencil. As I'm reading, I take notes over important points. I then use those notes to complete the assignment for the week. Frequently that involves writing a post on an online discussion board that answers a question related to things from the reading.,
    "actions": ['[WALK] <home_office>', '[WALK] <stereo>', '[FIND] <stereo>', '[SWITCHON] <stereo>']
}

Input:
Scene_Objects:['pot', 'microwave', 'chair', 'freezer', 'walllamp', 'knife', 'knifeblock', 'wallshelf', 'clothes_underwear', 'kitchen_cabinet', 'floor', 'ceiling', 'bedroom', 'desk', 'bookshelf', 'toaster', 'stovefan', 'faucet', 'dustpan', 'wall', 'oven', 'food_food', 'food_donut', 'tray', 'after_shave', 'pencil', 'kitchen_counter', 'cupboard', 'food_steak', 'sink']
Task:Cook some food
response:

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

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


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

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

Input:
Scene_Objects:['food_pizza', 'freezer', 'band-aids', 'drawing', 'bathroom_counter', 'floor', 'ceiling', 'phone', 'stamp', 'desk', 'stovefan', 'shoe-shine_kit', 'couch', 'pillow', 'wall', 'bench', 'coffe_maker', 'toothbrush_holder', 'television', 'curtain', 'doorjamb', 'shaving_cream', 'cupboard', 'door', 'sink', 'bathtub', 'instrument_guitar', 'light', 'home_office', 'clothes_skirt']
Task:Turn on light
response:

I walk to room. I enter room. I find where the lightswitch is. I turn on the lights with the lightswitch.

[WALK] <bedroom>
[WALK] <light>
[FIND] <light>
[TURNTO] <light>
[LOOKAT] <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:['tablelamp', 'chair', 'freezer', 'bathroom', 'orchid', 'floor', 'ceiling', 'character', 'bedroom', 'computer', 'toaster', 'stovefan', 'ceilinglamp', 'picture', 'tooth_paste', 'couch', 'pillow', 'wall', 'nightstand', 'food_food', 'check', 'television', 'tray', 'doorjamb', 'mouse', 'kitchen_counter', 'cupboard', 'home_office', 'bathroom_cabinet', 'board_game']
Task:Put groceries in Fridge
response:
{
    "thoughts": Walk to the kitchen. Open the fridge, take the groceries and put in it. Closed the fridge,,
    "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', 'food_salt', 'measuring_cup', 'microwave', 'freezer', 'walllamp', 'orchid', 'drawing', 'cpuscreen', 'knifeblock', 'phone', 'bedroom', 'desk', 'button', 'stereo', 'faucet', 'picture', 'pillow', 'dining_room', 'nightstand', 'wall', 'bed', 'check', 'toothbrush_holder', 'tray', 'dresser', 'sink', 'home_office', 'table', 'dishwasher']
Task:Listen to music
response:

Find the radio; switch on the radio and listen to music.

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


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

Here is an example plan to achieve a goal for reference:
Scene_Objects:['pot', 'crayon', 'detergent', 'ceilingfan', 'food_carrot', 'milk', 'drawing', 'knifeblock', 'food_egg', 'floor', 'phone', 'desk', 'bookshelf', 'envelope', 'ceilinglamp', 'window', 'mousepad', 'couch', 'wall', 'food_cheese', 'novel', 'television', 'food_rice', 'after_shave', 'towel_rack', 'kitchen_counter', 'comb', 'table', 'dishwasher', 'creditcard']
Task:Relax on sofa
response:
{
    "thoughts": I walk to the living room and find the sofa. I sit on the sofa and get comfortable.,
    "actions": ['[WALK] <home_office>', '[WALK] <couch>', '[FIND] <couch>', '[SIT] <couch>']
}

Input:
Scene_Objects:['pot', 'tablelamp', 'blender', 'freezer', 'detergent', 'food_carrot', 'food_egg', 'wallshelf', 'floor', 'ceiling', 'food_cake', 'computer', 'ceilinglamp', 'stereo', 'shower', 'foundation', 'faucet', 'oil', 'broom', 'nightstand', 'oven', 'powersocket', 'newspaper', 'coffe_maker', 'television', 'cupboard', 'bathtub', 'napkin', 'bathroom_cabinet', 'light']
Task:Listen to music
response:

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

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