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

Here is an example plan to achieve a goal for reference:
Scene_Objects:['sheets', 'filing_cabinet', 'food_ice_cream', 'beer', 'microwave', 'freezer', 'walllamp', 'floor', 'ceiling', 'phone', 'dvd_player', 'stovefan', 'ceilinglamp', 'toaster', 'mousepad', 'wall', 'wall_clock', 'cup', 'bed', 'food_food', 'coin', 'food_rice', 'water', 'pencil', 'shoes', 'controller', 'napkin', 'bathroom_cabinet', 'table', 'dishwasher']
Task:Drink
response:
{
    "thoughts": Feeling tired after hard work I opened the fridge and grabbed cool water and drank from the glass.,
    "actions": ['[WALK] <dining_room>', '[WALK] <freezer>', '[FIND] <freezer>', '[OPEN] <freezer>', '[FIND] <cup>', '[GRAB] <cup>', '[CLOSE] <freezer>', '[FIND] <water>', '[GRAB] <water>', '[FIND] <cup>', '[POUR] <water> <cup>', '[FIND] <cup>', '[DRINK] <cup>']
}

Input:
Scene_Objects:['spectacles', 'sponge', 'measuring_cup', 'walllamp', 'nail_polish', 'drawing', 'orchid', 'floor', 'ceiling', 'dvd_player', 'keyboard', 'computer', 'button', 'toaster', 'ceilinglamp', 'tvstand', 'window', 'couch', 'pillow', 'broom', 'wall', 'powersocket', 'oven', 'television', 'oven_mitts', 'curtain', 'doorjamb', 'mouse', 'bag', 'table']
Task:Relax on sofa
response:

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

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


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

Here is an example plan to achieve a goal for reference:
Scene_Objects:['pot', 'filing_cabinet', 'freezer', 'blow_dryer', 'walllamp', 'drawing', 'knifeblock', 'cpuscreen', 'bathroom_counter', 'ceiling', 'character', 'faucet', 'picture', 'iron', 'mousepad', 'bowl', 'wall', 'powersocket', 'bench', 'photoframe', 'toilet_paper', 'coffe_maker', 'toothbrush_holder', 'tray', 'doorjamb', 'dishrack', 'sink', 'bathroom_cabinet', 'home_office', 'light']
Task:Get toilet paper
response:
{
    "thoughts": There are extra toilet papers in the bottom cabinet.,
    "actions": ['[WALK] <bathroom>', '[WALK] <bathroom_cabinet>', '[FIND] <bathroom_cabinet>', '[OPEN] <bathroom_cabinet>', '[FIND] <toilet_paper>', '[GRAB] <toilet_paper>', '[CLOSE] <bathroom_cabinet>']
}

Input:
Scene_Objects:['pot', 'filing_cabinet', 'toilet', 'trashcan', 'dough', 'food_carrot', 'knife', 'drawing', 'clothes_underwear', 'hanger', 'dvd_player', 'character', 'bookmark', 'toaster', 'mat', 'faucet', 'oven', 'tape', 'food_food', 'television', 'coffee_filter', 'ice', 'wooden_spoon', 'tray', 'lighter', 'chessboard', 'spoon', 'home_office', 'table', 'clothes_shirt']
Task:Pick up phone
response:

I hear the phone ringing in the living room. I walk to the living room and go to the phone. I pick it up and answer the phone.

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


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

Here is an example plan to achieve a goal for reference:
Scene_Objects:['pot', 'bathroom', 'trashcan', 'food_butter', 'drawing', 'floor', 'ceiling', 'phone', 'mat', 'ceilinglamp', 'window', 'couch', 'pillow', 'wall', 'wall_clock', 'powersocket', 'nightstand', 'food_food', 'check', 'television', 'curtain', 'doorjamb', 'towel_rack', 'kitchen_counter', 'dresser', 'door', 'sink', 'spoon', 'home_office', 'light']
Task:Turn on light
response:
{
    "thoughts": walk in kitchen. switch on light. walk in living room. switch on light.walk in entrance hall. switch on light.,
    "actions": ['[WALK] <dining_room>', '[WALK] <light>', '[FIND] <light>', '[SWITCHON] <light>', '[WALK] <home_office>', '[WALK] <home_office>']
}

Input:
Scene_Objects:['freezer', 'bathroom', 'detergent', 'cat', 'trashcan', 'cpuscreen', 'floor', 'ceiling', 'character', 'desk', 'keyboard', 'computer', 'stovefan', 'ceilinglamp', 'mousepad', 'form', 'wall', 'powersocket', 'photoframe', 'food_food', 'check', 'coffee_filter', 'doorjamb', 'cards', 'mouse', 'kitchen_counter', 'controller', 'door', 'light', 'coffee']
Task:Put groceries in Fridge
response:

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.

