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

Here is an example plan to achieve a goal for reference:
Scene_Objects:['spectacles', 'tablelamp', 'juice', 'microwave', 'toilet', 'chair', 'walllamp', 'dough', 'drawing', 'cpuscreen', 'floor', 'folder', 'desk', 'bookshelf', 'keyboard', 'computer', 'mail', 'shower', 'picture', 'mousepad', 'wall', 'nightstand', 'bench', 'oven', 'photoframe', 'novel', 'check', 'food_food', 'centerpiece', 'mouse']
Task:Arrange folders
response:
{
    "thoughts": Go through all my folders and re-arrange in alfabetaical order and put on computer desk,
    "actions": ['[WALK] <home_office>', '[WALK] <desk>', '[FIND] <folder>', '[GRAB] <folder>', '[OPEN] <desk>', '[PUTBACK] <folder> <desk>', '[FIND] <folder>', '[GRAB] <folder>', '[PUTBACK] <folder> <desk>', '[FIND] <folder>', '[GRAB] <folder>', '[PUTBACK] <folder> <desk>', '[FIND] <folder>', '[GRAB] <folder>', '[PUTBACK] <folder> <desk>', '[FIND] <folder>', '[GRAB] <folder>', '[PUTBACK] <folder> <desk>']
}

Input:
Scene_Objects:['tablelamp', 'chair', 'cloth_napkin', 'walllamp', 'orchid', 'cpuscreen', 'wallshelf', 'hanger', 'floor', 'ceiling', 'phone', 'desk', 'keyboard', 'computer', 'ceilinglamp', 'tvstand', 'mat', 'mousepad', 'couch', 'pillow', 'wall', 'nightstand', 'television', 'doorjamb', 'mouse', 'pencil', 'headset', 'dresser', 'door', 'sink']
Task:Clean
response:

Use a cloth to wipe away any marks on the computer screen.

[WALK] <home_office>
[WALK] <computer>
[FIND] <cloth_napkin>
[GRAB] <cloth_napkin>
[WIPE] <computer>


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

