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

Here is an example plan to achieve a goal for reference:
Scene_Objects:['beer', 'microwave', 'trashcan', 'drawing', 'cpuscreen', 'floor', 'ceiling', 'phone', 'keyboard', 'ceilinglamp', 'mat', 'picture', 'window', 'couch', 'dining_room', 'wall', 'oven', 'powersocket', 'toy', 'photoframe', 'television', 'oven_mitts', 'tray', 'centerpiece', 'kettle', 'towel_rack', 'pencil', 'dishrack', 'table', 'vase']
Task:Relax on sofa
response:
{
    "thoughts": go to the living room and sit on the couch, ease into the sofa and relax.,
    "actions": ['[WALK] <home_office>', '[WALK] <couch>', '[LIE] <couch>']
}

Input:
Scene_Objects:['chair', 'walllamp', 'bathroom', 'detergent', 'food_butter', 'orchid', 'wallshelf', 'floor', 'ceiling', 'character', 'bedroom', 'button', 'table_cloth', 'stovefan', 'mat', 'brush', 'stereo', 'picture', 'mousepad', 'couch', 'clothes_pants', 'food_jam', 'powersocket', 'oven', 'newspaper', 'cards', 'shoes', 'controller', 'clothes_skirt', 'board_game']
Task:Listen to music
response:

I go into the living room and turn on the radio.  Then, I select the station I want, which is usually a preset.

[WALK] <home_office>
[WALK] <stereo>
[FIND] <stereo>
[FIND] <button>
[PUSH] <button>
[FIND] <button>
[PUSH] <button>


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

Here is an example plan to achieve a goal for reference:
Scene_Objects:['freezer', 'walllamp', 'bathroom', 'drawing', 'orchid', 'floor', 'ceiling', 'video_game_console', 'desk', 'keyboard', 'stovefan', 'ceilinglamp', 'tvstand', 'mat', 'window', 'couch', 'pillow', 'wall', 'powersocket', 'video_game_controller', 'television', 'food_rice', 'ice', 'curtain', 'doorjamb', 'dresser', 'door', 'bathroom_cabinet', 'table', 'laser_pointer']
Task:Play games
response:
{
    "thoughts": Turn on game.  Use controller,
    "actions": ['[WALK] <home_office>', '[WALK] <television>', '[PLUGIN] <television>', '[SWITCHON] <television>', '[FIND] <video_game_console>', '[PLUGIN] <video_game_console>', '[SWITCHON] <video_game_console>', '[FIND] <video_game_console>', '[FIND] <video_game_controller>', '[GRAB] <video_game_controller>', '[WALK] <couch>', '[SIT] <couch>']
}

Input:
Scene_Objects:['sponge', 'glue', 'toilet', 'chair', 'detergent', 'dough', 'drawing', 'orchid', 'hanger', 'floor', 'ceiling', 'keyboard', 'alcohol', 'stovefan', 'ceilinglamp', 'couch', 'microphone', 'wall', 'nightstand', 'photoframe', 'coffe_maker', 'coffee_filter', 'doorjamb', 'kitchen_counter', 'hairbrush', 'cupboard', 'home_office', 'dishwasher', 'coffee', 'shoe_rack']
Task:Make coffee
response:

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

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


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

Here is an example plan to achieve a goal for reference:
Scene_Objects:['dry_pasta', 'freezer', 'walllamp', 'bathroom', 'dough', 'knife', 'orchid', 'thread', 'computer', 'ceilinglamp', 'deck_of_cards', 'shower', 'clothes_socks', 'food_noodles', 'dustpan', 'nightstand', 'photoframe', 'light_bulb', 'television', 'coffee_filter', 'mirror', 'curtain', 'doorjamb', 'laundry_detergent', 'sink', 'bag', 'table', 'soap', 'clothes_shirt', 'creditcard']
Task:Look at mirror
response:
{
    "thoughts": I look at my reflection to check my cleanliness.,
    "actions": ['[WALK] <bathroom>', '[WALK] <mirror>', '[FIND] <mirror>', '[TURNTO] <mirror>', '[LOOKAT] <mirror>']
}

Input:
Scene_Objects:['microwave', 'dog', 'walllamp', 'cat', 'knifeblock', 'drawing', 'bills', 'floor', 'ceiling', 'clothes_jacket', 'toaster', 'ceilinglamp', 'plate', 'faucet', 'iron', 'dish_soap', 'food_noodles', 'mousepad', 'couch', 'wall', 'nightstand', 'mouthwash', 'curtain', 'mouse', 'kitchen_counter', 'cupboard', 'conditioner', 'door', 'sink', 'dishwasher']
Task:Wash dishes by hand
response:

Walk to Kitchen, find sink, find dishes and dish soap. Put soap on plate. open faucet, rinse dishes close faucet.

[WALK] <dining_room>
[WALK] <sink>
[FIND] <sink>
[FIND] <plate>
[GRAB] <plate>
[FIND] <dish_soap>
[GRAB] <dish_soap>
[PUTBACK] <dish_soap> <plate>
[FIND] <faucet>
[SWITCHON] <faucet>
[RINSE] <plate>


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:['sponge', 'toilet', 'freezer', 'drawing', 'bathroom_counter', 'floor', 'ceiling', 'keyboard', 'ceilinglamp', 'mat', 'shower', 'food_noodles', 'couch', 'towel', 'wall', 'powersocket', 'oven', 'cutting_board', 'photoframe', 'newspaper', 'water', 'food_donut', 'curtain', 'doorjamb', 'headset', 'door', 'bathroom_cabinet', 'light', 'soap', 'tooth_paste']
Task:Take shower
response:

Walk into bathroom. Turn on shower. Take off clothing. Climb into shower. Rinse with water. Soap up body. Rinse off with water. Turn off shower. Climb out of shower. Dry off with towel.

[WALK] <bathroom>
[WALK] <shower>
[FIND] <shower>
[TURNTO] <shower>
[FIND] <water>
[RINSE] <water>
[FIND] <soap>
[WASH] <soap>
[RINSE] <water>
[FIND] <towel>
[GRAB] <towel>
[SCRUB] <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:['dry_pasta', 'pot', 'water_glass', 'tablelamp', 'microwave', 'chair', 'freezer', 'drawing', 'orchid', 'floor', 'ceiling', 'phone', 'tea_bag', 'toaster', 'stovefan', 'mat', 'shower', 'faucet', 'ceilinglamp', 'oil', 'wall', 'oven', 'powersocket', 'coffe_maker', 'food_food', 'water', 'ice', 'tray', 'doorjamb', 'towel_rack', 'coffee_pot', 'kitchen_counter', 'cupboard', 'door', 'sink', 'bag', 'table', 'dishwasher', 'light']
Task:Drink
response:
{
    "thoughts": Going to the kitchen to get a drink of water.,
    "actions": ['[WALK] <dining_room>', '[WALK] <cupboard>', '[FIND] <cupboard>', '[OPEN] <cupboard>', '[FIND] <water_glass>', '[GRAB] <water_glass>', '[WALK] <faucet>', '[SWITCHON] <faucet>', '[FIND] <water>', '[FIND] <sink>', '[PUTBACK] <water_glass> <sink>', '[GRAB] <water_glass>', '[SWITCHOFF] <faucet>', '[DRINK] <water_glass>', '[FIND] <kitchen_counter>', '[PUTBACK] <water_glass> <kitchen_counter>']
}

Input:
Scene_Objects:['dry_pasta', 'toilet', 'chair', 'freezer', 'detergent', 'food_butter', 'wallshelf', 'hanger', 'phone', 'character', 'desk', 'remote_control', 'button', 'piano_bench', 'toaster', 'mat', 'tvstand', 'picture', 'oil', 'couch', 'clothes_pants', 'pillow', 'towel', 'wall', 'novel', 'razor', 'diary', 'conditioner', 'table', 'coffee']
Task:Change TV channel
response:

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

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


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

Here is an example plan to achieve a goal for reference:
Scene_Objects:['toilet', 'detergent', 'drawing', 'orchid', 'cpuscreen', 'hanger', 'bathroom_counter', 'floor', 'character', 'desk', 'keyboard', 'thread', 'table_cloth', 'tvstand', 'balanceball', 'shower', 'mousepad', 'couch', 'wall', 'photoframe', 'bed', 'toilet_paper', 'food_onion', 'towel_rack', 'mouse', 'kitchen_counter', 'cd', 'hairbrush', 'bathroom_cabinet', 'light']
Task:Go to toilet
response:
{
    "thoughts": walk to bathroom , run to toilet,
    "actions": ['[WALK] <bathroom>', '[RUN] <toilet>']
}

Input:
Scene_Objects:['pot', 'food_pizza', 'food_salt', 'microwave', 'freezer', 'orchid', 'drawing', 'hanger', 'button', 'table_cloth', 'tvstand', 'homework', 'couch', 'dining_room', 'nightstand', 'keys', 'coffe_maker', 'television', 'oven_mitts', 'curtain', 'doorjamb', 'diary', 'cards', 'kitchen_counter', 'comb', 'dresser', 'food_steak', 'home_office', 'light', 'clothes_skirt']
Task:Pet cat
response:

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

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


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

Here is an example plan to achieve a goal for reference:
Scene_Objects:['walllamp', 'orchid', 'drawing', 'wallshelf', 'floor', 'ceiling', 'phone', 'bookshelf', 'remote_control', 'computer', 'mat', 'tvstand', 'ceilinglamp', 'shower', 'window', 'couch', 'clothes_hat', 'pillow', 'wall', 'nightstand', 'powersocket', 'photoframe', 'newspaper', 'television', 'curtain', 'doorjamb', 'door', 'home_office', 'light', 'table']
Task:Watch TV
response:
{
    "thoughts": walk to living room. look at remote control. grab remote control. plug in television. switch on television. lie in sofa. point at remote control. watch television.,
    "actions": ['[WALK] <home_office>', '[WALK] <remote_control>', '[FIND] <remote_control>', '[TURNTO] <remote_control>', '[LOOKAT] <remote_control>', '[GRAB] <remote_control>', '[FIND] <television>', '[PLUGIN] <television>', '[SWITCHON] <television>', '[FIND] <couch>', '[LIE] <couch>', '[TURNTO] <remote_control>', '[POINTAT] <remote_control>', '[TURNTO] <television>', '[WATCH] <television>']
}