[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:['food_ice_cream', 'toilet', 'walllamp', 'nail_polish', 'dough', 'orchid', 'wallshelf', 'floor', 'ceiling', 'bookshelf', 'remote_control', 'keyboard', 'computer', 'stovefan', 'mat', 'tvstand', 'ceilinglamp', 'shower', 'window', 'wall', 'nightstand', 'powersocket', 'photoframe', 'television', 'curtain', 'doorjamb', 'cards', 'dishrack', 'door', 'light']
Task:Change TV channel
response:
{
    "thoughts": first i will go to living room and then take the remote and swtitch on television after that il change the channel,
    "actions": ['[WALK] <home_office>', '[WALK] <television>', '[FIND] <television>', '[SWITCHON] <television>', '[FIND] <remote_control>', '[TURNTO] <remote_control>', '[POINTAT] <remote_control>', '[TOUCH] <remote_control>', '[TURNTO] <television>', '[WATCH] <television>']
}

Input:
Scene_Objects:['spectacles', 'pot', 'filing_cabinet', 'crayon', 'walllamp', 'drawing', 'knifeblock', 'orchid', 'floor', 'keyboard', 'computer', 'ceilinglamp', 'mat', 'window', 'couch', 'food_orange', 'pillow', 'dining_room', 'wall', 'powersocket', 'bench', 'cutting_board', 'curtain', 'cards', 'dresser', 'bag', 'table', 'light', 'colander', 'clothes_shirt']
Task:Relax on sofa
response:

Walk to the living room, turn to the sofa. Sit on the sofa and relax.

[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:['toilet', 'ceilingfan', 'drawing', 'floor', 'ceiling', 'bedroom', 'remote_control', 'toaster', 'ceilinglamp', 'tvstand', 'balanceball', 'window', 'mousepad', 'couch', 'dining_room', 'wall', 'wall_clock', 'powersocket', 'oven', 'television', 'toothbrush_holder', 'curtain', 'doorjamb', 'console', 'dresser', 'cupboard', 'home_office', 'table', 'clothes_skirt', 'vase']
Task:Watch TV
response:
{
    "thoughts": Watch the television,
    "actions": ['[WALK] <home_office>', '[WALK] <television>', '[TURNTO] <television>', '[LOOKAT] <television>', '[FIND] <remote_control>', '[GRAB] <remote_control>', '[SWITCHON] <television>', '[FIND] <couch>', '[TURNTO] <couch>', '[SIT] <couch>', '[TURNTO] <television>', '[WATCH] <television>']
}

Input:
Scene_Objects:['pot', 'tablelamp', 'chair', 'freezer', 'walllamp', 'food_butter', 'orchid', 'cpuscreen', 'floor', 'ceiling', 'desk', 'keyboard', 'computer', 'toaster', 'mat', 'ceilinglamp', 'mousepad', 'wall', 'powersocket', 'photoframe', 'newspaper', 'ice', 'curtain', 'mouse', 'headset', 'hairbrush', 'door', 'bathroom_cabinet', 'table', 'clothes_shirt']
Task:Write an email
response:

walk into office, sit in chair, turn on computer, write email

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


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

Here is an example plan to achieve a goal for reference:
Scene_Objects:['filing_cabinet', 'toilet', 'freezer', 'detergent', 'knifeblock', 'phone', 'bookshelf', 'computer', 'mop_bucket', 'brush', 'clothes_socks', 'mousepad', 'dining_room', 'nightstand', 'basket_for_clothes', 'food_food', 'curtain', 'doorjamb', 'towel_rack', 'mouse', 'kitchen_counter', 'dresser', 'laundry_detergent', 'bathtub', 'sink', 'home_office', 'napkin', 'dishwasher', 'bathroom_cabinet', 'washing_machine']
Task:Wash clothes
response:
{
    "thoughts": "I walk to entrance hall" "I walk to bedroom" "I find basket of clothes" "I lift basket of  clothes" "I walk to kitchen" "I find washing machine" "I open washing machine " "I put laundry in washing machine" "I add laundry detergent" " "I close washing machine lid" "I switch washing machine on",
    "actions": ['[WALK] <home_office>', '[WALK] <bedroom>', '[WALK] <basket_for_clothes>', '[FIND] <basket_for_clothes>', '[GRAB] <basket_for_clothes>', '[WALK] <dining_room>', '[WALK] <washing_machine>', '[FIND] <washing_machine>', '[OPEN] <washing_machine>', '[PUTBACK] <basket_for_clothes> <washing_machine>', '[FIND] <laundry_detergent>', '[GRAB] <laundry_detergent>', '[PUTBACK] <laundry_detergent> <washing_machine>', '[CLOSE] <washing_machine>', '[TURNTO] <washing_machine>']
}

Input:
Scene_Objects:['sheets', 'mop', 'microwave', 'ground_coffee', 'walllamp', 'cat', 'trashcan', 'knifeblock', 'cpuscreen', 'floor', 'ceiling', 'bedroom', 'toaster', 'brush', 'tvstand', 'shower', 'faucet', 'food_jam', 'wall', 'nightstand', 'photoframe', 'coffe_maker', 'mouthwash', 'coffee_filter', 'curtain', 'doorjamb', 'kitchen_counter', 'cupboard', 'dishwasher', 'scrabble']
Task:Make coffee
response:

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


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

Here is an example plan to achieve a goal for reference:
Scene_Objects:['sheets', 'filing_cabinet', 'food_pizza', 'walllamp', 'orchid', 'needle', 'cpuscreen', 'bathroom_counter', 'shampoo', 'desk', 'bookshelf', 'computer', 'stovefan', 'ceilinglamp', 'toaster', 'shower', 'faucet', 'couch', 'dining_room', 'cup', 'bed', 'tray', 'curtain', 'wooden_spoon', 'pencil', 'door', 'bathroom_cabinet', 'light', 'dishwasher', 'table']
Task:Pick up phone
response:
{
    "thoughts": I walk to the home office. I find the telephone. I pick up the telephone handset.,
    "actions": ['[WALK] <home_office>', '[WALK] <phone>', '[FIND] <phone>', '[GRAB] <phone>']
}

Input:
Scene_Objects:['sheets', 'food_pizza', 'filing_cabinet', 'dog', 'bathroom', 'knifeblock', 'drawing', 'orchid', 'bathroom_counter', 'floor', 'phone', 'ceiling', 'character', 'desk', 'bedroom', 'clothes_jacket', 'mat', 'tvstand', 'pillow', 'towel', 'wall', 'cup', 'food_donut', 'curtain', 'after_shave', 'dishrack', 'cupboard', 'controller', 'door', 'dishwasher']
Task:Pick up phone
response:

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


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

Here is an example plan to achieve a goal for reference:
Scene_Objects:['microwave', 'toilet', 'walllamp', 'bathroom', 'orchid', 'wallshelf', 'bathroom_counter', 'floor', 'phone', 'ceiling', 'desk', 'bookshelf', 'keyboard', 'computer', 'stovefan', 'tvstand', 'faucet', 'plate', 'mousepad', 'wall', 'powersocket', 'bench', 'oven', 'cutting_board', 'tape', 'cup', 'doorjamb', 'sink', 'light', 'table']
Task:Pick up phone
response:
{
    "thoughts": walk over and pick up the phone,
    "actions": ['[WALK] <phone>', '[GRAB] <phone>']
}

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

I walk to my bedroom.  I locate my stereo and turn it on.  I put on my headphones and sit to listen.

[WALK] <bedroom>
[WALK] <stereo>
[FIND] <stereo>
[WALK] <stereo>
[SWITCHON] <stereo>
[FIND] <headset>
[GRAB] <headset>
[PUTON] <headset>
[FIND] <chair>
[SIT] <chair>


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

Here is an example plan to achieve a goal for reference:
Scene_Objects:['chair', 'walllamp', 'orchid', 'drawing', 'wallshelf', 'floor', 'ceiling', 'bedroom', 'tea_bag', 'bookshelf', 'keyboard', 'brush', 'mat', 'tvstand', 'ceilinglamp', 'shower', 'window', 'stovefan', 'shoe-shine_kit', 'pillow', 'wall', 'powersocket', 'photoframe', 'novel', 'television', 'wooden_spoon', 'curtain', 'doorjamb', 'bathroom_cabinet', 'light']
Task:Watch TV
response:
{
    "thoughts": Walk into the living room. Sit on the couch. Turn on TV.,
    "actions": ['[WALK] <home_office>', '[WALK] <television>', '[FIND] <television>', '[SWITCHON] <television>']
}

Input:
Scene_Objects:['microwave', 'toilet', 'band-aids', 'detergent', 'toothbrush', 'drawing', 'needle', 'bathroom_counter', 'floor', 'ceiling', 'purse', 'stovefan', 'mat', 'tvstand', 'faucet', 'brush', 'window', 'oil', 'couch', 'bowl', 'wall', 'powersocket', 'coffee_pot', 'pencil', 'food_steak', 'sink', 'bag', 'bathroom_cabinet', 'tooth_paste', 'teeth']
Task:Wash teeth
response:

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

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


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

Here is an example plan to achieve a goal for reference:
Scene_Objects:['microwave', 'walllamp', 'detergent', 'toothbrush', 'drawing', 'cpuscreen', 'food_egg', 'phone', 'character', 'computer', 'piano_bench', 'shoe-shine_kit', 'faucet', 'food_noodles', 'mousepad', 'clothes_hat', 'towel', 'broom', 'cutting_board', 'shelf', 'keys', 'novel', 'food_food', 'check', 'wooden_spoon', 'towel_rack', 'sink', 'table', 'light', 'coffee']
Task:Change TV channel
response:
{
    "thoughts": I pull up my online classes on the computer to look at what the assigned reading is. I get my textbook, notebook, and mechanical pencil. As I'm reading, I take notes over important points. I then use those notes to complete the assignment for the week. Frequently that involves writing a post on an online discussion board that answers a question related to things from the reading.,
    "actions": ['[WALK] <home_office>', '[WALK] <remote_control>', '[GRAB] <remote_control>', '[TURNTO] <remote_control>', '[POINTAT] <remote_control>']
}

Input:
Scene_Objects:['dry_pasta', 'filing_cabinet', 'tablelamp', 'beer', 'bathroom', 'food_butter', 'food_carrot', 'milk', 'bathroom_counter', 'bedroom', 'thread', 'table_cloth', 'bookmark', 'ceilinglamp', 'shower', 'mousepad', 'nightstand', 'powersocket', 'box', 'photoframe', 'razor', 'wine', 'dresser', 'clothes_scarf', 'sink', 'home_office', 'light', 'colander', 'laser_pointer', 'dirt']
Task:Pet cat
response:

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


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

Here is an example plan to achieve a goal for reference:
Scene_Objects:['food_pizza', 'freezer', 'trashcan', 'drawing', 'bathroom_counter', 'ceiling', 'phone', 'thread', 'computer', 'stovefan', 'faucet', 'shower', 'food_jam', 'dining_room', 'wall', 'powersocket', 'tape', 'coffe_maker', 'food_food', 'mirror', 'doorjamb', 'mouse', 'paper_towel', 'dresser', 'cupboard', 'sink', 'clothes_scarf', 'bathroom_cabinet', 'home_office', 'dirt']
Task:Clean  mirror
response:
{
    "thoughts": Spray Windex or glass and mirror cleaner onto mirror. Use paper towel to wipe off cleaner until mirror is dry and has no streaks.,
    "actions": ['[WALK] <bathroom>', '[WALK] <bathroom_cabinet>', '[FIND] <bathroom_cabinet>', '[OPEN] <bathroom_cabinet>', '[FIND] <paper_towel>', '[GRAB] <paper_towel>', '[CLOSE] <bathroom_cabinet>', '[WALK] <mirror>', '[WIPE] <mirror>', '[FIND] <trashcan>', '[PUTBACK] <paper_towel> <trashcan>']
}

Input:
Scene_Objects:['fork', 'pot', 'measuring_cup', 'microwave', 'detergent', 'trashcan', 'orchid', 'bills', 'knife', 'bathroom_counter', 'floor', 'character', 'keyboard', 'mat', 'mousepad', 'nightstand', 'pasta', 'tape', 'novel', 'food_food', 'check', 'television', 'curtain', 'coffee_pot', 'laundry_detergent', 'clothes_scarf', 'bathroom_cabinet', 'colander', 'instrument_violin', 'washing_machine']
Task:Wash clothes
response:

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


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

Here is an example plan to achieve a goal for reference:
Scene_Objects:['chair', 'walllamp', 'woman', 'toothbrush', 'drawing', 'wallshelf', 'hanger', 'floor', 'ceiling', 'desk', 'stamp', 'bookshelf', 'computer', 'mat', 'tvstand', 'ceilinglamp', 'stereo', 'closetdrawer', 'couch', 'pillow', 'wall', 'child', 'box', 'photoframe', 'television', 'oven_mitts', 'doorjamb', 'cd', 'dresser', 'table']
Task:Watch movie
response:
{
    "thoughts": Sitting and watching  a movie with family,
    "actions": ['[WALK] <home_office>', '[WALK] <child>', '[FIND] <child>', '[TURNTO] <child>', '[LOOKAT] <child>', '[GREET] <child>', '[FIND] <woman>', '[TURNTO] <woman>', '[LOOKAT] <woman>', '[GREET] <woman>', '[WALK] <television>', '[SWITCHON] <television>', '[TURNTO] <television>', '[LOOKAT] <television>', '[TOUCH] <television>', '[TURNTO] <television>', '[LOOKAT] <television>', '[TOUCH] <television>', '[TURNTO] <television>', '[LOOKAT] <television>', '[TOUCH] <television>', '[WALK] <couch>', '[SIT] <couch>', '[TURNTO] <television>', '[LOOKAT] <television>', '[WATCH] <television>', '[WATCH] <television>', '[WATCH] <television>']
}

Input:
Scene_Objects:['food_pizza', 'blender', 'walllamp', 'cat', 'drawing', 'orchid', 'needle', 'bathroom_counter', 'floor', 'bedroom', 'desk', 'ceilinglamp', 'laptop', 'window', 'couch', 'pillow', 'wall', 'wall_clock', 'bench', 'oven', 'newspaper', 'check', 'tray', 'curtain', 'doorjamb', 'door', 'bathroom_cabinet', 'table', 'tooth_paste', 'coffee']
Task:Relax on sofa
response:

[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:['sheets', 'walllamp', 'trashcan', 'cpuscreen', 'bathroom_counter', 'floor', 'phone', 'ceiling', 'folder', 'bedroom', 'food_cake', 'computer', 'shower', 'iron', 'window', 'pillow', 'wall', 'nightstand', 'powersocket', 'tape', 'bed', 'television', 'wine', 'doorjamb', 'towel_rack', 'dresser', 'home_office', 'light', 'bathroom_cabinet', 'dishwasher']
Task:Pick up phone
response:
{
    "thoughts": I walk to the kitchen and find the phone. I pick up the phone. I hold it to my ear.,
    "actions": ['[WALK] <dining_room>', '[WALK] <phone>', '[FIND] <phone>', '[GRAB] <phone>']
}

Input:
Scene_Objects:['water_glass', 'filing_cabinet', 'food_salt', 'microwave', 'blow_dryer', 'detergent', 'knife', 'orchid', 'bathroom_counter', 'shampoo', 'keyboard', 'bookshelf', 'mail', 'stovefan', 'ceilinglamp', 'toaster', 'mat', 'faucet', 'food_peanut_butter', 'dining_room', 'nightstand', 'oven', 'cup', 'light_bulb', 'food_food', 'television', 'food_onion', 'pencil', 'napkin', 'light']
Task:Drink
response:

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

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


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

Here is an example plan to achieve a goal for reference:
Scene_Objects:['toilet', 'freezer', 'food_butter', 'knifeblock', 'bathroom_counter', 'floor', 'ceiling', 'phone', 'bookshelf', 'mop_bucket', 'ceilinglamp', 'tvstand', 'iron', 'window', 'mousepad', 'microphone', 'towel', 'dining_room', 'bowl', 'wall', 'powersocket', 'bench', 'cup', 'novel', 'television', 'coin', 'rag', 'doorjamb', 'headset', 'light']
Task:Turn on light
response:
{
    "thoughts": I walk in to the living room. I find the light switch. I turn on the lights.,
    "actions": ['[WALK] <home_office>', '[WALK] <light>', '[FIND] <light>', '[SWITCHON] <light>']
}

Input:
Scene_Objects:['filing_cabinet', 'juice', 'measuring_cup', 'microwave', 'walllamp', 'trashcan', 'floor', 'bedroom', 'computer', 'toaster', 'stovefan', 'ceilinglamp', 'faucet', 'window', 'mousepad', 'candle', 'pillow', 'wall', 'nightstand', 'bench', 'oven', 'cup', 'newspaper', 'coffe_maker', 'tray', 'kitchen_counter', 'cupboard', 'home_office', 'dishwasher', 'laser_pointer']
Task:Wash dishes with dishwasher
response:

Walk to the sink. Take dishes out of sink. Open dishwasher and place dishes in dishwasher.

[WALK] <dining_room>
[WALK] <dishwasher>
[FIND] <dishwasher>
[OPEN] <dishwasher>
[CLOSE] <dishwasher>
[SWITCHON] <dishwasher>


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

Here is an example plan to achieve a goal for reference:
Scene_Objects:['water_glass', 'food_bread', 'chair', 'freezer', 'walllamp', 'detergent', 'trashcan', 'drawing', 'desk', 'keyboard', 'bookshelf', 'bookmark', 'stovefan', 'ceilinglamp', 'tvstand', 'shower', 'faucet', 'pillow', 'bowl', 'wall', 'box', 'coffe_maker', 'razor', 'television', 'curtain', 'doorjamb', 'towel_rack', 'door', 'sink', 'bathroom_cabinet']
Task:Drink
response:
{
    "thoughts": Pour water into a glass and drink from the glass.,
    "actions": ['[WALK] <dining_room>', '[WALK] <water_glass>', '[FIND] <water_glass>', '[GRAB] <water_glass>', '[WALK] <water>', '[FIND] <water>', '[GRAB] <water>', '[POUR] <water> <water_glass>', '[DRINK] <water_glass>']
}

Input:
Scene_Objects:['freezer', 'ground_coffee', 'bathroom', 'drawing', 'floor', 'ceiling', 'bookshelf', 'mat', 'ceilinglamp', 'stereo', 'mousepad', 'couch', 'clothes_pants', 'dining_room', 'wall', 'powersocket', 'box', 'bed', 'check', 'television', 'wooden_spoon', 'after_shave', 'doorjamb', 'pencil', 'kitchen_counter', 'door', 'food_steak', 'napkin', 'light', 'board_game']
Task:Turn on light
response:

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


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

Here is an example plan to achieve a goal for reference:
Scene_Objects:['fork', 'chair', 'walllamp', 'drawing', 'wallshelf', 'hanger', 'floor', 'ceiling', 'desk', 'remote_control', 'envelope', 'computer', 'button', 'food_bacon', 'table_cloth', 'mat', 'tvstand', 'ceilinglamp', 'shoe-shine_kit', 'closetdrawer', 'couch', 'pillow', 'dining_room', 'wall', 'cup', 'photoframe', 'television', 'doorjamb', 'dresser', 'dirt']
Task:Change TV channel
response:
{
    "thoughts": Pickup remote control for the living room TV and push the change channel button,
    "actions": ['[WALK] <home_office>', '[WALK] <couch>', '[FIND] <couch>', '[SIT] <couch>', '[FIND] <remote_control>', '[GRAB] <remote_control>', '[FIND] <button>', '[PUSH] <button>', '[FIND] <television>', '[TURNTO] <television>', '[WATCH] <television>']
}

Input:
Scene_Objects:['pot', 'tablelamp', 'cpuscreen', 'clothes_underwear', 'hanger', 'shampoo', 'bookshelf', 'alcohol', 'table_cloth', 'faucet', 'shower', 'clothes_socks', 'clothes_pants', 'wall', 'wall_clock', 'oven', 'nightstand', 'basket_for_clothes', 'newspaper', 'clothes_gloves', 'tray', 'doorjamb', 'lighter', 'cards', 'clothes_dress', 'laundry_detergent', 'napkin', 'clothes_skirt', 'clothes_shirt', 'washing_machine']
Task:Wash clothes
response:

I go to the bathroom, take the dirt clothes and put into the washing machine, then put the soap, set the cleaning program and switch on the machine


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

Here is an example plan to achieve a goal for reference:
Scene_Objects:['tea', 'cat', 'drawing', 'bills', 'bathroom_counter', 'floor', 'ceiling', 'character', 'bedroom', 'mail', 'alcohol', 'mat', 'faucet', 'clothes_pants', 'pillow', 'wall', 'wall_clock', 'oven', 'pasta', 'bench', 'coffee_filter', 'ice', 'paper_towel', 'conditioner', 'sink', 'bathroom_cabinet', 'clothes_skirt', 'soap', 'hands_both', 'shoe_rack']
Task:Wash hands
response:
{
    "thoughts": I walk to the bathroom and find the sink. I grab the soap and rub some on my hands. I turn the faucet on and put my hands in the water. I rinse my hands and then turn off the faucet. Then I dry my hands on a paper towel.,
    "actions": ['[WALK] <bathroom>', '[WALK] <sink>', '[FIND] <sink>', '[FIND] <soap>', '[GRAB] <soap>', '[FIND] <hands_both>', '[SCRUB] <hands_both>', '[FIND] <faucet>', '[SWITCHON] <faucet>', '[RINSE] <hands_both>', '[FIND] <paper_towel>', '[GRAB] <paper_towel>', '[WIPE] <hands_both>']
}

Input:
Scene_Objects:['chair', 'freezer', 'walllamp', 'orchid', 'cpuscreen', 'floor', 'ceiling', 'dvd_player', 'desk', 'keyboard', 'bookshelf', 'computer', 'mat', 'ceilinglamp', 'faucet', 'picture', 'window', 'mousepad', 'oil', 'clothes_hat', 'wall', 'keys', 'food_food', 'coin', 'food_onion', 'mouse', 'cupboard', 'laundry_detergent', 'door', 'table']
Task:Write an email
response:

I walk into the home office and walk to the desk. I pull out the chair and sit down. I turn on the computer. After the computer is turned on I click on my email program.  When the program is loaded I write an email.

[WALK] <home_office>
[WALK] <desk>
[FIND] <chair>
[PULL] <chair>
[SIT] <chair>
[FIND] <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:['filing_cabinet', 'measuring_cup', 'dog', 'freezer', 'walllamp', 'orchid', 'bathroom_counter', 'keyboard', 'bookshelf', 'closetdrawer', 'pillow', 'dining_room', 'powersocket', 'oven', 'newspaper', 'clothes_gloves', 'bed', 'check', 'doorjamb', 'diary', 'towel_rack', 'mouse', 'cd', 'cupboard', 'door', 'napkin', 'home_office', 'bathroom_cabinet', 'dishwasher', 'scrabble']
Task:Read book
response:
{
    "thoughts": Read a book,
    "actions": ['[WALK] <home_office>', '[WALK] <novel>', '[FIND] <novel>', '[GRAB] <novel>', '[READ] <novel>', '[PUTOBJBACK] <novel>']
}

Input:
Scene_Objects:['filing_cabinet', 'microwave', 'walllamp', 'trashcan', 'knifeblock', 'floor', 'character', 'desk', 'bedroom', 'keyboard', 'thread', 'toaster', 'plate', 'couch', 'wall', 'light_bulb', 'novel', 'coffe_maker', 'food_rice', 'tray', 'food_onion', 'after_shave', 'curtain', 'kettle', 'kitchen_counter', 'shoes', 'cupboard', 'conditioner', 'door', 'dishwasher']
Task:Wash dishes with dishwasher
response:

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

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


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

Here is an example plan to achieve a goal for reference:
Scene_Objects:['filing_cabinet', 'mop', 'chair', 'bathroom', 'food_carrot', 'woman', 'drawing', 'orchid', 'bathroom_counter', 'floor', 'ceiling', 'man', 'keyboard', 'mat', 'faucet', 'window', 'foundation', 'nightstand', 'powersocket', 'cup', 'coffe_maker', 'food_food', 'television', 'tray', 'towel_rack', 'cd', 'dresser', 'sink', 'clothes_scarf', 'light']
Task:Greet guests
response:
{
    "thoughts": Stand next to the door. When the door opens from the outside, greet the guests.,
    "actions": ['[RUN] <home_office>', '[WALK] <woman>', '[FIND] <woman>', '[TURNTO] <woman>', '[LOOKAT] <woman>', '[GREET] <woman>', '[FIND] <man>', '[TURNTO] <man>', '[LOOKAT] <man>', '[GREET] <man>']
}

Input:
Scene_Objects:['food_ice_cream', 'measuring_cup', 'walllamp', 'drawing', 'orchid', 'floor', 'ceiling', 'keyboard', 'mail', 'ceilinglamp', 'tvstand', 'mat', 'shower', 'window', 'couch', 'candle', 'pillow', 'bowl', 'wall', 'powersocket', 'television', 'curtain', 'after_shave', 'doorjamb', 'chessboard', 'door', 'food_steak', 'bathroom_cabinet', 'table', 'board_game']
Task:Watch TV
response:

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

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


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

Here is an example plan to achieve a goal for reference:
Scene_Objects:['spectacles', 'tea', 'ground_coffee', 'walllamp', 'hanger', 'longboard', 'floor', 'ceiling', 'button', 'toaster', 'faucet', 'mousepad', 'candle', 'wall', 'nightstand', 'powersocket', 'keys', 'novel', 'coffe_maker', 'clothes_gloves', 'coffee_filter', 'water', 'ice', 'tray', 'food_onion', 'cupboard', 'door', 'light', 'dishwasher', 'soap']
Task:Make coffee
response:
{
    "thoughts": Open coffee maker. Put filter in main basket, put ground coffee in filter, fill reservoir with water, turn on coffee maker.,
    "actions": ['[WALK] <dining_room>', '[WALK] <coffe_maker>', '[FIND] <coffe_maker>', '[OPEN] <coffe_maker>', '[FIND] <coffee_filter>', '[GRAB] <coffee_filter>', '[PUTBACK] <coffee_filter> <coffe_maker>', '[FIND] <ground_coffee>', '[GRAB] <ground_coffee>', '[PUTBACK] <ground_coffee> <coffe_maker>', '[WALK] <water>', '[FIND] <water>', '[GRAB] <water>', '[POUR] <water> <coffe_maker>', '[CLOSE] <coffe_maker>', '[SWITCHON] <coffe_maker>']
}

Input:
Scene_Objects:['sponge', 'microwave', 'walllamp', 'bathroom', 'toothbrush', 'drawing', 'orchid', 'floor', 'desk', 'computer', 'ceilinglamp', 'mat', 'deck_of_cards', 'stereo', 'window', 'couch', 'food_jam', 'pillow', 'wall', 'light_bulb', 'food_donut', 'tray', 'curtain', 'shoes', 'dishrack', 'sink', 'spoon', 'table', 'dishwasher', 'coffee']
Task:Relax on sofa
response:

I walk to the living room. I see the couch.  I sit down on the couch, then lie down and put my feet up.

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


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

Here is an example plan to achieve a goal for reference:
Scene_Objects:['food_salt', 'toilet', 'walllamp', 'bathroom', 'trashcan', 'knifeblock', 'floor', 'tea_bag', 'bookshelf', 'food_bacon', 'toaster', 'plate', 'tvstand', 'dish_soap', 'mousepad', 'couch', 'wall', 'oven', 'powersocket', 'photoframe', 'coffe_maker', 'food_food', 'toothbrush_holder', 'ice', 'mouse', 'kitchen_counter', 'vacuum_cleaner', 'cupboard', 'clothes_dress', 'dishwasher']
Task:Wash dishes with dishwasher
response:
{
    "thoughts": Go to kitchen to put dirty dishs into dishwasher with soap to clean the dirty dishes,
    "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] <dish_soap>', '[GRAB] <dish_soap>', '[PUTBACK] <dish_soap> <dishwasher>', '[CLOSE] <dishwasher>', '[SWITCHON] <dishwasher>']
}

Input:
Scene_Objects:['water_glass', 'pot', 'freezer', 'walllamp', 'knifeblock', 'cpuscreen', 'floor', 'ceiling', 'desk', 'keyboard', 'computer', 'stovefan', 'ceilinglamp', 'faucet', 'oil', 'mousepad', 'food_peanut_butter', 'wall', 'oven', 'powersocket', 'food_food', 'water', 'tray', 'doorjamb', 'mouse', 'kitchen_counter', 'cupboard', 'door', 'sink', 'light']
Task:Drink
response:

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

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


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

Here is an example plan to achieve a goal for reference:
Scene_Objects:['spectacles', 'tablelamp', 'microwave', 'chair', 'wallshelf', 'hanger', 'floor', 'phone', 'food_bacon', 'piano_bench', 'stovefan', 'ceilinglamp', 'shower', 'mousepad', 'closetdrawer', 'powersocket', 'television', 'coin', 'food_donut', 'ice', 'rag', 'pencil', 'shoes', 'dresser', 'clothes_dress', 'clothes_scarf', 'sink', 'bathroom_cabinet', 'light', 'home_office']
Task:Hang up jacket
response:
{
    "thoughts": I put clothes on hangers and hang them in the closet,
    "actions": ['[WALK] <bedroom>', '[WALK] <clothes_dress>', '[FIND] <clothes_dress>', '[GRAB] <clothes_dress>', '[WALK] <dresser>', '[FIND] <hanger>', '[OPEN] <dresser>', '[PUTIN] <clothes_dress> <dresser>', '[FIND] <clothes_dress>', '[GRAB] <clothes_dress>', '[WALK] <dresser>', '[PUTIN] <clothes_dress> <dresser>', '[CLOSE] <dresser>']
}

Input:
Scene_Objects:['glue', 'microwave', 'walllamp', 'ground_coffee', 'trashcan', 'drawing', 'orchid', 'hanger', 'floor', 'ceiling', 'character', 'desk', 'remote_control', 'toaster', 'ceilinglamp', 'tvstand', 'mat', 'iron', 'window', 'couch', 'pillow', 'wall', 'powersocket', 'television', 'curtain', 'doorjamb', 'coffee_pot', 'kitchen_counter', 'door', 'table']
Task:Watch TV
response:

[WALK] <home_office>
[WALK] <couch>
[FIND] <couch>
[SIT] <couch>
[FIND] <remote_control>
[GRAB] <remote_control>
[FIND] <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:['glue', 'pot', 'scissors', 'walllamp', 'detergent', 'drawing', 'clothes_underwear', 'floor', 'phone', 'character', 'button', 'toaster', 'plate', 'tvstand', 'dish_soap', 'oil', 'candle', 'wall', 'oven', 'tape', 'box', 'coffe_maker', 'food_food', 'check', 'tray', 'centerpiece', 'controller', 'light', 'dishwasher', 'soap']
Task:Wash dishes with dishwasher
response:
{
    "thoughts": walk into kitchen, find dishwasher, put plates in dishwasher, put soap in dishwasher, turn on dishwasher,
    "actions": ['[WALK] <dining_room>', '[WALK] <dishwasher>', '[FIND] <dishwasher>', '[OPEN] <dishwasher>', '[FIND] <dish_soap>', '[GRAB] <dish_soap>', '[PUTBACK] <dish_soap> <dishwasher>', '[FIND] <plate>', '[GRAB] <plate>', '[PUTBACK] <plate> <dishwasher>', '[FIND] <plate>', '[GRAB] <plate>', '[PUTBACK] <plate> <dishwasher>', '[CLOSE] <dishwasher>', '[SWITCHON] <dishwasher>']
}

Input:
Scene_Objects:['pot', 'freezer', 'walllamp', 'bathroom', 'drawing', 'floor', 'ceiling', 'bookshelf', 'envelope', 'toaster', 'mat', 'food_orange', 'pillow', 'wall', 'wall_clock', 'powersocket', 'cutting_board', 'bed', 'oven_mitts', 'coin', 'doorjamb', 'lighter', 'pencil', 'kitchen_counter', 'dresser', 'pajamas', 'door', 'home_office', 'light', 'colander']
Task:Turn on light
response:

I walk towards to the bedroom, and I open the door of the bedroom, and I switch on the lights inside the bedroom, the switch is beside the door.

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


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

Here is an example plan to achieve a goal for reference:
Scene_Objects:['pot', 'juice', 'blow_dryer', 'walllamp', 'detergent', 'floor', 'ceiling', 'bedroom', 'keyboard', 'purse', 'tvstand', 'deck_of_cards', 'clothes_pants', 'dining_room', 'wall', 'nightstand', 'powersocket', 'oven', 'keys', 'tray', 'kettle', 'shoes', 'hair', 'sink', 'home_office', 'table', 'dishwasher', 'soap', 'board_game', 'dirt']
Task:Hang up car keys
response:
{
    "thoughts": Open the front door. Enter the entrance hall. Take out car keys from purse. Hang car keys up on hook on the wall.,
    "actions": ['[WALK] <home_office>', '[WALK] <purse>', '[FIND] <purse>', '[OPEN] <purse>', '[FIND] <keys>', '[GRAB] <keys>', '[CLOSE] <purse>']
}

Input:
Scene_Objects:['sponge', 'dry_pasta', 'beer', 'microwave', 'walllamp', 'bathroom', 'detergent', 'trashcan', 'drawing', 'knifeblock', 'floor', 'phone', 'bedroom', 'food_bacon', 'toaster', 'ceilinglamp', 'window', 'dish_soap', 'candle', 'pillow', 'bowl', 'wall', 'bench', 'newspaper', 'coffe_maker', 'kettle', 'kitchen_counter', 'vacuum_cleaner', 'cupboard', 'dishwasher']
Task:Wash dishes with dishwasher
response:

I go to the dishwasher and put dish soap. I close the dishwasher and turn it on.

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


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

Here is an example plan to achieve a goal for reference:
Scene_Objects:['sheets', 'filing_cabinet', 'tablelamp', 'crayon', 'drawing', 'hanger', 'floor', 'character', 'bedroom', 'mat', 'window', 'towel', 'pillow', 'wall', 'nightstand', 'cutting_board', 'cup', 'bed', 'toilet_paper', 'food_donut', 'curtain', 'doorjamb', 'mouse', 'shoes', 'chessboard', 'controller', 'laundry_detergent', 'door', 'table', 'vase']
Task:Go to sleep
response:
{
    "thoughts": go t the bedroom and go to sleep,
    "actions": ['[WALK] <bedroom>', '[WALK] <bed>', '[FIND] <bed>', '[LIE] <bed>']
}

Input:
Scene_Objects:['glue', 'filing_cabinet', 'food_salt', 'microwave', 'cpuscreen', 'hanger', 'bathroom_counter', 'floor', 'ceiling', 'phone', 'bookshelf', 'stovefan', 'mat', 'dustpan', 'food_orange', 'wall', 'powersocket', 'oven', 'photoframe', 'tray', 'doorjamb', 'mouse', 'kitchen_counter', 'pajamas', 'cupboard', 'clothes_dress', 'door', 'light', 'dishwasher', 'table']
Task:Turn on light
response:

Walk to the Living Room. Switch on 1 light. Walk to dining room. Switch on 1 light. Walk to Entrance hall. Switch on 1 light.

[WALK] <home_office>
[WALK] <light>
[FIND] <light>
[SWITCHON] <light>
[WALK] <dining_room>
[WALK] <home_office>


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

Here is an example plan to achieve a goal for reference:
Scene_Objects:['juice', 'toilet', 'chair', 'detergent', 'bathroom_counter', 'ceiling', 'character', 'desk', 'laptop', 'tvstand', 'faucet', 'electric_shaver', 'mousepad', 'couch', 'food_orange', 'bench', 'powersocket', 'cup', 'bed', 'novel', 'razor', 'oven_mitts', 'curtain', 'after_shave', 'cd', 'headset', 'dresser', 'pajamas', 'bathroom_cabinet', 'tooth_paste']
Task:Pick up phone
response:
{
    "thoughts": I'll enter the location containing the phone. Once there, I'll locate the phone, and move close to it. I'll then use my hand to pick up the phone such that I can then use it.,
    "actions": ['[WALK] <home_office>', '[WALK] <phone>', '[FIND] <phone>', '[WALK] <phone>', '[TURNTO] <phone>', '[LOOKAT] <phone>', '[GRAB] <phone>']
}

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

Go find a computer, turn it on, click google, and browse the internet.

[WALK] <home_office>
[WALK] <computer>
[FIND] <computer>
[SWITCHON] <computer>
[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', 'tablelamp', 'walllamp', 'cpuscreen', 'bathroom_counter', 'floor', 'ceiling', 'phone', 'bookshelf', 'keyboard', 'computer', 'clothes_jacket', 'mat', 'faucet', 'shower', 'towel', 'pillow', 'wall', 'nightstand', 'oven', 'food_food', 'tray', 'dresser', 'door', 'sink', 'bathroom_cabinet', 'home_office', 'soap', 'board_game', 'hands_both']
Task:Wash hands
response:
{
    "thoughts": I go to the bathroom, open the faucet rinse the hands, wash the hands with soap and rinse again, then wipe with a towel.,
    "actions": ['[WALK] <bathroom>', '[WALK] <faucet>', '[FIND] <faucet>', '[TURNTO] <faucet>', '[FIND] <hands_both>', '[RINSE] <hands_both>', '[FIND] <soap>', '[GRAB] <soap>', '[WASH] <hands_both>', '[RINSE] <hands_both>', '[TURNTO] <faucet>', '[FIND] <towel>', '[GRAB] <towel>', '[WIPE] <hands_both>']
}

Input:
Scene_Objects:['food_pizza', 'chair', 'freezer', 'walllamp', 'bathroom', 'orchid', 'cpuscreen', 'hanger', 'floor', 'ceiling', 'phone', 'desk', 'keyboard', 'computer', 'mop_bucket', 'ceilinglamp', 'mat', 'electric_shaver', 'mousepad', 'wall', 'powersocket', 'photoframe', 'food_food', 'coffe_maker', 'mouse', 'pencil', 'controller', 'door', 'table', 'teeth']
Task:Work
response:

walk to home office ,find computer ,switch on computer and work

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


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

Here is an example plan to achieve a goal for reference:
Scene_Objects:['tablelamp', 'chair', 'walllamp', 'drawing', 'orchid', 'cpuscreen', 'wallshelf', 'hanger', 'floor', 'ceiling', 'phone', 'desk', 'keyboard', 'computer', 'mail', 'mat', 'ceilinglamp', 'tvstand', 'mousepad', 'couch', 'pillow', 'wall', 'nightstand', 'oven', 'television', 'doorjamb', 'mouse', 'dresser', 'door', 'home_office']
Task:Check email
response:
{
    "thoughts": Turn on the computer.  Wait for it to load.  Get online.  Go to the email service.  Open the email.  Read the email.,
    "actions": ['[WALK] <home_office>', '[WALK] <chair>', '[FIND] <chair>', '[SIT] <chair>', '[FIND] <computer>', '[SWITCHON] <computer>', '[FIND] <keyboard>', '[TYPE] <keyboard>', '[FIND] <mail>', '[GRAB] <mail>', '[READ] <mail>']
}

Input:
Scene_Objects:['blender', 'food_ice_cream', 'walllamp', 'bathroom', 'knifeblock', 'cpuscreen', 'character', 'envelope', 'stovefan', 'stereo', 'shower', 'window', 'towel', 'dining_room', 'broom', 'nightstand', 'cup', 'basket_for_clothes', 'check', 'food_rice', 'doorjamb', 'diary', 'mouse', 'kitchen_counter', 'chessboard', 'hairbrush', 'hair', 'dresser', 'light', 'shoe_rack']
Task:Read book
response:

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

[WALK] <home_office>
[WALK] <address_book>
[FIND] <address_book>
[GRAB] <address_book>
[READ] <address_book>


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', 'walllamp', 'knifeblock', 'kitchen_cabinet', 'floor', 'ceiling', 'folder', 'character', 'desk', 'faucet', 'stereo', 'mousepad', 'food_orange', 'wall', 'oven', 'photoframe', 'oven_mitts', 'water', 'drinking_glass', 'wooden_spoon', 'towel_rack', 'shaving_cream', 'kitchen_counter', 'cupboard', 'food_steak', 'sink', 'spoon', 'board_game']
Task:Drink
response:
{
    "thoughts": Go to kitchen, open cabinet, get glass, close cabinet, put glass under faucet, turn on water, turn off water when glass has 85% water, lift glass to mouth, open mouth and put on glass, tilt glass up and swallow water.,
    "actions": ['[WALK] <dining_room>', '[WALK] <kitchen_cabinet>', '[FIND] <kitchen_cabinet>', '[TURNTO] <kitchen_cabinet>', '[LOOKAT] <kitchen_cabinet>', '[FIND] <drinking_glass>', '[GRAB] <drinking_glass>', '[FIND] <faucet>', '[SWITCHON] <faucet>', '[FIND] <water>', '[FIND] <sink>', '[PUTBACK] <drinking_glass> <sink>', '[GRAB] <drinking_glass>', '[SWITCHOFF] <faucet>', '[DRINK] <drinking_glass>']
}

Input:
Scene_Objects:['pot', 'food_ice_cream', 'tea', 'walllamp', 'ground_coffee', 'detergent', 'trashcan', 'milk', 'drawing', 'knifeblock', 'orchid', 'floor', 'phone', 'bookshelf', 'stovefan', 'ceilinglamp', 'deck_of_cards', 'shower', 'window', 'couch', 'dustpan', 'pillow', 'dining_room', 'wall', 'nightstand', 'toy', 'photoframe', 'food_food', 'curtain', 'table']
Task:Relax on sofa
response:

I walk into the living room. I bend down. I sit on the sofa.

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


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

Here is an example plan to achieve a goal for reference:
Scene_Objects:['tablelamp', 'chair', 'walllamp', 'orchid', 'drawing', 'cpuscreen', 'wallshelf', 'hanger', 'floor', 'ceiling', 'phone', 'shampoo', 'desk', 'keyboard', 'computer', 'ceilinglamp', 'tvstand', 'mat', 'mousepad', 'couch', 'pillow', 'wall', 'nightstand', 'oven', 'food_food', 'television', 'doorjamb', 'mouse', 'dresser', 'door']
Task:Work
response:
{
    "thoughts": I go to my office. I switch the computer on and sit on the office chair. I look at the computer screen to see what needs to be done. I use my mouse to navigate to the relevant directory, then release it. I type code with my keyboard. When I'm done, I look at the computer again to evaluate what I've done. Then I switch off the computer using the mouse and put back the mouse.,
    "actions": ['[WALK] <home_office>', '[WALK] <computer>', '[FIND] <computer>', '[SWITCHON] <computer>', '[FIND] <chair>', '[SIT] <chair>', '[TURNTO] <computer>', '[LOOKAT] <computer>', '[FIND] <mouse>', '[GRAB] <mouse>', '[PUTOBJBACK] <mouse>', '[FIND] <keyboard>', '[TYPE] <keyboard>', '[TURNTO] <computer>', '[LOOKAT] <computer>', '[GRAB] <mouse>', '[SWITCHOFF] <computer>', '[PUTOBJBACK] <mouse>']
}

Input:
Scene_Objects:['pot', 'chair', 'freezer', 'walllamp', 'detergent', 'drawing', 'orchid', 'floor', 'ceiling', 'phone', 'computer', 'ceilinglamp', 'tvstand', 'mat', 'window', 'couch', 'pillow', 'wall', 'powersocket', 'cutting_board', 'bed', 'television', 'curtain', 'doorjamb', 'hairbrush', 'controller', 'door', 'table', 'dishwasher', 'instrument_violin']
Task:Watch TV
response:

go to the living room. find the remote. sit on the couch. turn on the tv.

[WALK] <home_office>
[WALK] <remote_control>
[FIND] <remote_control>
[GRAB] <remote_control>
[WALK] <couch>
[SIT] <couch>
[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:['sheets', 'mop', 'bathroom', 'knife', 'hanger', 'bathroom_counter', 'ceiling', 'bedroom', 'desk', 'food_cake', 'window', 'electric_shaver', 'microphone', 'food_jam', 'dining_room', 'wall', 'photoframe', 'food_food', 'television', 'curtain', 'mouse', 'kitchen_counter', 'cd', 'chessboard', 'dresser', 'hairbrush', 'clothes_scarf', 'bathroom_cabinet', 'dishwasher', 'instrument_violin']
Task:Put on coat
response:
{
    "thoughts": I remove my scarf from a coat peg in the entrance hall.  I wrap the scarf around my neck,
    "actions": ['[WALK] <home_office>', '[WALK] <hanger>', '[TURNTO] <hanger>', '[LOOKAT] <hanger>', '[FIND] <clothes_scarf>', '[GRAB] <clothes_scarf>', '[PUTON] <clothes_scarf>']
}

Input:
Scene_Objects:['pot', 'measuring_cup', 'microwave', 'chair', 'food_butter', 'drawing', 'orchid', 'bathroom_counter', 'floor', 'phone', 'ceiling', 'desk', 'food_bacon', 'mat', 'tvstand', 'form', 'pillow', 'dining_room', 'wall', 'bench', 'cup', 'light_bulb', 'television', 'kettle', 'kitchen_counter', 'cd', 'cupboard', 'clothes_dress', 'door', 'bathroom_cabinet']
Task:Pick up phone
response:

I walk over to the phone. .I reach my arm out. I open my hand. I place my hand on the phone. I close my fingers around the phone. I pick up the phone.

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


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

Here is an example plan to achieve a goal for reference:
Scene_Objects:['sheets', 'chair', 'walllamp', 'drawing', 'wallshelf', 'hanger', 'floor', 'ceiling', 'shampoo', 'desk', 'bookshelf', 'remote_control', 'computer', 'mat', 'tvstand', 'ceilinglamp', 'closetdrawer', 'couch', 'pillow', 'food_kiwi', 'wall', 'nightstand', 'oven', 'photoframe', 'television', 'doorjamb', 'headset', 'dresser', 'bathroom_cabinet', 'soap']
Task:Change TV channel
response:
{
    "thoughts": I find the remote then I push the button to switch it to the tv channel i want to watch,
    "actions": ['[WALK] <home_office>', '[WALK] <remote_control>', '[FIND] <remote_control>', '[GRAB] <remote_control>', '[FIND] <television>', '[TURNTO] <television>', '[POINTAT] <television>', '[PUSH] <remote_control>']
}

Input:
Scene_Objects:['dry_pasta', 'sheets', 'filing_cabinet', 'tablelamp', 'walllamp', 'bathroom', 'trashcan', 'knifeblock', 'kitchen_cabinet', 'ceiling', 'bookshelf', 'piano_bench', 'plate', 'shower', 'window', 'couch', 'dining_room', 'pasta', 'oven', 'bench', 'television', 'water', 'drinking_glass', 'curtain', 'doorjamb', 'clothes_scarf', 'napkin', 'light', 'dishwasher', 'colander']
Task:Drink
response:

You walk to the kitchen and open the kitchen cabinet and grab a drinking glass. You find the water and pour the water into the drinking glass. You drink the water from the glass.

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


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

Here is an example plan to achieve a goal for reference:
Scene_Objects:['pot', 'filing_cabinet', 'freezer', 'bathroom', 'drawing', 'cpuscreen', 'floor', 'ceiling', 'phone', 'character', 'desk', 'bookshelf', 'keyboard', 'computer', 'clothes_jacket', 'table_cloth', 'mat', 'food_kiwi', 'wall', 'powersocket', 'clothes_gloves', 'food_food', 'coffe_maker', 'doorjamb', 'coffee_pot', 'headset', 'door', 'hairdryer', 'light', 'tooth_paste']
Task:Turn on light
response:
{
    "thoughts": I walk towards to the bedroom, and I open the door of the bedroom, and I switch on the lights inside the bedroom, the switch is beside the door.,
    "actions": ['[WALK] <bedroom>', '[WALK] <light>', '[FIND] <light>', '[SWITCHON] <light>']
}

Input:
Scene_Objects:['sheets', 'pot', 'filing_cabinet', 'food_pizza', 'food_salt', 'microwave', 'floor', 'phone', 'ceiling', 'bedroom', 'computer', 'table_cloth', 'stovefan', 'shower', 'stereo', 'couch', 'clothes_pants', 'nightstand', 'oven', 'cup', 'photoframe', 'novel', 'television', 'food_donut', 'ice', 'doorjamb', 'mouse', 'light', 'colander', 'board_game']
Task:Listen to music
response:

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


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

Here is an example plan to achieve a goal for reference:
Scene_Objects:['pot', 'chair', 'freezer', 'drawing', 'needle', 'cpuscreen', 'hanger', 'floor', 'ceiling', 'desk', 'bookshelf', 'envelope', 'computer', 'ceilinglamp', 'mousepad', 'closetdrawer', 'couch', 'dustpan', 'dining_room', 'wall', 'nightstand', 'powersocket', 'food_food', 'toilet_paper', 'doorjamb', 'coffee_pot', 'mouse', 'kettle', 'dresser', 'light']
Task:Turn on light
response:
{
    "thoughts": walk into living room, walk to light, turn on light switch.,
    "actions": ['[WALK] <home_office>', '[WALK] <light>', '[SWITCHON] <light>']
}

Input:
Scene_Objects:['pot', 'filing_cabinet', 'tablelamp', 'walllamp', 'drawing', 'bathroom_counter', 'floor', 'phone', 'piano_bench', 'toaster', 'mat', 'faucet', 'shower', 'window', 'dining_room', 'wall', 'bench', 'hands_both', 'bed', 'television', 'oven_mitts', 'water', 'curtain', 'paper_towel', 'hairdryer', 'sink', 'bathroom_cabinet', 'home_office', 'soap', 'teeth']
Task:Wash hands
response:

I walk into the bathroom. I turn on the water. I put soap on my hands. I rinse my hands. I turn off the water. I dry my hands.

[WALK] <bathroom>
[WALK] <sink>
[FIND] <water>
[TURNTO] <water>
[FIND] <soap>
[GRAB] <soap>
[FIND] <hands_both>
[SCRUB] <hands_both>
[RINSE] <hands_both>
[TURNTO] <water>
[FIND] <paper_towel>
[GRAB] <paper_towel>


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', 'tea', 'drawing', 'wallshelf', 'hanger', 'ceiling', 'tea_bag', 'bookshelf', 'stovefan', 'toaster', 'mat', 'faucet', 'floor_lamp', 'mousepad', 'nightstand', 'box', 'bed', 'photoframe', 'novel', 'food_food', 'coffee_filter', 'food_donut', 'wine', 'after_shave', 'curtain', 'doorjamb', 'clothes_dress', 'conditioner', 'sink']
Task:Read book
response:
{
    "thoughts": Turn a light on and read a book in the bedroom.,
    "actions": ['[WALK] <bedroom>', '[WALK] <floor_lamp>', '[FIND] <floor_lamp>', '[SWITCHON] <floor_lamp>', '[FIND] <novel>', '[GRAB] <novel>', '[READ] <novel>']
}

Input:
Scene_Objects:['dry_pasta', 'food_pizza', 'mop', 'cat', 'knife', 'drawing', 'bathroom_counter', 'floor', 'ceiling', 'shampoo', 'dvd_player', 'keyboard', 'computer', 'mat', 'ceilinglamp', 'faucet', 'stereo', 'window', 'couch', 'towel', 'wall', 'novel', 'tray', 'doorjamb', 'hairbrush', 'sink', 'bathroom_cabinet', 'soap', 'hands_both', 'shoe_rack']
Task:Wash hands
response:

I go to the sink, turn on the water,  put soap on my hands, rub them together, then rinse them off and turn off the water. I then towel off my hands.

[WALK] <bathroom>
[WALK] <sink>
[FIND] <faucet>
[SWITCHON] <faucet>
[FIND] <soap>
[GRAB] <soap>
[FIND] <hands_both>
[WASH] <hands_both>
[RINSE] <hands_both>
[SWITCHOFF] <faucet>
[FIND] <towel>
[GRAB] <towel>
[FIND] <hands_both>
[WIPE] <hands_both>


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

Here is an example plan to achieve a goal for reference:
Scene_Objects:['pot', 'crayon', 'chair', 'bathroom', 'food_butter', 'phone', 'ceiling', 'bedroom', 'tea_bag', 'laptop', 'ceilinglamp', 'shower', 'iron', 'clothes_socks', 'closetdrawer', 'clothes_pants', 'pillow', 'wall', 'powersocket', 'standingmirror', 'photoframe', 'toothbrush_holder', 'food_donut', 'curtain', 'doorjamb', 'towel_rack', 'pencil', 'controller', 'door', 'table']
Task:Switch on lamp
response:
{
    "thoughts": Press the button so the light comes on.,
    "actions": ['[WALK] <bedroom>', '[WALK] <floor_lamp>', '[FIND] <floor_lamp>', '[SWITCHON] <floor_lamp>']
}

Input:
Scene_Objects:['tea', 'toilet', 'freezer', 'band-aids', 'knifeblock', 'food_egg', 'shampoo', 'phone', 'bookshelf', 'purse', 'thread', 'deck_of_cards', 'shower', 'picture', 'clothes_socks', 'oven', 'food_cheese', 'novel', 'food_food', 'check', 'coffe_maker', 'tray', 'after_shave', 'curtain', 'doorjamb', 'cupboard', 'controller', 'bag', 'table', 'scrabble']
Task:Drink
response:

Pour water into a glass and drink from the glass.

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


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

Here is an example plan to achieve a goal for reference:
Scene_Objects:['fork', 'pot', 'microwave', 'toilet', 'cat', 'wallshelf', 'bathroom_counter', 'floor', 'dvd_player', 'bookshelf', 'stovefan', 'ceilinglamp', 'toaster', 'mat', 'shower', 'faucet', 'tvstand', 'couch', 'towel', 'wall', 'bench', 'cutting_board', 'bed', 'razor', 'television', 'curtain', 'kitchen_counter', 'dresser', 'home_office', 'light']
Task:Pet cat
response:
{
    "thoughts": Pet Cat,
    "actions": ['[WALK] <home_office>', '[WALK] <cat>', '[FIND] <cat>', '[WALK] <cat>', '[TURNTO] <cat>', '[LOOKAT] <cat>', '[TOUCH] <cat>']
}

Input:
Scene_Objects:['sheets', 'filing_cabinet', 'blender', 'beer', 'freezer', 'band-aids', 'walllamp', 'orchid', 'food_egg', 'cpuscreen', 'clothes_underwear', 'floor', 'ceiling', 'desk', 'keyboard', 'computer', 'food_bacon', 'button', 'ceilinglamp', 'mousepad', 'food_peanut_butter', 'wall', 'powersocket', 'food_food', 'doorjamb', 'mouse', 'door', 'sink', 'napkin', 'light']
Task:Put groceries in Fridge
response:

I walk in to the kitchen. I open the fridge. I place the groceries in the fridge. I close the fridge.

[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:['sheets', 'measuring_cup', 'microwave', 'freezer', 'ceilingfan', 'milk', 'floor', 'ceiling', 'character', 'bedroom', 'computer', 'button', 'toaster', 'faucet', 'picture', 'wall', 'nightstand', 'oven', 'photoframe', 'clothes_gloves', 'coffe_maker', 'food_food', 'curtain', 'centerpiece', 'food_sugar', 'vacuum_cleaner', 'chessboard', 'coffee_cup', 'dishwasher', 'light']
Task:Make coffee
response:
{
    "thoughts": walk to kitchen, look at the coffee maker, open the coffee maker, find milk, suger and water, mix that all, put into coffee maker, switch on the coffee maker, wait for few mins, push the coffee button in coffee maker, we get coffee in coffee cup, drink coffee,
    "actions": ['[WALK] <dining_room>', '[WALK] <coffe_maker>', '[FIND] <coffe_maker>', '[TURNTO] <coffe_maker>', '[LOOKAT] <coffe_maker>', '[OPEN] <coffe_maker>', '[FIND] <milk>', '[GRAB] <milk>', '[PUTBACK] <milk> <coffe_maker>', '[FIND] <food_sugar>', '[FIND] <coffee_cup>', '[GRAB] <coffee_cup>', '[PUTBACK] <coffee_cup> <coffe_maker>', '[SWITCHON] <coffe_maker>', '[FIND] <button>', '[PUSH] <button>', '[GRAB] <coffee_cup>', '[DRINK] <coffee_cup>']
}

Input:
Scene_Objects:['sheets', 'food_bread', 'tablelamp', 'crayon', 'walllamp', 'drawing', 'orchid', 'knifeblock', 'floor', 'ceiling', 'dvd_player', 'bedroom', 'remote_control', 'ceilinglamp', 'tvstand', 'mat', 'window', 'couch', 'pillow', 'dining_room', 'wall', 'powersocket', 'coffe_maker', 'television', 'curtain', 'after_shave', 'doorjamb', 'door', 'bathroom_cabinet', 'table']
Task:Watch TV
response:

You walk to the living room and sit on the sofa. You grab the remote control, look at it and point at the television, you watch television.

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


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', 'food_ice_cream', 'tea', 'walllamp', 'drawing', 'bills', 'knifeblock', 'orchid', 'bathroom_counter', 'floor', 'keyboard', 'bookshelf', 'envelope', 'computer', 'ceilinglamp', 'iron', 'window', 'couch', 'pillow', 'wall', 'powersocket', 'oven', 'toy', 'television', 'tray', 'curtain', 'sink', 'bathroom_cabinet', 'table']
Task:Read magazine
response:
{
    "thoughts": Please sit on the couch and read a magazine,
    "actions": ['[WALK] <home_office>', '[WALK] <newspaper>', '[FIND] <newspaper>', '[GRAB] <newspaper>', '[WALK] <couch>', '[SIT] <couch>', '[TURNTO] <newspaper>', '[LOOKAT] <newspaper>', '[READ] <newspaper>', '[READ] <newspaper>', '[READ] <newspaper>']
}

Input:
Scene_Objects:['pot', 'tablelamp', 'juice', 'toilet', 'walllamp', 'nail_polish', 'trashcan', 'knifeblock', 'cpuscreen', 'floor', 'phone', 'desk', 'stovefan', 'plate', 'faucet', 'window', 'mousepad', 'form', 'pillow', 'wall', 'wall_clock', 'oven', 'clothes_gloves', 'tray', 'diary', 'kitchen_counter', 'shoes', 'cupboard', 'door', 'sink']
Task:Wash dishes by hand
response:

Walking towards sink and look at the leftover plates. Scrape dishes to remove leftover food - use a rubber spatula or paper towel. Fill sink or dishpan with clean, hot water. Then wash and rinse to removing residues. Finally leave it to dry.

[WALK] <dining_room>
[WALK] <kitchen_counter>
[FIND] <plate>
[TURNTO] <plate>
[LOOKAT] <plate>
[GRAB] <plate>
[SCRUB] <plate>
[RINSE] <plate>
[WASH] <plate>
[PUTBACK] <plate> <kitchen_counter>


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

Here is an example plan to achieve a goal for reference:
Scene_Objects:['blender', 'band-aids', 'freezer', 'walllamp', 'nail_polish', 'trashcan', 'dough', 'drawing', 'bills', 'cpuscreen', 'bathroom_counter', 'ceiling', 'phone', 'character', 'desk', 'purse', 'alcohol', 'clothes_jacket', 'toaster', 'mat', 'faucet', 'oil', 'couch', 'broom', 'oven', 'photoframe', 'tray', 'kitchen_counter', 'dresser', 'laser_pointer']
Task:Pet cat
response:
{
    "thoughts": Find a cat in the kitchen and touch it,
    "actions": ['[WALK] <dining_room>', '[WALK] <cat>', '[FIND] <cat>', '[WALK] <cat>', '[TOUCH] <cat>']
}

Input:
Scene_Objects:['microwave', 'chair', 'walllamp', 'food_carrot', 'orchid', 'knife', 'cpuscreen', 'floor', 'ceiling', 'phone', 'desk', 'keyboard', 'bookshelf', 'computer', 'food_bacon', 'ceilinglamp', 'mat', 'tvstand', 'stereo', 'mousepad', 'couch', 'wall', 'powersocket', 'toy', 'photoframe', 'mouse', 'controller', 'door', 'table', 'light']
Task:Browse internet
response:

turn on the computer and browse the internet

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


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

Here is an example plan to achieve a goal for reference:
Scene_Objects:['microwave', 'toilet', 'freezer', 'walllamp', 'bathroom', 'trashcan', 'orchid', 'floor', 'toaster', 'mat', 'faucet', 'shower', 'pillow', 'wall', 'nightstand', 'bench', 'toy', 'coffe_maker', 'television', 'curtain', 'after_shave', 'doorjamb', 'towel_rack', 'kitchen_counter', 'chessboard', 'sink', 'home_office', 'bathroom_cabinet', 'table', 'instrument_violin']
Task:Go to toilet
response:
{
    "thoughts": Walk to the bathroom.  Find the toilet.  Lift the top of the toilet.  Sit on the toilet.,
    "actions": ['[WALK] <bathroom>', '[WALK] <toilet>', '[FIND] <toilet>', '[OPEN] <toilet>', '[SIT] <toilet>']
}

Input:
Scene_Objects:['sponge', 'pot', 'filing_cabinet', 'tablelamp', 'food_ice_cream', 'beer', 'toilet', 'drawing', 'hanger', 'floor', 'bookshelf', 'envelope', 'tvstand', 'shower', 'faucet', 'candle', 'dining_room', 'broom', 'wall', 'toy', 'cup', 'photoframe', 'clothes_gloves', 'light_bulb', 'wooden_spoon', 'curtain', 'doorjamb', 'chessboard', 'dishrack', 'door']
Task:Go to toilet
response:

I walk to the entrance of the bathroom. I turn to the door. I open the door to the bathroom. I walk inside of the bathroom. I find the toilet inside of the bathroom and walk over to it. I turn and look at the toilet.

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


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

Here is an example plan to achieve a goal for reference:
Scene_Objects:['filing_cabinet', 'tablelamp', 'dog', 'freezer', 'orchid', 'drawing', 'wallshelf', 'ceiling', 'character', 'mail', 'clothes_jacket', 'computer', 'mat', 'faucet', 'window', 'closetdrawer', 'nightstand', 'wall_clock', 'oven', 'basket_for_clothes', 'coffe_maker', 'mouse', 'dresser', 'cupboard', 'laundry_detergent', 'sink', 'bathroom_cabinet', 'light', 'scrabble', 'washing_machine']
Task:Wash clothes
response:
{
    "thoughts": Pick up my dirty clothes, load the washer, add detergent, turn on washer,
    "actions": ['[WALK] <bedroom>', '[WALK] <basket_for_clothes>', '[GRAB] <basket_for_clothes>', '[WALK] <home_office>', '[WALK] <washing_machine>', '[OPEN] <washing_machine>', '[PUTBACK] <basket_for_clothes> <washing_machine>', '[FIND] <laundry_detergent>', '[GRAB] <laundry_detergent>', '[PUTBACK] <laundry_detergent> <washing_machine>', '[RUN] <washing_machine>']
}

Input:
Scene_Objects:['food_pizza', 'food_bread', 'beer', 'freezer', 'knifeblock', 'cpuscreen', 'floor', 'ceiling', 'desk', 'keyboard', 'food_cake', 'alcohol', 'computer', 'clothes_jacket', 'ceilinglamp', 'tvstand', 'mousepad', 'microphone', 'towel', 'wall', 'powersocket', 'food_food', 'television', 'wine', 'doorjamb', 'mouse', 'pencil', 'door', 'light', 'dishwasher']
Task:Put groceries in Fridge
response:

Go to kitchen and put groceries in fridge

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


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

Here is an example plan to achieve a goal for reference:
Scene_Objects:['tablelamp', 'walllamp', 'knifeblock', 'drawing', 'cpuscreen', 'clothes_underwear', 'knife', 'floor', 'ceiling', 'cleaning_solution', 'piano_bench', 'toaster', 'ceilinglamp', 'faucet', 'stereo', 'iron', 'wall', 'oven', 'cutting_board', 'tape', 'check', 'coin', 'kitchen_counter', 'dishrack', 'cupboard', 'sink', 'bag', 'home_office', 'instrument_violin', 'hands_both']
Task:Wash hands
response:
{
    "thoughts": Washing hands,
    "actions": ['[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>']
}

Input:
Scene_Objects:['chair', 'walllamp', 'orchid', 'cpuscreen', 'clothes_underwear', 'floor', 'ceiling', 'phone', 'desk', 'keyboard', 'computer', 'mat', 'ceilinglamp', 'stereo', 'tvstand', 'mousepad', 'couch', 'broom', 'wall', 'bed', 'check', 'toilet_paper', 'television', 'ice', 'kettle', 'mouse', 'door', 'sink', 'home_office', 'table']
Task:Browse internet
response:

I go in my office, sit at my desk turn on the computer, then type on my keyboard and open my web browser.

[WALK] <home_office>
[WALK] <desk>
[FIND] <chair>
[SIT] <chair>
[FIND] <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:['filing_cabinet', 'juice', 'microwave', 'cat', 'drawing', 'bathroom_counter', 'floor', 'ceiling', 'keyboard', 'computer', 'clothes_jacket', 'button', 'ceilinglamp', 'mat', 'window', 'couch', 'food_jam', 'wall', 'nightstand', 'cutting_board', 'cup', 'television', 'mouse', 'pencil', 'kitchen_counter', 'cupboard', 'laundry_detergent', 'table', 'vase', 'coffee']
Task:Pet cat
response:
{
    "thoughts": Walk into bedrrom and to the sofa. Sit on the sofa and touch cat.,
    "actions": ['[WALK] <home_office>', '[WALK] <couch>', '[SIT] <couch>', '[FIND] <cat>', '[TOUCH] <cat>']
}

Input:
Scene_Objects:['toilet', 'chair', 'walllamp', 'food_butter', 'trashcan', 'orchid', 'drawing', 'cpuscreen', 'hanger', 'floor', 'ceiling', 'desk', 'bedroom', 'keyboard', 'computer', 'ceilinglamp', 'mat', 'mousepad', 'towel', 'wall', 'pasta', 'bench', 'cup', 'curtain', 'mouse', 'dresser', 'clothes_dress', 'door', 'table', 'tooth_paste']
Task:Write an email
response:

enter office, find computer, turn it on,

[WALK] <home_office>
[WALK] <computer>
[FIND] <computer>
[SWITCHON] <computer>
[FIND] <keyboard>
[TOUCH] <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:['chair', 'orchid', 'wallshelf', 'floor', 'ceiling', 'phone', 'bookshelf', 'computer', 'clothes_jacket', 'table_cloth', 'ceilinglamp', 'shower', 'window', 'homework', 'mousepad', 'pillow', 'powersocket', 'photoframe', 'coffe_maker', 'doorjamb', 'kettle', 'shoes', 'dresser', 'cupboard', 'laundry_detergent', 'clothes_dress', 'door', 'bag', 'light', 'washing_machine']
Task:Wash clothes
response:
{
    "thoughts": Go to bedroom and grab dirty pants and take to the washing machine in entrance hall. Put clothes in washing machine and then put in laundry detergent.,
    "actions": ['[WALK] <bedroom>', '[WALK] <clothes_pants>', '[FIND] <clothes_pants>', '[GRAB] <clothes_pants>', '[WALK] <home_office>', '[WALK] <washing_machine>', '[FIND] <washing_machine>', '[OPEN] <washing_machine>', '[PUTBACK] <clothes_pants> <washing_machine>', '[FIND] <laundry_detergent>', '[GRAB] <laundry_detergent>', '[PUTBACK] <laundry_detergent> <washing_machine>', '[CLOSE] <washing_machine>']
}

Input:
Scene_Objects:['dry_pasta', 'microwave', 'blow_dryer', 'detergent', 'cat', 'drawing', 'desk', 'thread', 'computer', 'button', 'table_cloth', 'ceilinglamp', 'tvstand', 'mousepad', 'broom', 'nightstand', 'oven', 'powersocket', 'box', 'newspaper', 'coffe_maker', 'tray', 'doorjamb', 'mouse', 'conditioner', 'bag', 'napkin', 'table', 'light', 'soap']
Task:Pet cat
response:


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

Here is an example plan to achieve a goal for reference:
Scene_Objects:['filing_cabinet', 'microwave', 'chair', 'walllamp', 'drawing', 'wallshelf', 'hanger', 'floor', 'ceiling', 'character', 'desk', 'remote_control', 'computer', 'piano_bench', 'mat', 'tvstand', 'ceilinglamp', 'clothes_socks', 'closetdrawer', 'couch', 'pillow', 'towel', 'wall', 'powersocket', 'photoframe', 'television', 'doorjamb', 'dresser', 'door', 'bathroom_cabinet']
Task:Watch TV
response:
{
    "thoughts": Sit on the couch and use the remote control to turn on the TV,
    "actions": ['[WALK] <home_office>', '[WALK] <couch>', '[FIND] <couch>', '[SIT] <couch>', '[FIND] <remote_control>', '[GRAB] <remote_control>', '[FIND] <television>', '[SWITCHON] <television>', '[PUTOBJBACK] <remote_control>', '[TURNTO] <television>', '[WATCH] <television>']
}

Input:
Scene_Objects:['food_bread', 'toilet', 'jelly', 'walllamp', 'trashcan', 'drawing', 'orchid', 'floor', 'ceiling', 'phone', 'remote_control', 'ceilinglamp', 'tvstand', 'mat', 'stereo', 'electric_shaver', 'microphone', 'wall', 'pasta', 'powersocket', 'oven', 'bed', 'television', 'doorjamb', 'mouse', 'hair', 'door', 'table', 'colander', 'instrument_violin']
Task:Change TV channel
response:

first i will go to living room and then take the remote and swtitch on television after that il change the channel

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


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

Here is an example plan to achieve a goal for reference:
Scene_Objects:['pot', 'tablelamp', 'chair', 'walllamp', 'drawing', 'cpuscreen', 'wallshelf', 'floor', 'phone', 'ceiling', 'desk', 'keyboard', 'computer', 'bookmark', 'mat', 'tvstand', 'mousepad', 'couch', 'pillow', 'wall', 'oven', 'powersocket', 'photoframe', 'novel', 'television', 'tray', 'doorjamb', 'towel_rack', 'mouse', 'comb', 'door', 'light']
Task:Read book
response:
{
    "thoughts": Find book, grab book, fin bookmark, sit down somewhere comfortable, open book, read book, close book after reading.,
    "actions": ['[WALK] <desk>', '[FIND] <novel>', '[FIND] <bookmark>', '[GRAB] <bookmark>', '[FIND] <couch>', '[SIT] <couch>', '[GRAB] <novel>', '[READ] <novel>', '[PUTBACK] <bookmark> <novel>']
}

Input:
Scene_Objects:['freezer', 'orchid', 'cpuscreen', 'floor', 'ceiling', 'phone', 'character', 'desk', 'bedroom', 'keyboard', 'food_cake', 'computer', 'button', 'ceilinglamp', 'mousepad', 'wall', 'nightstand', 'powersocket', 'cup', 'food_food', 'check', 'doorjamb', 'lighter', 'mouse', 'shoes', 'dishrack', 'controller', 'door', 'light', 'scrabble']
Task:Put groceries in Fridge
response:

put away groceries in fridge. open the door, put on shelf, close the door.

[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:['sheets', 'food_salt', 'walllamp', 'bathroom', 'trashcan', 'knifeblock', 'bedroom', 'toaster', 'ceilinglamp', 'tvstand', 'balanceball', 'shower', 'mousepad', 'microphone', 'dining_room', 'nightstand', 'basket_for_clothes', 'bed', 'newspaper', 'coffe_maker', 'check', 'tray', 'curtain', 'doorjamb', 'mouse', 'headset', 'laundry_detergent', 'maindoor', 'bathroom_cabinet', 'washing_machine']
Task:Wash clothes
response:
{
    "thoughts": Walk to laundry room. Find laundry basket. Grab laundry basket. Find washing machine. Walk to washing machine. Open washing machine. Find detergent. Grab detergent. Put in detergent. Put in clothes. Close washing machine. Turn on machine.,
    "actions": ['[WALK] <bathroom>', '[WALK] <basket_for_clothes>', '[FIND] <basket_for_clothes>', '[GRAB] <basket_for_clothes>', '[FIND] <washing_machine>', '[WALK] <washing_machine>', '[OPEN] <washing_machine>', '[FIND] <laundry_detergent>', '[GRAB] <laundry_detergent>', '[POUR] <laundry_detergent> <washing_machine>', '[PUTOBJBACK] <laundry_detergent>', '[PUTBACK] <basket_for_clothes> <washing_machine>', '[CLOSE] <washing_machine>', '[SWITCHON] <washing_machine>']
}

Input:
Scene_Objects:['filing_cabinet', 'knifeblock', 'bills', 'bathroom_counter', 'ceiling', 'character', 'desk', 'bedroom', 'computer', 'bookmark', 'shoe-shine_kit', 'pillow', 'towel', 'pasta', 'oven', 'powersocket', 'toy', 'cup', 'photoframe', 'light_bulb', 'television', 'kitchen_counter', 'chessboard', 'comb', 'pajamas', 'food_steak', 'sink', 'instrument_violin', 'bag', 'tooth_paste']
Task:Pick up phone
response:

Walk into the home office. Pick up the phone.

[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:['pot', 'microwave', 'walllamp', 'knifeblock', 'orchid', 'floor', 'phone', 'ceiling', 'bedroom', 'keyboard', 'food_bacon', 'stovefan', 'toaster', 'plate', 'faucet', 'window', 'homework', 'closetdrawer', 'wall', 'oven', 'ice', 'tray', 'rag', 'doorjamb', 'kitchen_counter', 'cupboard', 'hairdryer', 'sink', 'bathroom_cabinet', 'coffee']
Task:Wash dishes by hand
response:
{
    "thoughts": Walking towards sink and look at the leftover plates. Scrape dishes to remove leftover food - use a rubber spatula or paper towel. Fill sink or dishpan with clean, hot water. Then wash and rinse to removing residues. Finally leave it to dry.,
    "actions": ['[WALK] <dining_room>', '[WALK] <kitchen_counter>', '[FIND] <plate>', '[TURNTO] <plate>', '[LOOKAT] <plate>', '[GRAB] <plate>', '[SCRUB] <plate>', '[RINSE] <plate>', '[WASH] <plate>', '[PUTBACK] <plate> <kitchen_counter>']
}

Input:
Scene_Objects:['pot', 'filing_cabinet', 'measuring_cup', 'microwave', 'walllamp', 'bathroom', 'trashcan', 'knifeblock', 'cpuscreen', 'floor', 'desk', 'toaster', 'stovefan', 'plate', 'faucet', 'iron', 'dish_soap', 'wall', 'oven', 'coffe_maker', 'food_food', 'wooden_spoon', 'tray', 'kitchen_counter', 'dishrack', 'cupboard', 'door', 'sink', 'bathroom_cabinet', 'dishwasher']
Task:Wash dishes with dishwasher
response:

I walk into the kitchen and go to the dishwasher. I open the dishwasher and grab the dishes. Iplace the dishes into the dishwasher then close it. I add soap then turn the dishwasher on.

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


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

Here is an example plan to achieve a goal for reference:
Scene_Objects:['microwave', 'freezer', 'walllamp', 'blow_dryer', 'milk', 'bills', 'orchid', 'floor', 'ceiling', 'character', 'food_cake', 'alcohol', 'stovefan', 'homework', 'closetdrawer', 'pillow', 'broom', 'wall', 'oven', 'cutting_board', 'cup', 'coffe_maker', 'food_food', 'water', 'tray', 'kitchen_counter', 'shoes', 'sink', 'light', 'table']
Task:Drink
response:
{
    "thoughts": Feeling tired after hard work I opened the fridge and grabbed cool water and drank from the glass.,
    "actions": ['[WALK] <dining_room>', '[WALK] <freezer>', '[FIND] <freezer>', '[OPEN] <freezer>', '[FIND] <cup>', '[GRAB] <cup>', '[CLOSE] <freezer>', '[FIND] <water>', '[GRAB] <water>', '[FIND] <cup>', '[POUR] <water> <cup>', '[FIND] <cup>', '[DRINK] <cup>']
}

Input:
Scene_Objects:['food_ice_cream', 'chair', 'walllamp', 'orchid', 'cpuscreen', 'floor', 'ceiling', 'dvd_player', 'desk', 'keyboard', 'bookshelf', 'computer', 'clothes_jacket', 'ceilinglamp', 'mat', 'iron', 'mousepad', 'oil', 'couch', 'pillow', 'wall', 'powersocket', 'oven', 'video_game_controller', 'television', 'doorjamb', 'kettle', 'mouse', 'door', 'table']
Task:Browse internet
response:

Walk to home office. Walk to computer. Switch on Computer.

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