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', 'microwave', 'walllamp', 'drawing', 'knifeblock', 'cpuscreen', 'orchid', 'wallshelf', 'needle', 'bathroom_counter', 'floor', 'ceiling', 'phone', 'bookshelf', 'faucet', 'wall', 'oven', 'powersocket', 'bench', 'after_shave', 'curtain', 'centerpiece', 'pencil', 'kitchen_counter', 'cupboard', 'sink', 'bathtub', 'bathroom_cabinet', 'soap']
Task:Wipe down counter
response:
{
    "thoughts": Clean counter,
    "actions": ['[WALK] <dining_room>', '[WALK] <rag>', '[FIND] <rag>', '[GRAB] <rag>', '[WALK] <sink>', '[FIND] <faucet>', '[SWITCHON] <faucet>', '[RINSE] <rag>', '[SQUEEZE] <rag>', '[SWITCHOFF] <faucet>', '[WALK] <kitchen_counter>', '[WIPE] <kitchen_counter>']
}

Input:
Scene_Objects:['tablelamp', 'toilet', 'chair', 'freezer', 'walllamp', 'detergent', 'cpuscreen', 'floor', 'ceiling', 'dvd_player', 'desk', 'bookshelf', 'keyboard', 'computer', 'food_bacon', 'stovefan', 'mousepad', 'wall', 'nightstand', 'powersocket', 'photoframe', 'novel', 'check', 'television', 'food_rice', 'mouse', 'dresser', 'light', 'dishwasher', 'vase']
Task:Read book
response:

Walk to bookcase in office. Take book from desk. Take book over to chair. Sit down in the chair. Open book and then read book.