Input:
Scene_Objects:['sponge', 'spectacles', 'pot', 'microwave', 'knifeblock', 'floor', 'ceiling', 'folder', 'character', 'toaster', 'plate', 'drying_rack', 'faucet', 'dish_soap', 'couch', 'wall', 'powersocket', 'food_cheese', 'photoframe', 'bed', 'food_food', 'mouse', 'kitchen_counter', 'cupboard', 'door', 'sink', 'hairdryer', 'light', 'dirt', 'coffee']
Task:Wash dishes by hand
response:

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

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


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

Here is an example plan to achieve a goal for reference:
Scene_Objects:['pot', 'filing_cabinet', 'bathroom', 'detergent', 'food_butter', 'drawing', 'wallshelf', 'floor', 'desk', 'bookshelf', 'plate', 'faucet', 'picture', 'iron', 'window', 'dish_soap', 'food_jam', 'wall', 'nightstand', 'toy', 'cutting_board', 'food_food', 'television', 'curtain', 'pajamas', 'conditioner', 'light', 'dishwasher', 'tooth_paste', 'shoe_rack']
Task:Wash dishes with dishwasher
response:
{
    "thoughts": Go to the kitchen.  Find the dishwasher.  Open the dishwasher.  Find the plates.  Load the plates into the dishwasher.  Find the soap.  Load the soap into the dishwasher.  Close the dishwasher.  Turn on the dishwasher.,
    "actions": ['[WALK] <dining_room>', '[WALK] <dishwasher>', '[FIND] <dishwasher>', '[OPEN] <dishwasher>', '[FIND] <plate>', '[GRAB] <plate>', '[PUTBACK] <plate> <dishwasher>', '[FIND] <plate>', '[GRAB] <plate>', '[PUTBACK] <plate> <dishwasher>', '[FIND] <dish_soap>', '[GRAB] <dish_soap>', '[PUTBACK] <dish_soap> <dishwasher>', '[CLOSE] <dishwasher>', '[SWITCHON] <dishwasher>']
}

Input:
Scene_Objects:['sponge', 'sheets', 'filing_cabinet', 'crayon', 'toilet', 'bathroom_counter', 'ceiling', 'folder', 'shower', 'iron', 'window', 'mousepad', 'food_peanut_butter', 'pillow', 'wall', 'oven', 'toy', 'basket_for_clothes', 'photoframe', 'novel', 'coffe_maker', 'food_food', 'tray', 'cd', 'dishrack', 'door', 'napkin', 'light', 'dishwasher', 'board_game']
Task:Read book
response:

[WALK] <bedroom>
[WALK] <novel>
[GRAB] <novel>
[READ] <novel>


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

Here is an example plan to achieve a goal for reference:
Scene_Objects:['filing_cabinet', 'walllamp', 'drawing', 'hanger', 'floor', 'ceiling', 'bookshelf', 'ceilinglamp', 'laptop', 'faucet', 'mat', 'closetdrawer', 'teeth', 'dining_room', 'wall', 'pasta', 'toy', 'shelf', 'standingmirror', 'novel', 'check', 'television', 'curtain', 'console', 'dresser', 'napkin', 'table', 'light', 'scrabble', 'coffee']
Task:Look at painting
response:
{
    "thoughts": Walk to the painting.  Look up at the painting.  Admire it on the wall.,
    "actions": ['[WALK] <home_office>', '[WALK] <drawing>', '[FIND] <drawing>', '[TURNTO] <drawing>', '[LOOKAT] <drawing>']
}

Input:
Scene_Objects:['tablelamp', 'microwave', 'chair', 'dog', 'toothbrush', 'knifeblock', 'wallshelf', 'hanger', 'bathroom_counter', 'floor', 'phone', 'ceiling', 'character', 'desk', 'mat', 'tvstand', 'shower', 'homework', 'dining_room', 'wall', 'bed', 'clothes_gloves', 'toothbrush_holder', 'after_shave', 'doorjamb', 'mouse', 'pencil', 'cd', 'tooth_paste', 'shoe_rack']
Task:Wash teeth
response:

WALK TO THE BATHROOM USE PASTE AND BRUSH TO WASH YOUR TEETH

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


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

Here is an example plan to achieve a goal for reference:
Scene_Objects:['sheets', 'scissors', 'walllamp', 'needle', 'wallshelf', 'cpuscreen', 'hanger', 'bedroom', 'keyboard', 'bookmark', 'stovefan', 'shower', 'oil', 'dining_room', 'wall', 'powersocket', 'bench', 'love_seat', 'standingmirror', 'novel', 'coffe_maker', 'check', 'after_shave', 'towel_rack', 'mouse', 'pencil', 'kitchen_counter', 'maindoor', 'bathtub', 'soap']
Task:Read book
response:
{
    "thoughts": Obtain a book from the book shelf. Sit in the easy chair.  Read the book.  Mark the stopping point with a bookmark.  Put the book back on the book shelf.,
    "actions": ['[WALK] <home_office>', '[WALK] <novel>', '[FIND] <novel>', '[GRAB] <novel>', '[FIND] <love_seat>', '[SIT] <love_seat>', '[READ] <novel>', '[FIND] <bookmark>', '[GRAB] <bookmark>', '[PUTBACK] <bookmark> <novel>', '[PUTOBJBACK] <novel>']
}

Input:
Scene_Objects:['fork', 'juice', 'food_salt', 'measuring_cup', 'chair', 'detergent', 'milk', 'drawing', 'kitchen_cabinet', 'floor', 'shampoo', 'dvd_player', 'keyboard', 'computer', 'table_cloth', 'stovefan', 'ceilinglamp', 'plate', 'tvstand', 'candle', 'towel', 'food_cheese', 'light_bulb', 'television', 'razor', 'curtain', 'kitchen_counter', 'headset', 'table', 'soap']
Task:Set up table
response:

Walk into kitchen. Grab plates and forks. Walk into dining room. Put plates and forks on table.

[WALK] <dining_room>
[WALK] <kitchen_cabinet>
[FIND] <kitchen_cabinet>
[OPEN] <kitchen_cabinet>
[FIND] <fork>
[GRAB] <fork>
[FIND] <plate>
[GRAB] <plate>
[WALK] <dining_room>
[WALK]

[FIND]

[PUTBACK] <fork>

[PUTBACK] <plate>


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

Here is an example plan to achieve a goal for reference:
Scene_Objects:['filing_cabinet', 'food_pizza', 'tablelamp', 'food_ice_cream', 'crayon', 'shampoo', 'keyboard', 'mail', 'bookmark', 'stovefan', 'faucet', 'pillow', 'dining_room', 'broom', 'wall', 'love_seat', 'photoframe', 'novel', 'food_food', 'wine', 'tray', 'after_shave', 'shaving_cream', 'kettle', 'headset', 'pajamas', 'laundry_detergent', 'door', 'bathroom_cabinet', 'shoe_rack']
Task:Read book
response:
{
    "thoughts": Obtain a book from the book shelf. Sit in the easy chair.  Read the book.  Mark the stopping point with a bookmark.  Put the book back on the book shelf.,
    "actions": ['[WALK] <home_office>', '[WALK] <novel>', '[FIND] <novel>', '[GRAB] <novel>', '[FIND] <love_seat>', '[SIT] <love_seat>', '[READ] <novel>', '[FIND] <bookmark>', '[GRAB] <bookmark>', '[PUTBACK] <bookmark> <novel>', '[PUTOBJBACK] <novel>']
}

Input:
Scene_Objects:['food_salt', 'ceiling', 'phone', 'bookshelf', 'ceilinglamp', 'shoe-shine_kit', 'tvstand', 'homework', 'mousepad', 'food_jam', 'form', 'pillow', 'dining_room', 'wall', 'powersocket', 'bed', 'television', 'tray', 'curtain', 'doorjamb', 'pencil', 'dresser', 'controller', 'laundry_detergent', 'door', 'napkin', 'light', 'dishwasher', 'table', 'teeth']
Task:Pick up phone
response:

I walk to the home office. I find the telephone. I pick up the telephone handset.

[WALK] <home_office>
[WALK] <phone>
[FIND] <phone>
[GRAB] <phone>


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

Here is an example plan to achieve a goal for reference:
Scene_Objects:['filing_cabinet', 'tea', 'drawing', 'cpuscreen', 'floor', 'ceiling', 'desk', 'bookshelf', 'keyboard', 'computer', 'piano_bench', 'mat', 'shoe-shine_kit', 'balanceball', 'oil', 'clothes_hat', 'dining_room', 'wall', 'powersocket', 'photoframe', 'bed', 'food_food', 'mouthwash', 'doorjamb', 'towel_rack', 'vacuum_cleaner', 'door', 'home_office', 'light', 'soap']
Task:Turn on light
response:
{
    "thoughts": switching on the light,
    "actions": ['[WALK] <bedroom>', '[WALK] <light>', '[FIND] <light>', '[SWITCHON] <light>']
}

Input:
Scene_Objects:['sheets', 'food_pizza', 'toilet', 'freezer', 'ground_coffee', 'bathroom', 'drawing', 'knifeblock', 'floor', 'ceiling', 'desk', 'bookshelf', 'alcohol', 'mat', 'shower', 'window', 'dining_room', 'food_kiwi', 'nightstand', 'wall', 'powersocket', 'photoframe', 'food_food', 'television', 'doorjamb', 'mouse', 'door', 'light', 'colander', 'coffee']
Task:Put groceries in Fridge
response:

I get my groceries and go to the fridge. I open the fridge and put the groceries there.

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


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

Here is an example plan to achieve a goal for reference:
Scene_Objects:['tablelamp', 'toilet', 'bathroom', 'ceilingfan', 'drawing', 'floor', 'ceiling', 'character', 'desk', 'tea_bag', 'remote_control', 'ceilinglamp', 'tvstand', 'balanceball', 'picture', 'window', 'couch', 'pillow', 'dining_room', 'wall', 'powersocket', 'cutting_board', 'novel', 'check', 'television', 'curtain', 'conditioner', 'hairdryer', 'clothes_dress', 'table']
Task:Watch TV
response:
{
    "thoughts": watching TV from sofa,
    "actions": ['[WALK] <home_office>', '[WALK] <television>', '[FIND] <television>', '[PLUGIN] <television>', '[SWITCHON] <television>', '[FIND] <couch>', '[SIT] <couch>', '[FIND] <remote_control>', '[GRAB] <remote_control>', '[DROP] <remote_control>', '[TURNTO] <television>', '[LOOKAT] <television>']
}

