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', 'bathroom', 'knifeblock', 'wallshelf', 'bathroom_counter', 'character', 'bedroom', 'tea_bag', 'keyboard', 'food_cake', 'toaster', 'ceilinglamp', 'shower', 'faucet', 'couch', 'food_jam', 'clothes_pants', 'bowl', 'dining_room', 'nightstand', 'oven', 'ice', 'lighter', 'mouse', 'conditioner', 'door', 'bathroom_cabinet', 'light']
Task:Pick up phone
response:
{
    "thoughts": Walk to the living room, Find Phone stand. Find Phone. Pickup the receiver to attend the call.,
    "actions": ['[WALK] <home_office>', '[WALK] <phone>', '[FIND] <phone>', '[GRAB] <phone>']
}

Input:
Scene_Objects:['water_glass', 'tablelamp', 'microwave', 'toilet', 'freezer', 'walllamp', 'trashcan', 'drawing', 'wallshelf', 'floor', 'ceiling', 'phone', 'toaster', 'stovefan', 'mat', 'faucet', 'shower', 'window', 'wall', 'wall_clock', 'oven', 'coffe_maker', 'water', 'tray', 'doorjamb', 'towel_rack', 'kitchen_counter', 'cupboard', 'door', 'sink']
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:['pot', 'tablelamp', 'tea', 'chair', 'drawing', 'orchid', 'cpuscreen', 'floor', 'phone', 'ceiling', 'desk', 'keyboard', 'computer', 'laptop', 'mat', 'ceilinglamp', 'tvstand', 'mousepad', 'wall', 'nightstand', 'oven', 'powersocket', 'bed', 'television', 'tray', 'doorjamb', 'towel_rack', 'mouse', 'door', 'light']
Task:Browse internet
response:
{
    "thoughts": I go to the home office. I put the laptop on the desk. I sit on the chair. I switch on my laptop and I type on the keyboard and browse the internet.,
    "actions": ['[WALK] <home_office>', '[WALK] <laptop>', '[FIND] <laptop>', '[GRAB] <laptop>', '[FIND] <desk>', '[OPEN] <desk>', '[PUTBACK] <laptop> <desk>', '[FIND] <chair>', '[SIT] <chair>', '[SWITCHON] <laptop>', '[TURNTO] <laptop>', '[LOOKAT] <laptop>', '[FIND] <keyboard>', '[TYPE] <keyboard>', '[TURNTO] <laptop>', '[LOOKAT] <laptop>']
}

Input:
Scene_Objects:['sheets', 'pot', 'glue', 'filing_cabinet', 'tablelamp', 'toilet', 'freezer', 'bathroom', 'cat', 'trashcan', 'drawing', 'cpuscreen', 'bathroom_counter', 'ceiling', 'bookshelf', 'keyboard', 'button', 'shoe-shine_kit', 'stereo', 'closetdrawer', 'nightstand', 'bench', 'cup', 'bed', 'photoframe', 'coffe_maker', 'curtain', 'shoes', 'dresser', 'light']
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:['filing_cabinet', 'chair', 'freezer', 'orchid', 'bedroom', 'clothes_jacket', 'mop_bucket', 'stovefan', 'mousepad', 'pillow', 'dining_room', 'nightstand', 'wall', 'powersocket', 'oven', 'basket_for_clothes', 'bed', 'photoframe', 'mouthwash', 'television', 'wine', 'after_shave', 'doorjamb', 'sink', 'bathroom_cabinet', 'light', 'dishwasher', 'soap', 'washing_machine', 'coffee']
Task:Wash clothes
response:
{
    "thoughts": Walk to the kitchen and find the basket of clothes. Put the soap and clothes into the washing machine. Turn on the washing machine.,
    "actions": ['[WALK] <dining_room>', '[WALK] <basket_for_clothes>', '[FIND] <basket_for_clothes>', '[FIND] <washing_machine>', '[TURNTO] <washing_machine>', '[FIND] <soap>', '[GRAB] <soap>', '[OPEN] <washing_machine>', '[PUTBACK] <soap> <washing_machine>', '[FIND] <clothes_jacket>', '[GRAB] <clothes_jacket>', '[PUTBACK] <clothes_jacket> <washing_machine>', '[CLOSE] <washing_machine>', '[SWITCHON] <washing_machine>']
}

Input:
Scene_Objects:['filing_cabinet', 'tablelamp', 'chair', 'bathroom', 'detergent', 'drawing', 'cpuscreen', 'floor', 'ceiling', 'phone', 'desk', 'keyboard', 'bookshelf', 'computer', 'toaster', 'mousepad', 'couch', 'pillow', 'wall', 'powersocket', 'bench', 'toilet_paper', 'television', 'curtain', 'doorjamb', 'mouse', 'door', 'bathroom_cabinet', 'light', 'home_office']
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:['sheets', 'pot', 'filing_cabinet', 'walllamp', 'drawing', 'cpuscreen', 'floor', 'phone', 'button', 'mat', 'stereo', 'window', 'homework', 'foundation', 'couch', 'pillow', 'wall', 'toy', 'cup', 'light_bulb', 'television', 'razor', 'curtain', 'after_shave', 'doorjamb', 'rag', 'coffee_pot', 'laundry_detergent', 'bathtub', 'table']
Task:Arrange furniture
response:
{
    "thoughts": Move furniture where you want it.,
    "actions": ['[WALK] <home_office>', '[WALK] <coffee_table>', '[PUSH] <coffee_table>', '[WALK] <couch>', '[PUSH] <couch>', '[WALK] <couch>', '[PUSH] <couch>', '[WALK] <filing_cabinet>', '[PUSH] <filing_cabinet>']
}

Input:
Scene_Objects:['filing_cabinet', 'microwave', 'toilet', 'freezer', 'walllamp', 'wallshelf', 'hanger', 'floor', 'ceiling', 'phone', 'character', 'desk', 'toaster', 'shower', 'faucet', 'window', 'couch', 'wall', 'powersocket', 'bed', 'coffe_maker', 'doorjamb', 'mouse', 'kitchen_counter', 'cupboard', 'door', 'sink', 'bathtub', 'light', 'laser_pointer']
Task:Take shower
response:

walk to bathroom , find shower , take a shower

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


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

Here is an example plan to achieve a goal for reference:
Scene_Objects:['filing_cabinet', 'microwave', 'toilet', 'detergent', 'cat', 'food_butter', 'knife', 'phone', 'character', 'table_cloth', 'mat', 'deck_of_cards', 'stereo', 'form', 'pillow', 'dining_room', 'nightstand', 'wall', 'basket_for_clothes', 'photoframe', 'tray', 'doorjamb', 'kitchen_counter', 'chessboard', 'dresser', 'clothes_dress', 'table', 'soap', 'washing_machine', 'creditcard']
Task:Wash clothes
response:
{
    "thoughts": Walk to Bathroom. Find basket for clothes. Lift clothes dress from basket. Find washing machine. Walk to washing machine. Put clothes in washing machine. Put soap in washing machine. Switch on washing machine.,
    "actions": ['[WALK] <bathroom>', '[WALK] <basket_for_clothes>', '[FIND] <basket_for_clothes>', '[FIND] <clothes_dress>', '[GRAB] <clothes_dress>', '[FIND] <washing_machine>', '[WALK] <washing_machine>', '[OPEN] <washing_machine>', '[PUTBACK] <clothes_dress> <washing_machine>', '[FIND] <soap>', '[GRAB] <soap>', '[PUTBACK] <soap> <washing_machine>', '[CLOSE] <washing_machine>', '[SWITCHON] <washing_machine>']
}

Input:
Scene_Objects:['wallshelf', 'cpuscreen', 'hanger', 'floor', 'phone', 'desk', 'keyboard', 'bookshelf', 'toaster', 'ceilinglamp', 'tvstand', 'shower', 'window', 'dish_soap', 'form', 'nightstand', 'wall_clock', 'oven', 'powersocket', 'bench', 'tape', 'video_game_controller', 'doorjamb', 'kitchen_counter', 'dresser', 'home_office', 'light', 'dishwasher', 'bathroom_cabinet', 'table']
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:['pot', 'chair', 'walllamp', 'knife', 'desk', 'bookshelf', 'button', 'clothes_jacket', 'stovefan', 'deck_of_cards', 'mousepad', 'closetdrawer', 'oil', 'towel', 'pillow', 'broom', 'basket_for_clothes', 'photoframe', 'novel', 'coffe_maker', 'television', 'wine', 'curtain', 'after_shave', 'cards', 'home_office', 'light', 'clothes_skirt', 'soap', 'washing_machine']
Task:Wash clothes
response:
{
    "thoughts": walk to the bathroom, grab the basket for clothes, find soap, put in washing machine, turn on,
    "actions": ['[WALK] <bathroom>', '[WALK] <basket_for_clothes>', '[FIND] <basket_for_clothes>', '[GRAB] <basket_for_clothes>', '[WALK] <washing_machine>', '[OPEN] <washing_machine>', '[PUTBACK] <basket_for_clothes> <washing_machine>', '[FIND] <soap>', '[GRAB] <soap>', '[WALK] <washing_machine>', '[PUTBACK] <soap> <washing_machine>', '[CLOSE] <washing_machine>', '[SWITCHON] <washing_machine>']
}

Input:
Scene_Objects:['microwave', 'chair', 'hanger', 'bathroom_counter', 'character', 'keyboard', 'bookshelf', 'computer', 'stovefan', 'plate', 'tvstand', 'faucet', 'shower', 'dish_soap', 'mousepad', 'wall', 'wall_clock', 'oven', 'photoframe', 'bed', 'television', 'tray', 'towel_rack', 'dresser', 'door', 'sink', 'bathroom_cabinet', 'table', 'dishwasher', 'dirt']
Task:Wash dishes with dishwasher
response:

walk into kitchen, find dishwasher, put plates in dishwasher, put soap in dishwasher, turn on dishwasher

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


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

Here is an example plan to achieve a goal for reference:
Scene_Objects:['glue', 'tablelamp', 'chair', 'walllamp', 'trashcan', 'ceilingfan', 'drawing', 'cpuscreen', 'floor', 'ceiling', 'phone', 'character', 'desk', 'keyboard', 'bookshelf', 'computer', 'ceilinglamp', 'balanceball', 'mousepad', 'pillow', 'wall', 'nightstand', 'bench', 'food_food', 'doorjamb', 'kettle', 'mouse', 'pencil', 'headset', 'light']
Task:Browse internet
response:
{
    "thoughts": go to the office, turn computer on, open an browser or any application to open any website.,
    "actions": ['[WALK] <home_office>', '[WALK] <computer>', '[FIND] <computer>', '[SWITCHON] <computer>', '[FIND] <computer>']
}