[WALK] <home_office>
[WALK] <desk>
[FIND] <novel>
[GRAB] <novel>
[WALK] <chair>
[SIT] <chair>
[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:['blender', 'freezer', 'walllamp', 'bathroom', 'drawing', 'clothes_underwear', 'hanger', 'floor', 'ceiling', 'character', 'keyboard', 'brush', 'tvstand', 'stereo', 'window', 'closetdrawer', 'towel', 'wall', 'powersocket', 'tape', 'food_food', 'television', 'curtain', 'doorjamb', 'vacuum_cleaner', 'dresser', 'door', 'clothes_scarf', 'dishwasher', 'board_game']
Task:vacuum carpet
response:
{
    "thoughts": I bring my vacuum cleaner into the living room.  I plug it into the wall.  I press the on switch on the vacuum cleaner.  I push the vacuum cleaner back and forth over the length and width of the carpet until I have vacuumed the entire carpet.  I turn the vacuum cleaner off.  I take the vacuum cleaner back to the hall closet.,
    "actions": ['[WALK] <home_office>', '[WALK] <dresser>', '[OPEN] <dresser>', '[FIND] <vacuum_cleaner>', '[GRAB] <vacuum_cleaner>', '[PULL] <vacuum_cleaner>', '[PLUGIN] <vacuum_cleaner>', '[SWITCHON] <vacuum_cleaner>', '[PULL] <vacuum_cleaner>', '[PUSH] <vacuum_cleaner>', '[PULL] <vacuum_cleaner>', '[PUSH] <vacuum_cleaner>', '[PULL] <vacuum_cleaner>', '[PUSH] <vacuum_cleaner>', '[SWITCHOFF] <vacuum_cleaner>', '[PLUGOUT] <vacuum_cleaner>', '[WALK] <dresser>', '[PUTIN] <vacuum_cleaner> <dresser>', '[CLOSE] <dresser>']
}

Input:
Scene_Objects:['juice', 'toilet', 'chair', 'blow_dryer', 'food_carrot', 'orchid', 'knifeblock', 'cpuscreen', 'desk', 'clothes_jacket', 'toaster', 'deck_of_cards', 'tvstand', 'dining_room', 'bench', 'basket_for_clothes', 'novel', 'television', 'after_shave', 'coffee_pot', 'mouse', 'cupboard', 'clothes_dress', 'hairdryer', 'home_office', 'colander', 'clothes_shirt', 'washing_machine', 'coffee', 'shoe_rack']
Task:Wash clothes
response:

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


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

Here is an example plan to achieve a goal for reference:
Scene_Objects:['sheets', 'juice', 'microwave', 'freezer', 'bills', 'floor', 'ceiling', 'desk', 'tea_bag', 'computer', 'ceilinglamp', 'plate', 'window', 'mousepad', 'couch', 'dining_room', 'broom', 'wall', 'powersocket', 'novel', 'food_food', 'mouthwash', 'television', 'curtain', 'rag', 'towel_rack', 'kitchen_counter', 'comb', 'door', 'laser_pointer']
Task:Put groceries in Fridge
response:
{
    "thoughts": Walk to the kitchen. Open the fridge, take the groceries and put in it. Closed the fridge,,
    "actions": ['[WALK] <dining_room>', '[WALK] <freezer>', '[FIND] <freezer>', '[OPEN] <freezer>', '[FIND] <food_food>', '[GRAB] <food_food>', '[PUTIN] <food_food> <freezer>', '[CLOSE] <freezer>']
}

Input:
Scene_Objects:['food_bread', 'chair', 'detergent', 'food_carrot', 'clothes_underwear', 'hanger', 'floor', 'ceiling', 'phone', 'computer', 'bookmark', 'toaster', 'balanceball', 'wall', 'powersocket', 'photoframe', 'coffee_filter', 'tray', 'doorjamb', 'cards', 'mouse', 'shaving_cream', 'shoes', 'dresser', 'cupboard', 'door', 'napkin', 'home_office', 'light', 'vase']
Task:Turn on light
response:

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


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

Here is an example plan to achieve a goal for reference:
Scene_Objects:['dry_pasta', 'pot', 'food_pizza', 'tablelamp', 'microwave', 'freezer', 'drawing', 'cpuscreen', 'floor', 'ceiling', 'desk', 'keyboard', 'food_bacon', 'stovefan', 'mat', 'shower', 'couch', 'pillow', 'wall', 'oven', 'powersocket', 'food_food', 'television', 'tray', 'doorjamb', 'towel_rack', 'kitchen_counter', 'cupboard', 'door', 'light']
Task:Cook some food
response:
{
    "thoughts": go to the kitchen and cook some thing to eat,
    "actions": ['[WALK] <dining_room>', '[WALK] <freezer>', '[FIND] <freezer>', '[OPEN] <freezer>', '[FIND] <oven>', '[OPEN] <oven>', '[FIND] <food_pizza>', '[GRAB] <food_pizza>', '[PUTIN] <food_pizza> <oven>', '[SWITCHON] <oven>']
}

Input:
Scene_Objects:['dry_pasta', 'food_bread', 'microwave', 'dog', 'chair', 'ceilingfan', 'drawing', 'bathroom_counter', 'floor', 'ceiling', 'remote_control', 'button', 'ceilinglamp', 'tvstand', 'balanceball', 'window', 'couch', 'wall', 'oven', 'newspaper', 'check', 'television', 'coffee_filter', 'oven_mitts', 'coin', 'curtain', 'lighter', 'maindoor', 'napkin', 'table']
Task:Change TV channel
response:

Walk to TV, grab remote control, press change channel button, repeat pressing change channel button util find the channel wanted, put back remote control

[WALK] <television>
[FIND] <remote_control>
[GRAB] <remote_control>
[FIND] <button>
[TOUCH] <button>
[TURNTO] <television>
[WATCH] <television>
[TOUCH] <button>
[TURNTO] <television>
[WATCH] <television>
[PUTOBJBACK] <remote_control>


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

Here is an example plan to achieve a goal for reference:
Scene_Objects:['sponge', 'mop', 'chair', 'drawing', 'cpuscreen', 'hanger', 'floor', 'ceiling', 'character', 'desk', 'tea_bag', 'bookshelf', 'computer', 'toaster', 'faucet', 'mousepad', 'closetdrawer', 'clothes_hat', 'wall', 'powersocket', 'bed', 'standingmirror', 'television', 'doorjamb', 'cards', 'mouse', 'dresser', 'hair', 'light', 'table']
Task:Turn on light
response:
{
    "thoughts": I walk to wall. I put my hand on the switch. I push the button. I turn on the lights.,
    "actions": ['[WALK] <light>', '[FIND] <light>', '[SWITCHON] <light>']
}

Input:
Scene_Objects:['sponge', 'food_salt', 'bathroom', 'ceilingfan', 'drawing', 'floor', 'ceiling', 'desk', 'brush', 'ceilinglamp', 'tvstand', 'balanceball', 'faucet', 'window', 'couch', 'clothes_pants', 'dining_room', 'wall', 'toy', 'basket_for_clothes', 'bed', 'television', 'coin', 'coffee_filter', 'food_rice', 'curtain', 'cupboard', 'controller', 'table', 'dishwasher']
Task:Watch TV
response:

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


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

Here is an example plan to achieve a goal for reference:
Scene_Objects:['dry_pasta', 'pot', 'microwave', 'walllamp', 'food_butter', 'knifeblock', 'drawing', 'floor', 'ceiling', 'bookshelf', 'keyboard', 'toaster', 'tvstand', 'balanceball', 'picture', 'shower', 'oil', 'food_peanut_butter', 'pillow', 'wall', 'oven', 'television', 'coin', 'diary', 'mouse', 'cupboard', 'bag', 'bathroom_cabinet', 'vase', 'shoe_rack']
Task:Make popcorn
response:
{
    "thoughts": Lay popcorn bag flat inside microwave and press popcorn button to start.,
    "actions": ['[WALK] <dining_room>', '[WALK] <food_food>', '[FIND] <food_food>', '[GRAB] <food_food>', '[WALK] <microwave>', '[TURNTO] <microwave>', '[OPEN] <microwave>', '[PUTIN] <food_food> <microwave>', '[CLOSE] <microwave>', '[SWITCHON] <microwave>']
}

Input:
Scene_Objects:['sheets', 'microwave', 'toilet', 'chair', 'freezer', 'walllamp', 'detergent', 'hanger', 'floor', 'ceiling', 'phone', 'keyboard', 'computer', 'food_bacon', 'alcohol', 'ceilinglamp', 'pillow', 'wall', 'powersocket', 'bed', 'curtain', 'doorjamb', 'kettle', 'mouse', 'dresser', 'cupboard', 'door', 'maindoor', 'light', 'creditcard']
Task:Turn on light
response:

I open the room door and press the light button on

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


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

Here is an example plan to achieve a goal for reference:
Scene_Objects:['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:
{
    "thoughts": 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.,
    "actions": ['[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>']
}

Input:
Scene_Objects:['fork', 'food_bread', 'blender', 'food_salt', 'toilet', 'jelly', 'freezer', 'trashcan', 'clothes_underwear', 'longboard', 'phone', 'character', 'keyboard', 'thread', 'clothes_jacket', 'mop_bucket', 'stereo', 'electric_shaver', 'window', 'pillow', 'dining_room', 'powersocket', 'cup', 'television', 'tray', 'curtain', 'shaving_cream', 'kitchen_counter', 'laundry_detergent', 'home_office']
Task:Listen to music
response:

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


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

Here is an example plan to achieve a goal for reference:
Scene_Objects:['microwave', 'toilet', 'chair', 'walllamp', 'trashcan', 'cpuscreen', 'wallshelf', 'hanger', 'bathroom_counter', 'floor', 'ceiling', 'keyboard', 'tvstand', 'faucet', 'mousepad', 'closetdrawer', 'couch', 'food_jam', 'wall', 'nightstand', 'oven', 'newspaper', 'food_food', 'vacuum_cleaner', 'sink', 'bathtub', 'bathroom_cabinet', 'light', 'table', 'hands_both']
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:['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:

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

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


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

Here is an example plan to achieve a goal for reference:
Scene_Objects:['blender', 'chair', 'walllamp', 'trashcan', 'drawing', 'orchid', 'cpuscreen', 'bathroom_counter', 'floor', 'ceiling', 'character', 'desk', 'bookshelf', 'keyboard', 'computer', 'mat', 'mousepad', 'wall', 'bench', 'photoframe', 'novel', 'curtain', 'doorjamb', 'towel_rack', 'mouse', 'shaving_cream', 'door', 'bathroom_cabinet', 'light', 'home_office']
Task:Read
response:
{
    "thoughts": We pick out a book from the bookshelf and read it.,
    "actions": ['[WALK] <novel>', '[WALK] <bookshelf>', '[FIND] <novel>', '[GRAB] <novel>', '[FIND] <chair>', '[SIT] <chair>', '[READ] <novel>']
}

Input:
Scene_Objects:['pot', 'blender', 'chair', 'freezer', 'walllamp', 'trashcan', 'knifeblock', 'orchid', 'food_egg', 'kitchen_cabinet', 'floor', 'ceiling', 'food_bacon', 'stovefan', 'ceilinglamp', 'toaster', 'faucet', 'wall', 'oven', 'food_cheese', 'food_food', 'food_donut', 'food_rice', 'wine', 'tray', 'kitchen_counter', 'dresser', 'cupboard', 'sink', 'dishwasher']
Task:Cook some food
response:

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

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


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

Here is an example plan to achieve a goal for reference:
Scene_Objects:['glue', 'pot', 'microwave', 'freezer', 'walllamp', 'floor', 'ceiling', 'phone', 'keyboard', 'bookshelf', 'alcohol', 'stovefan', 'toaster', 'tvstand', 'couch', 'wall', 'oven', 'cutting_board', 'toy', 'food_cheese', 'novel', 'coffe_maker', 'food_food', 'television', 'tray', 'shaving_cream', 'cards', 'kitchen_counter', 'shoes', 'light']
Task:Put groceries in Fridge
response:
{
    "thoughts": put away groceries in fridge. open the door, put on shelf, close the door.,
    "actions": ['[WALK] <dining_room>', '[WALK] <freezer>', '[FIND] <freezer>', '[OPEN] <freezer>', '[FIND] <food_food>', '[GRAB] <food_food>', '[PUTIN] <food_food> <freezer>', '[CLOSE] <freezer>']
}

Input:
Scene_Objects:['pot', 'filing_cabinet', 'tablelamp', 'blow_dryer', 'bathroom', 'detergent', 'drawing', 'cpuscreen', 'floor', 'ceiling', 'shampoo', 'character', 'desk', 'bookshelf', 'keyboard', 'computer', 'mat', 'shower', 'food_jam', 'towel', 'dining_room', 'wall', 'powersocket', 'after_shave', 'doorjamb', 'centerpiece', 'door', 'maindoor', 'light', 'coffee']
Task:Turn on light
response:

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

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


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

Here is an example plan to achieve a goal for reference:
Scene_Objects:['sponge', 'pot', 'blender', 'food_ice_cream', 'microwave', 'chair', 'walllamp', 'bathroom', 'trashcan', 'milk', 'floor', 'bedroom', 'computer', 'toaster', 'plate', 'shoe-shine_kit', 'oil', 'wall', 'newspaper', 'coffe_maker', 'tray', 'centerpiece', 'console', 'pencil', 'kitchen_counter', 'cupboard', 'spoon', 'dishwasher', 'laser_pointer', 'clothes_shirt']
Task:Wash dishes with dishwasher
response:
{
    "thoughts": I walk to the kitchen. I take plate. I open the dishwasher. I put plate in the dishwasher. I switch on the dishwasher.,
    "actions": ['[WALK] <dining_room>', '[WALK] <plate>', '[FIND] <plate>', '[GRAB] <plate>', '[WALK] <dishwasher>', '[OPEN] <dishwasher>', '[PUTBACK] <plate> <dishwasher>', '[CLOSE] <dishwasher>', '[SWITCHON] <dishwasher>']
}

Input:
Scene_Objects:['dry_pasta', 'food_bread', 'walllamp', 'bathroom', 'cpuscreen', 'kitchen_cabinet', 'floor', 'tea_bag', 'toaster', 'mat', 'stereo', 'balanceball', 'dish_soap', 'towel', 'wall', 'oven', 'bed', 'light_bulb', 'novel', 'coffe_maker', 'check', 'coin', 'food_donut', 'tray', 'doorjamb', 'towel_rack', 'sink', 'dishwasher', 'vase', 'clothes_shirt']
Task:Wash dishes with dishwasher
response:

I walk to the kitchen. I open the dishwasher. I open the kitchen cabinet. I reach inside the cabinet and grab the box of dish soap. I add some soap to the open dishwasher. I put the box of dish soap back in the kitchen cabinet. I close the kitchen cabinet and then I close the dishwasher. I turn the dishwasher on and wait.

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


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', 'blender', 'walllamp', 'dough', 'knifeblock', 'hanger', 'floor', 'ceiling', 'character', 'keyboard', 'bookshelf', 'clothes_jacket', 'faucet', 'balanceball', 'pillow', 'wall', 'oven', 'food_food', 'wooden_spoon', 'curtain', 'kitchen_counter', 'headset', 'dishrack', 'cupboard', 'maindoor', 'sink', 'table', 'soap', 'hands_both']
Task:Wash hands
response:
{
    "thoughts": Washing Hands,
    "actions": ['[WALK] <dining_room>', '[WALK] <faucet>', '[FIND] <faucet>', '[SWITCHON] <faucet>', '[FIND] <soap>', '[GRAB] <soap>', '[TOUCH] <soap>', '[PUTOBJBACK] <soap>', '[FIND] <hands_both>', '[SCRUB] <hands_both>', '[RINSE] <hands_both>', '[SWITCHOFF] <faucet>']
}

Input:
Scene_Objects:['spectacles', 'sheets', 'drawing', 'cpuscreen', 'ceiling', 'desk', 'bookmark', 'mat', 'plate', 'stereo', 'deck_of_cards', 'mousepad', 'couch', 'clothes_hat', 'clothes_pants', 'bench', 'clothes_gloves', 'video_game_controller', 'curtain', 'towel_rack', 'cd', 'dishrack', 'chessboard', 'pajamas', 'laundry_detergent', 'maindoor', 'door', 'sink', 'bathroom_cabinet', 'clothes_shirt']
Task:Listen to music
response:

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

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


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

Here is an example plan to achieve a goal for reference:
Scene_Objects:['filing_cabinet', 'juice', 'walllamp', 'food_carrot', 'knife', 'orchid', 'cpuscreen', 'phone', 'dvd_player', 'desk', 'mop_bucket', 'toaster', 'laptop', 'tvstand', 'closetdrawer', 'food_jam', 'pillow', 'dining_room', 'food_food', 'television', 'oven_mitts', 'water', 'after_shave', 'pencil', 'hairbrush', 'clothes_dress', 'door', 'table', 'dishwasher', 'light']
Task:Drink
response:
{
    "thoughts": I go to the kitchen. I get a glass. I fill it with water. I take a drink from the glass.,
    "actions": ['[WALK] <dining_room>', '[WALK] <cup>', '[FIND] <cup>', '[GRAB] <cup>', '[WALK] <water>', '[FIND] <water>', '[GRAB] <water>', '[POUR] <water> <cup>', '[DRINK] <cup>']
}

Input:
Scene_Objects:['dry_pasta', 'pot', 'walllamp', 'drawing', 'bills', 'knifeblock', 'hanger', 'floor', 'phone', 'ceilinglamp', 'tvstand', 'faucet', 'iron', 'window', 'mousepad', 'couch', 'food_peanut_butter', 'clothes_hat', 'clothes_pants', 'wall', 'basket_for_clothes', 'clothes_gloves', 'check', 'television', 'after_shave', 'headset', 'maindoor', 'spoon', 'home_office', 'table']
Task:Relax on sofa
response:

allow sofa to support weight in order to decrease gravity induced entropy

[WALK] <home_office>
[WALK] <couch>
[FIND] <couch>
[WALK] <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:['sponge', 'chair', 'walllamp', 'dough', 'drawing', 'wallshelf', 'hanger', 'floor', 'ceiling', 'phone', 'desk', 'remote_control', 'computer', 'mat', 'tvstand', 'ceilinglamp', 'shoe-shine_kit', 'closetdrawer', 'couch', 'pillow', 'wall', 'photoframe', 'novel', 'television', 'doorjamb', 'diary', 'shoes', 'dresser', 'door', 'clothes_shirt']
Task:Watch TV
response:
{
    "thoughts": I walk into the living room. I sit on the couch. I pick up the remote control. I push the power button.  I push the guide button and look for my favorite show "The Middle."  I click that channel and enjoy my show.,
    "actions": ['[WALK] <home_office>', '[WALK] <couch>', '[FIND] <couch>', '[SIT] <couch>', '[FIND] <remote_control>', '[FIND] <television>', '[SWITCHON] <television>', '[PUSH] <remote_control>', '[TURNTO] <television>', '[WATCH] <television>']
}

Input:
Scene_Objects:['glue', 'pot', 'food_bread', 'tablelamp', 'microwave', 'freezer', 'ceilingfan', 'food_carrot', 'orchid', 'longboard', 'bookshelf', 'mail', 'food_bacon', 'brush', 'ceilinglamp', 'tvstand', 'stereo', 'balanceball', 'clothes_pants', 'pillow', 'wall', 'bench', 'powersocket', 'curtain', 'mouse', 'controller', 'maindoor', 'home_office', 'board_game', 'shoe_rack']
Task:Listen to music
response:

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

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


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', '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:
{
    "thoughts": I want to relax on the sofa to some relaxing music in the living room.,
    "actions": ['[WALK] <home_office>', '[WALK] <light>', '[FIND] <light>', '[SWITCHON] <light>', '[WALK] <stereo>', '[PLUGIN] <stereo>', '[SWITCHON] <stereo>', '[WALK] <couch>', '[SIT] <couch>', '[LIE] <couch>']
}

Input:
Scene_Objects:['sheets', 'freezer', 'ground_coffee', 'bathroom', 'ceilingfan', 'drawing', 'clothes_underwear', 'floor', 'food_cake', 'toaster', 'mousepad', 'dining_room', 'oven', 'tape', 'box', 'photoframe', 'coin', 'curtain', 'shaving_cream', 'coffee_pot', 'headset', 'dishrack', 'cupboard', 'sink', 'clothes_scarf', 'home_office', 'dishwasher', 'soap', 'board_game', 'washing_machine']
Task:Wash clothes
response:

Walk to bathroom. Open washer. Put clothes in washer. Put soap in washer. Close washer. Turn washer 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:['sheets', 'tablelamp', 'detergent', 'ceilingfan', 'hanger', 'bathroom_counter', 'phone', 'bedroom', 'bookshelf', 'keyboard', 'food_cake', 'clothes_jacket', 'button', 'laptop', 'tvstand', 'mat', 'dustpan', 'food_food', 'after_shave', 'towel_rack', 'pencil', 'kitchen_counter', 'laundry_detergent', 'sink', 'clothes_scarf', 'bathroom_cabinet', 'table', 'vase', 'washing_machine', 'coffee']
Task:Wash clothes
response:
{
    "thoughts": "I walk to entrance hall" "I walk to bedroom" "I find basket of clothes" "I lift basket of  clothes" "I walk to kitchen" "I find washing machine" "I open washing machine " "I put laundry in washing machine" "I add laundry detergent" " "I close washing machine lid" "I switch washing machine on",
    "actions": ['[WALK] <home_office>', '[WALK] <bedroom>', '[WALK] <basket_for_clothes>', '[FIND] <basket_for_clothes>', '[GRAB] <basket_for_clothes>', '[WALK] <dining_room>', '[WALK] <washing_machine>', '[FIND] <washing_machine>', '[OPEN] <washing_machine>', '[PUTBACK] <basket_for_clothes> <washing_machine>', '[FIND] <laundry_detergent>', '[GRAB] <laundry_detergent>', '[PUTBACK] <laundry_detergent> <washing_machine>', '[CLOSE] <washing_machine>', '[TURNTO] <washing_machine>']
}

Input:
Scene_Objects:['pot', 'filing_cabinet', 'band-aids', 'freezer', 'nail_polish', 'bathroom', 'cat', 'orchid', 'cpuscreen', 'phone', 'character', 'keyboard', 'mat', 'faucet', 'wall', 'oven', 'bed', 'keys', 'coffe_maker', 'mouthwash', 'food_onion', 'curtain', 'centerpiece', 'console', 'towel_rack', 'kitchen_counter', 'dresser', 'cupboard', 'door', 'home_office']
Task:Pet cat
response:

First I need to find the cat in the living room. Then I walk over to the cat and pet it gently.

[WALK] <home_office>
[WALK] <cat>
[FIND] <cat>
[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:['food_ice_cream', 'tea', 'bathroom_counter', 'floor', 'phone', 'keyboard', 'table_cloth', 'mat', 'stereo', 'window', 'foundation', 'mousepad', 'couch', 'clothes_hat', 'pillow', 'wall', 'nightstand', 'bench', 'keys', 'toilet_paper', 'food_food', 'television', 'curtain', 'doorjamb', 'kitchen_counter', 'vacuum_cleaner', 'comb', 'maindoor', 'bathtub', 'table']
Task:Relax on sofa
response:
{
    "thoughts": move to living room, locate sofa, move to sofa, sit on sofa, lie on sofa,
    "actions": ['[WALK] <home_office>', '[WALK] <couch>', '[FIND] <couch>', '[WALK] <couch>', '[SIT] <couch>', '[LIE] <couch>']
}

Input:
Scene_Objects:['food_salt', 'food_oatmeal', 'microwave', 'freezer', 'ceilingfan', 'food_carrot', 'orchid', 'drawing', 'hanger', 'kitchen_cabinet', 'floor', 'ceiling', 'longboard', 'bathroom_counter', 'stovefan', 'ceilinglamp', 'shower', 'food_cereal', 'wall', 'powersocket', 'nightstand', 'food_vegetable', 'food_food', 'doorjamb', 'shaving_cream', 'hairbrush', 'spoon', 'dishwasher', 'vase', 'coffee']
Task:Put groceries in Fridge
response:

Walk to kitchen, find groceries in cabinet and move them to fridge and close fridge.

[WALK] <dining_room>
[WALK] <kitchen_cabinet>
[FIND] <kitchen_cabinet>
[FIND] <food_vegetable>
[GRAB] <food_vegetable>
[FIND] <freezer>
[OPEN] <freezer>
[PUTIN] <food_vegetable> <freezer>
[FIND] <food_carrot>
[GRAB] <food_carrot>
[PUTIN] <food_carrot> <freezer>
[FIND] <food_cereal>
[GRAB] <food_cereal>
[PUTIN] <food_cereal> <freezer>
[FIND] <food_oatmeal>
[GRAB] <food_oatmeal>
[PUTIN] <food_oatmeal> <freezer>
[FIND] <food_food>
[GRAB] <food_food>
[PUTIN] <food_food> <freezer>
[FIND] <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:['filing_cabinet', 'walllamp', 'drawing', 'cpuscreen', 'floor', 'ceiling', 'desk', 'bookshelf', 'keyboard', 'computer', 'button', 'mat', 'balanceball', 'window', 'candle', 'wall', 'powersocket', 'photoframe', 'novel', 'coffee_filter', 'ice', 'doorjamb', 'kettle', 'console', 'door', 'bathroom_cabinet', 'light', 'home_office', 'table', 'soap']
Task:Turn on light
response:
{
    "thoughts": I walk to wall. I put my hand on the switch. I push the button. I turn on the lights.,
    "actions": ['[WALK] <light>', '[FIND] <light>', '[SWITCHON] <light>']
}

Input:
Scene_Objects:['sheets', 'pot', 'food_salt', 'walllamp', 'bathroom', 'trashcan', 'ceilingfan', 'floor', 'keyboard', 'computer', 'brush', 'window', 'candle', 'food_jam', 'pillow', 'food_kiwi', 'wall', 'pasta', 'wall_clock', 'bench', 'bed', 'wooden_spoon', 'curtain', 'towel_rack', 'mouse', 'pencil', 'maindoor', 'light', 'table', 'coffee']
Task:Go to sleep
response:

Enter bedroom, turn on the light, and shut door. Change into night clothes. Turn off light. Turn down comforter, climb into bed, lay head on pillow, and cover up with comforter. Close eyes and drift off to sleep.

[WALK] <bedroom>
[WALK] <bed>
[FIND] <bed>
[LIE] <bed>
[FIND] <sheets>
[PULL] <sheets>


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

Here is an example plan to achieve a goal for reference:
Scene_Objects:['sheets', 'microwave', 'chair', 'walllamp', 'drawing', 'wallshelf', 'hanger', 'floor', 'ceiling', 'shampoo', 'desk', 'keyboard', 'computer', 'mat', 'tvstand', 'ceilinglamp', 'stereo', 'closetdrawer', 'couch', 'pillow', 'wall', 'child', 'photoframe', 'food_food', 'television', 'after_shave', 'doorjamb', 'dresser', 'sink', 'bathroom_cabinet']
Task:Watch TV
response:
{
    "thoughts": Turn on tv.  Sit with kids.,
    "actions": ['[WALK] <home_office>', '[WALK] <television>', '[SWITCHON] <television>', '[WALK] <couch>', '[FIND] <child>', '[GREET] <child>', '[FIND] <child>', '[GREET] <child>', '[SIT] <couch>', '[TURNTO] <television>', '[WATCH] <television>', '[TURNTO] <television>', '[WATCH] <television>', '[TURNTO] <television>', '[WATCH] <television>']
}

Input:
Scene_Objects:['pot', 'detergent', 'ceilingfan', 'drawing', 'knifeblock', 'floor', 'ceiling', 'bedroom', 'remote_control', 'alcohol', 'table_cloth', 'ceilinglamp', 'tvstand', 'balanceball', 'plate', 'window', 'couch', 'wall', 'nightstand', 'oven', 'powersocket', 'novel', 'check', 'television', 'curtain', 'rag', 'doorjamb', 'dresser', 'table', 'clothes_skirt']
Task:Watch TV
response:

go to living room, sit on couch, get remote, switch on tv, watch tv

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


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

Here is an example plan to achieve a goal for reference:
Scene_Objects:['juice', 'detergent', 'knifeblock', 'cpuscreen', 'longboard', 'folder', 'character', 'bookshelf', 'table_cloth', 'toaster', 'stereo', 'picture', 'food_orange', 'nightstand', 'wall_clock', 'tape', 'light_bulb', 'coffe_maker', 'ice', 'tray', 'curtain', 'doorjamb', 'cd', 'shoes', 'dresser', 'door', 'sink', 'light', 'dishwasher', 'teeth']
Task:Listen to music
response:
{
    "thoughts": I walk to the living room. I find a radio there and switch it on to listen to music.,
    "actions": ['[WALK] <home_office>', '[WALK] <stereo>', '[FIND] <stereo>', '[SWITCHON] <stereo>']
}

Input:
Scene_Objects:['filing_cabinet', 'food_bread', 'freezer', 'walllamp', 'drawing', 'cpuscreen', 'floor', 'ceiling', 'bedroom', 'tea_bag', 'bookshelf', 'thread', 'alcohol', 'ceilinglamp', 'shoe-shine_kit', 'balanceball', 'wall', 'oven', 'food_food', 'coffe_maker', 'toilet_paper', 'check', 'food_rice', 'tray', 'towel_rack', 'pencil', 'kitchen_counter', 'napkin', 'dishwasher', 'clothes_shirt']
Task:Put groceries in Fridge
response:

Open the fridge, and put groceries in the fridge. 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:['sponge', 'dry_pasta', 'tablelamp', 'walllamp', 'detergent', 'milk', 'orchid', 'floor', 'ceiling', 'button', 'toaster', 'faucet', 'wall', 'box', 'basket_for_clothes', 'keys', 'coffe_maker', 'food_food', 'curtain', 'food_sugar', 'kitchen_counter', 'dresser', 'cupboard', 'controller', 'bathtub', 'sink', 'home_office', 'coffee_cup', 'dishwasher', 'clothes_skirt']
Task:Make coffee
response:
{
    "thoughts": walk to kitchen, look at the coffee maker, open the coffee maker, find milk, suger and water, mix that all, put into coffee maker, switch on the coffee maker, wait for few mins, push the coffee button in coffee maker, we get coffee in coffee cup, drink coffee,
    "actions": ['[WALK] <dining_room>', '[WALK] <coffe_maker>', '[FIND] <coffe_maker>', '[TURNTO] <coffe_maker>', '[LOOKAT] <coffe_maker>', '[OPEN] <coffe_maker>', '[FIND] <milk>', '[GRAB] <milk>', '[PUTBACK] <milk> <coffe_maker>', '[FIND] <food_sugar>', '[FIND] <coffee_cup>', '[GRAB] <coffee_cup>', '[PUTBACK] <coffee_cup> <coffe_maker>', '[SWITCHON] <coffe_maker>', '[FIND] <button>', '[PUSH] <button>', '[GRAB] <coffee_cup>', '[DRINK] <coffee_cup>']
}

Input:
Scene_Objects:['fork', 'water_glass', 'food_pizza', 'tablelamp', 'drawing', 'knifeblock', 'needle', 'bathroom_counter', 'floor', 'desk', 'purse', 'food_bacon', 'ceilinglamp', 'mat', 'faucet', 'picture', 'window', 'couch', 'wall', 'cup', 'check', 'toilet_paper', 'television', 'water', 'tray', 'hairbrush', 'cupboard', 'controller', 'clothes_scarf', 'table']
Task:Drink
response:

[WALK] <dining_room>
[WALK] <water>
[FIND] <water>
[GRAB] <water>
[FIND] <water_glass>
[POUR] <water> <water_glass>
[GRAB] <water_glass>
[DRINK] <water_glass>
[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:['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:
{
    "thoughts": I go to my desk. I turn on the computer. I open a web page and look at it.,
    "actions": ['[WALK] <home_office>', '[WALK] <computer>', '[FIND] <computer>', '[SWITCHON] <computer>', '[TURNTO] <computer>', '[LOOKAT] <computer>']
}

Input:
Scene_Objects:['pot', 'crayon', 'freezer', 'bathroom', 'trashcan', 'dough', 'knifeblock', 'orchid', 'floor', 'ceiling', 'clothes_jacket', 'brush', 'ceilinglamp', 'mat', 'balanceball', 'clothes_socks', 'couch', 'microphone', 'form', 'wall', 'food_food', 'check', 'oven_mitts', 'wine', 'mouse', 'cupboard', 'food_steak', 'spoon', 'table', 'tooth_paste']
Task:Cook some food
response:

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


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

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

Input:
Scene_Objects:['tea', 'microwave', 'band-aids', 'drawing', 'cpuscreen', 'hanger', 'floor', 'computer', 'ceilinglamp', 'balanceball', 'window', 'oil', 'mousepad', 'couch', 'pillow', 'dining_room', 'wall', 'nightstand', 'bench', 'coffe_maker', 'toilet_paper', 'television', 'kitchen_counter', 'chessboard', 'home_office', 'table', 'bathroom_cabinet', 'vase', 'light', 'coffee']
Task:Relax on sofa
response:

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


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

Here is an example plan to achieve a goal for reference:
Scene_Objects:['tablelamp', 'scissors', 'drawing', 'floor', 'ceiling', 'bookshelf', 'remote_control', 'button', 'ceilinglamp', 'tvstand', 'shower', 'electric_shaver', 'food_kiwi', 'wall', 'bench', 'food_cheese', 'photoframe', 'newspaper', 'bed', 'food_food', 'standingmirror', 'television', 'curtain', 'doorjamb', 'shaving_cream', 'door', 'soap', 'clothes_shirt', 'scrabble', 'coffee']
Task:Change TV channel
response:
{
    "thoughts": Walk to TV, grab remote control, press change channel button, repeat pressing change channel button util find the channel wanted, put back remote control,
    "actions": ['[WALK] <television>', '[FIND] <remote_control>', '[GRAB] <remote_control>', '[FIND] <button>', '[TOUCH] <button>', '[TURNTO] <television>', '[WATCH] <television>', '[TOUCH] <button>', '[TURNTO] <television>', '[WATCH] <television>', '[PUTOBJBACK] <remote_control>']
}

Input:
Scene_Objects:['filing_cabinet', 'blender', 'crayon', 'walllamp', 'ceilingfan', 'dough', 'drawing', 'orchid', 'cpuscreen', 'floor', 'ceiling', 'desk', 'bookshelf', 'keyboard', 'computer', 'toaster', 'mat', 'stovefan', 'wall', 'powersocket', 'oven', 'bench', 'cutting_board', 'food_rice', 'doorjamb', 'cd', 'door', 'light', 'vase', 'creditcard']
Task:Turn on light
response:

I enter the bedroom and find the light. Then I turn it on.

[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:['microwave', 'walllamp', 'detergent', 'floor', 'ceiling', 'toaster', 'faucet', 'stereo', 'electric_shaver', 'window', 'closetdrawer', 'pillow', 'wall', 'nightstand', 'oven', 'powersocket', 'cutting_board', 'coffe_maker', 'television', 'drinking_glass', 'after_shave', 'shaving_cream', 'pencil', 'kitchen_counter', 'comb', 'cupboard', 'sink', 'bathroom_cabinet', 'vase', 'clothes_shirt']
Task:Drink
response:
{
    "thoughts": First I go into the kitchen, open the cupboard and find a glass.Then I close the cupboard. Then I go to the sink, turn the faucet on fill the glass under the faucet. I turn off the faucet and then I drink.,
    "actions": ['[WALK] <dining_room>', '[WALK] <cupboard>', '[FIND] <cupboard>', '[OPEN] <cupboard>', '[FIND] <drinking_glass>', '[GRAB] <drinking_glass>', '[WALK] <sink>', '[FIND] <faucet>', '[SWITCHON] <faucet>', '[PUTBACK] <drinking_glass> <sink>', '[GRAB] <drinking_glass>', '[DRINK] <drinking_glass>']
}

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

I go to the bathroom, walk to the sink, turn on the faucet and then wash my hands under the water.

[WALK] <bathroom>
[WALK] <sink>
[FIND] <faucet>
[TURNTO] <faucet>
[FIND] <hands_both>
[WASH] <hands_both>


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

Here is an example plan to achieve a goal for reference:
Scene_Objects:['juice', 'food_salt', 'walllamp', 'detergent', 'trashcan', 'knifeblock', 'drawing', 'floor', 'stamp', 'table_cloth', 'plate', 'faucet', 'deck_of_cards', 'clothes_pants', 'wall', 'bench', 'powersocket', 'tape', 'photoframe', 'food_food', 'tray', 'pencil', 'kitchen_counter', 'cupboard', 'maindoor', 'sink', 'bathroom_cabinet', 'table', 'dishwasher', 'coffee']
Task:Bring dirty plate to sink
response:
{
    "thoughts": Stand up from the table.  Pick up dirty plate.  Walk to sink.  Put plate in sink.,
    "actions": ['[WALK] <dining_room>', '[WALK] <table>', '[FIND] <table>', '[TURNTO] <table>', '[FIND] <plate>', '[GRAB] <plate>', '[WALK] <dining_room>', '[WALK] <sink>', '[FIND] <sink>', '[PUTBACK] <plate> <sink>']
}

Input:
Scene_Objects:['spectacles', 'sponge', 'filing_cabinet', 'tea', 'chair', 'walllamp', 'bathroom', 'ceilingfan', 'character', 'computer', 'food_bacon', 'mop_bucket', 'balanceball', 'foundation', 'form', 'bowl', 'wall', 'pasta', 'basket_for_clothes', 'bed', 'check', 'doorjamb', 'diary', 'hairbrush', 'cupboard', 'dresser', 'laundry_detergent', 'food_steak', 'light', 'scrabble']
Task:Listen to music
response:

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


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

Here is an example plan to achieve a goal for reference:
Scene_Objects:['sheets', 'tablelamp', 'detergent', 'ceilingfan', 'hanger', 'bathroom_counter', 'phone', 'bedroom', 'bookshelf', 'keyboard', 'food_cake', 'clothes_jacket', 'button', 'laptop', 'tvstand', 'mat', 'dustpan', 'food_food', 'after_shave', 'towel_rack', 'pencil', 'kitchen_counter', 'laundry_detergent', 'sink', 'clothes_scarf', 'bathroom_cabinet', 'table', 'vase', 'washing_machine', 'coffee']
Task:Wash clothes
response:
{
    "thoughts": "I walk to entrance hall" "I walk to bedroom" "I find basket of clothes" "I lift basket of  clothes" "I walk to kitchen" "I find washing machine" "I open washing machine " "I put laundry in washing machine" "I add laundry detergent" " "I close washing machine lid" "I switch washing machine on",
    "actions": ['[WALK] <home_office>', '[WALK] <bedroom>', '[WALK] <basket_for_clothes>', '[FIND] <basket_for_clothes>', '[GRAB] <basket_for_clothes>', '[WALK] <dining_room>', '[WALK] <washing_machine>', '[FIND] <washing_machine>', '[OPEN] <washing_machine>', '[PUTBACK] <basket_for_clothes> <washing_machine>', '[FIND] <laundry_detergent>', '[GRAB] <laundry_detergent>', '[PUTBACK] <laundry_detergent> <washing_machine>', '[CLOSE] <washing_machine>', '[TURNTO] <washing_machine>']
}

Input:
Scene_Objects:['glue', 'filing_cabinet', 'beer', 'chair', 'freezer', 'ceilingfan', 'drawing', 'floor', 'ceiling', 'character', 'keyboard', 'bookmark', 'ceilinglamp', 'balanceball', 'window', 'mousepad', 'couch', 'dustpan', 'pillow', 'wall', 'food_cheese', 'coffe_maker', 'television', 'toothbrush_holder', 'mouse', 'pencil', 'maindoor', 'table', 'dishwasher', 'vase']
Task:Relax on sofa
response:

I go to the living room and sit in the sofa

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


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

Here is an example plan to achieve a goal for reference:
Scene_Objects:['sheets', 'food_pizza', 'filing_cabinet', 'beer', 'measuring_cup', 'chair', 'ground_coffee', 'knifeblock', 'longboard', 'floor', 'ceiling', 'bedroom', 'keyboard', 'computer', 'mail', 'toaster', 'picture', 'dustpan', 'wall', 'bench', 'cutting_board', 'tape', 'cup', 'coffe_maker', 'coffee_filter', 'water', 'after_shave', 'dresser', 'maindoor', 'dishwasher']
Task:Make coffee
response:
{
    "thoughts": Open coffee maker. Put filter in main basket, put ground coffee in filter, fill reservoir with water, turn on coffee maker.,
    "actions": ['[WALK] <dining_room>', '[WALK] <coffe_maker>', '[FIND] <coffe_maker>', '[OPEN] <coffe_maker>', '[FIND] <coffee_filter>', '[GRAB] <coffee_filter>', '[PUTBACK] <coffee_filter> <coffe_maker>', '[FIND] <ground_coffee>', '[GRAB] <ground_coffee>', '[PUTBACK] <ground_coffee> <coffe_maker>', '[GRAB] <ground_coffee>', '[PUTOBJBACK] <ground_coffee>', '[WALK] <water>', '[FIND] <water>', '[GRAB] <water>', '[POUR] <water> <coffe_maker>', '[CLOSE] <coffe_maker>', '[SWITCHON] <coffe_maker>']
}

Input:
Scene_Objects:['pot', 'tablelamp', 'walllamp', 'cat', 'drawing', 'needle', 'bathroom_counter', 'dvd_player', 'folder', 'desk', 'bedroom', 'computer', 'toaster', 'tvstand', 'balanceball', 'mousepad', 'dining_room', 'nightstand', 'oven', 'powersocket', 'food_food', 'pencil', 'maindoor', 'sink', 'bag', 'bathroom_cabinet', 'table', 'home_office', 'light', 'laser_pointer']
Task:Pet cat
response:

Walk to living room. Find the cat. Walk over to the cat. Touch the cat.

[WALK] <home_office>
[WALK] <cat>
[FIND] <cat>
[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:['food_bread', 'scissors', 'crayon', 'freezer', 'walllamp', 'drawing', 'orchid', 'floor', 'ceiling', 'character', 'bookmark', 'toaster', 'ceilinglamp', 'stovefan', 'faucet', 'window', 'homework', 'couch', 'wall', 'child', 'bench', 'photoframe', 'newspaper', 'coffe_maker', 'razor', 'television', 'kitchen_counter', 'cupboard', 'table', 'coffee']
Task:Let baby learn how to walk
response:
{
    "thoughts": The baby tries to stand up and balances on the couch and there are no sharp edges so it's safe.,
    "actions": ['[WALK] <home_office>', '[WALK] <child>', '[FIND] <child>', '[TOUCH] <child>', '[GREET] <child>', '[FIND] <couch>', '[TURNTO] <couch>', '[POINTAT] <couch>', '[TURNTO] <child>', '[LOOKAT] <child>']
}

Input:
Scene_Objects:['dog', 'walllamp', 'ceilingfan', 'drawing', 'orchid', 'knife', 'longboard', 'floor', 'ceiling', 'keyboard', 'remote_control', 'ceilinglamp', 'tvstand', 'balanceball', 'window', 'oil', 'couch', 'candle', 'pillow', 'wall', 'keys', 'coffe_maker', 'television', 'coin', 'curtain', 'dresser', 'conditioner', 'door', 'sink', 'table']
Task:Watch TV
response:

you go into the living room, sit on a chair/sofa, grab remote control, turn on tv, change channels, then watch somethign fun.

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


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

Here is an example plan to achieve a goal for reference:
Scene_Objects:['sponge', 'pot', 'dog', 'walllamp', 'knifeblock', 'cpuscreen', 'floor', 'ceiling', 'phone', 'bedroom', 'keyboard', 'computer', 'stovefan', 'faucet', 'oil', 'pillow', 'wall', 'wall_clock', 'oven', 'pasta', 'keys', 'check', 'tray', 'food_onion', 'kitchen_counter', 'cupboard', 'door', 'sink', 'bathtub', 'light']
Task:Keep an eye on stove as something is cooking
response:
{
    "thoughts": Watch whatever is cooking on the stove so it doesn't burn or pour. Turn off heat when done,
    "actions": ['[WALK] <dining_room>', '[WALK] <oven>', '[FIND] <pot>', '[TURNTO] <pot>', '[LOOKAT] <pot>', '[FIND] <wall_clock>', '[TURNTO] <wall_clock>', '[LOOKAT] <wall_clock>', '[SWITCHOFF] <oven>']
}

Input:
Scene_Objects:['sheets', 'pot', 'tablelamp', 'chair', 'trashcan', 'ceilingfan', 'drawing', 'knife', 'cpuscreen', 'hanger', 'longboard', 'floor', 'ceiling', 'phone', 'character', 'desk', 'keyboard', 'bookshelf', 'computer', 'ceilinglamp', 'balanceball', 'mousepad', 'wall', 'nightstand', 'powersocket', 'doorjamb', 'shaving_cream', 'mouse', 'bag', 'light']
Task:Work
response:

go to home office. turn the computer on. begin working

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


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

Here is an example plan to achieve a goal for reference:
Scene_Objects:['tablelamp', 'chair', 'walllamp', 'drawing', 'orchid', 'cpuscreen', 'wallshelf', 'hanger', 'floor', 'ceiling', 'desk', 'keyboard', 'remote_control', 'computer', 'mat', 'ceilinglamp', 'tvstand', 'mousepad', 'closetdrawer', 'couch', 'pillow', 'wall', 'nightstand', 'photoframe', 'bed', 'television', 'doorjamb', 'mouse', 'dresser', 'door']
Task:Watch TV
response:
{
    "thoughts": Go the living room,  sit in the chair. Take the remote control and switch on the TV.,
    "actions": ['[WALK] <home_office>', '[WALK] <chair>', '[FIND] <chair>', '[SIT] <chair>', '[FIND] <remote_control>', '[GRAB] <remote_control>', '[FIND] <television>', '[TURNTO] <television>', '[POINTAT] <television>', '[SWITCHON] <television>', '[WATCH] <television>']
}

Input:
Scene_Objects:['sponge', 'food_pizza', 'juice', 'toilet', 'freezer', 'blow_dryer', 'walllamp', 'ceilingfan', 'knifeblock', 'bathroom_counter', 'alcohol', 'button', 'stereo', 'form', 'towel', 'oven', 'basket_for_clothes', 'photoframe', 'light_bulb', 'toilet_paper', 'toothbrush_holder', 'kitchen_counter', 'shoes', 'chessboard', 'vacuum_cleaner', 'clothes_scarf', 'home_office', 'dishwasher', 'soap', 'shoe_rack']
Task:Wash hands
response:

I walk to the kitchen and get the soap and wash my both hand using the soap and rinse my hands and use towel.

[WALK] <dining_room>
[WALK] <soap>
[FIND] <soap>
[GRAB] <soap>
[SCRUB] <soap>
[FIND] <towel>
[RINSE] <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:['blender', 'walllamp', 'drawing', 'orchid', 'floor', 'ceiling', 'desk', 'computer', 'table_cloth', 'ceilinglamp', 'tvstand', 'mat', 'window', 'couch', 'pillow', 'wall', 'powersocket', 'bench', 'basket_for_clothes', 'cup', 'television', 'food_rice', 'curtain', 'doorjamb', 'diary', 'shoes', 'door', 'spoon', 'bathroom_cabinet', 'table']
Task:Watch TV
response:
{
    "thoughts": I walk into the living room and sit on the sofa to watch tv,
    "actions": ['[WALK] <home_office>', '[WALK] <couch>', '[FIND] <couch>', '[SIT] <couch>', '[FIND] <television>', '[TURNTO] <television>', '[WATCH] <television>']
}

Input:
Scene_Objects:['tablelamp', 'food_salt', 'ceilingfan', 'drawing', 'orchid', 'floor', 'ceiling', 'phone', 'dvd_player', 'desk', 'remote_control', 'computer', 'ceilinglamp', 'tvstand', 'balanceball', 'window', 'clothes_socks', 'mousepad', 'couch', 'food_kiwi', 'wall', 'bench', 'cup', 'check', 'television', 'curtain', 'napkin', 'table', 'soap', 'instrument_violin']
Task:Watch TV
response:

I walk into the living room. I sit on the couch. I pick up the remote control. I push the power button.  I push the guide button and look for my favorite show "The Middle."  I click that channel and enjoy my show.

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


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

Here is an example plan to achieve a goal for reference:
Scene_Objects:['tablelamp', 'orchid', 'wallshelf', 'hanger', 'bathroom_counter', 'floor', 'stamp', 'tvstand', 'faucet', 'shower', 'mousepad', 'couch', 'dining_room', 'wall', 'toy', 'bed', 'food_food', 'toilet_paper', 'mouthwash', 'doorjamb', 'pencil', 'kitchen_counter', 'comb', 'dresser', 'laundry_detergent', 'napkin', 'home_office', 'bathroom_cabinet', 'dishwasher', 'washing_machine']
Task:Wash clothes
response:
{
    "thoughts": "I walk to entrance hall" "I walk to bedroom" "I find basket of clothes" "I lift basket of  clothes" "I walk to kitchen" "I find washing machine" "I open washing machine " "I put laundry in washing machine" "I add laundry detergent" " "I close washing machine lid" "I switch washing machine on",
    "actions": ['[WALK] <home_office>', '[WALK] <bedroom>', '[WALK] <basket_for_clothes>', '[FIND] <basket_for_clothes>', '[GRAB] <basket_for_clothes>', '[WALK] <dining_room>', '[WALK] <washing_machine>', '[FIND] <washing_machine>', '[OPEN] <washing_machine>', '[PUTBACK] <basket_for_clothes> <washing_machine>', '[FIND] <laundry_detergent>', '[GRAB] <laundry_detergent>', '[PUTBACK] <laundry_detergent> <washing_machine>', '[CLOSE] <washing_machine>', '[TURNTO] <washing_machine>']
}

Input:
Scene_Objects:['filing_cabinet', 'tea', 'ceilingfan', 'drawing', 'floor', 'bookshelf', 'ceilinglamp', 'shower', 'window', 'couch', 'food_orange', 'towel', 'dining_room', 'wall', 'powersocket', 'television', 'tray', 'wooden_spoon', 'rag', 'lighter', 'towel_rack', 'pencil', 'dresser', 'clothes_dress', 'hairdryer', 'sink', 'bathroom_cabinet', 'table', 'dishwasher', 'clothes_shirt']
Task:Relax on sofa
response:

walk to living room, find sofa, sit in sofa

[WALK] <home_office>
[WALK] <couch>
[FIND] <couch>
[WALK] <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:['walllamp', 'bathroom', 'orchid', 'drawing', 'wallshelf', 'floor', 'ceiling', 'bookshelf', 'alcohol', 'stovefan', 'mat', 'tvstand', 'ceilinglamp', 'shower', 'window', 'couch', 'pillow', 'dining_room', 'wall', 'powersocket', 'bench', 'photoframe', 'food_food', 'television', 'curtain', 'doorjamb', 'door', 'sink', 'light', 'table']
Task:Watch TV
response:
{
    "thoughts": walk to living room, find the television, switch on the television, find the sofa, walk to sofa, sit in sofa, watch the television,
    "actions": ['[WALK] <home_office>', '[WALK] <television>', '[FIND] <television>', '[SWITCHON] <television>', '[FIND] <couch>', '[WALK] <couch>', '[SIT] <couch>', '[TURNTO] <television>', '[WATCH] <television>']
}

Input:
Scene_Objects:['sheets', 'freezer', 'bathroom', 'ceilingfan', 'drawing', 'bills', 'floor', 'ceiling', 'phone', 'bedroom', 'desk', 'remote_control', 'button', 'ceilinglamp', 'tvstand', 'balanceball', 'shower', 'window', 'couch', 'wall', 'toy', 'tape', 'bed', 'television', 'curtain', 'comb', 'hair', 'home_office', 'table', 'soap']
Task:Watch TV
response:

Go to the living room and sit on the couch. Turn on television using remote control. Use remote control buttons to navigate to desired channel. Watch television.

[WALK] <home_office>
[WALK] <couch>
[FIND] <couch>
[SIT] <couch>
[FIND] <remote_control>
[GRAB] <remote_control>
[FIND] <television>
[SWITCHON] <television>
[FIND] <button>
[PUSH] <button>
[TURNTO] <television>
[WATCH] <television>


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

Here is an example plan to achieve a goal for reference:
Scene_Objects:['pot', 'tablelamp', 'chair', 'freezer', 'walllamp', 'milk', 'floor', 'keyboard', 'table_cloth', 'stovefan', 'mat', 'tvstand', 'faucet', 'window', 'couch', 'clothes_hat', 'pillow', 'dining_room', 'toy', 'basket_for_clothes', 'coffe_maker', 'video_game_controller', 'tray', 'doorjamb', 'kettle', 'dresser', 'cupboard', 'clothes_dress', 'sink', 'table']
Task:Pick up toys
response:
{
    "thoughts": Bend down and pick up the toys off of the floor.,
    "actions": ['[WALK] <bedroom>', '[WALK] <toy>', '[FIND] <toy>', '[GRAB] <toy>', '[WALK] <dresser>', '[OPEN] <dresser>', '[PUTIN] <toy> <dresser>', '[FIND] <toy>', '[GRAB] <toy>', '[WALK] <dresser>', '[PUTIN] <toy> <dresser>', '[FIND] <toy>', '[WALK] <dresser>', '[GRAB] <toy>', '[PUTIN] <toy> <dresser>', '[CLOSE] <dresser>']
}

Input:
Scene_Objects:['tablelamp', 'detergent', 'ceilingfan', 'drawing', 'needle', 'knifeblock', 'floor', 'ceiling', 'phone', 'bedroom', 'computer', 'toaster', 'ceilinglamp', 'tvstand', 'balanceball', 'shower', 'window', 'couch', 'wall', 'bench', 'check', 'television', 'oven_mitts', 'curtain', 'conditioner', 'food_steak', 'home_office', 'table', 'vase', 'clothes_shirt']
Task:Watch TV
response:

I walk into the living room and sit on the sofa to watch tv

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


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

Here is an example plan to achieve a goal for reference:
Scene_Objects:['fork', 'pot', 'food_pizza', 'juice', 'board_game', 'dog', 'food_butter', 'orchid', 'drawing', 'bathroom_counter', 'bookshelf', 'stovefan', 'mat', 'laptop', 'tvstand', 'picture', 'window', 'couch', 'nightstand', 'wall_clock', 'toy', 'clothes_gloves', 'toilet_paper', 'television', 'ice', 'bathroom_cabinet', 'table', 'light', 'vase', 'instrument_violin']
Task:Set up table
response:
{
    "thoughts": Walk into kitchen, find plate, drop plate on table in living room, walk into kitchen, find cup, bring cup to table in living room, walk into kitchen find fork, bring fork to table in living room,
    "actions": ['[WALK] <dining_room>', '[WALK] <plate>', '[FIND] <plate>', '[GRAB] <plate>', '[WALK] <home_office>', '[DROP] <plate>', '[WALK] <dining_room>', '[WALK] <cup>', '[FIND] <cup>', '[GRAB] <cup>', '[WALK] <home_office>', '[DROP] <cup>', '[WALK] <dining_room>', '[WALK] <fork>', '[FIND] <fork>', '[GRAB] <fork>', '[WALK] <home_office>', '[DROP] <fork>']
}

Input:
Scene_Objects:['filing_cabinet', 'tablelamp', 'beer', 'chair', 'trashcan', 'ceilingfan', 'drawing', 'orchid', 'cpuscreen', 'floor', 'ceiling', 'phone', 'desk', 'keyboard', 'bookshelf', 'computer', 'table_cloth', 'stovefan', 'ceilinglamp', 'mat', 'balanceball', 'mousepad', 'candle', 'wall', 'nightstand', 'newspaper', 'doorjamb', 'mouse', 'light', 'clothes_skirt']
Task:Browse internet
response:

Turn on computer, pull up browser, 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:['pot', 'walllamp', 'drawing', 'orchid', 'wallshelf', 'floor', 'ceiling', 'bookshelf', 'remote_control', 'computer', 'mat', 'tvstand', 'ceilinglamp', 'shower', 'window', 'mousepad', 'couch', 'pillow', 'wall', 'powersocket', 'bench', 'photoframe', 'check', 'television', 'curtain', 'doorjamb', 'door', 'home_office', 'table', 'light']
Task:Watch TV
response:
{
    "thoughts": Go to the living room. Find the remote. Pick up the remote. Find the sofa. Sit on the sofa. Look at the television. Aim the remote at the television. Press the power button. Flip the channels.,
    "actions": ['[WALK] <home_office>', '[WALK] <remote_control>', '[FIND] <remote_control>', '[GRAB] <remote_control>', '[FIND] <couch>', '[SIT] <couch>', '[FIND] <television>', '[TURNTO] <television>', '[LOOKAT] <television>', '[TURNTO] <television>', '[POINTAT] <television>', '[SWITCHON] <television>', '[PUSH] <remote_control>', '[WATCH] <television>']
}

Input:
Scene_Objects:['pot', 'filing_cabinet', 'juice', 'ground_coffee', 'detergent', 'trashcan', 'hanger', 'floor', 'folder', 'desk', 'bedroom', 'bookshelf', 'mop_bucket', 'toaster', 'ceilinglamp', 'balanceball', 'microphone', 'clothes_hat', 'form', 'food_kiwi', 'nightstand', 'bench', 'photoframe', 'newspaper', 'kitchen_counter', 'hair', 'maindoor', 'door', 'food_steak', 'hairdryer']
Task:Turn on light
response:

Walk to the living room, walk to the lamp, switch on the lamp.

[WALK] <home_office>
[WALK] <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:['pot', 'tablelamp', 'microwave', 'walllamp', 'knifeblock', 'cpuscreen', 'floor', 'ceiling', 'bedroom', 'desk', 'bookshelf', 'stovefan', 'ceilinglamp', 'faucet', 'stereo', 'shower', 'candle', 'wall', 'oven', 'cup', 'photoframe', 'water', 'tray', 'doorjamb', 'kitchen_counter', 'cupboard', 'sink', 'bathtub', 'bathroom_cabinet', 'light']
Task:Drink
response:
{
    "thoughts": Walk to kitchen, walk to cupboard, open cupboard, grab cup, walk to sink, pour water in cup, drink water.,
    "actions": ['[WALK] <dining_room>', '[WALK] <cupboard>', '[FIND] <cupboard>', '[OPEN] <cupboard>', '[FIND] <cup>', '[GRAB] <cup>', '[WALK] <sink>', '[WALK] <water>', '[FIND] <water>', '[GRAB] <water>', '[POUR] <water> <cup>', '[DRINK] <cup>']
}

Input:
Scene_Objects:['tablelamp', 'walllamp', 'food_butter', 'ceilingfan', 'trashcan', 'floor', 'ceiling', 'bedroom', 'mat', 'plate', 'balanceball', 'faucet', 'oil', 'clothes_pants', 'food_orange', 'wall', 'bench', 'tape', 'cup', 'bed', 'light_bulb', 'video_game_controller', 'razor', 'food_rice', 'diary', 'towel_rack', 'mouse', 'headset', 'dishrack', 'spoon']
Task:Listen to music
response:

walk to living room ,find radio ,switch on radio ,listen to music 4

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


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

Here is an example plan to achieve a goal for reference:
Scene_Objects:['blender', 'walllamp', 'drawing', 'orchid', 'floor', 'ceiling', 'desk', 'computer', 'table_cloth', 'ceilinglamp', 'tvstand', 'mat', 'window', 'couch', 'pillow', 'wall', 'powersocket', 'bench', 'basket_for_clothes', 'cup', 'television', 'food_rice', 'curtain', 'doorjamb', 'diary', 'shoes', 'door', 'spoon', 'bathroom_cabinet', 'table']
Task:Watch TV
response:
{
    "thoughts": I walk into the living room and sit on the sofa to watch tv,
    "actions": ['[WALK] <home_office>', '[WALK] <couch>', '[FIND] <couch>', '[SIT] <couch>', '[FIND] <television>', '[TURNTO] <television>', '[WATCH] <television>']
}

Input:
Scene_Objects:['microwave', 'chair', 'nail_polish', 'knifeblock', 'hanger', 'longboard', 'floor', 'ceiling', 'phone', 'shampoo', 'bookshelf', 'computer', 'ceilinglamp', 'food_kiwi', 'wall', 'bench', 'newspaper', 'bed', 'doorjamb', 'kitchen_counter', 'dresser', 'cupboard', 'controller', 'conditioner', 'door', 'hairdryer', 'light', 'table', 'tooth_paste', 'shoe_rack']
Task:Turn on light
response:

Walk into living room. Find wall. Find light button. Switch on light button.

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


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

Here is an example plan to achieve a goal for reference:
Scene_Objects:['pot', 'filing_cabinet', 'measuring_cup', 'microwave', 'walllamp', 'bathroom', 'trashcan', 'knifeblock', 'cpuscreen', 'floor', 'desk', 'toaster', 'stovefan', 'plate', 'faucet', 'iron', 'dish_soap', 'wall', 'oven', 'coffe_maker', 'food_food', 'wooden_spoon', 'tray', 'kitchen_counter', 'dishrack', 'cupboard', 'door', 'sink', 'bathroom_cabinet', 'dishwasher']
Task:Wash dishes with dishwasher
response:
{
    "thoughts": 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.,
    "actions": ['[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>']
}

Input:
Scene_Objects:['jelly', 'nail_polish', 'detergent', 'drawing', 'orchid', 'bathroom_counter', 'floor', 'dvd_player', 'computer', 'ceilinglamp', 'plate', 'balanceball', 'faucet', 'window', 'stereo', 'couch', 'wall', 'oven', 'newspaper', 'television', 'tray', 'rag', 'mouse', 'hair', 'controller', 'laundry_detergent', 'napkin', 'home_office', 'table', 'creditcard']
Task:Listen to music
response:

walk to living room, look at the DVD player, switch on the dvd player, look at the sofa, sit on the sofa and listen the music

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


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', 'drawing', 'wallshelf', 'bathroom_counter', 'floor', 'ceiling', 'phone', 'computer', 'stovefan', 'ceilinglamp', 'tvstand', 'faucet', 'shower', 'stereo', 'couch', 'wall', 'nightstand', 'bench', 'powersocket', 'tape', 'bed', 'coffe_maker', 'check', 'tray', 'curtain', 'sink', 'bathroom_cabinet', 'soap', 'hands_both']
Task:Wash hands
response:
{
    "thoughts": Go to the bathroom and to the sink, turn the faucet on, push the bottle of soap onto your hands and scrub them. Then rinse your hands out and turn the faucet off.,
    "actions": ['[WALK] <bathroom>', '[WALK] <sink>', '[FIND] <sink>', '[FIND] <faucet>', '[SWITCHON] <faucet>', '[FIND] <soap>', '[PUSH] <soap>', '[FIND] <hands_both>', '[SCRUB] <hands_both>', '[RINSE] <hands_both>', '[SWITCHOFF] <faucet>']
}

Input:
Scene_Objects:['microwave', 'toilet', 'chair', 'band-aids', 'drawing', 'knifeblock', 'hanger', 'floor', 'phone', 'ceiling', 'desk', 'computer', 'bookmark', 'ceilinglamp', 'window', 'mousepad', 'couch', 'wall', 'nightstand', 'powersocket', 'television', 'tray', 'doorjamb', 'dresser', 'cupboard', 'door', 'light', 'table', 'dishwasher', 'board_game']
Task:Pick up phone
response:

My friend is calling and I want to pick up the phone and chat with him for a little while on the couch.

[WALK] <home_office>
[WALK] <light>
[FIND] <light>
[SWITCHON] <light>
[FIND] <phone>
[GRAB] <phone>
[WALK] <couch>
[SIT] <couch>
[LIE] <couch>
[TYPE] <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', 'tablelamp', 'chair', 'cat', 'orchid', 'drawing', 'cpuscreen', 'floor', 'ceiling', 'desk', 'keyboard', 'computer', 'mat', 'ceilinglamp', 'tvstand', 'shower', 'mousepad', 'closetdrawer', 'wall', 'nightstand', 'cutting_board', 'coffee_table', 'novel', 'food_food', 'television', 'towel_rack', 'mouse', 'shoes', 'door', 'light']
Task:Read book
response:
{
    "thoughts": I walk to the living room and pick up a book from the coffee table. I find my favorite chair.  I sit in the armchair and open the book.  I read.,
    "actions": ['[WALK] <home_office>', '[WALK] <novel>', '[FIND] <novel>', '[WALK] <coffee_table>', '[GRAB] <novel>', '[WALK] <chair>', '[SIT] <chair>', '[READ] <novel>']
}

Input:
Scene_Objects:['tablelamp', 'toilet', 'chair', 'walllamp', 'trashcan', 'ceilingfan', 'drawing', 'cpuscreen', 'hanger', 'floor', 'ceiling', 'phone', 'desk', 'bookshelf', 'keyboard', 'envelope', 'computer', 'bookmark', 'ceilinglamp', 'balanceball', 'mousepad', 'wall', 'nightstand', 'photoframe', 'check', 'doorjamb', 'mouse', 'dresser', 'cupboard', 'door', 'light']
Task:Work
response:

I go to the home office to work on my project. I turn on the light and walk to my desk. I turn on the computer. Then I look through the documents. After I'm done, I turn off the computer.

[WALK] <home_office>
[WALK] <light>
[FIND] <light>
[SWITCHON] <light>
[WALK] <desk>
[FIND] <computer>
[SWITCHON] <computer>
[FIND] <check>
[TURNTO] <check>
[LOOKAT] <check>
[SWITCHOFF] <computer>


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

Here is an example plan to achieve a goal for reference:
Scene_Objects:['tablelamp', 'toilet', 'freezer', 'bathroom', 'orchid', 'phone', 'dvd_player', 'character', 'bedroom', 'ceilinglamp', 'balanceball', 'iron', 'window', 'couch', 'food_orange', 'wall', 'tape', 'cup', 'basket_for_clothes', 'check', 'wooden_spoon', 'console', 'mouse', 'kitchen_counter', 'hairbrush', 'food_steak', 'sink', 'home_office', 'soap', 'hands_both']
Task:Wash hands
response:
{
    "thoughts": Wash hands with soap,
    "actions": ['[WALK] <bathroom>', '[WALK] <soap>', '[FIND] <soap>', '[GRAB] <soap>', '[FIND] <hands_both>', '[SCRUB] <hands_both>', '[WASH] <hands_both>', '[RINSE] <hands_both>']
}

Input:
Scene_Objects:['fork', 'water_glass', 'blender', 'food_salt', 'microwave', 'nail_polish', 'trashcan', 'drawing', 'hanger', 'longboard', 'floor', 'character', 'computer', 'food_bacon', 'mat', 'electric_shaver', 'mousepad', 'dining_room', 'bench', 'bed', 'food_food', 'video_game_controller', 'water', 'tray', 'doorjamb', 'mouse', 'kitchen_counter', 'bathroom_cabinet', 'table', 'dirt']
Task:Drink
response:

walk to kitchen, hold drinking glass, lift glass, pour water in drinking glass

[WALK] <dining_room>
[WALK]

[FIND]

[FIND] <water_glass>
[GRAB] <water_glass>
[FIND] <water>
[GRAB] <water>
[WALK] <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', 'filing_cabinet', 'beer', 'freezer', 'walllamp', 'bathroom', 'bathroom_counter', 'character', 'bedroom', 'desk', 'ceilinglamp', 'tvstand', 'faucet', 'clothes_socks', 'clothes_pants', 'towel', 'bench', 'basket_for_clothes', 'bed', 'coin', 'food_donut', 'curtain', 'towel_rack', 'mouse', 'cd', 'comb', 'laundry_detergent', 'bathtub', 'bathroom_cabinet', 'washing_machine']
Task:Wash clothes
response:
{
    "thoughts": Go to kitchen, find washing machine, find laundry, put laundry in washing machine, find soap, put soap in washing machine, turn on.,
    "actions": ['[WALK] <dining_room>', '[WALK] <washing_machine>', '[FIND] <washing_machine>', '[FIND] <basket_for_clothes>', '[GRAB] <basket_for_clothes>', '[OPEN] <washing_machine>', '[PUTBACK] <basket_for_clothes> <washing_machine>', '[WALK] <laundry_detergent>', '[FIND] <laundry_detergent>', '[GRAB] <laundry_detergent>', '[POUR] <laundry_detergent> <washing_machine>', '[CLOSE] <washing_machine>', '[SWITCHON] <washing_machine>']
}

Input:
Scene_Objects:['fork', 'toilet', 'chair', 'freezer', 'walllamp', 'bills', 'hanger', 'floor', 'ceiling', 'phone', 'desk', 'bedroom', 'computer', 'toaster', 'mat', 'plate', 'faucet', 'couch', 'form', 'wall', 'wall_clock', 'television', 'food_onion', 'doorjamb', 'towel_rack', 'dresser', 'cupboard', 'door', 'light', 'table']
Task:Turn on light
response:

I walk in to the living room. I find the light switch. I turn on the lights.

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


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

Here is an example plan to achieve a goal for reference:
Scene_Objects:['fork', 'filing_cabinet', 'beer', 'tea', 'freezer', 'shampoo', 'character', 'desk', 'piano_bench', 'ceilinglamp', 'iron', 'picture', 'mousepad', 'couch', 'bowl', 'nightstand', 'wall_clock', 'toy', 'bed', 'coffe_maker', 'television', 'coin', 'after_shave', 'curtain', 'doorjamb', 'towel_rack', 'mouse', 'pencil', 'shoes', 'bathroom_cabinet']
Task:Change TV channel
response:
{
    "thoughts": take remote control, push "change channel" button,
    "actions": ['[WALK] <home_office>', '[WALK] <remote_control>', '[FIND] <remote_control>', '[PUSH] <remote_control>']
}

Input:
Scene_Objects:['pot', 'tablelamp', 'tea', 'measuring_cup', 'toilet', 'walllamp', 'bathroom', 'knifeblock', 'orchid', 'floor', 'ceiling', 'folder', 'bookshelf', 'stovefan', 'ceilinglamp', 'faucet', 'mousepad', 'wall', 'nightstand', 'pasta', 'cup', 'food_food', 'television', 'water', 'kitchen_counter', 'cupboard', 'sink', 'spoon', 'light', 'vase']
Task:Drink
response:

Walk to kitchen, walk to cupboard, open cupboard, grab cup, walk to sink, pour water in cup, drink water.

[WALK] <dining_room>
[WALK] <cupboard>
[FIND] <cupboard>
[OPEN] <cupboard>
[FIND] <cup>
[GRAB] <cup>
[WALK] <sink>
[WALK] <water>
[FIND] <water>
[GRAB] <water>
[POUR] <water> <cup>
[DRINK] <cup>


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

Here is an example plan to achieve a goal for reference:
Scene_Objects:['microwave', 'toilet', 'dog', 'freezer', 'walllamp', 'bathroom', 'trashcan', 'drawing', 'knifeblock', 'cpuscreen', 'phone', 'bookshelf', 'table_cloth', 'bookmark', 'toaster', 'mat', 'faucet', 'oven', 'cup', 'photoframe', 'check', 'television', 'towel_rack', 'kitchen_counter', 'chessboard', 'cupboard', 'door', 'sink', 'light', 'tooth_paste']
Task:Pet dog
response:
{
    "thoughts": Pet my dog in hall,
    "actions": ['[WALK] <home_office>', '[WALK] <dog>', '[TURNTO] <dog>', '[LOOKAT] <dog>', '[TOUCH] <dog>']
}

Input:
Scene_Objects:['tablelamp', 'food_salt', 'measuring_cup', 'jelly', 'freezer', 'nail_polish', 'ceilingfan', 'drawing', 'orchid', 'longboard', 'floor', 'ceiling', 'bedroom', 'keyboard', 'ceilinglamp', 'tvstand', 'balanceball', 'stereo', 'window', 'deck_of_cards', 'mousepad', 'couch', 'clothes_pants', 'wall', 'television', 'curtain', 'kitchen_counter', 'chessboard', 'spoon', 'table']
Task:Change TV channel
response:

I walk in living room. I find TV remote. I grab TV remote. I sit on sofa. I switch on TV. I switch channel.

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


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

Here is an example plan to achieve a goal for reference:
Scene_Objects:['filing_cabinet', 'toilet', 'walllamp', 'trashcan', 'drawing', 'cpuscreen', 'bathroom_counter', 'floor', 'phone', 'character', 'bedroom', 'desk', 'bookshelf', 'computer', 'mat', 'tvstand', 'window', 'pillow', 'wall', 'powersocket', 'tray', 'towel_rack', 'mouse', 'kitchen_counter', 'cupboard', 'laundry_detergent', 'bathtub', 'light', 'teeth', 'shoe_rack']
Task:Go to toilet
response:
{
    "thoughts": walk to bathroom , run to toilet,
    "actions": ['[WALK] <bathroom>', '[RUN] <toilet>']
}

Input:
Scene_Objects:['tablelamp', 'food_salt', 'beer', 'dog', 'freezer', 'walllamp', 'trashcan', 'orchid', 'floor', 'ceiling', 'phone', 'desk', 'clothes_jacket', 'toaster', 'ceilinglamp', 'plate', 'mousepad', 'microphone', 'food_orange', 'wall', 'wall_clock', 'bench', 'food_food', 'oven_mitts', 'coffee_filter', 'kitchen_counter', 'cd', 'cupboard', 'maindoor', 'home_office']
Task:Put groceries in Fridge
response:

I pick up groceries. I open fridge. I put groceries in the fridge.

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


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

Here is an example plan to achieve a goal for reference:
Scene_Objects:['fork', 'filing_cabinet', 'juice', 'freezer', 'walllamp', 'drawing', 'orchid', 'phone', 'ceiling', 'character', 'cleaning_solution', 'button', 'toaster', 'ceilinglamp', 'homework', 'oil', 'mousepad', 'pillow', 'dining_room', 'food_kiwi', 'pasta', 'oven', 'coffe_maker', 'food_food', 'television', 'rag', 'towel_rack', 'bathtub', 'instrument_guitar', 'vase']
Task:Clean
response:
{
    "thoughts": Spray counter tops with all purpose cleaner. Using towel, wipe counter, removing all dirt and grime until clean.,
    "actions": ['[WALK] <dining_room>', '[WALK] <cleaning_solution>', '[FIND] <cleaning_solution>', '[GRAB] <cleaning_solution>', '[PUTOBJBACK] <cleaning_solution>', '[FIND] <rag>', '[GRAB] <rag>', '[PUTOBJBACK] <rag>']
}

Input:
Scene_Objects:['spectacles', 'glue', 'filing_cabinet', 'microwave', 'jelly', 'freezer', 'ceilingfan', 'orchid', 'food_egg', 'floor', 'phone', 'ceiling', 'desk', 'thread', 'mat', 'laptop', 'deck_of_cards', 'faucet', 'foundation', 'pillow', 'nightstand', 'powersocket', 'basket_for_clothes', 'food_food', 'lighter', 'sink', 'home_office', 'vase', 'soap', 'washing_machine']
Task:Wash clothes
response:

I go to the bedroom to find and grab basket of clothes. I then go to the bathroom and find the washing machine. I put clothes inside the washing machine and put washing powder. I switch on the washing machine.


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

Here is an example plan to achieve a goal for reference:
Scene_Objects:['chair', 'walllamp', 'cpuscreen', 'kitchen_cabinet', 'bathroom_counter', 'desk', 'bedroom', 'thread', 'faucet', 'shower', 'electric_shaver', 'microphone', 'towel', 'dining_room', 'wall', 'oven', 'cutting_board', 'photoframe', 'water', 'drinking_glass', 'curtain', 'food_onion', 'doorjamb', 'kettle', 'kitchen_counter', 'dresser', 'laundry_detergent', 'light', 'table', 'dirt']
Task:Drink
response:
{
    "thoughts": You walk to the kitchen and open the kitchen cabinet and grab a drinking glass. You find the water and pour the water into the drinking glass. You drink the water from the glass.,
    "actions": ['[WALK] <dining_room>', '[WALK] <kitchen_cabinet>', '[FIND] <kitchen_cabinet>', '[OPEN] <kitchen_cabinet>', '[FIND] <drinking_glass>', '[GRAB] <drinking_glass>', '[WALK] <water>', '[FIND] <water>', '[GRAB] <water>', '[POUR] <water> <drinking_glass>', '[DRINK] <drinking_glass>']
}

Input:
Scene_Objects:['pot', 'food_pizza', 'tablelamp', 'mop', 'freezer', 'blow_dryer', 'bathroom', 'detergent', 'milk', 'bathroom_counter', 'ceiling', 'character', 'mop_bucket', 'stovefan', 'shoe-shine_kit', 'balanceball', 'deck_of_cards', 'stereo', 'shower', 'mousepad', 'microphone', 'pillow', 'light_bulb', 'coffee_filter', 'doorjamb', 'towel_rack', 'pencil', 'cupboard', 'light', 'dishwasher']
Task:Browse internet
response:

The task is browse and surf on the internet regarding a particular topic

[WALK] <bedroom>
[WALK] <laptop>
[FIND] <laptop>
[SWITCHON] <laptop>
[TURNTO] <laptop>
[LOOKAT] <laptop>
[WATCH] <laptop>


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

Here is an example plan to achieve a goal for reference:
Scene_Objects:['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:
{
    "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:['chair', 'food_carrot', 'drawing', 'hanger', 'floor', 'ceiling', 'phone', 'dvd_player', 'character', 'bedroom', 'keyboard', 'piano_bench', 'bookmark', 'laptop', 'electric_shaver', 'food_kiwi', 'wall', 'powersocket', 'toothbrush_holder', 'curtain', 'rag', 'doorjamb', 'shaving_cream', 'cards', 'dresser', 'cupboard', 'door', 'bathroom_cabinet', 'light', 'coffee']
Task:Turn on light
response:

I walk into the dining room and turn on the lights

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


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

Here is an example plan to achieve a goal for reference:
Scene_Objects:['glue', 'pot', 'tablelamp', 'chair', 'walllamp', 'drawing', 'orchid', 'cpuscreen', 'wallshelf', 'hanger', 'floor', 'phone', 'ceiling', 'desk', 'keyboard', 'computer', 'mat', 'ceilinglamp', 'tvstand', 'mousepad', 'couch', 'pillow', 'wall', 'nightstand', 'oven', 'powersocket', 'novel', 'check', 'television', 'tray', 'doorjamb', 'towel_rack', 'mouse', 'dresser', 'door', 'light']
Task:Work
response:
{
    "thoughts": I sit at my desk and work on the computer.,
    "actions": ['[WALK] <home_office>', '[WALK] <desk>', '[FIND] <chair>', '[SIT] <chair>', '[FIND] <computer>', '[SWITCHON] <computer>', '[TURNTO] <computer>', '[LOOKAT] <computer>', '[FIND] <check>', '[GRAB] <check>', '[READ] <check>', '[FIND] <keyboard>', '[TYPE] <keyboard>']
}

Input:
Scene_Objects:['food_ice_cream', 'chair', 'detergent', 'milk', 'knife', 'drawing', 'cpuscreen', 'orchid', 'hanger', 'bathroom_counter', 'floor', 'ceiling', 'phone', 'computer', 'tvstand', 'faucet', 'couch', 'wall', 'photoframe', 'bed', 'water', 'after_shave', 'mouse', 'controller', 'laundry_detergent', 'sink', 'bathroom_cabinet', 'home_office', 'soap', 'hands_both']
Task:Wash hands
response:

Walk to bathroom. Walk to sink and turn on the water. Grab the soap and wash the hands.

[WALK] <bathroom>
[WALK] <sink>
[FIND] <water>
[TURNTO] <water>
[FIND] <soap>
[GRAB] <soap>
[FIND] <hands_both>
[WASH] <hands_both>