Input:
Scene_Objects:['pot', 'mop', 'microwave', 'walllamp', 'detergent', 'food_carrot', 'knifeblock', 'wallshelf', 'hanger', 'floor', 'ceiling', 'keyboard', 'stovefan', 'toaster', 'stereo', 'window', 'oil', 'clothes_socks', 'wall', 'oven', 'food_vegetable', 'bed', 'photoframe', 'television', 'food_donut', 'water', 'tray', 'kitchen_counter', 'cupboard', 'dishwasher']
Task:Cook some food
response:

walk to kicthen , find stove , find cooking pot , find vegetables , find water  ,put vegetables in cooking pot, pour water to cooking pot,put cooking pot on stove, switch on stove

[WALK] <dining_room>
[WALK] <oven>
[FIND] <oven>
[FIND] <pot>
[FIND] <food_vegetable>
[FIND] <water>
[GRAB] <water>
[WASH] <food_vegetable>
[POUR] <water> <pot>
[FIND] <pot>
[GRAB] <pot>
[PUTBACK] <pot> <oven>
[SWITCHON] <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:['microwave', 'cat', 'food_carrot', 'drawing', 'knifeblock', 'cpuscreen', 'wallshelf', 'hanger', 'bathroom_counter', 'ceiling', 'desk', 'bookshelf', 'keyboard', 'mousepad', 'bench', 'newspaper', 'coffe_maker', 'food_food', 'tray', 'curtain', 'mouse', 'door', 'hairdryer', 'sink', 'food_steak', 'light', 'dishwasher', 'spoon', 'table', 'board_game']
Task:Write  school paper
response:
{
    "thoughts": Writing  and drafting a paper for  class work,
    "actions": ['[WALK] <home_office>', '[WALK] <computer>', '[SWITCHON] <computer>', '[SWITCHOFF] <computer>']
}

Input:
Scene_Objects:['tablelamp', 'toilet', 'chair', 'walllamp', 'cat', 'food_carrot', 'cpuscreen', 'hanger', 'floor', 'ceiling', 'desk', 'keyboard', 'bookshelf', 'computer', 'laptop', 'ceilinglamp', 'homework', 'mousepad', 'wall', 'coffe_maker', 'video_game_controller', 'ice', 'doorjamb', 'diary', 'mouse', 'kitchen_counter', 'shoes', 'comb', 'dresser', 'hairdryer']
Task:Write an email
response:

I open my laptop and then login to Windows. Then I open Google Chrome, and type gmail.com into the address bar. My email automatically logs in, then I click the Compose button, type in the address of the recipient, then the subject of the email, and then start typing my email

[WALK] <laptop>
[SWITCHON] <laptop>
[FIND] <keyboard>
[TYPE] <keyboard>


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

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

Input:
Scene_Objects:['spectacles', 'filing_cabinet', 'blender', 'walllamp', 'orchid', 'cpuscreen', 'hanger', 'floor', 'bedroom', 'bookshelf', 'stovefan', 'food_peanut_butter', 'clothes_hat', 'clothes_pants', 'dining_room', 'nightstand', 'wall_clock', 'video_game_controller', 'food_donut', 'curtain', 'kettle', 'shoes', 'dresser', 'cupboard', 'hairbrush', 'controller', 'home_office', 'light', 'clothes_skirt', 'soap']
Task:Listen to music
response:

Walk into the living room. Walk up to the radio. Turn on the radio. Listen to the radio.

[WALK] <home_office>
[WALK] <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', 'orchid', 'drawing', 'hanger', 'floor', 'phone', 'character', 'keyboard', 'toaster', 'plate', 'faucet', 'shower', 'window', 'mousepad', 'closetdrawer', 'dining_room', 'oven', 'powersocket', 'cup', 'bed', 'food_food', 'coffe_maker', 'tray', 'doorjamb', 'dresser', 'sink', 'bathtub', 'home_office', 'table']
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:['filing_cabinet', 'tablelamp', 'toilet', 'bathroom', 'knifeblock', 'cpuscreen', 'hanger', 'bathroom_counter', 'ceiling', 'folder', 'character', 'keyboard', 'bookshelf', 'envelope', 'computer', 'dining_room', 'wall', 'nightstand', 'cup', 'clothes_gloves', 'light_bulb', 'check', 'curtain', 'pencil', 'kitchen_counter', 'controller', 'sink', 'napkin', 'clothes_skirt', 'tooth_paste']
Task:Browse internet
response:

I turn on computer. I use keyboard to type. I open browser. I search.

[WALK] <bedroom>
[WALK] <computer>
[FIND] <keyboard>
[TYPE] <keyboard>
[TURNTO] <computer>
[LOOKAT] <computer>


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

Here is an example plan to achieve a goal for reference:
Scene_Objects:['freezer', 'cat', 'drawing', 'knife', 'knifeblock', 'hanger', 'floor', 'bedroom', 'keyboard', 'computer', 'piano_bench', 'ceilinglamp', 'faucet', 'iron', 'window', 'mousepad', 'couch', 'form', 'dining_room', 'wall', 'oven', 'box', 'newspaper', 'bed', 'novel', 'toilet_paper', 'television', 'tray', 'sink', 'table']
Task:Pet cat
response:
{
    "thoughts": I walk to the living room.  I locate the cat.  I walk to the couch and sit down beside the cat.  I pet the cat.,
    "actions": ['[WALK] <home_office>', '[WALK] <cat>', '[FIND] <cat>', '[WALK] <couch>', '[SIT] <couch>', '[TOUCH] <cat>']
}

Input:
Scene_Objects:['filing_cabinet', 'tablelamp', 'beer', 'measuring_cup', 'microwave', 'dog', 'orchid', 'wallshelf', 'floor', 'bedroom', 'computer', 'mop_bucket', 'ceilinglamp', 'faucet', 'electric_shaver', 'couch', 'food_peanut_butter', 'broom', 'cutting_board', 'photoframe', 'newspaper', 'mouthwash', 'ice', 'tray', 'curtain', 'kitchen_counter', 'shoes', 'headset', 'bathroom_cabinet', 'board_game']
Task:Pet cat
response:

I walk to my living room, find my cat, scrub it using my hand.

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


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

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

Input:
Scene_Objects:['sponge', 'microwave', 'cpuscreen', 'floor', 'ceiling', 'phone', 'character', 'folder', 'desk', 'alcohol', 'stovefan', 'plate', 'mousepad', 'wall', 'oven', 'food_food', 'check', 'tray', 'doorjamb', 'cards', 'mouse', 'kitchen_counter', 'shoes', 'cupboard', 'clothes_dress', 'sink', 'clothes_scarf', 'light', 'clothes_shirt', 'teeth']
Task:Pick up phone
response:


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

Here is an example plan to achieve a goal for reference:
Scene_Objects:['filing_cabinet', 'mop', 'microwave', 'freezer', 'walllamp', 'detergent', 'toothbrush', 'orchid', 'drawing', 'clothes_underwear', 'floor', 'thread', 'mat', 'closetdrawer', 'wall', 'nightstand', 'toy', 'standingmirror', 'light_bulb', 'novel', 'check', 'tray', 'cards', 'mouse', 'pencil', 'vacuum_cleaner', 'headset', 'maindoor', 'napkin', 'light']
Task:Read book
response:
{
    "thoughts": Walk to the Living Room. Look at the Cabinet. Find a Textbook. Grab the textbook. Open the Textbook. Read the textbook.,
    "actions": ['[WALK] <home_office>', '[WALK] <filing_cabinet>', '[FIND] <filing_cabinet>', '[TURNTO] <filing_cabinet>', '[LOOKAT] <filing_cabinet>', '[FIND] <novel>', '[GRAB] <novel>', '[READ] <novel>']
}

Input:
Scene_Objects:['pot', 'freezer', 'blow_dryer', 'bathroom', 'nail_polish', 'drawing', 'knife', 'cpuscreen', 'character', 'bookshelf', 'table_cloth', 'mop_bucket', 'bookmark', 'faucet', 'homework', 'nightstand', 'wall', 'novel', 'check', 'coffee_filter', 'coffee_pot', 'shaving_cream', 'kitchen_counter', 'pajamas', 'cupboard', 'clothes_dress', 'laundry_detergent', 'napkin', 'table', 'washing_machine']
Task:Wash clothes
response:

walk to kitchen. grab clothes_dress. look at washing machine. open washing machine. put clothes_dress on washing machine. close washing machine. switch on washing machine. switch off 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:['measuring_cup', 'mop', 'walllamp', 'clothes_underwear', 'hanger', 'floor', 'ceiling', 'dvd_player', 'desk', 'tvstand', 'window', 'clothes_socks', 'closetdrawer', 'oil', 'dining_room', 'wall', 'toy', 'photoframe', 'television', 'curtain', 'rag', 'doorjamb', 'console', 'kitchen_counter', 'shoes', 'dresser', 'pajamas', 'bathroom_cabinet', 'table', 'tooth_paste']
Task:Put away shoes
response:
{
    "thoughts": Pick up shoes from entry hall. Open entry way closet. Put shoes in closet. Close closet door.,
    "actions": ['[WALK] <home_office>', '[WALK] <shoes>', '[FIND] <shoes>', '[GRAB] <shoes>', '[FIND] <dresser>', '[OPEN] <dresser>', '[PUTIN] <shoes> <dresser>', '[CLOSE] <dresser>']
}

Input:
Scene_Objects:['sheets', 'filing_cabinet', 'mop', 'bathroom', 'dough', 'knifeblock', 'hanger', 'keyboard', 'alcohol', 'toaster', 'shower', 'foundation', 'couch', 'bowl', 'wall', 'pasta', 'basket_for_clothes', 'check', 'television', 'razor', 'tray', 'doorjamb', 'chessboard', 'dishrack', 'hairbrush', 'napkin', 'bathroom_cabinet', 'light', 'dishwasher', 'table']
Task:Pick up phone
response:

go to living room, find phone, pick up phone

[WALK] <home_office>
[WALK] <phone>
[FIND] <phone>
[GRAB] <phone>


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

Here is an example plan to achieve a goal for reference:
Scene_Objects:['pot', 'toilet', 'freezer', 'ground_coffee', 'ceilingfan', 'drawing', 'orchid', 'floor', 'ceiling', 'character', 'video_game_console', 'table_cloth', 'ceilinglamp', 'tvstand', 'balanceball', 'window', 'couch', 'dustpan', 'pillow', 'wall', 'cup', 'video_game_controller', 'television', 'curtain', 'dishrack', 'napkin', 'table', 'vase', 'scrabble', 'shoe_rack']
Task:Play games
response:
{
    "thoughts": Turn on game.  Use controller,
    "actions": ['[WALK] <home_office>', '[WALK] <television>', '[PLUGIN] <television>', '[SWITCHON] <television>', '[FIND] <video_game_console>', '[PLUGIN] <video_game_console>', '[SWITCHON] <video_game_console>', '[FIND] <video_game_console>', '[FIND] <video_game_controller>', '[GRAB] <video_game_controller>', '[WALK] <couch>', '[SIT] <couch>']
}

Input:
Scene_Objects:['pot', 'toilet', 'freezer', 'walllamp', 'drawing', 'knifeblock', 'floor', 'ceiling', 'food_chicken', 'food_cake', 'stovefan', 'mat', 'toaster', 'shower', 'food_noodles', 'oil', 'nightstand', 'wall', 'powersocket', 'oven', 'cup', 'photoframe', 'food_food', 'tray', 'doorjamb', 'kitchen_counter', 'cupboard', 'door', 'light', 'dishwasher']
Task:Cook some food
response:

I walk in the kitchen, I open the fridge and remove the Chicken. I grab frying fan and put it on stove. I put chicken in the frying pan and I cook food.

[WALK] <dining_room>
[WALK] <freezer>
[FIND] <freezer>
[OPEN] <freezer>
[FIND] <food_chicken>
[GRAB] <food_chicken>
[FIND] <pot>
[GRAB] <pot>
[FIND] <oven>
[PUTBACK] <pot> <oven>
[PUTBACK] <food_chicken> <oven>


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

Here is an example plan to achieve a goal for reference:
Scene_Objects:['sponge', 'filing_cabinet', 'juice', 'microwave', 'knifeblock', 'wallshelf', 'bathroom_counter', 'floor', 'ceiling', 'computer', 'piano_bench', 'toaster', 'ceilinglamp', 'plate', 'faucet', 'stovefan', 'tvstand', 'dish_soap', 'wall', 'pasta', 'coffee_filter', 'tray', 'doorjamb', 'mouse', 'kitchen_counter', 'shoes', 'dishrack', 'cupboard', 'sink', 'scrabble']
Task:Wash dishes
response:
{
    "thoughts": Place all of the dirty dishes in a sink full of clean, soapy water.  Wash them.  Rinse them in fresh, running water.  Place them in the strainer to dry.,
    "actions": ['[WALK] <dining_room>', '[WALK] <sink>', '[FIND] <faucet>', '[SWITCHON] <faucet>', '[FIND] <plate>', '[GRAB] <plate>', '[RINSE] <plate>', '[PUTBACK] <plate> <sink>', '[FIND] <plate>', '[GRAB] <plate>', '[RINSE] <plate>', '[PUTBACK] <plate> <sink>', '[SWITCHOFF] <faucet>', '[FIND] <dish_soap>', '[GRAB] <dish_soap>', '[FIND] <sponge>', '[GRAB] <sponge>', '[POUR] <dish_soap> <sponge>', '[PUTOBJBACK] <dish_soap>', '[GRAB] <plate>', '[SCRUB] <plate>', '[PUTOBJBACK] <plate>', '[GRAB] <plate>', '[SCRUB] <plate>', '[PUTOBJBACK] <plate>', '[SWITCHON] <faucet>', '[RINSE] <sponge>', '[PUTOBJBACK] <sponge>', '[GRAB] <plate>', '[RINSE] <plate>', '[FIND] <dishrack>', '[PUTBACK] <plate> <dishrack>', '[GRAB] <plate>', '[RINSE] <plate>', '[PUTBACK] <plate> <dishrack>', '[SWITCHOFF] <faucet>']
}

Input:
Scene_Objects:['filing_cabinet', 'tablelamp', 'blender', 'chair', 'walllamp', 'blow_dryer', 'detergent', 'orchid', 'knife', 'hanger', 'floor', 'ceiling', 'thread', 'ceilinglamp', 'laptop', 'faucet', 'mousepad', 'couch', 'candle', 'food_jam', 'pillow', 'wall', 'nightstand', 'tape', 'television', 'tray', 'after_shave', 'food_onion', 'shoes', 'cupboard']
Task:Relax on sofa
response:

I walk to the living room. I sit in the sofa and I relax.