Input:
Scene_Objects:['filing_cabinet', 'chair', 'freezer', 'walllamp', 'cpuscreen', 'bathroom_counter', 'floor', 'ceiling', 'desk', 'keyboard', 'computer', 'ceilinglamp', 'tvstand', 'mousepad', 'closetdrawer', 'pillow', 'dining_room', 'wall', 'wall_clock', 'powersocket', 'photoframe', 'coffe_maker', 'television', 'doorjamb', 'centerpiece', 'mouse', 'cupboard', 'sink', 'bathroom_cabinet', '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:['tea', 'walllamp', 'drawing', 'orchid', 'wallshelf', 'floor', 'ceiling', 'phone', 'bookshelf', 'remote_control', 'toaster', 'mat', 'tvstand', 'ceilinglamp', 'shower', 'window', 'couch', 'form', 'pillow', 'wall', 'powersocket', 'photoframe', 'bed', 'television', 'curtain', 'doorjamb', 'cupboard', 'door', 'table', 'light']
Task:Watch TV
response:
{
    "thoughts": Walk to livingroom, sit on couch, grab remote and turn on tv.,
    "actions": ['[WALK] <home_office>', '[WALK] <couch>', '[FIND] <couch>', '[SIT] <couch>', '[FIND] <remote_control>', '[GRAB] <remote_control>', '[FIND] <television>', '[TURNTO] <television>', '[WATCH] <television>']
}

Input:
Scene_Objects:['filing_cabinet', 'chair', 'walllamp', 'knife', 'cpuscreen', 'bathroom_counter', 'floor', 'ceiling', 'character', 'desk', 'keyboard', 'computer', 'toaster', 'ceilinglamp', 'tvstand', 'mousepad', 'microphone', 'pillow', 'wall', 'powersocket', 'novel', 'television', 'doorjamb', 'towel_rack', 'mouse', 'chessboard', 'door', 'sink', 'home_office', 'table']
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:['sheets', 'tablelamp', 'food_salt', 'crayon', 'drawing', 'orchid', 'hanger', 'floor', 'ceiling', 'bedroom', 'bookshelf', 'ceilinglamp', 'clothes_socks', 'closetdrawer', 'couch', 'pillow', 'wall', 'nightstand', 'powersocket', 'bed', 'food_food', 'video_game_controller', 'doorjamb', 'diary', 'chessboard', 'dresser', 'door', 'light', 'table', 'dishwasher']
Task:Turn on light
response:
{
    "thoughts": flip the switch and turn on the lights,
    "actions": ['[WALK] <light>', '[SWITCHON] <light>']
}

Input:
Scene_Objects:['tablelamp', 'chair', 'freezer', 'bathroom', 'orchid', 'wallshelf', 'bathroom_counter', 'floor', 'phone', 'bedroom', 'desk', 'bookshelf', 'keyboard', 'computer', 'stovefan', 'mat', 'tvstand', 'shower', 'stereo', 'ceilinglamp', 'closetdrawer', 'wall', 'nightstand', 'oven', 'newspaper', 'coffe_maker', 'mouse', 'dresser', 'door', 'bathroom_cabinet']
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', 'food_pizza', 'tablelamp', 'food_salt', 'toilet', 'freezer', 'detergent', 'bills', 'orchid', 'hanger', 'ceiling', 'envelope', 'table_cloth', 'brush', 'mat', 'ceilinglamp', 'shower', 'stovefan', 'nightstand', 'powersocket', 'bench', 'photoframe', 'check', 'food_food', 'wooden_spoon', 'sink', 'napkin', 'instrument_guitar', 'table', 'coffee']
Task:Pull up carpet
response:
{
    "thoughts": Pry up a corner of your old dirty carpet.  Tug as hard as you can until it comes off the tacs. Pull up the pad. Try not to be sick at all the dirt.,
    "actions": ['[WALK] <home_office>', '[WALK] <mat>', '[FIND] <mat>', '[TOUCH] <mat>', '[PULL] <mat>']
}

Input:
Scene_Objects:['freezer', 'walllamp', 'bathroom', 'drawing', 'floor', 'character', 'bedroom', 'keyboard', 'computer', 'stovefan', 'mat', 'tvstand', 'ceilinglamp', 'window', 'couch', 'pillow', 'wall', 'pasta', 'bench', 'cup', 'bed', 'television', 'curtain', 'doorjamb', 'towel_rack', 'mouse', 'headset', 'cupboard', 'instrument_guitar', '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:['microwave', 'toilet', 'chair', 'bathroom', 'toothbrush', 'cpuscreen', 'bathroom_counter', 'floor', 'ceiling', 'bedroom', 'bookshelf', 'computer', 'toaster', 'faucet', 'closetdrawer', 'couch', 'pillow', 'wall', 'wall_clock', 'oven', 'nightstand', 'television', 'toothbrush_holder', 'curtain', 'mouse', 'shoes', 'clothes_dress', 'sink', 'bathroom_cabinet', 'tooth_paste']
Task:Brush teeth
response:
{
    "thoughts": go to bathroom. grab toothbrush. put toothpaste on toothbrush. brush teeth. turn on faucet. rinse toothbrush and mouth. put toothbrush away.,
    "actions": ['[WALK] <bathroom>', '[WALK] <sink>', '[FIND] <toothbrush_holder>', '[TURNTO] <toothbrush_holder>', '[LOOKAT] <toothbrush_holder>', '[FIND] <tooth_paste>', '[GRAB] <tooth_paste>', '[FIND] <toothbrush>', '[GRAB] <toothbrush>', '[PUTBACK] <tooth_paste> <toothbrush_holder>', '[FIND] <faucet>', '[SWITCHON] <faucet>', '[RINSE] <toothbrush>', '[PUTBACK] <toothbrush> <toothbrush_holder>']
}

Input:
Scene_Objects:['pot', 'filing_cabinet', 'microwave', 'chair', 'freezer', 'bathroom', 'drawing', 'cpuscreen', 'wallshelf', 'bathroom_counter', 'ceiling', 'desk', 'computer', 'stovefan', 'mat', 'ceilinglamp', 'homework', 'mousepad', 'closetdrawer', 'pillow', 'dining_room', 'wall_clock', 'oven', 'tape', 'photoframe', 'dresser', 'cupboard', 'bathtub', 'light', 'dirt']
Task:Listen to music
response:

I reach out arm. I put hand on radio. I turn on radio. I pick a station.

[WALK] <bedroom>
[WALK] <stereo>
[TOUCH] <stereo>
[TURNTO] <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:['sheets', 'food_ice_cream', 'measuring_cup', 'knife', 'orchid', 'cpuscreen', 'bathroom_counter', 'ceiling', 'phone', 'alcohol', 'computer', 'table_cloth', 'mat', 'deck_of_cards', 'stereo', 'window', 'pillow', 'powersocket', 'cup', 'newspaper', 'check', 'ice', 'after_shave', 'lighter', 'diary', 'cd', 'cupboard', 'maindoor', 'colander', 'board_game']
Task:Listen to music
response:
{
    "thoughts": Find radio, turn it on,
    "actions": ['[WALK] <home_office>', '[WALK] <stereo>', '[FIND] <stereo>', '[SWITCHON] <stereo>']
}

Input:
Scene_Objects:['pot', 'filing_cabinet', 'freezer', 'walllamp', 'bathroom', 'drawing', 'orchid', 'wallshelf', 'bathroom_counter', 'floor', 'phone', 'character', 'keyboard', 'mat', 'tvstand', 'ceilinglamp', 'window', 'closetdrawer', 'couch', 'pillow', 'wall', 'bench', 'tape', 'photoframe', 'television', 'curtain', 'cards', 'bathtub', 'table', 'light']
Task:Relax on sofa
response:

go to living room and lie down on the sofa.

[WALK] <home_office>
[WALK] <couch>
[FIND] <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:['tablelamp', 'toilet', 'chair', 'drawing', 'cpuscreen', 'floor', 'phone', 'desk', 'keyboard', 'bookshelf', 'computer', 'mop_bucket', 'mat', 'laptop', 'window', 'homework', 'mousepad', 'food_orange', 'dining_room', 'wall', 'nightstand', 'oven', 'powersocket', 'cup', 'bed', 'tray', 'curtain', 'mouse', 'pencil', 'light']
Task:Watch movie
response:
{
    "thoughts": Bring laptop to bed and watch a movie,
    "actions": ['[WALK] <bedroom>', '[WALK] <laptop>', '[FIND] <laptop>', '[GRAB] <laptop>', '[WALK] <bed>', '[SIT] <bed>', '[SWITCHON] <laptop>', '[FIND] <keyboard>', '[TYPE] <keyboard>', '[TURNTO] <laptop>', '[LOOKAT] <laptop>']
}

Input:
Scene_Objects:['tablelamp', 'trashcan', 'toothbrush', 'bathroom_counter', 'shampoo', 'floor', 'phone', 'character', 'desk', 'bookshelf', 'keyboard', 'toaster', 'ceilinglamp', 'iron', 'shower', 'stereo', 'pillow', 'wall', 'wall_clock', 'photoframe', 'food_food', 'water', 'tray', 'kitchen_counter', 'cupboard', 'sink', 'home_office', 'bathroom_cabinet', 'tooth_paste', 'teeth']
Task:Wash teeth
response:

Walk to bathroom. Find tooth paste, tooth brush and water. Squeeze tooth paste on tooth brush. Wash teeth.

[WALK] <bathroom>
[WALK] <tooth_paste>
[FIND] <tooth_paste>
[FIND] <toothbrush>
[FIND] <water>
[SQUEEZE] <tooth_paste>
[FIND] <teeth>
[WASH] <teeth>


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

Here is an example plan to achieve a goal for reference:
Scene_Objects:['tablelamp', 'food_ice_cream', 'chair', 'nail_polish', 'trashcan', 'ceilingfan', 'drawing', 'cpuscreen', 'floor', 'ceiling', 'phone', 'character', 'desk', 'keyboard', 'bookshelf', 'computer', 'button', 'ceilinglamp', 'balanceball', 'shower', 'mousepad', 'pillow', 'wall', 'nightstand', 'basket_for_clothes', 'toothbrush_holder', 'doorjamb', 'mouse', 'light', 'vase']
Task:Browse internet
response:
{
    "thoughts": Walk to the Home Office.  Find the computer.  Turn on the computer.,
    "actions": ['[WALK] <home_office>', '[WALK] <computer>', '[FIND] <computer>', '[SWITCHON] <computer>']
}

Input:
Scene_Objects:['food_salt', 'microwave', 'detergent', 'cpuscreen', 'hanger', 'bathroom_counter', 'floor', 'ceiling', 'desk', 'shoe-shine_kit', 'faucet', 'clothes_socks', 'closetdrawer', 'mousepad', 'dining_room', 'broom', 'wall', 'nightstand', 'photoframe', 'television', 'water', 'tray', 'cards', 'paper_towel', 'door', 'sink', 'bathroom_cabinet', 'home_office', 'soap', 'hands_both']
Task:Wash hands
response:

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:['food_salt', 'bathroom', 'detergent', 'ceilingfan', 'drawing', 'orchid', 'floor', 'ceiling', 'character', 'keyboard', 'remote_control', 'ceilinglamp', 'tvstand', 'balanceball', 'window', 'couch', 'food_peanut_butter', 'pillow', 'towel', 'dining_room', 'wall', 'powersocket', 'toilet_paper', 'television', 'curtain', 'pencil', 'headset', 'cd', 'table', 'dishwasher']
Task:Change TV channel
response:
{
    "thoughts": Lift the remote and change the channel,
    "actions": ['[WALK] <home_office>', '[WALK] <television>', '[FIND] <television>', '[SWITCHON] <television>', '[FIND] <remote_control>', '[GRAB] <remote_control>', '[TURNTO] <television>', '[WATCH] <television>']
}

Input:
Scene_Objects:['chair', 'drawing', 'orchid', 'cpuscreen', 'phone', 'desk', 'bedroom', 'bookshelf', 'thread', 'computer', 'stovefan', 'mat', 'tvstand', 'shower', 'closetdrawer', 'pillow', 'nightstand', 'wall_clock', 'bed', 'light_bulb', 'photoframe', 'tray', 'doorjamb', 'mouse', 'cupboard', 'door', 'bathtub', 'sink', 'light', 'clothes_shirt']
Task:Brush teeth
response:

[WALK] <bathroom>
[WALK] <toothbrush>
[FIND] <toothbrush>
[GRAB] <toothbrush>
[WALK] <tooth_paste>
[FIND] <tooth_paste>
[GRAB] <tooth_paste>
[POUR] <tooth_paste> <toothbrush>


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', 'cpuscreen', 'phone', 'desk', 'cleaning_solution', 'keyboard', 'purse', 'table_cloth', 'stovefan', 'tvstand', 'shower', 'stereo', 'food_noodles', 'towel', 'pillow', 'wall', 'wall_clock', 'oven', 'basket_for_clothes', 'photoframe', 'novel', 'food_rice', 'rag', 'towel_rack', 'mouse', 'dresser', 'cupboard', 'clothes_dress', 'napkin', 'table']
Task:Clean  mirror
response:
{
    "thoughts": GET CLEANING CLOTH, SPRAY CLEANER ON CLOTH, CLEAN MIRROR,
    "actions": ['[WALK] <bathroom>', '[WALK] <cleaning_solution>', '[FIND] <cleaning_solution>', '[GRAB] <cleaning_solution>', '[FIND] <rag>', '[GRAB] <rag>', '[POUR] <cleaning_solution> <rag>', '[PUTOBJBACK] <cleaning_solution>', '[WALK] <mirror>', '[WIPE] <mirror>', '[WIPE] <mirror>', '[WIPE] <mirror>', '[PUTOBJBACK] <rag>']
}

Input:
Scene_Objects:['filing_cabinet', 'microwave', 'trashcan', 'orchid', 'wallshelf', 'bathroom_counter', 'floor', 'ceiling', 'phone', 'character', 'ceilinglamp', 'mat', 'faucet', 'shower', 'couch', 'towel', 'wall', 'bench', 'oven', 'photoframe', 'bed', 'mouse', 'kitchen_counter', 'dresser', 'pajamas', 'sink', 'bathroom_cabinet', 'home_office', 'soap', 'hands_both']
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:['microwave', 'toilet', 'detergent', 'food_butter', 'dough', 'orchid', 'drawing', 'bathroom_counter', 'floor', 'ceiling', 'purse', 'faucet', 'stereo', 'picture', 'dustpan', 'bowl', 'dining_room', 'wall', 'oven', 'powersocket', 'photoframe', 'wine', 'tray', 'console', 'pencil', 'sink', 'bathroom_cabinet', 'dishwasher', 'hands_both', 'shoe_rack']
Task:Wash hands
response:
{
    "thoughts": I go to the bathroom, walk to the sink, turn on the faucet and then wash my hands under the water.,
    "actions": ['[WALK] <bathroom>', '[WALK] <sink>', '[FIND] <faucet>', '[TURNTO] <faucet>', '[FIND] <hands_both>', '[WASH] <hands_both>']
}

Input:
Scene_Objects:['pot', 'food_salt', 'chair', 'freezer', 'walllamp', 'bathroom', 'trashcan', 'toothbrush', 'needle', 'desk', 'keyboard', 'alcohol', 'tvstand', 'faucet', 'window', 'food_noodles', 'couch', 'form', 'pillow', 'wall', 'wall_clock', 'bench', 'bed', 'curtain', 'cupboard', 'instrument_violin', 'bathtub', 'home_office', 'light', 'board_game']
Task:Pick up phone
response:

i go find the phone. i 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:['spectacles', 'sponge', 'food_bread', 'blender', 'chair', 'walllamp', 'orchid', 'knife', 'cpuscreen', 'floor', 'ceiling', 'desk', 'keyboard', 'bookshelf', 'computer', 'ceilinglamp', 'mat', 'tvstand', 'window', 'mousepad', 'clothes_socks', 'wall', 'oven', 'cup', 'television', 'mouse', 'cupboard', 'door', 'home_office', 'table']
Task:Browse internet
response:
{
    "thoughts": go to the office, turn computer on, open an browser or any application to open any website.,
    "actions": ['[WALK] <home_office>', '[WALK] <computer>', '[FIND] <computer>', '[SWITCHON] <computer>', '[FIND] <computer>']
}

Input:
Scene_Objects:['sponge', 'tablelamp', 'microwave', 'toilet', 'chair', 'freezer', 'band-aids', 'trashcan', 'drawing', 'orchid', 'wallshelf', 'bathroom_counter', 'floor', 'ceiling', 'character', 'food_bacon', 'mat', 'tvstand', 'shower', 'pillow', 'wall', 'bed', 'photoframe', 'food_food', 'doorjamb', 'console', 'kitchen_counter', 'dresser', 'cupboard', 'door']
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:['fork', 'pot', 'filing_cabinet', 'beer', 'bathroom', 'detergent', 'trashcan', 'cpuscreen', 'ceiling', 'bedroom', 'desk', 'keyboard', 'clothes_jacket', 'tvstand', 'couch', 'pillow', 'food_kiwi', 'oven', 'bench', 'coffe_maker', 'oven_mitts', 'towel_rack', 'pencil', 'cupboard', 'hair', 'clothes_dress', 'food_steak', 'napkin', 'vase', 'laser_pointer']
Task:Listen to music
response:
{
    "thoughts": I walk into the bedroom. I walk to stereo. I turn on stereo.,
    "actions": ['[WALK] <bedroom>', '[WALK] <stereo>', '[SWITCHON] <stereo>']
}

Input:
Scene_Objects:['filing_cabinet', 'chair', 'walllamp', 'bathroom', 'drawing', 'orchid', 'cpuscreen', 'floor', 'ceiling', 'dvd_player', 'desk', 'keyboard', 'computer', 'ceilinglamp', 'tvstand', 'faucet', 'mat', 'mousepad', 'wall', 'nightstand', 'powersocket', 'coffe_maker', 'check', 'television', 'wine', 'doorjamb', 'mouse', 'cupboard', 'controller', 'table']
Task:Browse internet
response:

I go to my desk. I turn on the computer. I open a web page and look at it.

[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:['microwave', 'walllamp', 'drawing', 'bathroom_counter', 'floor', 'ceiling', 'bookshelf', 'stovefan', 'laptop', 'faucet', 'mousepad', 'candle', 'microphone', 'food_orange', 'wall', 'photoframe', 'check', 'mouthwash', 'after_shave', 'doorjamb', 'cupboard', 'pajamas', 'conditioner', 'door', 'sink', 'bathroom_cabinet', 'light', 'soap', 'clothes_shirt', 'hands_both']
Task:Wash hands
response:
{
    "thoughts": I go into the bathroom and turn on the light. I walk to the sink and turn on the water. I grab the soap and wash my hands,
    "actions": ['[WALK] <bathroom>', '[WALK] <light>', '[FIND] <light>', '[SWITCHON] <light>', '[WALK] <sink>', '[FIND] <soap>', '[GRAB] <soap>', '[FIND] <faucet>', '[SWITCHON] <faucet>', '[FIND] <hands_both>', '[WASH] <hands_both>', '[RINSE] <hands_both>', '[PUTOBJBACK] <soap>', '[SWITCHOFF] <faucet>']
}

Input:
Scene_Objects:['toilet', 'chair', 'freezer', 'walllamp', 'cpuscreen', 'hanger', 'floor', 'ceiling', 'character', 'desk', 'keyboard', 'computer', 'ceilinglamp', 'tvstand', 'mat', 'faucet', 'window', 'mousepad', 'wall', 'powersocket', 'box', 'coffe_maker', 'television', 'doorjamb', 'towel_rack', 'mouse', 'dresser', 'door', 'bathroom_cabinet', 'table']
Task:Browse internet
response:

Walk to the Home Office.  Find the computer.  Turn on the computer.

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


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

Here is an example plan to achieve a goal for reference:
Scene_Objects:['sponge', 'pot', 'toilet', 'dog', 'freezer', 'walllamp', 'bathroom', 'food_carrot', 'drawing', 'hanger', 'phone', 'ceiling', 'desk', 'computer', 'toaster', 'mat', 'mousepad', 'closetdrawer', 'food_peanut_butter', 'towel', 'cup', 'food_cheese', 'keys', 'tray', 'after_shave', 'towel_rack', 'mouse', 'cupboard', 'sink', 'coffee']
Task:Pet cat
response:
{
    "thoughts": I walk into the living room and I pet the cat,
    "actions": ['[WALK] <home_office>', '[WALK] <cat>', '[TOUCH] <cat>']
}

Input:
Scene_Objects:['microwave', 'toilet', 'chair', 'freezer', 'bathroom', 'trashcan', 'orchid', 'floor', 'phone', 'character', 'keyboard', 'envelope', 'clothes_jacket', 'piano_bench', 'toaster', 'ceilinglamp', 'faucet', 'shower', 'closetdrawer', 'couch', 'wall', 'nightstand', 'bench', 'wall_clock', 'television', 'kitchen_counter', 'cupboard', 'sink', 'spoon', 'bathroom_cabinet']
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:['sponge', 'sheets', 'tablelamp', 'toilet', 'freezer', 'bathroom', 'orchid', 'wallshelf', 'hanger', 'bathroom_counter', 'floor', 'phone', 'bedroom', 'bookshelf', 'computer', 'ceilinglamp', 'tvstand', 'faucet', 'closetdrawer', 'couch', 'pillow', 'oven', 'bed', 'coffe_maker', 'doorjamb', 'mouse', 'dresser', 'door', 'bathroom_cabinet', 'home_office']
Task:Pet cat
response:
{
    "thoughts": I enter the room where the cat is. I look for the cat. I find the cat. I walk over to the cat. I use my hand to pet the cat.,
    "actions": ['[WALK] <home_office>', '[WALK] <cat>', '[FIND] <cat>', '[TURNTO] <cat>', '[LOOKAT] <cat>', '[FIND] <cat>', '[WALK] <cat>', '[TOUCH] <cat>']
}

Input:
Scene_Objects:['chair', 'freezer', 'walllamp', 'cpuscreen', 'hanger', 'floor', 'ceiling', 'desk', 'keyboard', 'computer', 'toaster', 'ceilinglamp', 'shoe-shine_kit', 'tvstand', 'mat', 'shower', 'mousepad', 'wall', 'powersocket', 'oven', 'bench', 'television', 'tray', 'curtain', 'doorjamb', 'mouse', 'door', 'table', 'light', 'coffee']
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', 'microwave', 'chair', 'knife', 'knifeblock', 'orchid', 'drawing', 'floor', 'phone', 'character', 'bedroom', 'remote_control', 'computer', 'button', 'mat', 'tvstand', 'faucet', 'shower', 'oil', 'dining_room', 'powersocket', 'newspaper', 'ice', 'tray', 'doorjamb', 'towel_rack', 'dresser', 'door', 'home_office', 'table']
Task:Change TV channel
response:
{
    "thoughts": I pick up the remote. I press button on remote.,
    "actions": ['[WALK] <bedroom>', '[WALK] <remote_control>', '[FIND] <remote_control>', '[GRAB] <remote_control>', '[FIND] <button>', '[PUSH] <button>']
}

Input:
Scene_Objects:['tablelamp', 'microwave', 'toilet', 'freezer', 'walllamp', 'trashcan', 'drawing', 'cpuscreen', 'wallshelf', 'hanger', 'floor', 'ceiling', 'character', 'food_bacon', 'mat', 'ceilinglamp', 'shower', 'wall', 'wall_clock', 'cup', 'photoframe', 'bed', 'food_food', 'tray', 'doorjamb', 'mouse', 'kitchen_counter', 'cupboard', 'door', 'coffee']
Task:Drink
response:

Walk into kitchen, look for cup, walk to cup, look for refrigerator, walk to refrigerator, open door, grab water, pour water into cup

[WALK] <dining_room>
[WALK] <cup>
[FIND] <cup>
[TURNTO] <cup>
[LOOKAT] <cup>
[WALK] <cup>
[FIND] <freezer>
[TURNTO] <freezer>
[LOOKAT] <freezer>
[WALK] <freezer>
[GRAB] <cup>
[WALK] <water>
[FIND] <water>
[GRAB] <water>
[POUR] <water> <cup>


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

Here is an example plan to achieve a goal for reference:
Scene_Objects:['pot', 'freezer', 'ceilingfan', 'drawing', 'knifeblock', 'bathroom_counter', 'floor', 'ceiling', 'phone', 'keyboard', 'bookshelf', 'faucet', 'picture', 'window', 'dustpan', 'towel', 'wall', 'nightstand', 'photoframe', 'keys', 'toothbrush_holder', 'food_donut', 'mouse', 'kitchen_counter', 'sink', 'bathroom_cabinet', 'table', 'vase', 'soap', 'hands_both']
Task:Wash hands
response:
{
    "thoughts": Cleaning hands,
    "actions": ['[WALK] <bathroom>', '[WALK] <faucet>', '[FIND] <faucet>', '[SWITCHON] <faucet>', '[FIND] <soap>', '[GRAB] <soap>', '[FIND] <hands_both>', '[SCRUB] <hands_both>', '[PUTOBJBACK] <soap>', '[RINSE] <hands_both>', '[SWITCHOFF] <faucet>', '[FIND] <towel>', '[GRAB] <towel>', '[WIPE] <hands_both>', '[PUTOBJBACK] <towel>']
}

Input:
Scene_Objects:['filing_cabinet', 'toilet', 'chair', 'trashcan', 'drawing', 'orchid', 'hanger', 'floor', 'phone', 'ceiling', 'desk', 'computer', 'toaster', 'deck_of_cards', 'mousepad', 'closetdrawer', 'couch', 'wall', 'wall_clock', 'powersocket', 'bench', 'television', 'doorjamb', 'cd', 'dresser', 'conditioner', 'door', 'home_office', 'light', 'table']
Task:Pick up phone
response:

I walk to the kitchen and find the phone. I pick up the phone. I hold it to my ear.

[WALK] <dining_room>
[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', 'ground_coffee', 'orchid', 'drawing', 'cpuscreen', 'floor', 'phone', 'ceiling', 'toaster', 'ceilinglamp', 'plate', 'tvstand', 'window', 'dish_soap', 'pillow', 'wall', 'oven', 'powersocket', 'photoframe', 'coffe_maker', 'razor', 'tray', 'mouse', 'kitchen_counter', 'cupboard', 'bathtub', 'dishwasher', 'instrument_violin']
Task:Wash dishes with dishwasher
response:
{
    "thoughts": Go to the kitchen.  Find the dishwasher.  Open the dishwasher.  Find the plates.  Load the plates into the dishwasher.  Find the soap.  Load the soap into the dishwasher.  Close the dishwasher.  Turn on the dishwasher.,
    "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] <dish_soap>', '[GRAB] <dish_soap>', '[PUTBACK] <dish_soap> <dishwasher>', '[CLOSE] <dishwasher>', '[SWITCHON] <dishwasher>']
}

Input:
Scene_Objects:['chair', 'drawing', 'orchid', 'wallshelf', 'floor', 'ceiling', 'desk', 'bookshelf', 'computer', 'stovefan', 'toaster', 'laptop', 'faucet', 'closetdrawer', 'couch', 'bowl', 'dining_room', 'wall', 'oven', 'bench', 'bed', 'coffe_maker', 'food_food', 'tray', 'doorjamb', 'kitchen_counter', 'dresser', 'cupboard', 'door', 'bathtub']
Task:Cook some food
response:

I switch on the stove and cook my groceries there.

[WALK] <dining_room>
[WALK] <oven>
[FIND] <oven>
[SWITCHON] <oven>
[FIND] <bowl>
[GRAB] <bowl>
[PUTBACK] <bowl> <oven>
[FIND] <food_food>
[SWITCHOFF] <oven>


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

Here is an example plan to achieve a goal for reference:
Scene_Objects:['toilet', 'freezer', 'drawing', 'knifeblock', 'floor', 'ceiling', 'ceilinglamp', 'mat', 'shower', 'picture', 'window', 'food_noodles', 'food_jam', 'wall', 'powersocket', 'oven', 'photoframe', 'check', 'television', 'toothbrush_holder', 'water', 'curtain', 'doorjamb', 'kitchen_counter', 'cd', 'headset', 'door', 'bathroom_cabinet', 'light', 'soap']
Task:Take shower
response:
{
    "thoughts": go to a bathroom, open the shower, let water wash your body,
    "actions": ['[WALK] <bathroom>', '[WALK] <shower>', '[FIND] <soap>', '[SCRUB] <soap>', '[FIND] <water>', '[RINSE] <water>']
}

Input:
Scene_Objects:['toilet', 'walllamp', 'detergent', 'trashcan', 'drawing', 'cpuscreen', 'floor', 'ceiling', 'desk', 'mat', 'tvstand', 'ceilinglamp', 'window', 'couch', 'pillow', 'dining_room', 'wall', 'nightstand', 'novel', 'television', 'tray', 'curtain', 'mouse', 'kitchen_counter', 'cupboard', 'door', 'home_office', 'table', 'bathroom_cabinet', 'soap']
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:['chair', 'band-aids', 'walllamp', 'bathroom', 'orchid', 'cpuscreen', 'floor', 'ceiling', 'desk', 'keyboard', 'computer', 'mat', 'ceilinglamp', 'mousepad', 'oil', 'broom', 'wall', 'nightstand', 'bench', 'newspaper', 'coffe_maker', 'food_food', 'coin', 'food_donut', 'lighter', 'mouse', 'chessboard', 'door', 'table', 'dirt']
Task:Turking
response:
{
    "thoughts": Do a random variety very small jobs from different clients on mturk.Com,
    "actions": ['[WALK] <home_office>', '[WALK] <desk>', '[FIND] <chair>', '[SIT] <chair>', '[FIND] <computer>', '[SWITCHON] <computer>']
}

Input:
Scene_Objects:['tablelamp', 'microwave', 'toilet', 'walllamp', 'trashcan', 'drawing', 'cpuscreen', 'wallshelf', 'floor', 'ceiling', 'keyboard', 'mat', 'tvstand', 'ceilinglamp', 'faucet', 'window', 'mousepad', 'closetdrawer', 'couch', 'pillow', 'dining_room', 'food_kiwi', 'wall', 'light_bulb', 'novel', 'television', 'curtain', 'cupboard', 'bathtub', 'table']
Task:Read book
response:

I go to the living room, take a book from the shelf, sit in the sofa and read the book

[WALK] <home_office>
[WALK] <novel>
[FIND] <novel>
[GRAB] <novel>
[FIND] <couch>
[SIT] <couch>
[READ] <novel>


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

Here is an example plan to achieve a goal for reference:
Scene_Objects:['pot', 'food_pizza', 'tablelamp', 'crayon', 'mop', 'toilet', 'chair', 'bathroom', 'detergent', 'dough', 'ceiling', 'keyboard', 'stereo', 'couch', 'pillow', 'cup', 'newspaper', 'keys', 'check', 'toothbrush_holder', 'food_donut', 'after_shave', 'rag', 'mouse', 'pajamas', 'cupboard', 'bag', 'light', 'table', 'tooth_paste']
Task:Put away keys
response:
{
    "thoughts": Return keys into a bag,
    "actions": ['[WALK] <home_office>', '[WALK] <keys>', '[FIND] <keys>', '[GRAB] <keys>', '[FIND] <bag>', '[OPEN] <bag>', '[PUTBACK] <keys> <bag>', '[CLOSE] <bag>']
}

Input:
Scene_Objects:['freezer', 'walllamp', 'bathroom', 'drawing', 'cpuscreen', 'floor', 'ceiling', 'character', 'remote_control', 'computer', 'mat', 'ceilinglamp', 'tvstand', 'window', 'electric_shaver', 'mousepad', 'couch', 'pillow', 'wall', 'nightstand', 'powersocket', 'photoframe', 'television', 'curtain', 'mouse', 'kitchen_counter', 'dresser', 'bathtub', 'table', 'light']
Task:Watch TV
response:

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


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

Here is an example plan to achieve a goal for reference:
Scene_Objects:['filing_cabinet', 'microwave', 'drawing', 'orchid', 'wallshelf', 'floor', 'desk', 'bookshelf', 'purse', 'computer', 'mat', 'tvstand', 'couch', 'clothes_pants', 'pillow', 'wall', 'bench', 'powersocket', 'basket_for_clothes', 'photoframe', 'bed', 'television', 'doorjamb', 'pencil', 'laundry_detergent', 'clothes_dress', 'table', 'light', 'clothes_shirt', 'washing_machine']
Task:Do laundry
response:
{
    "thoughts": Collecting laundry from the children's hamper,
    "actions": ['[WALK] <bedroom>', '[WALK] <basket_for_clothes>', '[FIND] <basket_for_clothes>', '[GRAB] <basket_for_clothes>', '[WALK] <home_office>', '[WALK] <table>', '[FIND] <table>', '[PUTBACK] <basket_for_clothes> <table>', '[WALK] <filing_cabinet>', '[OPEN] <filing_cabinet>', '[FIND] <laundry_detergent>', '[GRAB] <laundry_detergent>', '[FIND] <washing_machine>', '[OPEN] <washing_machine>', '[POUR] <laundry_detergent> <washing_machine>', '[PUTOBJBACK] <laundry_detergent>', '[CLOSE] <filing_cabinet>', '[FIND] <clothes_dress>', '[GRAB] <clothes_dress>', '[PUTBACK] <clothes_dress> <washing_machine>', '[FIND] <clothes_pants>', '[GRAB] <clothes_pants>', '[PUTBACK] <clothes_pants> <washing_machine>', '[FIND] <clothes_shirt>', '[GRAB] <clothes_shirt>', '[PUTBACK] <clothes_shirt> <washing_machine>', '[PLUGIN] <washing_machine>', '[CLOSE] <washing_machine>', '[SWITCHON] <washing_machine>']
}

Input:
Scene_Objects:['filing_cabinet', 'tablelamp', 'microwave', 'freezer', 'trashcan', 'drawing', 'orchid', 'ceiling', 'bedroom', 'mail', 'mat', 'tvstand', 'mousepad', 'dining_room', 'wall', 'wall_clock', 'basket_for_clothes', 'coffe_maker', 'tray', 'doorjamb', 'mouse', 'kitchen_counter', 'dresser', 'laundry_detergent', 'door', 'clothes_dress', 'bathroom_cabinet', 'table', 'light', 'washing_machine']
Task:Wash clothes
response:

Go to kitchen, find washing machine, find laundry, put laundry in washing machine, find soap, put soap in washing machine, turn on.


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

Here is an example plan to achieve a goal for reference:
Scene_Objects:['chair', 'walllamp', 'drawing', 'wallshelf', 'hanger', 'floor', 'ceiling', 'desk', 'bookshelf', 'computer', 'mat', 'tvstand', 'ceilinglamp', 'stereo', 'closetdrawer', 'couch', 'pillow', 'wall', 'photoframe', 'bed', 'television', 'doorjamb', 'shaving_cream', 'mouse', 'coffee', 'dresser', 'hairbrush', 'clothes_scarf', 'soap', 'teeth']
Task:Watch TV
response:
{
    "thoughts": Sitting on the couch watching my favorite television show.,
    "actions": ['[WALK] <home_office>', '[WALK] <couch>', '[FIND] <couch>', '[SIT] <couch>', '[FIND] <television>', '[TURNTO] <television>', '[WATCH] <television>']
}

Input:
Scene_Objects:['microwave', 'toilet', 'ground_coffee', 'walllamp', 'detergent', 'trashcan', 'drawing', 'wallshelf', 'character', 'remote_control', 'button', 'shower', 'faucet', 'window', 'pillow', 'wall', 'bench', 'newspaper', 'coffee_table', 'photoframe', 'coffe_maker', 'television', 'food_donut', 'tray', 'sink', 'napkin', 'bathroom_cabinet', 'home_office', 'instrument_guitar', 'light']
Task:Change TV channel
response:

walk next to the coffee table. pick up the remote control from the top of the coffee table. Point the remote to the TV. Press the blue arrow on the remote.

[WALK] <home_office>
[WALK] <coffee_table>
[FIND] <remote_control>
[GRAB] <remote_control>
[FIND] <button>
[PUSH] <button>


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

Here is an example plan to achieve a goal for reference:
Scene_Objects:['tablelamp', 'chair', 'walllamp', 'drawing', 'orchid', 'cpuscreen', 'wallshelf', 'hanger', 'floor', 'ceiling', 'phone', 'desk', 'keyboard', 'computer', 'mat', 'ceilinglamp', 'tvstand', 'mousepad', 'couch', 'pillow', 'wall', 'nightstand', 'oven', 'check', 'television', 'doorjamb', 'mouse', 'address_book', 'dresser', 'door']
Task:Write an email
response:
{
    "thoughts": Walk to Home office. Sit on the chair. Switch on the computer. Find address in addressbook. Type in the keyboard. Write mail.,
    "actions": ['[WALK] <home_office>', '[WALK] <chair>', '[FIND] <chair>', '[SIT] <chair>', '[FIND] <computer>', '[SWITCHON] <computer>', '[FIND] <address_book>', '[FIND] <keyboard>', '[TYPE] <keyboard>']
}

Input:
Scene_Objects:['microwave', 'toilet', 'freezer', 'trashcan', 'drawing', 'cpuscreen', 'floor', 'stamp', 'bedroom', 'stovefan', 'toaster', 'plate', 'faucet', 'shower', 'dish_soap', 'food_jam', 'towel', 'wall', 'nightstand', 'oven', 'coffe_maker', 'food_food', 'ice', 'tray', 'curtain', 'kitchen_counter', 'cupboard', 'sink', 'bathtub', '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:['filing_cabinet', 'food_salt', 'chair', 'bathroom', 'orchid', 'cpuscreen', 'bathroom_counter', 'desk', 'keyboard', 'button', 'piano_bench', 'ceilinglamp', 'stereo', 'floor_lamp', 'oil', 'mousepad', 'closetdrawer', 'tape', 'love_seat', 'newspaper', 'bed', 'check', 'video_game_controller', 'mouthwash', 'curtain', 'lighter', 'diary', 'doorjamb', 'dresser', 'sink']
Task:Read
response:
{
    "thoughts": Sit on an easy chair.  Turn on music.  Take a book and read.  Turn on lamp at night.,
    "actions": ['[WALK] <home_office>', '[WALK] <stereo>', '[FIND] <stereo>', '[SWITCHON] <stereo>', '[FIND] <newspaper>', '[GRAB] <newspaper>', '[FIND] <love_seat>', '[SIT] <love_seat>', '[FIND] <floor_lamp>', '[SWITCHON] <floor_lamp>', '[READ] <newspaper>']
}

Input:
Scene_Objects:['filing_cabinet', 'food_ice_cream', 'chair', 'freezer', 'bathroom', 'trashcan', 'orchid', 'cpuscreen', 'hanger', 'character', 'computer', 'mail', 'stovefan', 'mat', 'shower', 'couch', 'pillow', 'nightstand', 'wall', 'powersocket', 'bed', 'coffe_maker', 'television', 'tray', 'curtain', 'doorjamb', 'towel_rack', 'cupboard', 'sink', 'light']
Task:Pet cat
response:

I walk to the living room. I find the cat. I pet the cat.

[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:['pot', 'food_bread', 'tablelamp', 'food_salt', 'microwave', 'chair', 'freezer', 'ground_coffee', 'dough', 'drawing', 'orchid', 'cpuscreen', 'kitchen_cabinet', 'floor', 'ceiling', 'phone', 'desk', 'keyboard', 'toaster', 'mat', 'ceilinglamp', 'stovefan', 'faucet', 'shower', 'oil', 'couch', 'pillow', 'wall', 'pasta', 'oven', 'powersocket', 'food_food', 'coffe_maker', 'television', 'wine', 'tray', 'doorjamb', 'towel_rack', 'kitchen_counter', 'cupboard', 'food_steak', 'door', 'sink', 'table', 'dishwasher', 'light']
Task:Cook some food
response:
{
    "thoughts": Walk into kitchen. Open fridge. Take food from fridge. Close fridge. Put food on kitchen counter. Prepare food. Turn on stove. Open kitchen cabinet. Take pot. Close cabinet. Put food in pot. Put pot on stove. Cook food.,
    "actions": ['[WALK] <dining_room>', '[WALK] <freezer>', '[FIND] <freezer>', '[OPEN] <freezer>', '[FIND] <food_food>', '[GRAB] <food_food>', '[FIND] <kitchen_counter>', '[PUTBACK] <food_food> <kitchen_counter>', '[CLOSE] <freezer>', '[FIND] <kitchen_cabinet>', '[OPEN] <kitchen_cabinet>', '[FIND] <pot>', '[GRAB] <pot>', '[CLOSE] <kitchen_cabinet>', '[FIND] <oven>', '[PUTBACK] <pot> <oven>', '[GRAB] <food_food>', '[PUTBACK] <food_food> <oven>']
}

Input:
Scene_Objects:['filing_cabinet', 'tablelamp', 'microwave', 'chair', 'freezer', 'detergent', 'floor', 'phone', 'ceiling', 'bedroom', 'keyboard', 'stovefan', 'shower', 'faucet', 'window', 'closetdrawer', 'wall', 'wall_clock', 'powersocket', 'bench', 'photoframe', 'coffe_maker', 'check', 'television', 'food_food', 'ice', 'rag', 'towel_rack', 'kitchen_counter', 'cupboard']
Task:Turn on light
response:

I go home and it's dark so I can not see anything

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


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

Here is an example plan to achieve a goal for reference:
Scene_Objects:['filing_cabinet', 'microwave', 'chair', 'freezer', 'walllamp', 'food_butter', 'drawing', 'hanger', 'bathroom_counter', 'floor', 'phone', 'ceiling', 'bedroom', 'alcohol', 'window', 'food_jam', 'dining_room', 'wall', 'bench', 'powersocket', 'newspaper', 'food_food', 'doorjamb', 'kettle', 'towel_rack', 'dresser', 'cupboard', 'door', 'table', 'light']
Task:Eat dinner
response:
{
    "thoughts": In our dining room, my family eats dinner. Once the food has been prepared, we gather at the dining room table and prepare to eat.,
    "actions": ['[WALK] <dining_room>', '[WALK] <food_food>', '[FIND] <food_food>', '[GRAB] <food_food>', '[WALK] <dining_room>', '[WALK] <table>', '[PUTBACK] <food_food> <table>', '[WALK] <dining_room>', '[WALK] <food_food>', '[FIND] <food_food>', '[GRAB] <food_food>', '[WALK] <dining_room>', '[WALK] <table>', '[PUTBACK] <food_food> <table>', '[WALK] <chair>', '[PULL] <chair>', '[SIT] <chair>', '[TURNTO] <food_food>', '[LOOKAT] <food_food>', '[TURNTO] <food_food>', '[LOOKAT] <food_food>']
}

Input:
Scene_Objects:['filing_cabinet', 'microwave', 'walllamp', 'trashcan', 'drawing', 'wallshelf', 'cpuscreen', 'hanger', 'floor', 'ceiling', 'bookshelf', 'mat', 'tvstand', 'ceilinglamp', 'shower', 'window', 'couch', 'pillow', 'wall', 'nightstand', 'oven', 'keys', 'television', 'curtain', 'doorjamb', 'towel_rack', 'mouse', 'door', 'light', 'table']
Task:Relax on sofa
response:

I want to relax on the sofa to some relaxing music in the living room.

[WALK] <home_office>
[WALK] <light>
[FIND] <light>
[SWITCHON] <light>
[WALK] <stereo>
[PLUGIN] <stereo>
[SWITCHON] <stereo>
[WALK] <couch>
[SIT] <couch>
[LIE] <couch>


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

Here is an example plan to achieve a goal for reference:
Scene_Objects:['pot', 'crayon', 'tea', 'beer', 'microwave', 'toilet', 'trashcan', 'food_carrot', 'knifeblock', 'cpuscreen', 'bathroom_counter', 'floor', 'character', 'bedroom', 'desk', 'keyboard', 'bookshelf', 'computer', 'ceilinglamp', 'window', 'dining_room', 'food_kiwi', 'nightstand', 'bed', 'photoframe', 'doorjamb', 'dishrack', 'cupboard', 'sink', 'home_office']
Task:Open bathroom window
response:
{
    "thoughts": Make sure bathroom window is unlocked. Lift up bathroom window so it is open.,
    "actions": ['[WALK] <bathroom>', '[WALK] <window>', '[FIND] <window>', '[OPEN] <window>']
}

Input:
Scene_Objects:['filing_cabinet', 'tablelamp', 'food_salt', 'microwave', 'toilet', 'walllamp', 'drawing', 'needle', 'hanger', 'bathroom_counter', 'ceiling', 'bedroom', 'desk', 'computer', 'bookmark', 'stovefan', 'plate', 'tvstand', 'dish_soap', 'closetdrawer', 'dining_room', 'wall', 'wall_clock', 'oven', 'powersocket', 'curtain', 'kitchen_counter', 'sink', 'bathroom_cabinet', 'dishwasher']
Task:Wash dishes with dishwasher
response:

Walk to the kitchen. Open the dishwasher. Grab plate and put it in the dishwasher. Grab dish soap and put it in the dishwasher. Switch on the dishwasher.

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


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

Here is an example plan to achieve a goal for reference:
Scene_Objects:['sponge', 'food_salt', 'chair', 'detergent', 'trashcan', 'dough', 'drawing', 'character', 'computer', 'button', 'brush', 'mat', 'couch', 'clothes_pants', 'clothes_hat', 'wall', 'nightstand', 'basket_for_clothes', 'food_cheese', 'rag', 'kitchen_counter', 'shoes', 'vacuum_cleaner', 'laundry_detergent', 'conditioner', 'sink', 'home_office', 'table', 'clothes_shirt', 'washing_machine']
Task:Wash clothes
response:
{
    "thoughts": Walk to bathroom, open wash-machine, lift laundry basket, grab cloth and put into wash-machine one by one, put down laundry basket, pour detergent, close wash-machine, turn on wash-machine.,
    "actions": ['[WALK] <bathroom>', '[WALK] <washing_machine>', '[FIND] <washing_machine>', '[OPEN] <washing_machine>', '[FIND] <basket_for_clothes>', '[GRAB] <basket_for_clothes>', '[FIND] <clothes_pants>', '[GRAB] <clothes_pants>', '[PUTBACK] <clothes_pants> <washing_machine>', '[FIND] <clothes_shirt>', '[GRAB] <clothes_shirt>', '[PUTBACK] <clothes_shirt> <washing_machine>', '[PUTOBJBACK] <basket_for_clothes>', '[WALK] <laundry_detergent>', '[FIND] <laundry_detergent>', '[GRAB] <laundry_detergent>', '[POUR] <laundry_detergent> <washing_machine>', '[CLOSE] <washing_machine>', '[SWITCHON] <washing_machine>']
}

Input:
Scene_Objects:['spectacles', 'microwave', 'freezer', 'walllamp', 'trashcan', 'floor', 'desk', 'keyboard', 'clothes_jacket', 'piano_bench', 'tvstand', 'shower', 'faucet', 'mousepad', 'closetdrawer', 'food_kiwi', 'nightstand', 'oven', 'bench', 'powersocket', 'basket_for_clothes', 'photoframe', 'tray', 'dresser', 'cupboard', 'home_office', 'light', 'clothes_skirt', 'soap', 'washing_machine']
Task:Wash clothes
response:

Walk to the kitchen and find the basket of clothes. Put the soap and clothes into the washing machine. Turn on the washing machine.


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

Here is an example plan to achieve a goal for reference:
Scene_Objects:['pot', 'food_salt', 'microwave', 'toilet', 'dog', 'detergent', 'orchid', 'wallshelf', 'food_egg', 'cpuscreen', 'phone', 'stamp', 'bedroom', 'bookshelf', 'bookmark', 'shower', 'mousepad', 'food_jam', 'towel', 'pasta', 'bed', 'novel', 'food_food', 'curtain', 'centerpiece', 'shaving_cream', 'dresser', 'cupboard', 'table', 'creditcard']
Task:Walk through
response:
{
    "thoughts": Walk through the entrance hall,
    "actions": ['[WALK] <home_office>', '[WALK] <home_office>']
}

Input:
Scene_Objects:['food_ice_cream', 'microwave', 'toilet', 'chair', 'bathroom_counter', 'floor', 'laptop', 'faucet', 'shower', 'towel', 'wall', 'wall_clock', 'nightstand', 'cup', 'bed', 'photoframe', 'water', 'tray', 'doorjamb', 'towel_rack', 'dresser', 'door', 'sink', 'bathtub', 'bathroom_cabinet', 'light', 'table', 'soap', 'scrabble', 'hands_both']
Task:Wash hands
response:

Go into the bathroom and go over to the sink. Grab soap and turn on the water. Wet your hands and rub them together so that the soap lathers. Rub the soap all over your hands thoroughly. Rinse off the soap with water and turn off the sink. Dry your hands with a towel.

[WALK] <bathroom>
[WALK] <sink>
[FIND] <soap>
[GRAB] <soap>
[FIND] <water>
[GRAB] <water>
[FIND] <hands_both>
[POUR] <water> <hands_both>
[FIND] <hands_both>
[SCRUB] <hands_both>
[PUTOBJBACK] <soap>
[RINSE] <hands_both>
[FIND] <towel>
[GRAB] <towel>
[WIPE] <hands_both>


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

Here is an example plan to achieve a goal for reference:
Scene_Objects:['sponge', 'glue', 'toilet', 'chair', 'detergent', 'dough', 'drawing', 'orchid', 'hanger', 'floor', 'ceiling', 'keyboard', 'alcohol', 'stovefan', 'ceilinglamp', 'couch', 'microphone', 'wall', 'nightstand', 'photoframe', 'coffe_maker', 'coffee_filter', 'doorjamb', 'kitchen_counter', 'hairbrush', 'cupboard', 'home_office', 'dishwasher', 'coffee', 'shoe_rack']
Task:Make coffee
response:
{
    "thoughts": Open coffee maker. Put filter in main basket, put ground coffee in filter, fill reservoir with water, turn on coffee maker.,
    "actions": ['[WALK] <dining_room>', '[WALK] <coffe_maker>', '[FIND] <coffe_maker>', '[OPEN] <coffe_maker>', '[FIND] <coffee_filter>', '[GRAB] <coffee_filter>', '[PUTBACK] <coffee_filter> <coffe_maker>', '[FIND] <coffee>', '[GRAB] <coffee>', '[PUTBACK] <coffee> <coffe_maker>']
}

Input:
Scene_Objects:['filing_cabinet', 'toilet', 'freezer', 'bathroom', 'hanger', 'floor', 'phone', 'ceiling', 'character', 'bedroom', 'bookshelf', 'toaster', 'mat', 'plate', 'faucet', 'dish_soap', 'closetdrawer', 'couch', 'pillow', 'cup', 'coffe_maker', 'television', 'tray', 'doorjamb', 'towel_rack', 'mouse', 'sink', 'home_office', 'light', 'dishwasher']
Task:Wash dishes with dishwasher
response:

I go to the kitchen and open the dishwasher. I fill it up with dirty dishes and glasses. Then I put dish soap in the dishwasher, close it and turn it on.

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


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', 'chair', 'freezer', 'walllamp', 'orchid', 'cpuscreen', 'wallshelf', 'hanger', 'floor', 'ceiling', 'desk', 'keyboard', 'thread', 'computer', 'piano_bench', 'ceilinglamp', 'mousepad', 'closetdrawer', 'wall', 'powersocket', 'photoframe', 'bed', 'television', 'doorjamb', 'towel_rack', 'mouse', 'kitchen_counter', 'dresser', 'light', 'table']
Task:Work
response:
{
    "thoughts": Walk to the home office and turn to the desk. Switch on the computer. Grab the mouse and keyboard to start working.,
    "actions": ['[WALK] <home_office>', '[WALK] <desk>', '[FIND] <desk>', '[TURNTO] <desk>', '[FIND] <computer>', '[TURNTO] <computer>', '[LOOKAT] <computer>', '[SWITCHON] <computer>', '[FIND] <keyboard>', '[GRAB] <keyboard>', '[FIND] <mouse>', '[GRAB] <mouse>']
}

Input:
Scene_Objects:['tablelamp', 'toilet', 'walllamp', 'trashcan', 'drawing', 'knife', 'wallshelf', 'bathroom_counter', 'floor', 'ceiling', 'bookshelf', 'computer', 'toaster', 'ceilinglamp', 'stereo', 'faucet', 'mousepad', 'wall_clock', 'powersocket', 'oven', 'photoframe', 'check', 'curtain', 'doorjamb', 'mouse', 'kitchen_counter', 'controller', 'bathtub', 'home_office', 'light']
Task:Pet cat
response:

Walk to living room. Find cat. Walk to cat. Pull cat.

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


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

Here is an example plan to achieve a goal for reference:
Scene_Objects:['tablelamp', 'chair', 'walllamp', 'drawing', 'orchid', 'cpuscreen', 'wallshelf', 'hanger', 'floor', 'ceiling', 'phone', 'desk', 'keyboard', 'computer', 'mat', 'ceilinglamp', 'tvstand', 'mousepad', 'couch', 'pillow', 'wall', 'nightstand', 'cup', 'newspaper', 'coffe_maker', 'television', 'doorjamb', 'mouse', 'dresser', 'door']
Task:Start computer
response:
{
    "thoughts": Sit in desk chair, press power button, let computer power on,
    "actions": ['[WALK] <home_office>', '[WALK] <chair>', '[FIND] <chair>', '[SIT] <chair>', '[FIND] <computer>', '[TURNTO] <computer>', '[LOOKAT] <computer>', '[SWITCHON] <computer>']
}

Input:
Scene_Objects:['microwave', 'chair', 'freezer', 'band-aids', 'walllamp', 'cat', 'drawing', 'floor', 'alcohol', 'computer', 'mat', 'tvstand', 'ceilinglamp', 'deck_of_cards', 'window', 'shower', 'couch', 'pillow', 'wall', 'wall_clock', 'oven', 'photoframe', 'keys', 'television', 'curtain', 'doorjamb', 'mouse', 'home_office', 'table', 'bathroom_cabinet']
Task:Pet cat
response:

Walk into bedrrom and to the sofa. Sit on the sofa and touch cat.

[WALK] <home_office>
[WALK] <couch>
[SIT] <couch>
[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:['filing_cabinet', 'tablelamp', 'walllamp', 'bathroom', 'drawing', 'cpuscreen', 'bathroom_counter', 'floor', 'shampoo', 'character', 'wine_glass', 'computer', 'toaster', 'mat', 'tvstand', 'ceilinglamp', 'faucet', 'window', 'couch', 'pillow', 'wall', 'bench', 'powersocket', 'food_cheese', 'food_food', 'coffe_maker', 'television', 'wine', 'curtain', 'table']
Task:Entertain
response:
{
    "thoughts": Give guests wine, cheese, crackers and sit and talk,
    "actions": ['[WALK] <home_office>', '[WALK] <food_cheese>', '[FIND] <food_cheese>', '[FIND] <food_food>', '[FIND] <couch>', '[SIT] <couch>', '[FIND] <wine_glass>', '[GRAB] <wine_glass>', '[DRINK] <wine_glass>']
}

Input:
Scene_Objects:['filing_cabinet', 'measuring_cup', 'chair', 'orchid', 'drawing', 'cpuscreen', 'hanger', 'floor', 'ceiling', 'desk', 'bookshelf', 'keyboard', 'computer', 'ceilinglamp', 'window', 'mousepad', 'closetdrawer', 'dining_room', 'wall', 'nightstand', 'doorjamb', 'mouse', 'dresser', 'controller', 'laundry_detergent', 'door', 'light', 'table', 'scrabble', 'dirt']
Task:Work
response:

I walk to the bedroom, then find the computer and sit in the chair ,next switch on the computer and finally type in the keyboard to start to work on it

[WALK] <bedroom>
[WALK] <computer>
[FIND] <computer>
[FIND] <chair>
[SIT] <chair>
[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:['sponge', 'glue', 'toilet', 'chair', 'detergent', 'dough', 'drawing', 'orchid', 'hanger', 'floor', 'ceiling', 'keyboard', 'alcohol', 'stovefan', 'ceilinglamp', 'couch', 'microphone', 'wall', 'nightstand', 'photoframe', 'coffe_maker', 'coffee_filter', 'doorjamb', 'kitchen_counter', 'hairbrush', 'cupboard', 'home_office', 'dishwasher', 'coffee', 'shoe_rack']
Task:Make coffee
response:
{
    "thoughts": Open coffee maker. Put filter in main basket, put ground coffee in filter, fill reservoir with water, turn on coffee maker.,
    "actions": ['[WALK] <dining_room>', '[WALK] <coffe_maker>', '[FIND] <coffe_maker>', '[OPEN] <coffe_maker>', '[FIND] <coffee_filter>', '[GRAB] <coffee_filter>', '[PUTBACK] <coffee_filter> <coffe_maker>', '[FIND] <coffee>', '[GRAB] <coffee>', '[PUTBACK] <coffee> <coffe_maker>']
}

Input:
Scene_Objects:['pot', 'chair', 'walllamp', 'orchid', 'cpuscreen', 'wallshelf', 'hanger', 'floor', 'ceiling', 'desk', 'bedroom', 'keyboard', 'tea_bag', 'computer', 'table_cloth', 'ceilinglamp', 'tvstand', 'mousepad', 'pillow', 'wall', 'nightstand', 'powersocket', 'bench', 'photoframe', 'television', 'tray', 'doorjamb', 'mouse', 'home_office', 'table']
Task:Browse internet
response:

Walk to home office. Find computer. Sit in chair in front of computer desk. Turn on computer. Open internet browser. Browse the internet

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


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

Here is an example plan to achieve a goal for reference:
Scene_Objects:['walllamp', 'bathroom', 'drawing', 'orchid', 'wallshelf', 'bills', 'floor', 'ceiling', 'desk', 'bookshelf', 'remote_control', 'computer', 'stovefan', 'mat', 'tvstand', 'ceilinglamp', 'shower', 'window', 'couch', 'pillow', 'wall', 'powersocket', 'bench', 'photoframe', 'television', 'curtain', 'doorjamb', 'door', 'table', 'light']
Task:Watch  TV
response:
{
    "thoughts": Sit on my couch  directly opposite  my tv , switch  on my tv with the  remote control  and watch,
    "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:['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:

Pick up my dirty clothes, load the washer, add detergent, turn on washer


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

Here is an example plan to achieve a goal for reference:
Scene_Objects:['pot', 'tablelamp', 'chair', 'walllamp', 'drawing', 'orchid', 'cpuscreen', 'wallshelf', 'hanger', 'floor', 'phone', 'ceiling', 'desk', 'keyboard', 'computer', 'mat', 'ceilinglamp', 'tvstand', 'mousepad', 'couch', 'pillow', 'wall', 'nightstand', 'oven', 'powersocket', 'television', 'tray', 'doorjamb', 'towel_rack', 'mouse', 'dresser', 'door', 'light']
Task:Work
response:
{
    "thoughts": Using desktop computer in home office,
    "actions": ['[WALK] <home_office>', '[WALK] <desk>', '[FIND] <desk>', '[WALK] <desk>', '[FIND] <computer>', '[SWITCHON] <computer>', '[FIND] <chair>', '[PULL] <chair>', '[SIT] <chair>', '[FIND] <mouse>', '[GRAB] <mouse>', '[FIND] <keyboard>', '[TYPE] <keyboard>', '[TURNTO] <computer>', '[LOOKAT] <computer>']
}

Input:
Scene_Objects:['tablelamp', 'microwave', 'toilet', 'freezer', 'walllamp', 'trashcan', 'toothbrush', 'orchid', 'hanger', 'bathroom_counter', 'floor', 'ceiling', 'desk', 'bookshelf', 'table_cloth', 'stovefan', 'tvstand', 'faucet', 'shower', 'mousepad', 'couch', 'towel', 'wall', 'bed', 'coffe_maker', 'door', 'sink', 'bathroom_cabinet', 'tooth_paste', 'teeth']
Task:Wash teeth
response:

I go to sleep and i eat the dinner so i have to clean my mouth

[WALK] <bathroom>
[WALK] <sink>
[FIND] <tooth_paste>
[GRAB] <tooth_paste>
[FIND] <toothbrush>
[GRAB] <toothbrush>
[DROP] <tooth_paste>
[FIND] <teeth>
[SCRUB] <teeth>
[RINSE] <teeth>
[FIND] <towel>
[GRAB] <towel>


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

Here is an example plan to achieve a goal for reference:
Scene_Objects:['tablelamp', 'chair', 'walllamp', 'orchid', 'drawing', 'cpuscreen', 'wallshelf', 'hanger', 'clothes_underwear', 'floor', 'ceiling', 'phone', 'desk', 'keyboard', 'computer', 'ceilinglamp', 'tvstand', 'mat', 'mousepad', 'couch', 'pillow', 'wall', 'nightstand', 'oven', 'television', 'doorjamb', 'shaving_cream', 'mouse', 'dresser', 'door']
Task:Browse internet
response:
{
    "thoughts": switch on the computer,  grab a chair and sit in front of the computer. type with keyboard and browse the internet.,
    "actions": ['[WALK] <home_office>', '[WALK] <computer>', '[FIND] <computer>', '[FIND] <chair>', '[SIT] <chair>', '[SWITCHON] <computer>', '[TURNTO] <computer>', '[LOOKAT] <computer>', '[FIND] <keyboard>', '[TYPE] <keyboard>']
}

Input:
Scene_Objects:['microwave', 'toilet', 'chair', 'freezer', 'detergent', 'trashcan', 'drawing', 'wallshelf', 'clothes_underwear', 'floor', 'ceiling', 'phone', 'computer', 'toaster', 'mat', 'tvstand', 'shower', 'closetdrawer', 'wall', 'oven', 'cup', 'novel', 'water', 'drinking_glass', 'doorjamb', 'mouse', 'kitchen_counter', 'comb', 'cupboard', 'door']
Task:Drink
response:

[WALK] <dining_room>
[WALK] <freezer>
[FIND] <freezer>
[OPEN] <freezer>
[FIND] <drinking_glass>
[GRAB] <drinking_glass>
[FIND] <water>
[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', 'chair', 'freezer', 'walllamp', 'trashcan', 'milk', 'knifeblock', 'floor', 'ceiling', 'keyboard', 'table_cloth', 'ceilinglamp', 'tvstand', 'faucet', 'homework', 'towel', 'dining_room', 'wall', 'nightstand', 'oven', 'food_food', 'tray', 'console', 'kitchen_counter', 'dresser', 'cupboard', 'sink', 'bag', 'napkin', 'soap']
Task:Put groceries in Fridge
response:
{
    "thoughts": Walk to kitchen counter, grab a grocery, walk to fridge, open fridge, put the grocery into fridge, and close fridge,
    "actions": ['[WALK] <dining_room>', '[WALK] <kitchen_counter>', '[FIND] <food_food>', '[GRAB] <food_food>', '[WALK] <freezer>', '[OPEN] <freezer>', '[PUTIN] <food_food> <freezer>', '[CLOSE] <freezer>']
}

Input:
Scene_Objects:['tablelamp', 'microwave', 'freezer', 'walllamp', 'detergent', 'cat', 'knife', 'drawing', 'wallshelf', 'cpuscreen', 'bathroom_counter', 'phone', 'ceiling', 'character', 'faucet', 'window', 'foundation', 'closetdrawer', 'food_orange', 'dining_room', 'coffe_maker', 'check', 'television', 'food_food', 'tray', 'curtain', 'mouse', 'pajamas', 'door', 'bathroom_cabinet']
Task:Pet cat
response:

I walk into the living room and I pet the cat

[WALK] <home_office>
[WALK] <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:['glue', 'pot', 'tablelamp', 'microwave', 'dog', 'milk', 'orchid', 'floor', 'ceiling', 'computer', 'toaster', 'plate', 'shower', 'dish_soap', 'wall', 'food_cheese', 'coffe_maker', 'check', 'coffee_filter', 'oven_mitts', 'cards', 'towel_rack', 'pencil', 'kitchen_counter', 'comb', 'cupboard', 'conditioner', 'door', 'bathroom_cabinet', 'dishwasher']
Task:Wash dishes with dishwasher
response:
{
    "thoughts": Walk to the  kitchen. Open the dishwasher. Put plates into the dishwasher. Put dish soap into the dishwasher. Close the dishwasher. Turn on the dishwasher.,
    "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] <dish_soap>', '[GRAB] <dish_soap>', '[PUTBACK] <dish_soap> <dishwasher>', '[CLOSE] <dishwasher>', '[SWITCHON] <dishwasher>']
}

Input:
Scene_Objects:['microwave', 'chair', 'ground_coffee', 'drawing', 'cpuscreen', 'floor', 'ceiling', 'stovefan', 'toaster', 'tvstand', 'faucet', 'shower', 'closetdrawer', 'wall', 'nightstand', 'oven', 'bench', 'tape', 'photoframe', 'coffe_maker', 'coffee_filter', 'water', 'tray', 'diary', 'mouse', 'kitchen_counter', 'cupboard', 'sink', 'bathtub', 'bathroom_cabinet']
Task:Make coffee
response:

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

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


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

Here is an example plan to achieve a goal for reference:
Scene_Objects:['tablelamp', 'crayon', 'toilet', 'chair', 'bathroom', 'orchid', 'floor', 'ceiling', 'character', 'bedroom', 'desk', 'computer', 'tvstand', 'faucet', 'stereo', 'food_orange', 'photoframe', 'novel', 'television', 'curtain', 'doorjamb', 'diary', 'towel_rack', 'mouse', 'shoes', 'dresser', 'cupboard', 'sink', 'bathtub', 'home_office']
Task:Get dressed
response:
{
    "thoughts": I get dressed in my bedroom in the mornings.,
    "actions": ['[WALK] <bedroom>', '[WALK] <shoes>', '[FIND] <shoes>', '[GRAB] <shoes>', '[PUTON] <shoes>']
}

Input:
Scene_Objects:['microwave', 'walllamp', 'bathroom', 'trashcan', 'bathroom_counter', 'floor', 'phone', 'bedroom', 'keyboard', 'bookshelf', 'table_cloth', 'stovefan', 'ceilinglamp', 'tvstand', 'shower', 'faucet', 'window', 'food_peanut_butter', 'clothes_pants', 'oven', 'basket_for_clothes', 'food_food', 'television', 'kettle', 'dresser', 'laundry_detergent', 'door', 'bathtub', 'clothes_shirt', 'washing_machine']
Task:Wash clothes
response:

Walk to bathroom, open wash-machine, lift laundry basket, grab cloth and put into wash-machine one by one, put down laundry basket, pour detergent, close wash-machine, turn on wash-machine.


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

Here is an example plan to achieve a goal for reference:
Scene_Objects:['tablelamp', 'microwave', 'chair', 'dog', 'drawing', 'cpuscreen', 'floor', 'phone', 'desk', 'keyboard', 'computer', 'laptop', 'mat', 'mousepad', 'wall', 'oven', 'love_seat', 'bed', 'coffe_maker', 'food_food', 'doorjamb', 'centerpiece', 'coffee_pot', 'mouse', 'pencil', 'hairbrush', 'controller', 'door', 'dishwasher', 'electrical_outlet']
Task:Write book
response:
{
    "thoughts": Writing a book,
    "actions": ['[WALK] <home_office>', '[WALK] <laptop>', '[FIND] <laptop>', '[GRAB] <laptop>', '[FIND] <electrical_outlet>', '[PLUGIN] <laptop>', '[WALK] <love_seat>', '[SIT] <love_seat>', '[SWITCHON] <laptop>', '[FIND] <keyboard>', '[TYPE] <keyboard>']
}

Input:
Scene_Objects:['microwave', 'freezer', 'walllamp', 'bathroom', 'drawing', 'cpuscreen', 'wallshelf', 'hanger', 'bathroom_counter', 'floor', 'character', 'desk', 'computer', 'food_bacon', 'mat', 'tvstand', 'ceilinglamp', 'plate', 'window', 'shower', 'couch', 'pillow', 'wall', 'nightstand', 'oven', 'television', 'wine', 'curtain', 'home_office', 'table']
Task:Relax on sofa
response:

Walk into the living room. Walk to the sofa and sit on it. Put your feet up on the sofa and lay down.

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


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

Here is an example plan to achieve a goal for reference:
Scene_Objects:['chair', 'freezer', 'food_carrot', 'drawing', 'orchid', 'cpuscreen', 'kitchen_cabinet', 'floor', 'ceiling', 'computer', 'mat', 'plate', 'ceilinglamp', 'stereo', 'couch', 'candle', 'food_orange', 'pillow', 'wall', 'oven', 'food_vegetable', 'novel', 'food_food', 'razor', 'television', 'console', 'kitchen_counter', 'cupboard', 'controller', 'table']
Task:Fix snack
response:
{
    "thoughts": Open fridge. Take out carrots and other vegetables. Put vegetables on a plate. Put away carrots and celery. Close fridge.,
    "actions": ['[WALK] <dining_room>', '[WALK] <kitchen_cabinet>', '[FIND] <kitchen_cabinet>', '[OPEN] <kitchen_cabinet>', '[FIND] <plate>', '[GRAB] <plate>', '[CLOSE] <kitchen_cabinet>', '[WALK] <freezer>', '[OPEN] <freezer>', '[FIND] <food_carrot>', '[GRAB] <food_carrot>', '[PUTBACK] <food_carrot> <plate>', '[FIND] <food_vegetable>', '[GRAB] <food_vegetable>', '[PUTBACK] <food_vegetable> <plate>', '[CLOSE] <freezer>', '[WALK] <table>', '[PUTBACK] <plate> <table>']
}

Input:
Scene_Objects:['food_salt', 'chair', 'ground_coffee', 'drawing', 'orchid', 'cpuscreen', 'phone', 'bedroom', 'stamp', 'desk', 'bookshelf', 'computer', 'stovefan', 'ceilinglamp', 'tvstand', 'mat', 'nightstand', 'wall', 'oven', 'wall_clock', 'photoframe', 'coffe_maker', 'mouse', 'dresser', 'cupboard', 'bathtub', 'sink', 'home_office', 'table', 'light']
Task:Pet cat
response:

You walk to the living room and find the cat. You look at the cat and touch it to pet it.

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


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

Here is an example plan to achieve a goal for reference:
Scene_Objects:['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:['tablelamp', 'chair', 'freezer', 'dough', 'drawing', 'cpuscreen', 'floor', 'ceiling', 'phone', 'desk', 'keyboard', 'bookshelf', 'computer', 'bookmark', 'stovefan', 'mat', 'window', 'pillow', 'wall', 'nightstand', 'powersocket', 'bed', 'novel', 'coffe_maker', 'curtain', 'doorjamb', 'door', 'sink', 'light', 'laser_pointer']
Task:Read book
response:

I go to the bedroom and turn on the light. I lie in bed. I grab my book from the nightstand, and look for the bookmark to check where I last left off. I read for a while. When I'm done, I put the bookmark on the page I stop at and place the book back on the nightstand.

[WALK] <bedroom>
[WALK] <light>
[FIND] <light>
[SWITCHON] <light>
[FIND] <bed>
[LIE] <bed>
[FIND] <novel>
[GRAB] <novel>
[FIND] <bookmark>
[GRAB] <bookmark>
[READ] <novel>
[PUTBACK] <bookmark> <novel>
[FIND] <nightstand>
[PUTBACK] <novel> <nightstand>