Here is an example plan to achieve a goal for reference:
Scene_Objects:['pot', '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:['tablelamp', 'walllamp', 'food_butter', 'toothbrush', 'drawing', 'hanger', 'floor', 'ceiling', 'bookshelf', 'ceilinglamp', 'mousepad', 'closetdrawer', 'oil', 'microphone', 'pillow', 'dining_room', 'broom', 'wall', 'nightstand', 'powersocket', 'bed', 'photoframe', 'razor', 'television', 'doorjamb', 'kettle', 'mouse', 'dresser', 'door', 'light']
Task:Turn off light
response:

[WALK] <bedroom>
[WALK] <light>
[SWITCHOFF] <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', 'walllamp', 'orchid', 'wallshelf', 'bathroom_counter', 'floor', 'ceiling', 'bedroom', 'bookshelf', 'remote_control', 'mat', 'tvstand', 'ceilinglamp', 'shower', 'window', 'mousepad', 'pillow', 'wall', 'powersocket', 'photoframe', 'bed', 'coffe_maker', 'television', 'curtain', 'doorjamb', 'mouse', 'door', 'sink', 'light', 'coffee']
Task:Watch TV
response:
{
    "thoughts": walk to living room ,find television , switch on remote control,
    "actions": ['[WALK] <home_office>', '[WALK] <television>', '[FIND] <television>', '[FIND] <remote_control>', '[SWITCHON] <remote_control>']
}

Input:
Scene_Objects:['tablelamp', 'scissors', 'microwave', 'chair', 'drawing', 'orchid', 'cpuscreen', 'hanger', 'floor', 'ceiling', 'desk', 'keyboard', 'bookshelf', 'computer', 'brush', 'mat', 'ceilinglamp', 'tvstand', 'window', 'mousepad', 'wall', 'nightstand', 'powersocket', 'food_food', 'television', 'curtain', 'lighter', 'mouse', 'door', 'clothes_scarf']
Task:Enjoy view out window
response:

Sitting in teak deck chair, gaze out window at the view.

[WALK] <home_office>
[WALK] <chair>
[FIND] <chair>
[SIT] <chair>
[FIND] <window>
[TURNTO] <window>
[LOOKAT] <window>


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

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

Input:
Scene_Objects:['fork', 'pot', 'food_pizza', 'juice', 'microwave', 'freezer', 'drawing', 'orchid', 'floor', 'ceiling', 'tea_bag', 'keyboard', 'toaster', 'mat', 'stovefan', 'shower', 'couch', 'pillow', 'wall', 'nightstand', 'oven', 'food_food', 'coffe_maker', 'television', 'tray', 'towel_rack', 'kitchen_counter', 'cupboard', 'food_snack', 'dishwasher']
Task:Have snack
response:

Pour soda into a glass. Get pretzels out of bag. Eat and drink

[WALK] <dining_room>
[WALK] <cup>
[FIND] <cup>
[GRAB] <cup>
[WALK] <freezer>
[OPEN] <freezer>
[FIND] <juice>
[GRAB] <juice>
[POUR] <juice> <cup>
[PUTIN] <juice> <freezer>
[CLOSE] <freezer>
[WALK] <cupboard>
[OPEN] <cupboard>
[FIND] <food_snack>
[GRAB] <food_snack>
[CLOSE] <cupboard>
[DRINK] <cup>
[EAT] <food_snack>


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

Here is an example plan to achieve a goal for reference:
Scene_Objects:['dry_pasta', 'pot', 'measuring_cup', 'jelly', 'chair', 'freezer', 'hanger', 'ceiling', 'thread', 'computer', 'mail', 'bookmark', 'deck_of_cards', 'faucet', 'mousepad', 'dining_room', 'broom', 'wall', 'wall_clock', 'box', 'razor', 'doorjamb', 'mouse', 'pencil', 'hairbrush', 'door', 'napkin', 'table', 'light', 'dirt']
Task:Pick up phone
response:
{
    "thoughts": Enter the Home office, then walk to the phone, pickup the phone.,
    "actions": ['[WALK] <home_office>', '[WALK] <phone>', '[GRAB] <phone>']
}

Input:
Scene_Objects:['pot', 'filing_cabinet', 'tablelamp', 'toilet', 'bathroom', 'drawing', 'hanger', 'floor', 'bedroom', 'stovefan', 'mat', 'tvstand', 'stereo', 'faucet', 'couch', 'wall', 'nightstand', 'powersocket', 'oven', 'bed', 'photoframe', 'coffe_maker', 'check', 'kettle', 'kitchen_counter', 'dresser', 'home_office', 'light', 'dishwasher', 'teeth']
Task:Listen to music
response:

Put iPhone into speaker holder, open up the Pandora app, listen to music.

[WALK] <bedroom>
[WALK] <phone>
[FIND] <phone>
[GRAB] <phone>
[WALK] <stereo>
[PLUGIN] <phone>
[SWITCHON] <stereo>
[FIND] <bed>
[SIT] <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:['sheets', 'dry_pasta', 'ceilingfan', 'trashcan', 'drawing', 'longboard', 'floor', 'ceiling', 'bedroom', 'stovefan', 'ceilinglamp', 'tvstand', 'balanceball', 'laptop', 'window', 'shower', 'deck_of_cards', 'couch', 'food_kiwi', 'wall', 'tape', 'basket_for_clothes', 'keys', 'coffe_maker', 'toilet_paper', 'television', 'curtain', 'cd', 'controller', 'table']
Task:Watch TV
response:
{
    "thoughts": Sit on the couch. Get comfortable. Switch on the television. Stare at the television.,
    "actions": ['[WALK] <home_office>', '[WALK] <television>', '[FIND] <television>', '[SWITCHON] <television>', '[FIND] <couch>', '[SIT] <couch>', '[TURNTO] <television>', '[WATCH] <television>']
}

Input:
Scene_Objects:['pot', 'filing_cabinet', 'chair', 'walllamp', 'drawing', 'wallshelf', 'cpuscreen', 'hanger', 'floor', 'ceiling', 'desk', 'remote_control', 'computer', 'mat', 'tvstand', 'ceilinglamp', 'closetdrawer', 'couch', 'pillow', 'wall', 'powersocket', 'oven', 'photoframe', 'television', 'doorjamb', 'towel_rack', 'dresser', 'pajamas', 'sink', 'dishwasher']
Task:Watch TV
response:

We sit on the couch facing the tv turn on the television with the remote and watch programs

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


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

Here is an example plan to achieve a goal for reference:
Scene_Objects:['pot', 'food_ice_cream', 'chair', 'food_carrot', 'hanger', 'bathroom_counter', 'floor', 'keyboard', 'mat', 'plate', 'ceilinglamp', 'window', 'mousepad', 'couch', 'food_orange', 'pillow', 'broom', 'wall', 'toy', 'bed', 'toilet_paper', 'television', 'wine', 'curtain', 'food_onion', 'doorjamb', 'dresser', 'spoon', 'home_office', 'table']
Task:Relax on sofa
response:
{
    "thoughts": Walk to living room. Sit on sofa. Lie down on sofa.,
    "actions": ['[WALK] <home_office>', '[WALK] <couch>', '[FIND] <couch>', '[SIT] <couch>', '[LIE] <couch>']
}

Input:
Scene_Objects:['dry_pasta', 'pot', 'filing_cabinet', 'food_pizza', 'chair', 'walllamp', 'detergent', 'food_carrot', 'drawing', 'floor', 'desk', 'alcohol', 'computer', 'brush', 'mat', 'stovefan', 'toaster', 'tvstand', 'foundation', 'pillow', 'wall', 'toy', 'tape', 'bed', 'keys', 'food_rice', 'curtain', 'pencil', 'comb', 'dresser']
Task:Pick up toys
response:

Grab toys off floor.  Put it in a container.

[WALK] <bedroom>
[WALK] <toy>
[FIND] <toy>
[GRAB] <toy>
[WALK] <filing_cabinet>
[OPEN] <filing_cabinet>
[PUTBACK] <toy> <filing_cabinet>
[FIND] <toy>
[GRAB] <toy>
[WALK] <filing_cabinet>
[PUTBACK] <toy> <filing_cabinet>
[FIND] <toy>
[GRAB] <toy>
[WALK] <filing_cabinet>
[PUTBACK] <toy> <filing_cabinet>
[CLOSE] <filing_cabinet>


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', 'trashcan', 'dough', 'orchid', 'knife', 'clothes_underwear', 'phone', 'tea_bag', 'envelope', 'mat', 'faucet', 'clothes_socks', 'clothes_pants', 'clothes_hat', 'bench', 'powersocket', 'basket_for_clothes', 'food_food', 'food_rice', 'tray', 'curtain', 'after_shave', 'doorjamb', 'pencil', 'laundry_detergent', 'bathroom_cabinet', 'table', 'light', '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:['scissors', 'tablelamp', 'chair', 'freezer', 'walllamp', 'drawing', 'wallshelf', 'hanger', 'floor', 'ceiling', 'desk', 'keyboard', 'computer', 'mat', 'tvstand', 'ceilinglamp', 'faucet', 'shower', 'closetdrawer', 'couch', 'pillow', 'wall', 'nightstand', 'photoframe', 'newspaper', 'television', 'doorjamb', 'dresser', 'soap', 'instrument_violin']
Task:Watch TV
response:

I sit on my couch and watch TV in my living room

[WALK] <home_office>
[WALK] <television>
[SWITCHON] <television>
[TURNTO] <television>
[LOOKAT] <television>
[TOUCH] <television>
[TURNTO] <television>
[LOOKAT] <television>
[TOUCH] <television>
[TURNTO] <television>
[LOOKAT] <television>
[WALK] <couch>
[SIT] <couch>
[TURNTO] <television>
[LOOKAT] <television>
[WATCH] <television>
[WATCH] <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:['glue', 'filing_cabinet', 'tablelamp', 'blender', 'milk', 'orchid', 'bathroom_counter', 'floor', 'phone', 'keyboard', 'thread', 'stovefan', 'mat', 'toaster', 'faucet', 'plate', 'couch', 'food_jam', 'pillow', 'dining_room', 'wall', 'wall_clock', 'oven', 'tray', 'curtain', 'mouse', 'sink', 'napkin', 'bathroom_cabinet', 'soap']
Task:Wash hands
response:
{
    "thoughts": walk to bathroom, find sink, turn on faucet, put soap in hands, wash and rinse hands,,
    "actions": ['[WALK] <bathroom>', '[WALK] <sink>', '[FIND] <sink>', '[FIND] <soap>', '[WASH] <soap>', '[RINSE] <soap>']
}

Input:
Scene_Objects:['pot', 'tablelamp', 'chair', 'walllamp', 'drawing', 'orchid', 'cpuscreen', 'wallshelf', 'hanger', 'floor', 'phone', 'ceiling', 'desk', 'stamp', 'keyboard', 'computer', 'mat', 'ceilinglamp', 'tvstand', 'mousepad', 'couch', 'pillow', 'wall', 'nightstand', 'oven', 'powersocket', 'television', 'fax_machine', 'tray', 'doorjamb', 'towel_rack', 'mouse', 'dresser', 'door', 'light']
Task:Write report
response:

Sit at a desk, turn on a computer.  Open an existing document and revise it.  Print a hard copy for mailing.  Email a copy to the client.

[WALK] <home_office>
[WALK] <desk>
[FIND] <computer>
[SWITCHON] <computer>
[FIND] <chair>
[PULL] <chair>
[SIT] <chair>
[TURNTO] <computer>
[LOOKAT] <computer>
[FIND] <mouse>
[GRAB] <mouse>
[PULL] <mouse>
[TOUCH] <mouse>
[TURNTO] <computer>
[LOOKAT] <computer>
[FIND] <keyboard>
[TYPE] <keyboard>
[TURNTO] <computer>
[LOOKAT] <computer>
[TYPE] <keyboard>
[TURNTO] <computer>
[LOOKAT] <computer>
[TYPE] <keyboard>
[TOUCH] <mouse>
[FIND] <fax_machine>
[SWITCHON] <fax_machine>
[SWITCHOFF] <fax_machine>
[SWITCHOFF] <computer>


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

Here is an example plan to achieve a goal for reference:
Scene_Objects:['pot', 'filing_cabinet', 'chair', 'jelly', 'trashcan', 'toothbrush', 'orchid', 'cpuscreen', 'character', 'bookshelf', 'button', 'mat', 'deck_of_cards', 'faucet', 'shower', 'pillow', 'powersocket', 'bench', 'photoframe', 'bed', 'novel', 'coin', 'kitchen_counter', 'headset', 'chessboard', 'comb', 'dresser', 'table', 'coffee', 'creditcard']
Task:Pick up phone
response:
{
    "thoughts": Walk to the entrance hall. Find the telephone. Grab the telephone.,
    "actions": ['[WALK] <home_office>', '[WALK] <phone>', '[FIND] <phone>', '[WALK] <phone>', '[GRAB] <phone>']
}

Input:
Scene_Objects:['tablelamp', 'chair', 'orchid', 'drawing', 'cpuscreen', 'bills', 'floor', 'ceiling', 'phone', 'character', 'desk', 'keyboard', 'computer', 'mail', 'mat', 'ceilinglamp', 'tvstand', 'laptop', 'mousepad', 'clothes_socks', 'wall', 'nightstand', 'oven', 'powersocket', 'television', 'mouse', 'shoes', 'comb', 'door', 'light']
Task:Check email
response:

Turn on laptop.  Connect to Internet.  Type in the url.  Check for new email messages.

[WALK] <home_office>
[WALK] <chair>
[FIND] <chair>
[SIT] <chair>
[FIND] <laptop>
[SWITCHON] <laptop>
[FIND] <keyboard>
[TYPE] <keyboard>
[TURNTO] <laptop>
[LOOKAT] <laptop>
[FIND] <mail>
[GRAB] <mail>
[READ] <mail>


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

Here is an example plan to achieve a goal for reference:
Scene_Objects:['pot', 'tablelamp', 'chair', 'walllamp', 'knifeblock', 'cpuscreen', 'wallshelf', 'bathroom_counter', 'floor', 'ceiling', 'ceilinglamp', 'faucet', 'couch', 'dustpan', 'pillow', 'towel', 'wall', 'nightstand', 'oven', 'box', 'bed', 'keys', 'check', 'toilet_paper', 'television', 'kitchen_counter', 'dresser', 'instrument_guitar', 'soap', 'tooth_paste']
Task:Relax on sofa
response:
{
    "thoughts": Go to living room.  Find sofa.  Sit on sofa.,
    "actions": ['[WALK] <home_office>', '[WALK] <couch>', '[FIND] <couch>', '[SIT] <couch>']
}

Input:
Scene_Objects:['sheets', 'chair', 'drawing', 'wallshelf', 'hanger', 'bathroom_counter', 'floor', 'ceiling', 'purse', 'brush', 'mat', 'stereo', 'clothes_socks', 'closetdrawer', 'couch', 'mousepad', 'pillow', 'bowl', 'wall', 'powersocket', 'photoframe', 'tray', 'doorjamb', 'pencil', 'shoes', 'cd', 'dresser', 'door', 'bathroom_cabinet', 'light']
Task:Take off shoes
response:

Bend down to reach your feet. Shift balance to one leg. Grab the shoe of the foot of the other leg, it is best to use one hand to grip near the front, and one towards the heel. Pull the shoe down toward the ground while also pushing on the heel away from the body. Repeat with other shoe. Place shoes in a designated area.

[WALK] <bedroom>
[WALK] <shoes>
[FIND] <shoes>
[GRAB] <shoes>
[PULL] <shoes>
[WALK] <dresser>
[OPEN] <dresser>
[PUTIN] <shoes> <dresser>
[FIND] <shoes>
[GRAB] <shoes>
[PULL] <shoes>
[WALK] <dresser>
[PUTIN] <shoes> <dresser>
[CLOSE] <dresser>


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

Here is an example plan to achieve a goal for reference:
Scene_Objects:['tablelamp', 'microwave', 'toilet', 'walllamp', 'bathroom', 'drawing', 'orchid', 'knifeblock', 'floor', 'ceiling', 'bookshelf', 'stovefan', 'couch', 'pillow', 'wall', 'nightstand', 'powersocket', 'toy', 'novel', 'coffe_maker', 'television', 'wooden_spoon', 'doorjamb', 'kitchen_counter', 'shoes', 'cupboard', 'door', 'home_office', 'table', 'light']
Task:Read book
response:
{
    "thoughts": Go to the living room and find the book you want to read. Take it and then go to the couch. Sit on it, open the book and start reading.,
    "actions": ['[WALK] <home_office>', '[WALK] <novel>', '[FIND] <novel>', '[GRAB] <novel>', '[FIND] <couch>', '[SIT] <couch>', '[READ] <novel>']
}

Input:
Scene_Objects:['tablelamp', 'beer', 'chair', 'drawing', 'orchid', 'cpuscreen', 'wallshelf', 'floor', 'ceiling', 'phone', 'desk', 'keyboard', 'purse', 'computer', 'food_bacon', 'bookmark', 'mat', 'ceilinglamp', 'tvstand', 'mousepad', 'wall', 'nightstand', 'television', 'food_donut', 'wine', 'tray', 'mouse', 'kitchen_counter', 'door', 'hairdryer']
Task:Read book
response:

Sitting and  reading a hardcover book in a recliner

[RUN] <home_office>
[WALK] <novel>
[FIND] <novel>
[GRAB] <novel>
[RUN] <chair>
[SIT] <chair>
[FIND] <bookmark>
[GRAB] <bookmark>
[DROP] <bookmark>
[TURNTO] <novel>
[LOOKAT] <novel>
[READ] <novel>
[READ] <novel>
[READ] <novel>


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

Here is an example plan to achieve a goal for reference:
Scene_Objects:['tablelamp', 'toilet', 'chair', 'freezer', 'walllamp', 'bathroom', 'nail_polish', 'detergent', 'trashcan', 'drawing', 'floor', 'ceiling', 'desk', 'stamp', 'keyboard', 'computer', 'table_cloth', 'stereo', 'mousepad', 'broom', 'wall', 'nightstand', 'powersocket', 'oven', 'television', 'rag', 'mouse', 'headset', 'door', 'shoe_rack']
Task:Listen to music
response:
{
    "thoughts": I walk to my bedroom.  I locate my stereo and turn it on.  I put on my headphones and sit to listen.,
    "actions": ['[WALK] <bedroom>', '[WALK] <stereo>', '[FIND] <stereo>', '[WALK] <stereo>', '[SWITCHON] <stereo>', '[FIND] <headset>', '[GRAB] <headset>', '[PUTON] <headset>', '[FIND] <chair>', '[SIT] <chair>']
}

Input:
Scene_Objects:['filing_cabinet', 'chair', 'walllamp', 'bathroom', 'drawing', 'orchid', 'wallshelf', 'hanger', 'floor', 'ceiling', 'desk', 'bedroom', 'computer', 'mat', 'tvstand', 'ceilinglamp', 'shower', 'closetdrawer', 'couch', 'pillow', 'dining_room', 'wall', 'box', 'cup', 'photoframe', 'television', 'doorjamb', 'coffee_pot', 'dresser', 'light']
Task:Watch TV
response:

Sit on the couch. Get comfortable. Switch on the television. Stare at the television.

[WALK] <home_office>
[WALK] <television>
[FIND] <television>
[SWITCHON] <television>
[FIND] <couch>
[SIT] <couch>
[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:['water_glass', 'scissors', 'blender', 'chair', 'walllamp', 'drawing', 'wallshelf', 'clothes_underwear', 'floor', 'ceiling', 'character', 'desk', 'computer', 'food_bacon', 'mat', 'tvstand', 'mousepad', 'closetdrawer', 'couch', 'pillow', 'wall', 'cup', 'photoframe', 'newspaper', 'television', 'ice', 'doorjamb', 'diary', 'console', 'towel_rack']
Task:Relax on sofa
response:
{
    "thoughts": Drink a glass of water in the sofa,
    "actions": ['[WALK] <home_office>', '[WALK] <couch>', '[FIND] <couch>', '[SIT] <couch>', '[FIND] <water_glass>', '[GRAB] <water_glass>', '[DRINK] <water_glass>']
}

Input:
Scene_Objects:['food_salt', 'freezer', 'walllamp', 'drawing', 'orchid', 'floor', 'ceiling', 'stamp', 'bookshelf', 'clothes_jacket', 'mop_bucket', 'toaster', 'mat', 'brush', 'shoe-shine_kit', 'laptop', 'couch', 'pillow', 'wall', 'oven', 'cup', 'food_cheese', 'photoframe', 'check', 'television', 'tray', 'food_onion', 'kitchen_counter', 'cupboard', 'bathroom_cabinet']
Task:Eat cheese
response:

[WALK] <dining_room>
[WALK] <freezer>
[OPEN] <freezer>
[FIND] <food_cheese>
[GRAB] <food_cheese>
[EAT] <food_cheese>


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', 'filing_cabinet', 'tablelamp', 'crayon', 'woman', 'wallshelf', 'shampoo', 'floor', 'phone', 'desk', 'man', 'bookshelf', 'closetdrawer', 'couch', 'dining_room', 'nightstand', 'child', 'bed', 'photoframe', 'standingmirror', 'toilet_paper', 'oven_mitts', 'towel_rack', 'kitchen_counter', 'dresser', 'sink', 'bathroom_cabinet', 'clothes_skirt', 'vase']
Task:Say goodbye to guests leaving
response:
{
    "thoughts": Tell them bye,
    "actions": ['[WALK] <home_office>', '[WALK] <child>', '[FIND] <child>', '[TOUCH] <child>', '[FIND] <man>', '[TOUCH] <man>', '[FIND] <woman>', '[TOUCH] <woman>']
}

Input:
Scene_Objects:['food_pizza', 'chair', 'walllamp', 'dough', 'woman', 'drawing', 'wallshelf', 'bathroom_counter', 'floor', 'ceiling', 'bedroom', 'man', 'keyboard', 'computer', 'mat', 'tvstand', 'couch', 'pillow', 'wall', 'nightstand', 'photoframe', 'coffe_maker', 'television', 'coin', 'wooden_spoon', 'doorjamb', 'clothes_dress', 'clothes_scarf', 'table', 'coffee']
Task:Hang with friends
response:

[WALK] <home_office>
[WALK] <man>
[FIND] <man>
[TURNTO] <man>
[LOOKAT] <man>
[GREET] <man>
[FIND] <woman>
[TURNTO] <woman>
[LOOKAT] <woman>
[GREET] <woman>
[WALK] <couch>
[SIT] <couch>
[TURNTO] <man>
[LOOKAT] <man>
[GREET] <man>
[TURNTO] <woman>
[LOOKAT] <woman>
[GREET] <woman>


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', 'freezer', 'cat', 'drawing', 'orchid', 'floor', 'ceiling', 'phone', 'bedroom', 'bookshelf', 'table_cloth', 'ceilinglamp', 'faucet', 'couch', 'clothes_hat', 'pillow', 'wall', 'oven', 'bed', 'photoframe', 'television', 'doorjamb', 'pencil', 'kitchen_counter', 'door', 'bathtub', 'bathroom_cabinet', 'table', 'light']
Task:Pet cat
response:
{
    "thoughts": I would walk into the living room. Then sit on the couch and pet the cat.,
    "actions": ['[WALK] <home_office>', '[WALK] <couch>', '[SIT] <couch>', '[FIND] <cat>', '[TOUCH] <cat>']
}

Input:
Scene_Objects:['pot', 'tablelamp', 'chair', 'walllamp', 'drawing', 'orchid', 'cpuscreen', 'wallshelf', 'hanger', 'floor', 'phone', 'ceiling', 'desk', 'keyboard', 'computer', 'mat', 'ceilinglamp', 'tvstand', 'mousepad', 'couch', 'pillow', 'wall', 'nightstand', 'oven', 'powersocket', 'check', 'television', 'tray', 'doorjamb', 'towel_rack', 'mouse', 'dresser', 'door', 'light']
Task:Do homework
response:

I do my online homework on the computer.  I use Pearson My Math Lab for math class and excel for my engineering class.

[WALK] <home_office>
[WALK] <desk>
[FIND] <chair>
[SIT] <chair>
[FIND] <computer>
[SWITCHON] <computer>
[TURNTO] <computer>
[LOOKAT] <computer>
[FIND] <check>
[GRAB] <check>
[READ] <check>
[FIND] <keyboard>
[TYPE] <keyboard>


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

Here is an example plan to achieve a goal for reference:
Scene_Objects:['microwave', 'chair', 'walllamp', 'orchid', 'bills', 'cpuscreen', 'knifeblock', 'floor', 'ceiling', 'desk', 'keyboard', 'computer', 'ceilinglamp', 'mat', 'mousepad', 'microphone', 'form', 'towel', 'wall', 'oven', 'food_food', 'television', 'ice', 'cards', 'mouse', 'pencil', 'cupboard', 'door', 'clothes_scarf', 'table']
Task:Clean
response:
{
    "thoughts": Wipe down computer desk and monitor,
    "actions": ['[WALK] <home_office>', '[WALK] <rag>', '[FIND] <rag>', '[GRAB] <rag>', '[WALK] <desk>', '[FIND] <computer>', '[WIPE] <computer>', '[WIPE] <desk>', '[PUTOBJBACK] <rag>']
}

Input:
Scene_Objects:['tablelamp', 'chair', 'walllamp', 'bathroom', 'orchid', 'cpuscreen', 'wallshelf', 'hanger', 'bathroom_counter', 'floor', 'ceiling', 'phone', 'desk', 'keyboard', 'computer', 'ceilinglamp', 'tvstand', 'mat', 'laptop', 'mousepad', 'oil', 'couch', 'pillow', 'wall', 'nightstand', 'television', 'doorjamb', 'mouse', 'dresser', 'door']
Task:Write  school paper
response:

Writing  and drafting a paper for  class work

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


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

Here is an example plan to achieve a goal for reference:
Scene_Objects:['sheets', 'fork', 'filing_cabinet', 'tablelamp', 'blender', 'mop', 'bathroom', 'detergent', 'toothbrush', 'bills', 'hanger', 'floor', 'bedroom', 'envelope', 'toaster', 'stovefan', 'clothes_socks', 'mousepad', 'powersocket', 'basket_for_clothes', 'coffe_maker', 'toilet_paper', 'towel_rack', 'clothes_dress', 'bag', 'home_office', 'light', 'vase', 'soap', 'washing_machine']
Task:Wash clothes
response:
{
    "thoughts": 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.,
    "actions": ['[WALK] <bathroom>', '[WALK] <basket_for_clothes>', '[FIND] <basket_for_clothes>', '[FIND] <clothes_dress>', '[GRAB] <clothes_dress>', '[FIND] <washing_machine>', '[WALK] <washing_machine>', '[OPEN] <washing_machine>', '[PUTBACK] <clothes_dress> <washing_machine>', '[FIND] <soap>', '[GRAB] <soap>', '[PUTBACK] <soap> <washing_machine>', '[CLOSE] <washing_machine>', '[SWITCHON] <washing_machine>']
}

Input:
Scene_Objects:['microwave', 'walllamp', 'food_carrot', 'drawing', 'orchid', 'wallshelf', 'floor', 'ceiling', 'shampoo', 'computer', 'food_bacon', 'mat', 'tvstand', 'stereo', 'foundation', 'mousepad', 'couch', 'pillow', 'wall', 'photoframe', 'check', 'video_game_controller', 'television', 'doorjamb', 'kitchen_counter', 'dresser', 'hairdryer', 'bag', 'home_office', 'dishwasher']
Task:Relax
response:

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


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

Here is an example plan to achieve a goal for reference:
Scene_Objects:['fork', 'chair', 'freezer', 'knife', 'drawing', 'needle', 'wallshelf', 'floor', 'phone', 'ceiling', 'dvd_player', 'food_bacon', 'ceilinglamp', 'laptop', 'plate', 'shower', 'tvstand', 'tooth_paste', 'wall', 'tape', 'cup', 'novel', 'food_food', 'television', 'coffee_filter', 'hair', 'cupboard', 'table', 'board_game', 'clothes_shirt']
Task:Eat
response:
{
    "thoughts": I get my prepared dinner set on the dining table, sit down on chair, pick up utensils, eat food,
    "actions": ['[WALK] <dining_room>', '[WALK] <food_food>', '[FIND] <food_food>', '[GRAB] <food_food>', '[WALK] <dining_room>', '[WALK] <table>', '[FIND] <table>', '[PUTBACK] <food_food> <table>', '[FIND] <chair>', '[SIT] <chair>', '[FIND] <fork>', '[GRAB] <fork>', '[FIND] <knife>', '[GRAB] <knife>', '[FIND] <plate>', '[EAT] <plate>']
}

Input:
Scene_Objects:['microwave', 'toilet', 'bathroom', 'orchid', 'hanger', 'bathroom_counter', 'floor', 'ceiling', 'phone', 'character', 'purse', 'computer', 'food_bacon', 'toaster', 'mat', 'closetdrawer', 'candle', 'wall', 'nightstand', 'television', 'curtain', 'doorjamb', 'centerpiece', 'cards', 'shoes', 'dresser', 'hairbrush', 'bathroom_cabinet', 'clothes_shirt', 'shoe_rack']
Task:Put on coat
response:

Open closet and grab coat.  Put on coat and fasten the front closed.  Close closet.

[WALK] <home_office>
[WALK] <dresser>
[FIND] <dresser>
[OPEN] <dresser>
[FIND] <clothes_shirt>
[GRAB] <clothes_shirt>
[PUTON] <clothes_shirt>


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_pizza', 'tablelamp', 'chair', 'detergent', 'bathroom_counter', 'floor', 'ceiling', 'phone', 'desk', 'bookshelf', 'stovefan', 'ceilinglamp', 'mat', 'faucet', 'shower', 'mousepad', 'dustpan', 'dining_room', 'wall', 'powersocket', 'oven', 'check', 'television', 'doorjamb', 'hairbrush', 'controller', 'sink', 'home_office', 'light']
Task:Turn on light
response:
{
    "thoughts": Walk to living room.  Find light switch.  Switch on light switch.,
    "actions": ['[WALK] <home_office>', '[WALK] <light>', '[FIND] <light>', '[SWITCHON] <light>']
}

Input:
Scene_Objects:['sponge', 'filing_cabinet', 'cat', 'food_butter', 'hanger', 'floor', 'ceiling', 'food_cake', 'ceilinglamp', 'deck_of_cards', 'tvstand', 'homework', 'mousepad', 'closetdrawer', 'teeth', 'food_jam', 'nightstand', 'powersocket', 'bed', 'check', 'video_game_controller', 'mouthwash', 'towel_rack', 'mouse', 'console', 'cd', 'cupboard', 'instrument_guitar', 'coffee', 'shoe_rack']
Task:Clean
response:

[WALK] <home_office>
[WALK] <vacuum_cleaner>
[FIND] <vacuum_cleaner>
[GRAB] <vacuum_cleaner>
[SWITCHON] <vacuum_cleaner>
[SWITCHOFF] <vacuum_cleaner>


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

Here is an example plan to achieve a goal for reference:
Scene_Objects:['pot', 'chair', 'band-aids', 'bathroom', 'trashcan', 'phone', 'bedroom', 'bookshelf', 'computer', 'stovefan', 'picture', 'window', 'couch', 'bowl', 'broom', 'wall', 'oven', 'bench', 'cup', 'food_food', 'oven_mitts', 'colander', 'curtain', 'pencil', 'kitchen_counter', 'clothes_dress', 'sink', 'dishwasher', 'soap', 'instrument_violin']
Task:Pet cat
response:
{
    "thoughts": Find Cat in living room.  Walk to cat.  Pet cat.,
    "actions": ['[WALK] <home_office>', '[WALK] <cat>', '[FIND] <cat>', '[TURNTO] <cat>', '[LOOKAT] <cat>', '[TOUCH] <cat>']
}

Input:
Scene_Objects:['pot', 'filing_cabinet', 'mop', 'measuring_cup', 'dog', 'walllamp', 'bathroom', 'food_butter', 'woman', 'cpuscreen', 'floor', 'ceiling', 'character', 'desk', 'man', 'table_cloth', 'electric_shaver', 'dining_room', 'child', 'mouthwash', 'razor', 'rag', 'doorjamb', 'lighter', 'towel_rack', 'mouse', 'shoes', 'hair', 'food_steak', 'soap']
Task:Greet guests
response:

Greet guests when they knock on the door and invite them to enter my home

[WALK] <home_office>
[WALK] <child>
[FIND] <child>
[GREET] <child>
[FIND] <man>
[GREET] <man>
[FIND] <woman>
[GREET] <woman>


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', 'button', 'ceilinglamp', 'tvstand', 'mat', 'mousepad', 'couch', 'pillow', 'wall', 'nightstand', 'food_food', 'television', 'doorjamb', 'mouse', 'dresser', 'door', 'sink']
Task:Work
response:
{
    "thoughts": working on computer,
    "actions": ['[WALK] <home_office>', '[WALK] <home_office>', '[WALK] <computer>', '[FIND] <computer>', '[SWITCHON] <computer>', '[FIND] <button>', '[TURNTO] <button>', '[LOOKAT] <button>', '[FIND] <mouse>', '[GRAB] <mouse>', '[GRAB] <button>', '[FIND] <chair>', '[SIT] <chair>', '[SWITCHOFF] <computer>']
}

Input:
Scene_Objects:['blender', 'chair', 'walllamp', 'detergent', 'milk', 'drawing', 'wallshelf', 'hanger', 'floor', 'ceiling', 'desk', 'bedroom', 'remote_control', 'computer', 'mat', 'tvstand', 'ceilinglamp', 'faucet', 'shower', 'closetdrawer', 'couch', 'pillow', 'wall', 'photoframe', 'television', 'doorjamb', 'diary', 'kitchen_counter', 'dresser', 'napkin']
Task:Watch TV
response:

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


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

Here is an example plan to achieve a goal for reference:
Scene_Objects:['microwave', 'walllamp', 'trashcan', 'drawing', 'floor', 'character', 'toaster', 'plate', 'tvstand', 'foundation', 'dish_soap', 'tooth_paste', 'wall', 'cup', 'coffe_maker', 'food_food', 'food_onion', 'centerpiece', 'cards', 'kettle', 'kitchen_counter', 'vacuum_cleaner', 'cupboard', 'door', 'sink', 'light', 'dishwasher', 'board_game', 'clothes_shirt', 'creditcard']
Task:Wash dishes with dishwasher
response:
{
    "thoughts": Wash a plate using the dishwasher in the kitchen.,
    "actions": ['[WALK] <dining_room>', '[WALK] <dishwasher>', '[FIND] <dishwasher>', '[OPEN] <dishwasher>', '[FIND] <plate>', '[GRAB] <plate>', '[PUTBACK] <plate> <dishwasher>', '[FIND] <dish_soap>', '[GRAB] <dish_soap>', '[PUTBACK] <dish_soap> <dishwasher>', '[CLOSE] <dishwasher>', '[SWITCHON] <dishwasher>']
}

Input:
Scene_Objects:['sponge', 'fork', 'pot', 'chair', 'detergent', 'floor', 'ceiling', 'dvd_player', 'toaster', 'mat', 'faucet', 'dish_soap', 'food_peanut_butter', 'form', 'bowl', 'dining_room', 'wall', 'nightstand', 'cup', 'bed', 'coffe_maker', 'mouthwash', 'check', 'pencil', 'kitchen_counter', 'dishrack', 'cupboard', 'controller', 'sink', 'clothes_shirt']
Task:Wash dishes
response:

Fill sink with warm, sudsy water. Place dirty dishes in soapy water. With a washcloth or sponge scrub dishes clean. Rinse under clean warm water. Place in dish rack to dry.

[WALK] <dining_room>
[WALK] <sink>
[FIND] <faucet>
[SWITCHON] <faucet>
[FIND] <dish_soap>
[GRAB] <dish_soap>
[POUR] <dish_soap> <sink>
[PUTOBJBACK] <dish_soap>
[FIND] <sponge>
[GRAB] <sponge>
[FIND] <bowl>
[GRAB] <bowl>
[SCRUB] <bowl>
[RINSE] <bowl>
[FIND] <dishrack>
[PUTBACK] <bowl> <dishrack>
[FIND] <bowl>
[GRAB] <bowl>
[SCRUB] <bowl>
[RINSE] <bowl>
[PUTBACK] <bowl> <dishrack>
[RINSE] <sponge>
[SWITCHOFF] <faucet>
[PUTOBJBACK] <sponge>


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

Here is an example plan to achieve a goal for reference:
Scene_Objects:['beer', 'walllamp', 'ceilingfan', 'orchid', 'hanger', 'longboard', 'floor', 'ceiling', 'character', 'bedroom', 'folder', 'bookshelf', 'toaster', 'ceilinglamp', 'plate', 'dish_soap', 'candle', 'wall', 'oven', 'bench', 'box', 'cup', 'clothes_gloves', 'coffe_maker', 'tray', 'console', 'maindoor', 'door', 'napkin', 'dishwasher']
Task:Wash dishes with dishwasher
response:
{
    "thoughts": I go to the kitchen and open the dishwasher. I fill it up with dirty dishes and glasses. Then I put dish soap in the dishwasher, close it and turn it on.,
    "actions": ['[WALK] <dining_room>', '[WALK] <dishwasher>', '[FIND] <dishwasher>', '[OPEN] <dishwasher>', '[FIND] <plate>', '[GRAB] <plate>', '[PUTBACK] <plate> <dishwasher>', '[FIND] <plate>', '[GRAB] <plate>', '[PUTBACK] <plate> <dishwasher>', '[FIND] <plate>', '[GRAB] <plate>', '[PUTBACK] <plate> <dishwasher>', '[FIND] <plate>', '[GRAB] <plate>', '[PUTBACK] <plate> <dishwasher>', '[FIND] <plate>', '[GRAB] <plate>', '[PUTBACK] <plate> <dishwasher>', '[FIND] <cup>', '[GRAB] <cup>', '[PUTBACK] <cup> <dishwasher>', '[FIND] <dish_soap>', '[GRAB] <dish_soap>', '[PUTBACK] <dish_soap> <dishwasher>', '[CLOSE] <dishwasher>', '[SWITCHON] <dishwasher>']
}

Input:
Scene_Objects:['sheets', 'filing_cabinet', 'juice', 'measuring_cup', 'walllamp', 'detergent', 'drawing', 'wallshelf', 'cpuscreen', 'floor', 'ceiling', 'character', 'bedroom', 'purse', 'computer', 'mat', 'tvstand', 'shower', 'ceilinglamp', 'couch', 'pillow', 'dining_room', 'wall', 'cup', 'photoframe', 'television', 'doorjamb', 'shaving_cream', 'mouse', 'home_office']
Task:Arrange furniture
response:

[WALK] <home_office>
[WALK] <coffee_table>
[PUSH] <coffee_table>
[WALK] <couch>
[PUSH] <couch>
[WALK] <couch>
[PUSH] <couch>
[WALK] <filing_cabinet>
[PUSH] <filing_cabinet>


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:['dog', 'freezer', 'bathroom', 'food_carrot', 'knifeblock', 'food_egg', 'hanger', 'floor', 'phone', 'stovefan', 'mat', 'plate', 'stereo', 'dish_soap', 'food_noodles', 'closetdrawer', 'mousepad', 'dustpan', 'cup', 'food_food', 'coffe_maker', 'check', 'oven_mitts', 'water', 'food_rice', 'curtain', 'mouse', 'hairbrush', 'sink', 'home_office']
Task:Wash dishes by hand
response:
{
    "thoughts": walk to kitchen, fins soap, arrange dishes, wash dishes,
    "actions": ['[WALK] <dining_room>', '[WALK] <plate>', '[FIND] <plate>', '[FIND] <dish_soap>', '[FIND] <water>', '[GRAB] <plate>', '[GRAB] <dish_soap>', '[WASH] <plate>', '[RINSE] <plate>', '[DROP] <plate>']
}

Input:
Scene_Objects:['glue', 'sheets', 'filing_cabinet', 'food_bread', 'food_salt', 'microwave', 'chair', 'orchid', 'drawing', 'bathroom_counter', 'floor', 'mail', 'stovefan', 'ceilinglamp', 'mat', 'stereo', 'couch', 'wall', 'powersocket', 'cup', 'check', 'mouthwash', 'food_donut', 'tray', 'kitchen_counter', 'cd', 'cupboard', 'controller', 'table', 'teeth']
Task:Play games
response:

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.

[WALK] <home_office>
[WALK] <board_game>
[FIND] <board_game>
[GRAB] <board_game>
[WALK] <dining_room>
[WALK] <table>
[PUTBACK] <board_game> <table>


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', 'blender', 'chair', 'walllamp', 'blow_dryer', 'detergent', 'orchid', 'knife', 'hanger', 'floor', 'ceiling', 'thread', 'ceilinglamp', 'laptop', 'faucet', 'mousepad', 'couch', 'candle', 'food_jam', 'pillow', 'wall', 'nightstand', 'tape', 'television', 'tray', 'after_shave', 'food_onion', 'shoes', 'cupboard']
Task:Relax on sofa
response:
{
    "thoughts": I walk to the living room. I sit in the sofa and I relax.,
    "actions": ['[WALK] <home_office>', '[WALK] <couch>', '[FIND] <couch>', '[SIT] <couch>']
}

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

[WALK] <bedroom>
[WALK] <dresser>
[OPEN] <dresser>
[FIND] <clothes_dress>
[GRAB] <clothes_dress>
[PUTON] <clothes_dress>
[CLOSE] <dresser>


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

Here is an example plan to achieve a goal for reference:
Scene_Objects:['tablelamp', 'chair', 'walllamp', 'drawing', 'wallshelf', 'cpuscreen', 'bathroom_counter', 'floor', 'ceiling', 'phone', 'desk', 'keyboard', 'computer', 'laptop', 'mat', 'tvstand', 'mousepad', 'closetdrawer', 'couch', 'pillow', 'dining_room', 'wall', 'oven', 'cup', 'photoframe', 'television', 'doorjamb', 'mouse', 'door', 'creditcard']
Task:Play on laptop
response:
{
    "thoughts": Sit down on the couch. Place laptop on lap. Open laptop. Turn on laptop. Choose selected program. Play selected program. Close game. Close laptop.,
    "actions": ['[WALK] <home_office>', '[WALK] <laptop>', '[FIND] <laptop>', '[GRAB] <laptop>', '[FIND] <couch>', '[SIT] <couch>', '[SWITCHON] <laptop>', '[FIND] <keyboard>', '[TYPE] <keyboard>', '[SWITCHOFF] <laptop>', '[PUTOBJBACK] <laptop>']
}

Input:
Scene_Objects:['dry_pasta', 'pot', 'tablelamp', 'juice', 'microwave', 'freezer', 'dough', 'drawing', 'cpuscreen', 'floor', 'ceiling', 'desk', 'keyboard', 'stovefan', 'mat', 'shower', 'couch', 'pillow', 'wall', 'pasta', 'oven', 'powersocket', 'food_vegetable', 'food_food', 'television', 'ice', 'tray', 'doorjamb', 'towel_rack', 'kitchen_counter', 'cupboard', 'door', 'light']
Task:Cook some food
response:

I prepare meals and cook them on the stove.

[WALK] <dining_room>
[WALK] <freezer>
[OPEN] <freezer>
[FIND] <food_vegetable>
[GRAB] <food_vegetable>
[CLOSE] <freezer>
[FIND] <oven>
[SWITCHON] <oven>
[SWITCHOFF] <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:['sponge', 'microwave', 'walllamp', 'trashcan', 'drawing', 'floor', 'ceiling', 'button', 'toaster', 'window', 'mousepad', 'clothes_pants', 'wall', 'basket_for_clothes', 'coffe_maker', 'check', 'television', 'toothbrush_holder', 'ice', 'diary', 'mouse', 'kitchen_counter', 'vacuum_cleaner', 'cupboard', 'pajamas', 'napkin', 'coffee_cup', 'dishwasher', 'soap', 'coffee']
Task:Make coffee
response:
{
    "thoughts": Walk to the kitchen at the coffee maker, grab coffee, pour coffee into coffee maker, put coffee into coffee maker, push coffee maker's button, wait to complete, grab coffee cup,
    "actions": ['[WALK] <dining_room>', '[WALK] <coffe_maker>', '[FIND] <coffee>', '[GRAB] <coffee>', '[OPEN] <coffe_maker>', '[POUR] <coffee> <coffe_maker>', '[FIND] <coffee_cup>', '[GRAB] <coffee_cup>', '[PUTBACK] <coffee_cup> <coffe_maker>', '[FIND] <button>', '[PUSH] <button>', '[GRAB] <coffee_cup>']
}

Input:
Scene_Objects:['chair', 'walllamp', 'drawing', 'wallshelf', 'cpuscreen', 'hanger', 'floor', 'ceiling', 'phone', 'desk', 'remote_control', 'computer', 'clothes_jacket', 'mat', 'tvstand', 'ceilinglamp', 'closetdrawer', 'couch', 'pillow', 'wall', 'photoframe', 'television', 'tray', 'food_onion', 'doorjamb', 'shoes', 'dresser', 'sink', 'table', 'tooth_paste']
Task:Change TV channel
response:

I go to the living room, I settle on the sofa, I turn on the television, change the channel

[WALK] <home_office>
[WALK] <couch>
[FIND] <couch>
[SIT] <couch>
[FIND] <shoes>
[FIND] <shoes>
[GRAB] <shoes>
[DROP] <shoes>
[FIND] <remote_control>
[GRAB] <remote_control>
[FIND] <television>
[SWITCHON] <television>
[TURNTO] <television>
[WATCH] <television>


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

Here is an example plan to achieve a goal for reference:
Scene_Objects:['measuring_cup', 'chair', 'walllamp', 'drawing', 'orchid', 'wallshelf', 'floor', 'bookshelf', 'brush', 'mat', 'stereo', 'picture', 'window', 'couch', 'pillow', 'wall', 'powersocket', 'oven', 'shelf', 'cup', 'television', 'wine', 'curtain', 'food_onion', 'doorjamb', 'towel_rack', 'mouse', 'cd', 'home_office', 'table']
Task:Listen to music
response:
{
    "thoughts": Walk to living room. Walk to radio. Switch on the radio. Walk to sofa and sit on it.,
    "actions": ['[WALK] <home_office>', '[WALK] <stereo>', '[SWITCHON] <stereo>', '[WALK] <couch>', '[SIT] <couch>']
}

Input:
Scene_Objects:['pot', 'tablelamp', 'chair', 'walllamp', 'drawing', 'orchid', 'cpuscreen', 'wallshelf', 'hanger', 'floor', 'phone', 'ceiling', 'desk', 'keyboard', 'computer', 'mat', 'ceilinglamp', 'tvstand', 'mousepad', 'couch', 'pillow', 'wall', 'nightstand', 'oven', 'powersocket', 'television', 'tray', 'doorjamb', 'towel_rack', 'mouse', 'dresser', 'door', 'light']
Task:Work
response:

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


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

Here is an example plan to achieve a goal for reference:
Scene_Objects:['toilet', 'walllamp', 'ceilingfan', 'drawing', 'cpuscreen', 'floor', 'purse', 'stovefan', 'ceilinglamp', 'stereo', 'faucet', 'window', 'balanceball', 'electric_shaver', 'couch', 'wall', 'bench', 'food_food', 'television', 'curtain', 'diary', 'mouse', 'dresser', 'hair', 'bathroom_cabinet', 'table', 'home_office', 'vase', 'teeth', 'shoe_rack']
Task:Relax on sofa
response:
{
    "thoughts": Walk into the living room. Walk to the sofa and sit on it. Put your feet up on the sofa and lay down.,
    "actions": ['[WALK] <home_office>', '[WALK] <couch>', '[SIT] <couch>', '[LIE] <couch>']
}

Input:
Scene_Objects:['filing_cabinet', 'tablelamp', 'microwave', 'walllamp', 'drawing', 'orchid', 'wallshelf', 'floor', 'ceiling', 'bookshelf', 'computer', 'mat', 'tvstand', 'ceilinglamp', 'clothes_socks', 'couch', 'pillow', 'wall', 'powersocket', 'box', 'cup', 'photoframe', 'television', 'food_rice', 'doorjamb', 'towel_rack', 'kitchen_counter', 'door', 'home_office', 'soap']
Task:Relax on sofa
response:

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.

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


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

Here is an example plan to achieve a goal for reference:
Scene_Objects:['food_pizza', 'tablelamp', 'toilet', 'chair', 'walllamp', 'trashcan', 'ceilingfan', 'drawing', 'cpuscreen', 'floor', 'ceiling', 'phone', 'desk', 'keyboard', 'bookshelf', 'computer', 'ceilinglamp', 'balanceball', 'faucet', 'mousepad', 'wall', 'nightstand', 'cup', 'coffe_maker', 'doorjamb', 'mouse', 'chessboard', 'controller', 'bathroom_cabinet', 'light']
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:['pot', 'mop', 'toilet', 'freezer', 'walllamp', 'bathroom', 'cat', 'food_butter', 'drawing', 'wallshelf', 'hanger', 'floor', 'ceiling', 'computer', 'mat', 'tvstand', 'iron', 'mousepad', 'couch', 'pillow', 'wall', 'nightstand', 'toy', 'tape', 'photoframe', 'television', 'food_rice', 'doorjamb', 'cards', 'door']
Task:Relax on sofa
response:

walk into living room, look at the sofa which one is available, sit on the sofa, now take relax on the sofa

[WALK] <home_office>
[WALK] <couch>
[FIND] <couch>
[TURNTO] <couch>
[LOOKAT] <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:['glue', 'tablelamp', 'chair', 'walllamp', 'bathroom', 'trashcan', 'ceilingfan', 'hanger', 'floor', 'ceiling', 'phone', 'desk', 'computer', 'laptop', 'balanceball', 'mousepad', 'pillow', 'wall', 'cup', 'bed', 'television', 'razor', 'doorjamb', 'kitchen_counter', 'dresser', 'cupboard', 'door', 'spoon', 'light', 'vase']
Task:Turn on light
response:
{
    "thoughts": push any ligth button to turn it on, for example in the living room,
    "actions": ['[WALK] <home_office>', '[WALK] <light>', '[FIND] <light>', '[SWITCHON] <light>']
}

Input:
Scene_Objects:['spectacles', 'pot', 'tablelamp', 'chair', 'drawing', 'cpuscreen', 'floor', 'phone', 'desk', 'keyboard', 'computer', 'mat', 'mousepad', 'couch', 'form', 'wall', 'oven', 'powersocket', 'tape', 'cup', 'check', 'television', 'tray', 'doorjamb', 'towel_rack', 'mouse', 'vacuum_cleaner', 'shoes', 'door', 'light']
Task:Pick up phone
response:

I go to my home office. I walk towards my desk. I see the phone. I pick it up.

[WALK] <home_office>
[WALK] <desk>
[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:['fork', 'tablelamp', 'toilet', 'chair', 'walllamp', 'floor', 'ceiling', 'phone', 'keyboard', 'envelope', 'toaster', 'ceilinglamp', 'stereo', 'faucet', 'window', 'couch', 'pillow', 'wall', 'nightstand', 'powersocket', 'cup', 'clothes_gloves', 'novel', 'check', 'video_game_controller', 'television', 'kitchen_counter', 'hairdryer', 'light', 'table']
Task:Relax on sofa
response:
{
    "thoughts": Walk to the living room. Walk to the sofa and sit on the sofa.,
    "actions": ['[WALK] <home_office>', '[WALK] <couch>', '[SIT] <couch>']
}

Input:
Scene_Objects:['pot', 'food_bread', 'tablelamp', 'microwave', 'freezer', 'food_butter', 'drawing', 'wallshelf', 'cpuscreen', 'hanger', 'kitchen_cabinet', 'floor', 'ceiling', 'food_chicken', 'desk', 'keyboard', 'stovefan', 'mat', 'tvstand', 'shower', 'closetdrawer', 'couch', 'pillow', 'wall', 'nightstand', 'powersocket', 'oven', 'food_cheese', 'photoframe', 'food_food', 'television', 'wine', 'tray', 'doorjamb', 'towel_rack', 'kitchen_counter', 'dresser', 'cupboard', 'door', 'light', 'dishwasher']
Task:Cook some food
response:

I walk into the kitchen and walk over the cabinent. I pull out a pan and walk to the stove. I put the pan on the stove and walk over to the fridge. I pull out out meat from the fridge and walk back over the stove. Then I put the meat in the pan.

[WALK] <dining_room>
[WALK] <light>
[FIND] <light>
[SWITCHON] <light>
[WALK] <kitchen_cabinet>
[FIND] <pot>
[GRAB] <pot>
[WALK] <oven>
[PUTBACK] <pot> <oven>
[WALK] <freezer>
[OPEN] <freezer>
[FIND] <food_chicken>
[GRAB] <food_chicken>
[WALK] <oven>
[PUTBACK] <food_chicken> <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:['spectacles', 'sheets', 'chair', 'ground_coffee', 'walllamp', 'hanger', 'longboard', 'floor', 'ceiling', 'phone', 'bookshelf', 'keyboard', 'computer', 'stovefan', 'tvstand', 'stereo', 'window', 'clothes_hat', 'wall', 'nightstand', 'bench', 'box', 'food_cheese', 'doorjamb', 'mouse', 'dresser', 'cupboard', 'hair', 'door', 'light']
Task:Turn on light
response:
{
    "thoughts": Walk to living room.  Find light switch.  Switch on light switch.,
    "actions": ['[WALK] <home_office>', '[WALK] <light>', '[FIND] <light>', '[SWITCHON] <light>']
}

Input:
Scene_Objects:['sheets', 'walllamp', 'drawing', 'needle', 'wallshelf', 'floor', 'ceiling', 'shampoo', 'character', 'computer', 'toaster', 'mat', 'tvstand', 'deck_of_cards', 'stovefan', 'ceilinglamp', 'couch', 'pillow', 'wall', 'nightstand', 'photoframe', 'coffe_maker', 'television', 'tray', 'doorjamb', 'pencil', 'conditioner', 'door', 'table', 'dishwasher']
Task:Relax on sofa
response:

Walk to living room. Find couch. Sit on couch

[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:['toilet', 'walllamp', 'bathroom', 'drawing', 'cpuscreen', 'floor', 'dvd_player', 'desk', 'bedroom', 'bookshelf', 'computer', 'toaster', 'mat', 'tvstand', 'ceilinglamp', 'window', 'closetdrawer', 'couch', 'pillow', 'wall', 'nightstand', 'television', 'tray', 'curtain', 'controller', 'sink', 'bathroom_cabinet', 'table', 'home_office', 'light']
Task:Listen to music
response:
{
    "thoughts": walk to living room, look at the DVD player, switch on the dvd player, look at the sofa, sit on the sofa and listen the music,
    "actions": ['[WALK] <home_office>', '[WALK] <dvd_player>', '[FIND] <dvd_player>', '[TURNTO] <dvd_player>', '[LOOKAT] <dvd_player>', '[SWITCHON] <dvd_player>', '[FIND] <couch>', '[TURNTO] <couch>', '[LOOKAT] <couch>', '[SIT] <couch>']
}

Input:
Scene_Objects:['tablelamp', 'chair', 'walllamp', 'orchid', 'drawing', 'cpuscreen', 'wallshelf', 'hanger', 'floor', 'ceiling', 'phone', 'desk', 'keyboard', 'computer', 'ceilinglamp', 'tvstand', 'mat', 'laptop', 'mousepad', 'couch', 'pillow', 'wall', 'nightstand', 'oven', 'television', 'doorjamb', 'mouse', 'dresser', 'door', 'soap']
Task:Work
response:

Sit in front of the computer, switch on the computer and start typing (Work)

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


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

Here is an example plan to achieve a goal for reference:
Scene_Objects:['dry_pasta', 'pot', 'ceilingfan', 'toothbrush', 'knifeblock', 'drawing', 'bathroom_counter', 'floor', 'ceiling', 'phone', 'piano_bench', 'toaster', 'faucet', 'window', 'mousepad', 'clothes_pants', 'wall', 'nightstand', 'pasta', 'photoframe', 'toothbrush_holder', 'shoes', 'dresser', 'clothes_dress', 'door', 'sink', 'bathroom_cabinet', 'clothes_skirt', 'tooth_paste', 'laser_pointer']
Task:Brush teeth
response:
{
    "thoughts": go to bathroom. grab toothbrush. put toothpaste on toothbrush. brush teeth. turn on faucet. rinse toothbrush and mouth. put toothbrush away.,
    "actions": ['[WALK] <bathroom>', '[WALK] <sink>', '[FIND] <toothbrush_holder>', '[TURNTO] <toothbrush_holder>', '[LOOKAT] <toothbrush_holder>', '[FIND] <tooth_paste>', '[GRAB] <tooth_paste>', '[FIND] <toothbrush>', '[GRAB] <toothbrush>', '[PUTBACK] <tooth_paste> <toothbrush_holder>', '[FIND] <faucet>', '[SWITCHON] <faucet>', '[RINSE] <toothbrush>', '[PUTBACK] <toothbrush> <toothbrush_holder>']
}

Input:
Scene_Objects:['measuring_cup', 'chair', 'walllamp', 'food_butter', 'drawing', 'wallshelf', 'floor', 'ceiling', 'character', 'computer', 'mat', 'tvstand', 'couch', 'pillow', 'dining_room', 'wall', 'nightstand', 'oven', 'photoframe', 'bed', 'coffe_maker', 'television', 'food_donut', 'tray', 'curtain', 'doorjamb', 'pencil', 'dresser', 'napkin', 'dirt']
Task:Relax on sofa
response:

move to living room, locate sofa, move to sofa, sit on sofa, lie on sofa

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


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

Here is an example plan to achieve a goal for reference:
Scene_Objects:['filing_cabinet', 'mop', 'cd_player', 'chair', 'knifeblock', 'music_stand', 'floor', 'ceiling', 'character', 'bedroom', 'desk', 'envelope', 'food_bacon', 'mop_bucket', 'stovefan', 'ceilinglamp', 'shower', 'nightstand', 'bed', 'photoframe', 'coffe_maker', 'tray', 'curtain', 'lighter', 'kitchen_counter', 'comb', 'dresser', 'cupboard', 'bathroom_cabinet', 'light']
Task:Listen to music
response:
{
    "thoughts": Walk to the living and turn to the music stand. Switch on the CD player to listen to music.,
    "actions": ['[WALK] <home_office>', '[WALK] <music_stand>', '[FIND] <music_stand>', '[TURNTO] <music_stand>', '[FIND] <cd_player>', '[SWITCHON] <cd_player>']
}

Input:
Scene_Objects:['microwave', 'walllamp', 'orchid', 'drawing', 'floor', 'ceiling', 'toaster', 'food_noodles', 'mousepad', 'food_peanut_butter', 'wall', 'oven', 'cup', 'bed', 'photoframe', 'coffe_maker', 'toilet_paper', 'television', 'coffee_filter', 'ice', 'curtain', 'console', 'kitchen_counter', 'cupboard', 'sink', 'clothes_scarf', 'dishwasher', 'soap', 'dirt', 'coffee']
Task:Make coffee
response:

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

[WALK] <dining_room>
[WALK] <coffe_maker>
[FIND] <coffe_maker>
[OPEN] <coffe_maker>
[FIND] <coffee_filter>
[GRAB] <coffee_filter>
[PUTBACK] <coffee_filter> <coffe_maker>
[FIND] <coffee>
[GRAB] <coffee>
[PUTBACK] <coffee> <coffe_maker>


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', 'juice', 'walllamp', 'bathroom', 'drawing', 'orchid', 'wallshelf', 'floor', 'ceiling', 'bookshelf', 'remote_control', 'mat', 'tvstand', 'ceilinglamp', 'shower', 'window', 'couch', 'pillow', 'wall', 'powersocket', 'oven', 'cup', 'photoframe', 'coffee_table', 'television', 'curtain', 'doorjamb', 'door', 'table', 'light']
Task:Watch TV
response:
{
    "thoughts": Sit down, turn on the TV with the remote control that is on the coffee table.,
    "actions": ['[WALK] <home_office>', '[WALK] <couch>', '[FIND] <couch>', '[SIT] <couch>', '[FIND] <coffee_table>', '[TURNTO] <coffee_table>', '[LOOKAT] <coffee_table>', '[FIND] <remote_control>', '[GRAB] <remote_control>', '[FIND] <television>', '[TURNTO] <television>', '[LOOKAT] <television>', '[TURNTO] <television>', '[POINTAT] <television>', '[SWITCHON] <television>']
}

Input:
Scene_Objects:['chair', 'jelly', 'walllamp', 'drawing', 'knife', 'wallshelf', 'orchid', 'hanger', 'floor', 'ceiling', 'phone', 'character', 'desk', 'remote_control', 'computer', 'mat', 'tvstand', 'ceilinglamp', 'closetdrawer', 'couch', 'candle', 'pillow', 'wall', 'photoframe', 'television', 'tray', 'doorjamb', 'towel_rack', 'dresser', 'sink']
Task:Watch TV
response:

Walk to Living room. Find Television. Walk to sofa. Sit on sofa. Find Remote. Grab remote. Turn to television. Look at television. Switch on Television.

[WALK] <home_office>
[WALK] <television>
[FIND] <television>
[WALK] <couch>
[SIT] <couch>
[FIND] <remote_control>
[GRAB] <remote_control>
[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:['food_bread', 'toilet', 'walllamp', 'bills', 'drawing', 'cpuscreen', 'bathroom_counter', 'ceiling', 'cleaning_solution', 'mop_bucket', 'table_cloth', 'faucet', 'shower', 'iron', 'clothes_socks', 'pillow', 'wall', 'food_food', 'mirror', 'wine', 'doorjamb', 'coffee_pot', 'paper_towel', 'cupboard', 'conditioner', 'door', 'sink', 'bathroom_cabinet', 'dishwasher', 'scrabble']
Task:Clean mirror
response:
{
    "thoughts": First spray the mirrors with Windex or window type spray.  Take paper towels and wipe until sparkly clean.  If they have streaks, repeat the process.,
    "actions": ['[WALK] <bathroom>', '[WALK] <bathroom_cabinet>', '[OPEN] <bathroom_cabinet>', '[FIND] <paper_towel>', '[GRAB] <paper_towel>', '[CLOSE] <bathroom_cabinet>', '[WALK] <mirror>', '[FIND] <cleaning_solution>', '[RINSE] <cleaning_solution>', '[WIPE] <mirror>']
}

Input:
Scene_Objects:['pot', 'tablelamp', 'chair', 'walllamp', 'drawing', 'orchid', 'cpuscreen', 'wallshelf', 'hanger', 'floor', 'phone', 'ceiling', 'desk', 'keyboard', 'computer', 'mat', 'ceilinglamp', 'tvstand', 'picture', 'mousepad', 'couch', 'pillow', 'wall', 'nightstand', 'oven', 'powersocket', 'tape', 'check', 'television', 'tray', 'doorjamb', 'towel_rack', 'mouse', 'pencil', 'comb', 'dresser', 'door', 'light']
Task:Work
response:

Walk to home office, walk to desk, sit in chair, turn on computer, look at computer, click mouse and type on keyboard.

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


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

Here is an example plan to achieve a goal for reference:
Scene_Objects:['sheets', 'spectacles', 'glue', 'jelly', 'freezer', 'detergent', 'food_carrot', 'orchid', 'clothes_underwear', 'hanger', 'floor', 'bedroom', 'thread', 'bookmark', 'mat', 'stereo', 'shower', 'mousepad', 'oil', 'nightstand', 'light_bulb', 'coffe_maker', 'television', 'tray', 'pencil', 'shoes', 'bathroom_cabinet', 'dishwasher', 'colander', 'dirt']
Task:Pick up phone
response:
{
    "thoughts": Go to the living room.  Find the telephone.  Lift up the receiver.,
    "actions": ['[WALK] <home_office>', '[WALK] <phone>', '[FIND] <phone>', '[GRAB] <phone>']
}

Input:
Scene_Objects:['tablelamp', 'chair', 'ground_coffee', 'drawing', 'orchid', 'cpuscreen', 'floor', 'ceiling', 'desk', 'keyboard', 'computer', 'table_cloth', 'piano_bench', 'mat', 'ceilinglamp', 'tvstand', 'laptop', 'stereo', 'deck_of_cards', 'mousepad', 'dining_room', 'wall', 'nightstand', 'powersocket', 'television', 'food_rice', 'mouse', 'door', 'table', 'laser_pointer']
Task:Work
response:

Go to the office and sit on the chair, then work on the computer

[WALK] <home_office>
[WALK] <chair>
[FIND] <chair>
[SIT] <chair>
[FIND] <laptop>
[TURNTO] <laptop>
[LOOKAT] <laptop>


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

Here is an example plan to achieve a goal for reference:
Scene_Objects:['pot', 'tablelamp', 'microwave', 'ground_coffee', 'food_carrot', 'drawing', 'knifeblock', 'cpuscreen', 'hanger', 'floor', 'toaster', 'plate', 'faucet', 'foundation', 'mousepad', 'food_jam', 'food_kiwi', 'wall', 'pasta', 'powersocket', 'food_food', 'coffe_maker', 'rag', 'shaving_cream', 'kitchen_counter', 'dishrack', 'dresser', 'cupboard', 'sink', 'dishwasher']
Task:Wash dishes with dishwasher
response:
{
    "thoughts": Take a dish and put it in the dishwasher to be washed,
    "actions": ['[WALK] <dining_room>', '[WALK] <sink>', '[FIND] <plate>', '[GRAB] <plate>', '[FIND] <dishwasher>', '[OPEN] <dishwasher>', '[PUTBACK] <plate> <dishwasher>', '[FIND] <dishwasher>', '[CLOSE] <dishwasher>', '[SWITCHON] <dishwasher>']
}

Input:
Scene_Objects:['tablelamp', 'chair', 'walllamp', 'drawing', 'orchid', 'wallshelf', 'cpuscreen', 'hanger', 'floor', 'ceiling', 'desk', 'keyboard', 'computer', 'mat', 'tvstand', 'ceilinglamp', 'mousepad', 'closetdrawer', 'couch', 'pillow', 'wall', 'nightstand', 'photoframe', 'television', 'oven_mitts', 'tray', 'doorjamb', 'mouse', 'dresser', 'door']
Task:Watch TV
response:

Go to entrance hall, switch on TV, sit back in a chair and using remote watch your favorite program.

[WALK] <home_office>
[WALK] <television>
[FIND] <television>
[SWITCHON] <television>
[WALK] <chair>
[SIT] <chair>
[TURNTO] <television>
[WATCH] <television>
[SWITCHOFF] <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:['toilet', 'band-aids', 'drawing', 'orchid', 'kitchen_cabinet', 'floor', 'bathroom_counter', 'phone', 'bookshelf', 'computer', 'stovefan', 'mat', 'plate', 'ceilinglamp', 'tvstand', 'window', 'couch', 'food_peanut_butter', 'pillow', 'wall', 'nightstand', 'bench', 'powersocket', 'oven', 'cutting_board', 'curtain', 'mouse', 'table', 'dishwasher', 'light']
Task:Set up table
response:
{
    "thoughts": Walk to the kitchen. Open the kitchen cabinet. Grab the plate and put it on the table.,
    "actions": ['[WALK] <dining_room>', '[WALK] <kitchen_cabinet>', '[FIND] <kitchen_cabinet>', '[OPEN] <kitchen_cabinet>', '[FIND] <plate>', '[GRAB] <plate>', '[FIND] <table>', '[PUTBACK] <plate> <table>']
}

Input:
Scene_Objects:['juice', 'walllamp', 'nail_polish', 'detergent', 'dough', 'drawing', 'food_egg', 'tea_bag', 'bookshelf', 'remote_control', 'alcohol', 'button', 'mop_bucket', 'table_cloth', 'stovefan', 'tvstand', 'shoe-shine_kit', 'shower', 'stereo', 'deck_of_cards', 'mousepad', 'powersocket', 'check', 'rag', 'towel_rack', 'pencil', 'conditioner', 'door', 'bathroom_cabinet', 'soap']
Task:Change TV channel
response:

Take the Tv Remote Control  in the Living Room table And Press the Channel Change Button to change the channel

[WALK] <home_office>
[WALK] <remote_control>
[FIND] <remote_control>
[GRAB] <remote_control>
[FIND] <button>
[PUSH] <button>
[PUTOBJBACK] <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:['spectacles', 'filing_cabinet', 'walllamp', 'drawing', 'floor', 'desk', 'tea_bag', 'computer', 'clothes_jacket', 'toaster', 'mat', 'mousepad', 'closetdrawer', 'towel', 'tape', 'basket_for_clothes', 'bed', 'curtain', 'shaving_cream', 'towel_rack', 'mouse', 'kitchen_counter', 'chessboard', 'dresser', 'hair', 'laundry_detergent', 'bathroom_cabinet', 'light', 'board_game', 'dirt']
Task:Open front door
response:
{
    "thoughts": Walk over to the front door, turn the knob, and open the door.,
    "actions": ['[WALK] <home_office>']
}

Input:
Scene_Objects:['scissors', 'chair', 'walllamp', 'drawing', 'wallshelf', 'hanger', 'floor', 'ceiling', 'character', 'desk', 'bookshelf', 'remote_control', 'computer', 'button', 'mat', 'tvstand', 'ceilinglamp', 'food_noodles', 'closetdrawer', 'couch', 'pillow', 'wall', 'photoframe', 'television', 'doorjamb', 'kitchen_counter', 'headset', 'dresser', 'food_steak', 'sink']
Task:Change TV channel
response:

[WALK] <home_office>
[WALK] <television>
[SWITCHON] <television>
[FIND] <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:['filing_cabinet', 'juice', 'chair', 'blow_dryer', 'bathroom_counter', 'floor', 'ceiling', 'bedroom', 'toaster', 'laptop', 'deck_of_cards', 'faucet', 'food_noodles', 'closetdrawer', 'food_orange', 'wall', 'nightstand', 'clothes_gloves', 'coffe_maker', 'toilet_paper', 'food_food', 'curtain', 'towel_rack', 'console', 'kitchen_counter', 'shoes', 'cupboard', 'sink', 'spoon', 'dishwasher']
Task:Make coffee
response:
{
    "thoughts": Making coffee,
    "actions": ['[WALK] <dining_room>', '[WALK] <coffe_maker>', '[FIND] <coffe_maker>', '[SWITCHON] <coffe_maker>']
}

Input:
Scene_Objects:['glue', 'food_pizza', 'toilet', 'chair', 'bathroom_counter', 'floor', 'ceiling', 'cleaning_solution', 'food_bacon', 'mop_bucket', 'toaster', 'stovefan', 'faucet', 'shower', 'mousepad', 'dustpan', 'pillow', 'wall', 'nightstand', 'powersocket', 'coffe_maker', 'console', 'towel_rack', 'kitchen_counter', 'chessboard', 'cupboard', 'pajamas', 'sink', 'napkin', 'hands_both']
Task:Wash hands
response:

[WALK] <dining_room>
[WALK] <faucet>
[FIND] <faucet>
[SWITCHON] <faucet>
[FIND] <hands_both>
[RINSE] <hands_both>
[SWITCHOFF] <faucet>
[FIND] <cleaning_solution>
[SQUEEZE] <cleaning_solution>
[SCRUB] <hands_both>
[SWITCHON] <faucet>
[RINSE] <hands_both>
[SWITCHOFF] <faucet>


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

Here is an example plan to achieve a goal for reference:
Scene_Objects:['pot', 'filing_cabinet', 'tablelamp', 'scissors', 'freezer', 'ceilingfan', 'knifeblock', 'knife', 'hanger', 'phone', 'desk', 'clothes_jacket', 'toaster', 'ceilinglamp', 'electric_shaver', 'window', 'mousepad', 'couch', 'candle', 'cutting_board', 'food_cheese', 'food_rice', 'food_onion', 'pencil', 'cd', 'comb', 'door', 'maindoor', 'napkin', 'soap']
Task:Pet cat
response:
{
    "thoughts": You walk to the living room and find the cat. You look at the cat and touch it to pet it.,
    "actions": ['[WALK] <home_office>', '[WALK] <cat>', '[FIND] <cat>', '[TURNTO] <cat>', '[LOOKAT] <cat>', '[TOUCH] <cat>']
}

Input:
Scene_Objects:['filing_cabinet', 'microwave', 'toilet', 'bathroom', 'cat', 'drawing', 'cpuscreen', 'hanger', 'bathroom_counter', 'bedroom', 'food_bacon', 'piano_bench', 'bookmark', 'stovefan', 'ceilinglamp', 'laptop', 'shower', 'stereo', 'mat', 'couch', 'nightstand', 'wall', 'photoframe', 'coffee_filter', 'towel_rack', 'dishrack', 'controller', 'table', 'clothes_skirt', 'soap']
Task:Pick up phone
response:

[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:['sponge', 'scissors', 'microwave', 'bathroom', 'drawing', 'knifeblock', 'floor', 'bedroom', 'desk', 'toaster', 'mat', 'plate', 'faucet', 'shower', 'closetdrawer', 'wall', 'powersocket', 'newspaper', 'photoframe', 'bed', 'check', 'food_rice', 'ice', 'curtain', 'mouse', 'kitchen_counter', 'cupboard', 'sink', 'instrument_guitar', 'board_game']
Task:Wash dishes by hand
response:
{
    "thoughts": go into the kitchen, walk to the sink. Turn on the water and rinse of a plate and clean them off fully with a sponge.,
    "actions": ['[WALK] <dining_room>', '[WALK] <sink>', '[FIND] <plate>', '[RINSE] <plate>', '[FIND] <sponge>', '[GRAB] <sponge>', '[WASH] <plate>']
}

Input:
Scene_Objects:['pot', 'food_ice_cream', 'food_salt', 'measuring_cup', 'mop', 'chair', 'walllamp', 'cat', 'wallshelf', 'cpuscreen', 'floor', 'ceiling', 'bookshelf', 'computer', 'mat', 'clothes_pants', 'oven', 'check', 'toilet_paper', 'oven_mitts', 'food_donut', 'after_shave', 'lighter', 'cards', 'headset', 'instrument_violin', 'instrument_guitar', 'light', 'board_game', 'teeth']
Task:Pet cat
response:

I go to the living room then go to the cat and touch it.

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


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

Here is an example plan to achieve a goal for reference:
Scene_Objects:['sheets', 'pot', 'chair', 'walllamp', 'food_butter', 'orchid', 'drawing', 'cpuscreen', 'floor', 'ceiling', 'desk', 'keyboard', 'bookshelf', 'computer', 'mat', 'shower', 'picture', 'mousepad', 'pillow', 'wall', 'oven', 'powersocket', 'bed', 'photoframe', 'food_donut', 'tray', 'mouse', 'pencil', 'bag', 'soap']
Task:Read book
response:
{
    "thoughts": go to living room,find the text book on the self ,sat on the chair ,open and read the book,
    "actions": ['[WALK] <home_office>', '[WALK] <novel>', '[FIND] <novel>', '[GRAB] <novel>', '[WALK] <home_office>', '[WALK] <chair>', '[FIND] <chair>', '[SIT] <chair>', '[READ] <novel>']
}

Input:
Scene_Objects:['pot', 'freezer', 'drawing', 'orchid', 'cpuscreen', 'floor', 'ceiling', 'mat', 'ceilinglamp', 'shower', 'clothes_socks', 'mousepad', 'couch', 'food_peanut_butter', 'pillow', 'wall', 'oven', 'food_food', 'television', 'tray', 'wooden_spoon', 'food_onion', 'pencil', 'kitchen_counter', 'vacuum_cleaner', 'cupboard', 'hairdryer', 'door', 'dishwasher', 'clothes_skirt']
Task:Put groceries in Fridge
response:

Open the fridge, put the groceries in the fridge and close it.

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


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

Here is an example plan to achieve a goal for reference:
Scene_Objects:['tablelamp', 'chair', 'freezer', 'bathroom', 'cpuscreen', 'wallshelf', 'floor', 'phone', 'ceiling', 'character', 'desk', 'keyboard', 'computer', 'mat', 'tvstand', 'mousepad', 'dining_room', 'wall', 'light_bulb', 'check', 'tray', 'doorjamb', 'towel_rack', 'mouse', 'pencil', 'kitchen_counter', 'clothes_dress', 'door', 'table', 'clothes_shirt']
Task:Pick up phone
response:
{
    "thoughts": Walk to living room. Go near telephone. take the receiver and then talk to other person on that side.,
    "actions": ['[WALK] <phone>', '[GRAB] <phone>']
}

Input:
Scene_Objects:['scissors', 'chair', 'freezer', 'band-aids', 'walllamp', 'nail_polish', 'orchid', 'drawing', 'cpuscreen', 'kitchen_cabinet', 'floor', 'keyboard', 'toaster', 'ceilinglamp', 'plate', 'stereo', 'mat', 'iron', 'food_peanut_butter', 'food_jam', 'wall', 'oven', 'check', 'food_food', 'food_rice', 'ice', 'food_onion', 'console', 'kitchen_counter', 'table']
Task:Set up table
response:

Walk to the kitchen. Open the kitchen cabinet. Grab the plate and put it on the table.

[WALK] <dining_room>
[WALK] <kitchen_cabinet>
[FIND] <kitchen_cabinet>
[OPEN] <kitchen_cabinet>
[FIND] <plate>
[GRAB] <plate>
[FIND] <table>
[PUTBACK] <plate> <table>


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', 'beer', 'toilet', 'dough', 'toothbrush', 'drawing', 'floor', 'ceiling', 'computer', 'ceilinglamp', 'tvstand', 'stereo', 'shower', 'window', 'oil', 'couch', 'bowl', 'wall', 'oven', 'toy', 'cup', 'bed', 'food_food', 'television', 'wooden_spoon', 'towel_rack', 'comb', 'cupboard', 'table', 'dishwasher']
Task:Relax on sofa
response:
{
    "thoughts": Walk to living room. Find couch. Sit on couch,
    "actions": ['[WALK] <home_office>', '[WALK] <couch>', '[FIND] <couch>', '[SIT] <couch>']
}

Input:
Scene_Objects:['sponge', 'band-aids', 'detergent', 'food_carrot', 'milk', 'bathroom_counter', 'floor', 'ceiling', 'bookshelf', 'button', 'piano_bench', 'toaster', 'plate', 'faucet', 'drying_rack', 'shower', 'dish_soap', 'closetdrawer', 'clothes_pants', 'wall', 'oven', 'food_cheese', 'newspaper', 'food_food', 'doorjamb', 'kitchen_counter', 'cupboard', 'door', 'sink', 'shoe_rack']
Task:Wash dishes by hand
response:

I walk in to the Kitchen. I find a plate, a sponge, and the dish soap. I find the faucet. I turn the faucet on. I pour water on the sponge and plate. I add dish soap to the sponge. I put the dish soap back. I scrub the plate. I rinse the plate. I place the plate on the drying rack. I rinse the sponge. I turn the faucet off.

[WALK] <dining_room>
[WALK] <faucet>
[FIND] <faucet>
[SWITCHON] <faucet>
[FIND] <sponge>
[GRAB] <sponge>
[RINSE] <sponge>
[FIND] <dish_soap>
[GRAB] <dish_soap>
[POUR] <dish_soap> <sponge>
[PUTOBJBACK] <dish_soap>
[FIND] <plate>
[GRAB] <plate>
[WASH] <plate>
[RINSE] <plate>
[FIND] <drying_rack>
[PUTBACK] <plate> <plate>
[RINSE] <sponge>
[PUTOBJBACK] <sponge>
[SWITCHOFF] <faucet>


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

Here is an example plan to achieve a goal for reference:
Scene_Objects:['fork', 'filing_cabinet', 'scissors', 'juice', 'food_salt', 'microwave', 'chair', 'food_butter', 'toothbrush', 'drawing', 'wallshelf', 'bathroom_counter', 'floor', 'button', 'brush', 'ceilinglamp', 'plate', 'wall', 'tape', 'food_food', 'check', 'food_donut', 'wooden_spoon', 'rag', 'door', 'clothes_scarf', 'napkin', 'table', 'light', 'dishwasher']
Task:Eat
response:
{
    "thoughts": Serve food on dinning table in appropriate utensils, sit on the chair, eat,
    "actions": ['[WALK] <dining_room>', '[WALK] <table>', '[FIND] <table>', '[TURNTO] <table>', '[FIND] <chair>', '[SIT] <chair>', '[FIND] <food_food>', '[GRAB] <food_food>', '[FIND] <plate>', '[PUTBACK] <food_food> <plate>', '[GRAB] <food_food>', '[PUTOBJBACK] <food_food>', '[FIND] <fork>', '[GRAB] <fork>', '[EAT] <plate>']
}

Input:
Scene_Objects:['tablelamp', 'chair', 'walllamp', 'ground_coffee', 'drawing', 'orchid', 'cpuscreen', 'wallshelf', 'hanger', 'floor', 'ceiling', 'phone', 'desk', 'keyboard', 'computer', 'mat', 'ceilinglamp', 'tvstand', 'mousepad', 'couch', 'pillow', 'wall', 'nightstand', 'oven', 'photoframe', 'television', 'doorjamb', 'mouse', 'dresser', 'door']
Task:Browse internet
response:

Sit down at desk in home office, turn on computer, open browser on computer, browse internet

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


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

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

Input:
Scene_Objects:['sheets', 'beer', 'freezer', 'walllamp', 'food_carrot', 'drawing', 'hanger', 'floor', 'ceiling', 'keyboard', 'toaster', 'mat', 'tvstand', 'couch', 'food_orange', 'pillow', 'wall', 'basket_for_clothes', 'food_cheese', 'food_food', 'television', 'after_shave', 'towel_rack', 'pencil', 'kitchen_counter', 'cupboard', 'controller', 'bathroom_cabinet', 'table', 'dirt']
Task:Put groceries in Fridge
response:

I leave the bags with groceries near the fridge, open the door and put the groceries in the shelves.

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


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

Here is an example plan to achieve a goal for reference:
Scene_Objects:['filing_cabinet', 'tablelamp', 'chair', 'walllamp', 'orchid', 'cpuscreen', 'clothes_underwear', 'floor', 'ceiling', 'desk', 'keyboard', 'bookshelf', 'computer', 'mail', 'stovefan', 'ceilinglamp', 'mat', 'mousepad', 'dustpan', 'wall', 'bed', 'coffe_maker', 'lighter', 'coffee_pot', 'mouse', 'hair', 'door', 'napkin', 'home_office', 'table']
Task:Browse internet
response:
{
    "thoughts": Go find a computer, turn it on, click google, and browse the internet.,
    "actions": ['[WALK] <home_office>', '[WALK] <computer>', '[FIND] <computer>', '[SWITCHON] <computer>', '[TURNTO] <computer>', '[LOOKAT] <computer>']
}

Input:
Scene_Objects:['water_glass', 'scissors', 'blender', 'chair', 'walllamp', 'drawing', 'wallshelf', 'clothes_underwear', 'floor', 'ceiling', 'character', 'desk', 'computer', 'food_bacon', 'mat', 'tvstand', 'mousepad', 'closetdrawer', 'couch', 'pillow', 'wall', 'cup', 'photoframe', 'newspaper', 'television', 'ice', 'doorjamb', 'diary', 'console', 'towel_rack']
Task:Relax on sofa
response:

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