[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', 'band-aids', 'walllamp', 'drawing', 'food_egg', 'bathroom_counter', 'ceiling', 'stamp', 'desk', 'cleaning_solution', 'computer', 'stovefan', 'deck_of_cards', 'faucet', 'tvstand', 'window', 'couch', 'wall', 'nightstand', 'coffe_maker', 'television', 'mirror', 'after_shave', 'paper_towel', 'clothes_dress', 'sink', 'bag', 'bathroom_cabinet', 'dishwasher', 'laser_pointer']
Task:Clean mirror
response:
{
    "thoughts": First spray the mirrors with Windex or window type spray.  Take paper towels and wipe until sparkly clean.  If they have streaks, repeat the process.,
    "actions": ['[WALK] <bathroom>', '[WALK] <bathroom_cabinet>', '[OPEN] <bathroom_cabinet>', '[FIND] <paper_towel>', '[GRAB] <paper_towel>', '[CLOSE] <bathroom_cabinet>', '[WALK] <mirror>', '[FIND] <cleaning_solution>', '[RINSE] <cleaning_solution>', '[WIPE] <mirror>']
}

Input:
Scene_Objects:['pot', 'filing_cabinet', 'tablelamp', 'chair', 'cpuscreen', 'wallshelf', 'hanger', 'floor', 'phone', 'bedroom', 'button', 'plate', 'dish_soap', 'wall', 'nightstand', 'food_cheese', 'photoframe', 'newspaper', 'coffe_maker', 'check', 'tray', 'kettle', 'pencil', 'kitchen_counter', 'comb', 'cupboard', 'door', 'table', 'dishwasher', 'light']
Task:Wash dishes with dishwasher
response:

Go to kitchen to put dirty dishs into dishwasher with soap to clean the dirty dishes

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


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', 'spectacles', 'microwave', 'walllamp', 'drawing', 'orchid', 'hanger', 'floor', 'character', 'desk', 'alcohol', 'stovefan', 'ceilinglamp', 'mat', 'window', 'couch', 'pillow', 'wall', 'oven', 'powersocket', 'cutting_board', 'photoframe', 'light_bulb', 'television', 'curtain', 'kettle', 'napkin', 'bathroom_cabinet', 'table', 'creditcard']
Task:Relax on sofa
response:
{
    "thoughts": walk to living room, walk to sofa, sit on sofa.,
    "actions": ['[WALK] <home_office>', '[WALK] <couch>', '[SIT] <couch>']
}

Input:
Scene_Objects:['spectacles', 'food_salt', 'microwave', 'walllamp', 'dough', 'hanger', 'ceiling', 'phone', 'character', 'keyboard', 'bookmark', 'toaster', 'mat', 'tvstand', 'stereo', 'window', 'oil', 'food_peanut_butter', 'tape', 'check', 'video_game_controller', 'razor', 'oven_mitts', 'food_rice', 'curtain', 'kitchen_counter', 'hairbrush', 'food_steak', 'bathroom_cabinet', 'home_office']
Task:Listen to music
response:

I walk into the bedroom. I walk to stereo. I turn on stereo.

[WALK] <bedroom>
[WALK] <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', 'chair', 'walllamp', 'drawing', 'cpuscreen', 'hanger', 'floor', 'ceiling', 'desk', 'keyboard', 'computer', 'stovefan', 'ceilinglamp', 'toaster', 'stereo', 'shower', 'mousepad', 'closetdrawer', 'dustpan', 'wall', 'powersocket', 'box', 'television', 'fax_machine', 'doorjamb', 'mouse', 'dresser', 'light', 'table', 'printing_paper']
Task:Print out papers
response:
{
    "thoughts": Turn on printer and fill with blank paper. Use computer to click on printing option. Take printed page out of print.,
    "actions": ['[WALK] <home_office>', '[WALK] <fax_machine>', '[FIND] <fax_machine>', '[SWITCHON] <fax_machine>', '[FIND] <printing_paper>', '[GRAB] <printing_paper>', '[PUTBACK] <printing_paper> <fax_machine>', '[FIND] <computer>', '[FIND] <mouse>', '[GRAB] <mouse>', '[GRAB] <printing_paper>']
}

Input:
Scene_Objects:['fork', 'pot', 'filing_cabinet', 'tablelamp', 'blender', 'beer', 'toilet', 'jelly', 'freezer', 'blow_dryer', 'detergent', 'orchid', 'knifeblock', 'wallshelf', 'cpuscreen', 'bathroom_counter', 'floor', 'mail', 'computer', 'bookmark', 'stereo', 'window', 'couch', 'microphone', 'check', 'television', 'rag', 'pencil', 'controller', 'dishwasher']
Task:Pet cat
response:

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


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

Here is an example plan to achieve a goal for reference:
Scene_Objects:['tablelamp', 'bathroom', 'knife', 'bathroom_counter', 'floor', 'shampoo', 'ceiling', 'stovefan', 'mat', 'faucet', 'mousepad', 'couch', 'food_peanut_butter', 'dustpan', 'towel', 'wall', 'wall_clock', 'oven', 'novel', 'ice', 'tray', 'rag', 'shoes', 'maindoor', 'sink', 'bathroom_cabinet', 'vase', 'soap', 'tooth_paste', '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:['filing_cabinet', 'tablelamp', 'toilet', 'walllamp', 'detergent', 'orchid', 'floor', 'ceiling', 'keyboard', 'remote_control', 'computer', 'button', 'alcohol', 'tvstand', 'window', 'closetdrawer', 'couch', 'pillow', 'nightstand', 'wall', 'check', 'mouthwash', 'television', 'coffe_maker', 'curtain', 'dresser', 'clothes_dress', 'door', 'sink', 'table']
Task:Change TV channel
response:

I go to the livingroom. The TV is on. I pick up the remote and press the next channel button. I look at the television, and see that the channel has changed.

[WALK] <home_office>
[WALK] <television>
[FIND] <television>
[TURNTO] <television>
[LOOKAT] <television>
[FIND] <remote_control>
[GRAB] <remote_control>
[FIND] <button>
[PUSH] <button>
[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:['glue', 'filing_cabinet', 'chair', 'walllamp', 'drawing', 'knifeblock', 'bathroom_counter', 'floor', 'bedroom', 'desk', 'computer', 'ceilinglamp', 'deck_of_cards', 'stereo', 'window', 'couch', 'clothes_pants', 'wall', 'cup', 'novel', 'toilet_paper', 'television', 'wine', 'kitchen_counter', 'dishrack', 'comb', 'dresser', 'coffee_cup', 'table', 'teeth']
Task:Relax on sofa
response:
{
    "thoughts": you walk to the living room, open the door, find a comfy sofa, sit on it, read a book or sip a cup of coffee and relax.,
    "actions": ['[WALK] <home_office>', '[WALK] <couch>', '[FIND] <couch>', '[FIND] <coffee_cup>', '[GRAB] <coffee_cup>', '[SIT] <couch>', '[FIND] <novel>', '[GRAB] <novel>', '[READ] <novel>', '[DRINK] <coffee_cup>']
}

Input:
Scene_Objects:['tablelamp', 'beer', 'crayon', 'chair', 'freezer', 'walllamp', 'orchid', 'drawing', 'hanger', 'floor', 'ceiling', 'bedroom', 'bookshelf', 'food_cake', 'ceilinglamp', 'tvstand', 'mat', 'couch', 'food_peanut_butter', 'pillow', 'wall', 'nightstand', 'powersocket', 'cup', 'food_food', 'television', 'curtain', 'pencil', 'kitchen_counter', 'door']
Task:Relax on sofa
response:

I walk to the sofa, and lie down on the sofa.


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', 'mop', 'toilet', 'cat', 'trashcan', 'ceilingfan', 'drawing', 'knifeblock', 'orchid', 'floor', 'ceiling', 'computer', 'clothes_jacket', 'table_cloth', 'stovefan', 'ceilinglamp', 'tvstand', 'faucet', 'window', 'couch', 'wall', 'nightstand', 'food_food', 'mouthwash', 'television', 'food_donut', 'curtain', 'after_shave', 'dresser', 'table']
Task:Look at painting
response:
{
    "thoughts": Walk to the painting.  Look up at the painting.  Admire it on the wall.,
    "actions": ['[WALK] <home_office>', '[WALK] <drawing>', '[FIND] <drawing>', '[TURNTO] <drawing>', '[LOOKAT] <drawing>']
}

Input:
Scene_Objects:['tablelamp', 'juice', 'toilet', 'freezer', 'walllamp', 'detergent', 'milk', 'drawing', 'floor', 'ceiling', 'phone', 'computer', 'toaster', 'mat', 'ceilinglamp', 'shower', 'food_orange', 'pillow', 'dining_room', 'nightstand', 'wall', 'powersocket', 'photoframe', 'newspaper', 'food_food', 'toothbrush_holder', 'doorjamb', 'door', 'sink', 'light']
Task:Put groceries in Fridge
response:

I walk to the kitchen, open the fridge and put the groceries in the fridge. Then I close the fridge.

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


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

Here is an example plan to achieve a goal for reference:
Scene_Objects:['dry_pasta', 'food_ice_cream', 'walllamp', 'nail_polish', 'cat', 'orchid', 'drawing', 'floor', 'ceiling', 'purse', 'alcohol', 'mail', 'table_cloth', 'mat', 'tvstand', 'ceilinglamp', 'window', 'couch', 'pillow', 'towel', 'wall', 'oven', 'cup', 'food_cheese', 'television', 'curtain', 'doorjamb', 'door', 'table', 'clothes_shirt']
Task:Straighten paintings on wall
response:
{
    "thoughts": Go up to the painting and tilt it which ever way it is uneven until it looks straight.,
    "actions": ['[WALK] <home_office>', '[WALK] <wall>', '[WALK] <drawing>', '[FIND] <drawing>', '[TURNTO] <drawing>', '[LOOKAT] <drawing>', '[TOUCH] <drawing>', '[PULL] <drawing>', '[PUSH] <drawing>', '[WALK] <drawing>', '[FIND] <drawing>', '[TURNTO] <drawing>', '[LOOKAT] <drawing>', '[TOUCH] <drawing>', '[PULL] <drawing>', '[PUSH] <drawing>', '[WALK] <drawing>', '[FIND] <drawing>', '[TURNTO] <drawing>', '[LOOKAT] <drawing>', '[TOUCH] <drawing>', '[PULL] <drawing>', '[PUSH] <drawing>', '[TURNTO] <drawing>', '[LOOKAT] <drawing>', '[TURNTO] <drawing>', '[LOOKAT] <drawing>', '[TURNTO] <drawing>', '[LOOKAT] <drawing>']
}

Input:
Scene_Objects:['pot', 'filing_cabinet', 'measuring_cup', 'microwave', 'orchid', 'knifeblock', 'wallshelf', 'character', 'keyboard', 'stovefan', 'mat', 'closetdrawer', 'dining_room', 'food_kiwi', 'box', 'cup', 'bed', 'coffe_maker', 'television', 'water', 'colander', 'tray', 'curtain', 'kitchen_counter', 'cd', 'cupboard', 'door', 'bag', 'soap', 'creditcard']
Task:Wash hands
response:

put soap on hands, scrub it and rinse with water

[WALK] <bathroom>
[WALK] <soap>
[FIND] <soap>
[SCRUB] <soap>
[FIND] <water>
[RINSE] <water>


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

Here is an example plan to achieve a goal for reference:
Scene_Objects:['microwave', 'toilet', 'chair', 'bathroom', 'detergent', 'orchid', 'knifeblock', 'drawing', 'bathroom_counter', 'bedroom', 'keyboard', 'button', 'toaster', 'tvstand', 'food_noodles', 'pillow', 'check', 'television', 'oven_mitts', 'wine', 'curtain', 'rag', 'doorjamb', 'kettle', 'mouse', 'pencil', 'hairbrush', 'food_steak', 'home_office', 'dishwasher']
Task:Pet cat
response:
{
    "thoughts": Find the cat; pet the cat by touching it,
    "actions": ['[WALK] <home_office>', '[WALK] <cat>', '[FIND] <cat>', '[TOUCH] <cat>']
}

Input:
Scene_Objects:['food_bread', 'microwave', 'toilet', 'walllamp', 'knifeblock', 'wallshelf', 'floor', 'shampoo', 'character', 'computer', 'bookmark', 'toaster', 'plate', 'faucet', 'shoe-shine_kit', 'dish_soap', 'wall', 'toy', 'light_bulb', 'coffe_maker', 'rag', 'kitchen_counter', 'hairbrush', 'cupboard', 'dresser', 'controller', 'sink', 'home_office', 'table', 'dishwasher']
Task:Wash dishes by hand
response:

Make some dish water, grab a dish rag, put dishes in dish water and wash.

[RUN] <sink>
[FIND] <dish_soap>
[GRAB] <dish_soap>
[FIND] <plate>
[PUTBACK] <dish_soap> <plate>
[RINSE] <dish_soap>
[FIND] <plate>
[WASH] <plate>


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', 'ground_coffee', 'walllamp', 'food_carrot', 'orchid', 'drawing', 'floor', 'ceiling', 'bedroom', 'bookshelf', 'keyboard', 'mail', 'mat', 'faucet', 'wall', 'nightstand', 'powersocket', 'oven', 'cup', 'photoframe', 'bed', 'novel', 'curtain', 'doorjamb', 'diary', 'cupboard', 'door', 'sink', 'instrument_guitar']
Task:Read book
response:
{
    "thoughts": Walk over to the bookshelf. Pick storybook off the shelf. Sit on bed. Open storybook and read out loud.,
    "actions": ['[WALK] <bedroom>', '[WALK] <bookshelf>', '[FIND] <novel>', '[GRAB] <novel>', '[TURNTO] <novel>', '[LOOKAT] <novel>', '[WALK] <bed>', '[SIT] <bed>', '[READ] <novel>']
}

Input:
Scene_Objects:['dry_pasta', 'pot', 'filing_cabinet', 'food_ice_cream', 'jelly', 'bathroom', 'orchid', 'knifeblock', 'wallshelf', 'bathroom_counter', 'desk', 'keyboard', 'ceilinglamp', 'iron', 'stereo', 'closetdrawer', 'clothes_pants', 'food_jam', 'cup', 'photoframe', 'toothbrush_holder', 'tray', 'curtain', 'centerpiece', 'coffee_pot', 'kitchen_counter', 'door', 'spoon', 'dishwasher', 'clothes_shirt']
Task:Pick up phone
response:

Enter living room. Walk to telephone. Pick up from hook.

[WALK] <home_office>
[WALK] <phone>
[GRAB] <phone>


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

Here is an example plan to achieve a goal for reference:
Scene_Objects:['mop', 'chair', 'jelly', 'walllamp', 'drawing', 'wallshelf', 'food_egg', 'hanger', 'floor', 'ceiling', 'character', 'desk', 'remote_control', 'computer', 'mat', 'tvstand', 'ceilinglamp', 'shower', 'closetdrawer', 'couch', 'pillow', 'wall', 'photoframe', 'television', 'food_rice', 'doorjamb', 'diary', 'kitchen_counter', 'dresser', 'coffee']
Task:Watch  horror  movie
response:
{
    "thoughts": I would  find something  scary  to  watch on dvd,
    "actions": ['[WALK] <home_office>', '[WALK] <remote_control>', '[FIND] <remote_control>', '[GRAB] <remote_control>', '[FIND] <couch>', '[SIT] <couch>', '[FIND] <television>', '[SWITCHON] <television>', '[TURNTO] <television>', '[WATCH] <television>']
}

Input:
Scene_Objects:['sheets', 'water_glass', 'pot', 'glue', 'filing_cabinet', 'knife', 'wallshelf', 'bathroom_counter', 'stamp', 'bedroom', 'keyboard', 'clothes_jacket', 'piano_bench', 'electric_shaver', 'food_jam', 'cutting_board', 'novel', 'check', 'coffee_filter', 'water', 'ice', 'curtain', 'food_onion', 'pencil', 'kitchen_counter', 'cd', 'headset', 'dresser', 'door', 'light']
Task:Drink
response:

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


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

Here is an example plan to achieve a goal for reference:
Scene_Objects:['sponge', 'pot', 'food_bread', 'tablelamp', 'scissors', 'microwave', 'chair', 'walllamp', 'hanger', 'floor', 'food_cake', 'toaster', 'plate', 'shower', 'tvstand', 'faucet', 'dish_soap', 'bowl', 'wall', 'oven', 'cup', 'basket_for_clothes', 'photoframe', 'coffe_maker', 'food_food', 'tray', 'curtain', 'maindoor', 'table', 'dishwasher']
Task:Wash dishes with dishwasher
response:
{
    "thoughts": Using dishwasher to wash dishes,
    "actions": ['[WALK] <dining_room>', '[WALK] <dishwasher>', '[FIND] <dishwasher>', '[OPEN] <dishwasher>', '[FIND] <plate>', '[GRAB] <plate>', '[FIND] <bowl>', '[GRAB] <bowl>', '[WALK] <dishwasher>', '[PUTBACK] <bowl> <dishwasher>', '[GRAB] <bowl>', '[PUTBACK] <bowl> <dishwasher>', '[FIND] <dish_soap>', '[GRAB] <dish_soap>', '[PUTBACK] <dish_soap> <dishwasher>', '[CLOSE] <dishwasher>', '[SWITCHON] <dishwasher>']
}

Input:
Scene_Objects:['sheets', 'blender', 'food_salt', 'crayon', 'tea', 'cat', 'milk', 'knifeblock', 'hanger', 'shampoo', 'bedroom', 'bookshelf', 'computer', 'brush', 'stovefan', 'toaster', 'foundation', 'window', 'mousepad', 'clothes_pants', 'clothes_hat', 'tape', 'bed', 'coffe_maker', 'food_onion', 'after_shave', 'dresser', 'light', 'dishwasher', 'laser_pointer']
Task:Pet cat
response:

Every time this animal is seen, you must approach it and show compassion for it by petting it in a gentle manner.

[WALK] <home_office>
[WALK] <bedroom>
[WALK] <bedroom>
[WALK] <home_office>
[WALK] <home_office>
[WALK] <cat>
[FIND] <cat>
[FIND] <brush>
[GRAB] <brush>


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

Here is an example plan to achieve a goal for reference:
Scene_Objects:['tablelamp', 'microwave', 'walllamp', 'bathroom', 'trashcan', 'drawing', 'orchid', 'bathroom_counter', 'floor', 'ceiling', 'bedroom', 'keyboard', 'mat', 'ceilinglamp', 'window', 'mousepad', 'closetdrawer', 'couch', 'pillow', 'wall', 'wall_clock', 'cup', 'video_game_controller', 'television', 'curtain', 'doorjamb', 'cupboard', 'door', 'light', 'table']
Task:Gaze out window
response:
{
    "thoughts": Look at the yard from the window,
    "actions": ['[WALK] <home_office>', '[WALK] <window>', '[FIND] <window>', '[TURNTO] <window>', '[LOOKAT] <window>']
}

Input:
Scene_Objects:['fork', 'filing_cabinet', 'food_pizza', 'knifeblock', 'food_egg', 'hanger', 'phone', 'desk', 'tea_bag', 'purse', 'envelope', 'clothes_jacket', 'table_cloth', 'faucet', 'window', 'closetdrawer', 'clothes_pants', 'food_jam', 'wall', 'basket_for_clothes', 'bed', 'cd', 'comb', 'laundry_detergent', 'clothes_scarf', 'napkin', 'home_office', 'bathroom_cabinet', 'washing_machine', 'teeth']
Task:Wash clothes
response:

Walk to bathroom. Open washing maschine. Grab pants and put it into washing maschine. Pour laundry detergent into washing machine and close the washing maschine. Plug in 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:['sponge', 'pot', 'food_bread', 'tablelamp', 'scissors', 'microwave', 'chair', 'walllamp', 'hanger', 'floor', 'food_cake', 'toaster', 'plate', 'shower', 'tvstand', 'faucet', 'dish_soap', 'bowl', 'wall', 'oven', 'cup', 'basket_for_clothes', 'photoframe', 'coffe_maker', 'food_food', 'tray', 'curtain', 'maindoor', 'table', 'dishwasher']
Task:Wash dishes with dishwasher
response:
{
    "thoughts": Using dishwasher to wash dishes,
    "actions": ['[WALK] <dining_room>', '[WALK] <dishwasher>', '[FIND] <dishwasher>', '[OPEN] <dishwasher>', '[FIND] <plate>', '[GRAB] <plate>', '[FIND] <bowl>', '[GRAB] <bowl>', '[WALK] <dishwasher>', '[PUTBACK] <bowl> <dishwasher>', '[GRAB] <bowl>', '[PUTBACK] <bowl> <dishwasher>', '[FIND] <dish_soap>', '[GRAB] <dish_soap>', '[PUTBACK] <dish_soap> <dishwasher>', '[CLOSE] <dishwasher>', '[SWITCHON] <dishwasher>']
}

Input:
Scene_Objects:['toilet', 'chair', 'dog', 'ground_coffee', 'detergent', 'floor', 'ceiling', 'shampoo', 'envelope', 'clothes_jacket', 'piano_bench', 'ceilinglamp', 'mat', 'couch', 'dining_room', 'wall', 'coffe_maker', 'food_food', 'television', 'coffee_filter', 'water', 'coffee_pot', 'console', 'kitchen_counter', 'dresser', 'cupboard', 'pajamas', 'bathroom_cabinet', 'light', 'dishwasher']
Task:Make coffee
response:

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


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

Here is an example plan to achieve a goal for reference:
Scene_Objects:['food_bread', 'filing_cabinet', 'tablelamp', 'food_ice_cream', 'beer', 'crayon', 'chair', 'knifeblock', 'cpuscreen', 'bathroom_counter', 'phone', 'desk', 'bedroom', 'bookshelf', 'thread', 'toaster', 'ceilinglamp', 'mousepad', 'closetdrawer', 'pillow', 'wall', 'cup', 'bed', 'keys', 'food_food', 'television', 'food_onion', 'doorjamb', 'mouse', 'home_office']
Task:Lock door
response:
{
    "thoughts": Turn the lock.,
    "actions": ['[WALK] <bedroom>']
}

Input:
Scene_Objects:['fork', 'tablelamp', 'toilet', 'chair', 'walllamp', 'floor', 'ceiling', 'phone', 'keyboard', 'envelope', 'toaster', 'ceilinglamp', 'stereo', 'faucet', 'window', 'couch', 'pillow', 'wall', 'nightstand', 'powersocket', 'cup', 'clothes_gloves', 'novel', 'check', 'video_game_controller', 'television', 'kitchen_counter', 'hairdryer', 'light', 'table']
Task:Relax on sofa
response:

Walk to the living room. Walk to the sofa and sit on the sofa.

[WALK] <home_office>
[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:['pot', 'tablelamp', 'microwave', 'chair', 'walllamp', 'blow_dryer', 'knifeblock', 'drawing', 'orchid', 'kitchen_cabinet', 'floor', 'ceiling', 'food_cake', 'mat', 'faucet', 'mousepad', 'couch', 'wall', 'oven', 'bench', 'toilet_paper', 'television', 'water', 'drinking_glass', 'curtain', 'kitchen_counter', 'cupboard', 'sink', 'light', 'table']
Task:Drink
response:
{
    "thoughts": I go to the kitchen to get a glass from the cabinet. I turn on the faucet and fill up the glass. I take a drink.,
    "actions": ['[WALK] <dining_room>', '[WALK] <kitchen_cabinet>', '[FIND] <kitchen_cabinet>', '[OPEN] <kitchen_cabinet>', '[FIND] <drinking_glass>', '[GRAB] <drinking_glass>', '[WALK] <sink>', '[FIND] <faucet>', '[SWITCHON] <faucet>', '[PUTBACK] <drinking_glass> <sink>', '[FIND] <water>', '[GRAB] <drinking_glass>', '[PUTBACK] <drinking_glass> <sink>', '[GRAB] <drinking_glass>', '[DRINK] <drinking_glass>']
}

Input:
Scene_Objects:['tablelamp', 'chair', 'walllamp', 'milk', 'orchid', 'drawing', 'knifeblock', 'floor', 'ceiling', 'folder', 'computer', 'ceilinglamp', 'tvstand', 'window', 'closetdrawer', 'couch', 'pillow', 'dining_room', 'wall', 'nightstand', 'cup', 'bed', 'television', 'razor', 'toothbrush_holder', 'tray', 'curtain', 'dresser', 'laundry_detergent', 'table']
Task:Watch TV
response:

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


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

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

Input:
Scene_Objects:['dry_pasta', 'tablelamp', 'chair', 'walllamp', 'orchid', 'floor', 'ceiling', 'phone', 'bookshelf', 'remote_control', 'computer', 'ceilinglamp', 'tvstand', 'window', 'oil', 'closetdrawer', 'couch', 'pillow', 'dining_room', 'nightstand', 'wall', 'oven', 'bed', 'coffe_maker', 'television', 'curtain', 'dresser', 'door', 'instrument_guitar', 'table']
Task:Watch TV
response:

I go to the living room, switch on the tv, take the remote and sit on the sofa.

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


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

Here is an example plan to achieve a goal for reference:
Scene_Objects:['spectacles', 'tablelamp', 'chair', 'freezer', 'walllamp', 'drawing', 'wallshelf', 'cpuscreen', 'floor', 'ceiling', 'phone', 'desk', 'keyboard', 'computer', 'mat', 'tvstand', 'laptop', 'mousepad', 'couch', 'pillow', 'wall', 'oven', 'tape', 'photoframe', 'television', 'doorjamb', 'mouse', 'kitchen_counter', 'door', 'light']
Task:Use laptop
response:
{
    "thoughts": Sit down on a couch and perform tasks such as navigating the internet on a laptop,
    "actions": ['[WALK] <home_office>', '[WALK] <couch>', '[FIND] <couch>', '[SIT] <couch>', '[FIND] <laptop>', '[SWITCHON] <laptop>', '[TURNTO] <laptop>', '[LOOKAT] <laptop>', '[FIND] <keyboard>', '[TYPE] <keyboard>', '[TURNTO] <keyboard>', '[LOOKAT] <keyboard>', '[TYPE] <keyboard>', '[TURNTO] <laptop>', '[LOOKAT] <laptop>']
}

Input:
Scene_Objects:['chair', 'detergent', 'food_butter', 'clothes_underwear', 'hanger', 'floor', 'stamp', 'bookshelf', 'computer', 'clothes_jacket', 'table_cloth', 'mat', 'shoe-shine_kit', 'clothes_socks', 'closetdrawer', 'couch', 'clothes_pants', 'basket_for_clothes', 'check', 'mouthwash', 'food_rice', 'vacuum_cleaner', 'laundry_detergent', 'clothes_dress', 'bathroom_cabinet', 'light', 'dishwasher', 'clothes_shirt', 'washing_machine', 'creditcard']
Task:Wash clothes
response:

I grab the basket for clothes from the bedroom. I carry it and walk to the washing machine. I open the washing machine. I grab the dirty clothes. I put the clothes in the washing machine. I grab the laundry detergent and put it in the washing machine. I close the washing machine. 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:['filing_cabinet', 'food_ice_cream', 'chair', 'wallshelf', 'bathroom_counter', 'floor', 'ceiling', 'phone', 'desk', 'keyboard', 'stovefan', 'mat', 'faucet', 'shower', 'window', 'mousepad', 'couch', 'towel', 'wall', 'bed', 'photoframe', 'curtain', 'after_shave', 'kitchen_counter', 'sink', 'bathroom_cabinet', 'light', 'soap', 'hands_both', 'shoe_rack']
Task:Wash hands
response:
{
    "thoughts": Wash hands with soap and hot water,
    "actions": ['[WALK] <bathroom>', '[WALK] <sink>', '[FIND] <faucet>', '[SWITCHON] <faucet>', '[FIND] <soap>', '[GRAB] <soap>', '[FIND] <hands_both>', '[SCRUB] <hands_both>', '[PUTOBJBACK] <soap>', '[RINSE] <hands_both>', '[SWITCHOFF] <faucet>', '[FIND] <towel>', '[GRAB] <towel>', '[WIPE] <hands_both>', '[PUTOBJBACK] <towel>']
}

Input:
Scene_Objects:['juice', 'microwave', 'toilet', 'ground_coffee', 'bathroom', 'cpuscreen', 'hanger', 'floor', 'phone', 'character', 'bookshelf', 'computer', 'table_cloth', 'mat', 'tvstand', 'shower', 'couch', 'pillow', 'bowl', 'wall', 'powersocket', 'novel', 'food_food', 'video_game_controller', 'check', 'food_onion', 'doorjamb', 'napkin', 'home_office', 'coffee']
Task:Listen to music
response:

I walk into the living room. I find the stereo and turn it on, and I listen to the 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:['microwave', 'chair', 'walllamp', 'bathroom', 'drawing', 'cpuscreen', 'bathroom_counter', 'floor', 'ceiling', 'character', 'keyboard', 'alcohol', 'toaster', 'tvstand', 'shower', 'closetdrawer', 'nightstand', 'wall_clock', 'bench', 'powersocket', 'food_food', 'doorjamb', 'towel_rack', 'mouse', 'cupboard', 'sink', 'home_office', 'table', 'light', 'coffee']
Task:Walk through
response:
{
    "thoughts": Walk through the hallway.,
    "actions": ['[WALK] <home_office>', '[WALK] <dining_room>', '[WALK] <home_office>']
}

Input:
Scene_Objects:['dry_pasta', 'pot', 'microwave', 'walllamp', 'toothbrush', 'drawing', 'knifeblock', 'wallshelf', 'keyboard', 'food_cake', 'ceilinglamp', 'tvstand', 'shower', 'stereo', 'oil', 'tooth_paste', 'couch', 'closetdrawer', 'dining_room', 'toy', 'basket_for_clothes', 'light_bulb', 'check', 'centerpiece', 'kettle', 'mouse', 'kitchen_counter', 'shoes', 'light', 'board_game']
Task:Brush teeth
response:

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


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

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

Input:
Scene_Objects:['blender', 'toilet', 'freezer', 'walllamp', 'drawing', 'bathroom_counter', 'floor', 'ceiling', 'ceilinglamp', 'shoe-shine_kit', 'shower', 'faucet', 'mat', 'oil', 'food_peanut_butter', 'towel', 'wall', 'nightstand', 'powersocket', 'photoframe', 'bed', 'toilet_paper', 'curtain', 'doorjamb', 'kitchen_counter', 'door', 'sink', 'bathroom_cabinet', 'light', 'colander']
Task:Take shower
response:

Walk to Bathroom. Open the Bathroom Cabinet. Grab a Towel. Close the Bathroom Cabinet. Rinse the Shower.

[WALK] <bathroom>
[WALK] <bathroom_cabinet>
[FIND] <bathroom_cabinet>
[OPEN] <bathroom_cabinet>
[FIND] <towel>
[GRAB] <towel>
[CLOSE] <bathroom_cabinet>
[FIND] <shower>
[RINSE] <shower>


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

Here is an example plan to achieve a goal for reference:
Scene_Objects:['tea', 'toilet', 'freezer', 'band-aids', 'knifeblock', 'food_egg', 'shampoo', 'phone', 'bookshelf', 'purse', 'thread', 'deck_of_cards', 'shower', 'picture', 'clothes_socks', 'oven', 'food_cheese', 'novel', 'food_food', 'check', 'coffe_maker', 'tray', 'after_shave', 'curtain', 'doorjamb', 'cupboard', 'controller', 'bag', 'table', 'scrabble']
Task:Drink
response:
{
    "thoughts": Pour water into a glass and drink from the glass.,
    "actions": ['[WALK] <dining_room>', '[WALK] <water_glass>', '[FIND] <water_glass>', '[GRAB] <water_glass>', '[WALK] <water>', '[FIND] <water>', '[GRAB] <water>', '[POUR] <water> <water_glass>', '[DRINK] <water_glass>']
}

Input:
Scene_Objects:['pot', 'filing_cabinet', 'freezer', 'walllamp', 'drawing', 'needle', 'orchid', 'floor', 'stamp', 'keyboard', 'plate', 'faucet', 'shower', 'dish_soap', 'oil', 'wall', 'keys', 'coffe_maker', 'coffee_filter', 'pencil', 'kitchen_counter', 'dishrack', 'dresser', 'cupboard', 'controller', 'pajamas', 'food_steak', 'spoon', 'light', 'dishwasher']
Task:Wash dishes with dishwasher
response:

Walk to the kitchen. Find the dishwasher. Walk to the dishwasher. Open the dishwasher. Find plate no.1. Grab plate no.1. Put plate no.1 into the dishwasher. Find plate no.2. Grab plate no.2. Put plate no.2 into the dishwasher. Find the spoon. Grab the spoon. Put the spoon into the dishwasher. Find the dish soap. Put the dish soap into the dishwasher. Close the dishwasher. Switch on the dishwasher.

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


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

Here is an example plan to achieve a goal for reference:
Scene_Objects:['food_bread', 'filing_cabinet', 'toilet', 'freezer', 'dough', 'drawing', 'hanger', 'floor', 'ceiling', 'mat', 'shoe-shine_kit', 'shower', 'clothes_hat', 'bowl', 'nightstand', 'wall', 'powersocket', 'wall_clock', 'photoframe', 'light_bulb', 'food_food', 'coffe_maker', 'razor', 'coffee_filter', 'doorjamb', 'hairbrush', 'door', 'home_office', 'light', 'soap']
Task:Put away groceries
response:
{
    "thoughts": Place groceries in refrigerator from shopping at the grocery store.,
    "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:['beer', 'walllamp', 'blow_dryer', 'knifeblock', 'hanger', 'floor', 'ceiling', 'piano_bench', 'ceilinglamp', 'faucet', 'stereo', 'oil', 'food_peanut_butter', 'pillow', 'dining_room', 'wall', 'coffe_maker', 'toilet_paper', 'coffee_filter', 'water', 'wine', 'tray', 'curtain', 'kitchen_counter', 'dresser', 'cupboard', 'sink', 'dishwasher', 'laser_pointer', 'coffee']
Task:Make coffee
response:

[RUN] <dining_room>
[WALK] <coffe_maker>
[FIND] <coffee_filter>
[GRAB] <coffee_filter>
[OPEN] <coffe_maker>
[PUTBACK] <coffee_filter> <coffe_maker>
[FIND] <coffee>
[GRAB] <coffee>
[POUR] <coffee> <coffe_maker>
[PUTOBJBACK] <coffee>
[WALK] <water>
[FIND] <water>
[GRAB] <water>
[POUR] <water> <coffe_maker>
[SWITCHON] <coffe_maker>


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

Here is an example plan to achieve a goal for reference:
Scene_Objects:['sheets', 'pot', 'chair', 'walllamp', 'orchid', 'cpuscreen', 'floor', 'ceiling', 'shampoo', 'desk', 'keyboard', 'computer', 'table_cloth', 'stovefan', 'ceilinglamp', 'mat', 'plate', 'stereo', 'mousepad', 'wall', 'bench', 'television', 'wine', 'rag', 'lighter', 'shaving_cream', 'mouse', 'hairbrush', 'door', 'table']
Task:Write an email
response:
{
    "thoughts": walk to living room, look at computer, find chair, sit in chair, grab keyboard, grab mouse, type using keyboard and mouse,
    "actions": ['[WALK] <home_office>', '[WALK] <computer>', '[FIND] <computer>', '[TURNTO] <computer>', '[LOOKAT] <computer>', '[WALK] <computer>', '[FIND] <chair>', '[SIT] <chair>', '[FIND] <keyboard>', '[GRAB] <keyboard>', '[FIND] <mouse>', '[GRAB] <mouse>', '[TYPE] <keyboard>']
}

Input:
Scene_Objects:['beer', 'toilet', 'freezer', 'bathroom', 'knifeblock', 'drawing', 'wallshelf', 'floor', 'ceiling', 'phone', 'bedroom', 'keyboard', 'clothes_jacket', 'mat', 'shower', 'candle', 'creditcard', 'food_jam', 'food_orange', 'wall', 'nightstand', 'powersocket', 'photoframe', 'food_rice', 'doorjamb', 'door', 'spoon', 'light', 'board_game', 'shoe_rack']
Task:Put groceries in Fridge
response:

Walk to kitchen. Grab groceries and walk to the fridge. Open fridge and put groceries in the fridge. Close the fridge.

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


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

Here is an example plan to achieve a goal for reference:
Scene_Objects:['scissors', 'cat', 'drawing', 'hanger', 'longboard', 'floor', 'phone', 'character', 'desk', 'purse', 'stovefan', 'ceilinglamp', 'iron', 'stereo', 'window', 'oil', 'couch', 'wall', 'bench', 'toy', 'food_food', 'television', 'food_rice', 'towel_rack', 'console', 'hairbrush', 'napkin', 'table', 'vase', 'dirt']
Task:Pet cat
response:
{
    "thoughts": I would walk into the living room. Then sit on the couch and pet the cat.,
    "actions": ['[WALK] <home_office>', '[WALK] <couch>', '[SIT] <couch>', '[FIND] <cat>', '[TOUCH] <cat>']
}

Input:
Scene_Objects:['sponge', 'fork', 'microwave', 'toilet', 'walllamp', 'detergent', 'knifeblock', 'cpuscreen', 'hanger', 'floor', 'ceiling', 'bedroom', 'keyboard', 'table_cloth', 'toaster', 'laptop', 'plate', 'faucet', 'stereo', 'shower', 'food_noodles', 'wall', 'nightstand', 'novel', 'check', 'food_food', 'coin', 'kitchen_counter', 'cupboard', 'sink']
Task:Wash dishes by hand
response:

Walk into the kitchen. Walk up to the sink. Turn on the faucet. Pick up the plate. Wash the plate. Rinse the plate.

[WALK] <dining_room>
[WALK] <sink>
[FIND] <faucet>
[SWITCHON] <faucet>
[FIND] <plate>
[GRAB] <plate>
[WASH] <plate>
[RINSE] <plate>


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

Here is an example plan to achieve a goal for reference:
Scene_Objects:['filing_cabinet', 'microwave', 'chair', 'freezer', 'detergent', 'hanger', 'floor', 'ceiling', 'phone', 'dvd_player', 'character', 'bedroom', 'keyboard', 'computer', 'stereo', 'shower', 'towel', 'wall', 'wall_clock', 'pasta', 'nightstand', 'bed', 'doorjamb', 'dresser', 'cupboard', 'conditioner', 'door', 'clothes_scarf', 'light', 'clothes_shirt']
Task:Turn on light
response:
{
    "thoughts": approach the light switch, raise hand to the switch, flip the switch,
    "actions": ['[WALK] <home_office>', '[WALK] <light>', '[FIND] <light>', '[SWITCHON] <light>']
}

Input:
Scene_Objects:['pot', 'food_ice_cream', 'microwave', 'freezer', 'walllamp', 'blow_dryer', 'detergent', 'knifeblock', 'bathroom_counter', 'floor', 'ceiling', 'table_cloth', 'stovefan', 'toaster', 'faucet', 'mousepad', 'wall', 'wall_clock', 'oven', 'cup', 'coffe_maker', 'food_food', 'water', 'tray', 'cards', 'kitchen_counter', 'cupboard', 'sink', 'light', 'dishwasher']
Task:Drink
response:

Walk to kitchen, grab a cup, fill with water and then drink it.

[WALK] <dining_room>
[WALK] <cupboard>
[FIND] <cupboard>
[OPEN] <cupboard>
[FIND] <cup>
[GRAB] <cup>
[FIND] <faucet>
[SWITCHON] <faucet>
[FIND] <water>
[FIND] <sink>
[PUTBACK] <cup> <sink>
[GRAB] <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:['tablelamp', 'crayon', 'tea', 'mop', 'microwave', 'toilet', 'toothbrush', 'drawing', 'knifeblock', 'orchid', 'phone', 'ceiling', 'computer', 'stovefan', 'toaster', 'tvstand', 'window', 'floor_lamp', 'couch', 'clothes_hat', 'photoframe', 'after_shave', 'food_onion', 'headset', 'chessboard', 'cupboard', 'controller', 'door', 'bathroom_cabinet', 'clothes_skirt']
Task:Switch on lamp
response:
{
    "thoughts": Press the button so the light comes on.,
    "actions": ['[WALK] <bedroom>', '[WALK] <floor_lamp>', '[FIND] <floor_lamp>', '[SWITCHON] <floor_lamp>']
}

Input:
Scene_Objects:['sheets', 'food_salt', 'beer', 'chair', 'bathroom', 'cpuscreen', 'hanger', 'ceiling', 'desk', 'ceilinglamp', 'mat', 'shower', 'stereo', 'window', 'oil', 'dustpan', 'microphone', 'dining_room', 'novel', 'check', 'food_food', 'razor', 'ice', 'curtain', 'rag', 'after_shave', 'coffee_pot', 'shoes', 'instrument_guitar', 'tooth_paste']
Task:Listen to music
response:

I find a radio. I turn on the radio. I 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:['juice', 'toilet', 'chair', 'detergent', 'bathroom_counter', 'ceiling', 'character', 'desk', 'laptop', 'tvstand', 'faucet', 'electric_shaver', 'mousepad', 'couch', 'food_orange', 'bench', 'powersocket', 'cup', 'bed', 'novel', 'razor', 'oven_mitts', 'curtain', 'after_shave', 'cd', 'headset', 'dresser', 'pajamas', 'bathroom_cabinet', 'tooth_paste']
Task:Pick up phone
response:
{
    "thoughts": I'll enter the location containing the phone. Once there, I'll locate the phone, and move close to it. I'll then use my hand to pick up the phone such that I can then use it.,
    "actions": ['[WALK] <home_office>', '[WALK] <phone>', '[FIND] <phone>', '[WALK] <phone>', '[TURNTO] <phone>', '[LOOKAT] <phone>', '[GRAB] <phone>']
}

Input:
Scene_Objects:['sponge', 'tablelamp', 'chair', 'walllamp', 'orchid', 'knifeblock', 'wallshelf', 'floor', 'ceiling', 'remote_control', 'computer', 'ceilinglamp', 'tvstand', 'mat', 'window', 'closetdrawer', 'couch', 'pillow', 'wall', 'nightstand', 'tape', 'photoframe', 'coffee_table', 'television', 'toothbrush_holder', 'razor', 'curtain', 'dresser', 'pajamas', 'table']
Task:Watch TV
response:

I walk into the living room and sit on the couch. I pick up the remote to turn on the television. I put down the remote on the coffee table and look at the television.


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', 'bathroom', 'trashcan', 'orchid', 'drawing', 'cpuscreen', 'knifeblock', 'floor', 'dvd_player', 'computer', 'bookmark', 'brush', 'ceilinglamp', 'faucet', 'electric_shaver', 'floor_lamp', 'mousepad', 'wall', 'powersocket', 'novel', 'food_food', 'check', 'television', 'after_shave', 'cupboard', 'sink', 'home_office', 'table', 'tooth_paste']
Task:Turn on light
response:
{
    "thoughts": Twist the lamp switch until the light goes on.,
    "actions": ['[WALK] <home_office>', '[WALK] <floor_lamp>', '[FIND] <floor_lamp>', '[SWITCHON] <floor_lamp>']
}

Input:
Scene_Objects:['filing_cabinet', 'toilet', 'freezer', 'ground_coffee', 'bathroom', 'food_carrot', 'toothbrush', 'orchid', 'knife', 'cpuscreen', 'hanger', 'bathroom_counter', 'floor', 'bookshelf', 'button', 'mat', 'shower', 'mousepad', 'oil', 'closetdrawer', 'microphone', 'oven', 'cutting_board', 'check', 'centerpiece', 'diary', 'clothes_dress', 'clothes_scarf', 'napkin', 'tooth_paste']
Task:Pet cat
response:

Walk into the living room. Walk up to the cat. Pet the cat with your hand.

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


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

Here is an example plan to achieve a goal for reference:
Scene_Objects:['walllamp', 'bathroom', 'drawing', 'orchid', 'wallshelf', 'floor', 'ceiling', 'bookshelf', 'remote_control', 'toaster', 'mat', 'tvstand', 'ceilinglamp', 'shower', 'window', 'couch', 'pillow', 'wall', 'powersocket', 'photoframe', 'television', 'curtain', 'after_shave', 'doorjamb', 'mouse', 'dresser', 'door', 'table', 'light', 'dishwasher']
Task:Change TV channel
response:
{
    "thoughts": I go in the living room. Then I find the remote, sit on the couch and turn on the television. Then I use the remote the change the TV channel.,
    "actions": ['[WALK] <home_office>', '[WALK] <remote_control>', '[FIND] <remote_control>', '[FIND] <couch>', '[SIT] <couch>', '[FIND] <television>', '[SWITCHON] <television>']
}

Input:
Scene_Objects:['pot', 'filing_cabinet', 'tablelamp', 'walllamp', 'food_carrot', 'orchid', 'cpuscreen', 'wallshelf', 'floor', 'ceiling', 'phone', 'bookshelf', 'remote_control', 'computer', 'button', 'tvstand', 'window', 'closetdrawer', 'couch', 'pillow', 'nightstand', 'wall', 'basket_for_clothes', 'food_food', 'television', 'curtain', 'dresser', 'clothes_dress', 'home_office', 'table']
Task:Change TV channel
response:

Take TV remote to change TV Channel. Press channel/program +/- button on TV remote.

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