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:['jelly', 'bathroom', 'trashcan', 'wallshelf', 'clothes_underwear', 'cpuscreen', 'bathroom_counter', 'ceiling', 'character', 'faucet', 'shower', 'window', 'mousepad', 'closetdrawer', 'couch', 'pillow', 'nightstand', 'wall_clock', 'newspaper', 'coffe_maker', 'television', 'curtain', 'centerpiece', 'towel_rack', 'kitchen_counter', 'cupboard', 'bathtub', 'sink', 'clothes_scarf', 'light']
Task:Watch fly
response:
{
    "thoughts": Look around for a fly, often on a wall or ceiling.  Follow it's movements.,
    "actions": ['[WALK] <bedroom>', '[WALK] <fly>', '[FIND] <fly>', '[TURNTO] <fly>', '[LOOKAT] <fly>']
}

Input:
Scene_Objects:['glue', 'chair', 'orchid', 'drawing', 'cpuscreen', 'wallshelf', 'floor', 'character', 'bedroom', 'toaster', 'ceilinglamp', 'mat', 'mousepad', 'couch', 'food_peanut_butter', 'wall', 'powersocket', 'cup', 'food_cheese', 'photoframe', 'food_food', 'coffe_maker', 'doorjamb', 'pencil', 'kitchen_counter', 'cd', 'shoes', 'hair', 'clothes_dress', 'table']
Task:Set up table
response:

Get dishes. Place dishes neatly around table. Get food. Place food on middle of table.

[WALK] <dining_room>
[WALK] <plate>
[FIND] <plate>
[GRAB] <plate>
[WALK] <dining_room>
[WALK]

[PUTBACK] <plate>

[WALK] <dining_room>
[WALK] <plate>
[FIND] <plate>
[GRAB] <plate>
[WALK] <dining_room>
[WALK]

[PUTBACK] <plate>

[WALK] <dining_room>
[WALK] <plate>
[FIND] <plate>
[GRAB] <plate>
[WALK] <dining_room>
[WALK]

[PUTBACK] <plate>

[WALK] <dining_room>
[WALK] <food_food>
[FIND] <food_food>
[GRAB] <food_food>
[WALK] <dining_room>
[WALK]

[PUTBACK] <food_food>

[WALK] <dining_room>
[WALK] <food_food>
[FIND] <food_food>
[GRAB] <food_food>
[WALK] <dining_room>
[WALK]

[PUTBACK] <food_food>


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

Here is an example plan to achieve a goal for reference:
Scene_Objects:['fork', 'pot', 'toilet', 'chair', 'freezer', 'food_butter', 'food_carrot', 'drawing', 'floor', 'ceiling', 'keyboard', 'mat', 'ceilinglamp', 'shower', 'oil', 'food_peanut_butter', 'food_orange', 'nightstand', 'wall', 'powersocket', 'photoframe', 'food_food', 'food_onion', 'doorjamb', 'pencil', 'dresser', 'door', 'napkin', 'light', 'shoe_rack']
Task:Put groceries in Fridge
response:
{
    "thoughts": put away groceries in fridge. open the door, put on shelf, close the door.,
    "actions": ['[WALK] <dining_room>', '[WALK] <freezer>', '[FIND] <freezer>', '[OPEN] <freezer>', '[FIND] <food_food>', '[GRAB] <food_food>', '[PUTIN] <food_food> <freezer>', '[CLOSE] <freezer>']
}

Input:
Scene_Objects:['tablelamp', 'food_ice_cream', 'drawing', 'wallshelf', 'clothes_underwear', 'hanger', 'floor', 'ceiling', 'mat', 'closetdrawer', 'couch', 'clothes_pants', 'pillow', 'dining_room', 'wall', 'powersocket', 'oven', 'basket_for_clothes', 'photoframe', 'mouthwash', 'doorjamb', 'kitchen_counter', 'shoes', 'dresser', 'door', 'sink', 'light', 'clothes_shirt', 'teeth', 'creditcard']
Task:Organize closet
response:

Organize the hanging clothes in my closet by color and type and get rid of clothes I don't wear.


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

Here is an example plan to achieve a goal for reference:
Scene_Objects:['food_pizza', 'microwave', 'toilet', 'jelly', 'freezer', 'band-aids', 'drawing', 'knifeblock', 'clothes_underwear', 'kitchen_cabinet', 'floor', 'ceiling', 'toaster', 'mat', 'faucet', 'shower', 'wall', 'nightstand', 'powersocket', 'cup', 'basket_for_clothes', 'photoframe', 'food_food', 'water', 'doorjamb', 'kitchen_counter', 'cupboard', 'door', 'sink', 'light']
Task:Get drink
response:
{
    "thoughts": I go to the fridge and open the door. I look for the water pitcher, and take it out, making sure to close the fridge door behind me. Then I take a pint glass out of the upper cabinet over the sink and use the water pitcher to pour a full glass of water. Then I return the pitcher to the fridge and shut the door again, and take my glass of water out of the kitche.,
    "actions": ['[WALK] <dining_room>', '[WALK] <sink>', '[FIND] <kitchen_cabinet>', '[OPEN] <kitchen_cabinet>', '[FIND] <cup>', '[GRAB] <cup>', '[CLOSE] <kitchen_cabinet>', '[WALK] <freezer>', '[WALK] <water>', '[FIND] <water>', '[GRAB] <water>', '[POUR] <water> <cup>', '[OPEN] <freezer>']
}

Input:
Scene_Objects:['spectacles', 'pot', 'freezer', 'walllamp', 'detergent', 'bills', 'wallshelf', 'clothes_underwear', 'floor', 'ceiling', 'phone', 'bedroom', 'keyboard', 'shower', 'faucet', 'closetdrawer', 'microphone', 'dining_room', 'pasta', 'mouthwash', 'mouse', 'pencil', 'dresser', 'pajamas', 'controller', 'sink', 'napkin', 'home_office', 'dishwasher', 'soap']
Task:Switch on lamp
response:

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


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

Here is an example plan to achieve a goal for reference:
Scene_Objects:['sheets', 'walllamp', 'drawing', 'cpuscreen', 'character', 'desk', 'keyboard', 'bookshelf', 'computer', 'button', 'alcohol', 'laptop', 'plate', 'faucet', 'homework', 'mousepad', 'dining_room', 'check', 'food_food', 'television', 'tray', 'wooden_spoon', 'mouse', 'shoes', 'conditioner', 'maindoor', 'napkin', 'home_office', 'soap', 'instrument_violin']
Task:Browse internet
response:
{
    "thoughts": I turn on computer. I use keyboard to type. I open browser. I search.,
    "actions": ['[WALK] <bedroom>', '[WALK] <computer>', '[FIND] <keyboard>', '[TYPE] <keyboard>', '[TURNTO] <computer>', '[LOOKAT] <computer>']
}

Input:
Scene_Objects:['tablelamp', 'drawing', 'wallshelf', 'hanger', 'floor', 'ceiling', 'character', 'cleaning_solution', 'bookshelf', 'table_cloth', 'mat', 'ceilinglamp', 'tvstand', 'foundation', 'closetdrawer', 'couch', 'clothes_pants', 'pillow', 'wall', 'nightstand', 'powersocket', 'photoframe', 'bed', 'television', 'rag', 'doorjamb', 'dresser', 'door', 'home_office', 'light']
Task:Dust
response:

Gather wood cleaner and cleaning rag. Wipe baseboards and window sills with dry cloth, then spray with cleaner and buff

[WALK] <bedroom>
[WALK] <cleaning_solution>
[FIND] <cleaning_solution>
[GRAB] <cleaning_solution>
[FIND] <rag>
[GRAB] <rag>
[POUR] <cleaning_solution> <rag>
[PUTOBJBACK] <cleaning_solution>
[WALK] <wall>
[WALK] <window>
[PUTOBJBACK] <rag>


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', 'toilet', 'chair', 'trashcan', 'ceilingfan', 'drawing', 'cpuscreen', 'floor', 'ceiling', 'phone', 'desk', 'keyboard', 'bookshelf', 'computer', 'ceilinglamp', 'deck_of_cards', 'balanceball', 'homework', 'mousepad', 'clothes_pants', 'wall', 'nightstand', 'photoframe', 'check', 'curtain', 'doorjamb', 'mouse', 'light', 'dirt']
Task:Work
response:
{
    "thoughts": Find a PC and do homework,
    "actions": ['[WALK] <home_office>', '[WALK] <computer>', '[FIND] <computer>', '[SWITCHON] <computer>', '[FIND] <keyboard>', '[FIND] <mouse>', '[FIND] <check>', '[FIND] <homework>', '[GRAB] <homework>', '[FIND] <homework>', '[READ] <homework>', '[SWITCHOFF] <computer>']
}

Input:
Scene_Objects:['glue', 'sponge', 'measuring_cup', 'toilet', 'food_butter', 'cpuscreen', 'bathroom_counter', 'ceiling', 'phone', 'character', 'face', 'food_bacon', 'shoe-shine_kit', 'closetdrawer', 'candle', 'food_jam', 'towel', 'pillow', 'nightstand', 'oven', 'cup', 'mouthwash', 'television', 'food_rice', 'after_shave', 'diary', 'headset', 'hair', 'door', 'light']
Task:Rain welcome
response:

The robot would greet me and then hand me a towel.  It would make an appropriate quip about the weather while I dried off.  It would receive the wet towel when I was done.

[WALK] <bedroom>
[WALK] <towel>
[FIND] <towel>
[GRAB] <towel>
[FIND] <face>
[WIPE] <face>
[FIND] <hair>
[WIPE] <hair>
[PUTOBJBACK] <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:['water_glass', 'food_bread', 'chair', 'freezer', 'walllamp', 'detergent', 'trashcan', 'drawing', 'desk', 'keyboard', 'bookshelf', 'bookmark', 'stovefan', 'ceilinglamp', 'tvstand', 'shower', 'faucet', 'pillow', 'bowl', 'wall', 'box', 'coffe_maker', 'razor', 'television', 'curtain', 'doorjamb', 'towel_rack', 'door', 'sink', 'bathroom_cabinet']
Task:Drink
response:
{
    "thoughts": Pour water into a glass and drink from the glass.,
    "actions": ['[WALK] <dining_room>', '[WALK] <water_glass>', '[FIND] <water_glass>', '[GRAB] <water_glass>', '[WALK] <water>', '[FIND] <water>', '[GRAB] <water>', '[POUR] <water> <water_glass>', '[DRINK] <water_glass>']
}

Input:
Scene_Objects:['sheets', 'crayon', 'chair', 'walllamp', 'bathroom', 'ceiling', 'bedroom', 'keyboard', 'bookshelf', 'clothes_jacket', 'toaster', 'deck_of_cards', 'faucet', 'mousepad', 'microphone', 'wall', 'tape', 'novel', 'food_food', 'check', 'food_donut', 'tray', 'towel_rack', 'dresser', 'pajamas', 'clothes_dress', 'hairdryer', 'bathroom_cabinet', 'home_office', 'table']
Task:Grab things
response:

The robot will need some kind of hands or grabbing device to transport objects.

[WALK] <novel>
[TURNTO] <novel>
[GRAB] <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:['sheets', 'scissors', 'toilet', 'band-aids', 'food_carrot', 'dough', 'orchid', 'wallshelf', 'hanger', 'floor', 'ceiling', 'folder', 'bedroom', 'shoe-shine_kit', 'closetdrawer', 'food_orange', 'nightstand', 'wall', 'powersocket', 'coin', 'shaving_cream', 'pencil', 'cupboard', 'sink', 'napkin', 'instrument_guitar', 'bathroom_cabinet', 'soap', 'scrabble', 'washing_machine']
Task:Wash clothes
response:
{
    "thoughts": I go to the bedroom to find and grab basket of clothes. I then go to the bathroom and find the washing machine. I put clothes inside the washing machine and put washing powder. I switch on the washing machine.,
    "actions": ['[WALK] <bedroom>', '[WALK] <basket_for_clothes>', '[FIND] <basket_for_clothes>', '[GRAB] <basket_for_clothes>', '[WALK] <bathroom>', '[WALK] <washing_machine>', '[FIND] <washing_machine>', '[OPEN] <washing_machine>', '[PUTBACK] <basket_for_clothes> <washing_machine>', '[FIND] <soap>', '[GRAB] <soap>', '[PUTBACK] <soap> <washing_machine>', '[FIND] <washing_machine>', '[CLOSE] <washing_machine>', '[SWITCHON] <washing_machine>']
}

Input:
Scene_Objects:['dry_pasta', 'tablelamp', 'food_salt', 'measuring_cup', 'microwave', 'chair', 'orchid', 'knife', 'food_egg', 'wallshelf', 'desk', 'alcohol', 'computer', 'bookmark', 'shower', 'stereo', 'mousepad', 'dining_room', 'oven', 'powersocket', 'photoframe', 'mouthwash', 'tray', 'curtain', 'mouse', 'vacuum_cleaner', 'pajamas', 'sink', 'dishwasher', 'dirt']
Task:Close door
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:['food_ice_cream', 'chair', 'walllamp', 'orchid', 'cpuscreen', 'floor', 'ceiling', 'dvd_player', 'desk', 'keyboard', 'bookshelf', 'computer', 'clothes_jacket', 'ceilinglamp', 'mat', 'iron', 'mousepad', 'oil', 'couch', 'pillow', 'wall', 'powersocket', 'oven', 'video_game_controller', 'television', 'doorjamb', 'kettle', 'mouse', 'door', 'table']
Task:Browse internet
response:
{
    "thoughts": Walk to home office. Walk to computer. Switch on Computer.,
    "actions": ['[WALK] <home_office>', '[WALK] <computer>', '[SWITCHON] <computer>']
}

Input:
Scene_Objects:['juice', 'walllamp', 'cat', 'drawing', 'orchid', 'wallshelf', 'bathroom_counter', 'floor', 'ceiling', 'desk', 'thread', 'computer', 'stovefan', 'mat', 'tvstand', 'toaster', 'couch', 'pillow', 'wall', 'photoframe', 'check', 'television', 'doorjamb', 'laundry_detergent', 'conditioner', 'sink', 'door', 'bathroom_cabinet', 'table', 'dishwasher']
Task:Do homework
response:

Sit on the couch in the Living room and pick u some papers

[WALK] <home_office>
[WALK] <couch>
[FIND] <couch>
[SIT] <couch>
[FIND] <check>
[GRAB] <check>
[DROP] <check>


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

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

Input:
Scene_Objects:['pot', 'filing_cabinet', 'tablelamp', 'microwave', 'freezer', 'walllamp', 'food_butter', 'cpuscreen', 'phone', 'folder', 'bedroom', 'computer', 'stovefan', 'tvstand', 'plate', 'mousepad', 'couch', 'food_peanut_butter', 'pillow', 'dining_room', 'wall', 'check', 'razor', 'television', 'tray', 'curtain', 'diary', 'shaving_cream', 'door', 'soap']
Task:Open curtains
response:

Gently pull the curtains open, from the middle to the sides.

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


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', 'freezer', 'cat', 'food_carrot', 'dough', 'orchid', 'needle', 'hanger', 'longboard', 'floor', 'ceiling', 'bathroom_counter', 'ceilinglamp', 'mat', 'stereo', 'couch', 'dustpan', 'pillow', 'wall', 'powersocket', 'light_bulb', 'food_food', 'coffe_maker', 'video_game_controller', 'oven_mitts', 'food_rice', 'vacuum_cleaner', 'dresser', 'door', 'hairdryer']
Task:Put groceries in Fridge
response:
{
    "thoughts": I leave the bags with groceries near the fridge, open the door and put the groceries in the shelves.,
    "actions": ['[WALK] <dining_room>', '[WALK] <food_food>', '[FIND] <food_food>', '[GRAB] <food_food>', '[FIND] <freezer>', '[OPEN] <freezer>', '[PUTIN] <food_food> <freezer>']
}

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

Sit down on a couch and perform tasks such as navigating the internet on a laptop

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


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:['bathroom_counter', 'floor', 'ceiling', 'phone', 'stovefan', 'mat', 'faucet', 'shower', 'tooth_paste', 'towel', 'wall', 'wall_clock', 'oven', 'tape', 'photoframe', 'clothes_gloves', 'light_bulb', 'tray', 'doorjamb', 'towel_rack', 'mouse', 'sink', 'bathtub', 'bathroom_cabinet', 'table', 'light', 'vase', 'soap', 'home_office', 'hands_both']
Task:Wash hands
response:
{
    "thoughts": I go to the bathroom, open the faucet rinse the hands, wash the hands with soap and rinse again, then wipe with a towel.,
    "actions": ['[WALK] <bathroom>', '[WALK] <faucet>', '[FIND] <faucet>', '[TURNTO] <faucet>', '[FIND] <hands_both>', '[RINSE] <hands_both>', '[FIND] <soap>', '[GRAB] <soap>', '[WASH] <hands_both>', '[RINSE] <hands_both>', '[TURNTO] <faucet>', '[FIND] <towel>', '[GRAB] <towel>', '[WIPE] <hands_both>']
}

Input:
Scene_Objects:['tablelamp', 'tea', 'chair', 'walllamp', 'orchid', 'cpuscreen', 'wallshelf', 'hanger', 'floor', 'ceiling', 'phone', 'desk', 'keyboard', 'computer', 'toaster', 'ceilinglamp', 'tvstand', 'mat', 'mousepad', 'couch', 'pillow', 'wall', 'nightstand', 'television', 'doorjamb', 'mouse', 'vacuum_cleaner', 'dresser', 'door', 'home_office']
Task:Vacuum
response:

Keep my keyboard vacuumed and free of debris.

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


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

Here is an example plan to achieve a goal for reference:
Scene_Objects:['tablelamp', 'chair', 'freezer', 'walllamp', 'bathroom', 'cat', 'trashcan', 'drawing', 'wallshelf', 'floor', 'desk', 'mat', 'tvstand', 'ceilinglamp', 'window', 'couch', 'pillow', 'wall', 'wall_clock', 'bench', 'cup', 'food_food', 'television', 'curtain', 'towel_rack', 'mouse', 'sink', 'bathroom_cabinet', 'table', 'scrabble']
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', 'microwave', 'chair', 'drawing', 'clothes_underwear', 'hanger', 'bathroom_counter', 'bedroom', 'keyboard', 'clothes_jacket', 'ceilinglamp', 'tvstand', 'faucet', 'picture', 'mat', 'mousepad', 'couch', 'pillow', 'dining_room', 'food_food', 'check', 'coffe_maker', 'mirror', 'ice', 'wooden_spoon', 'rag', 'cupboard', 'door', 'sink', 'table']
Task:Clean mirror
response:

Spray glass cleaner on mirror. Wipe with a clean cloth.

[WALK] <bathroom>
[WALK] <cleaning_solution>
[FIND] <cleaning_solution>
[GRAB] <cleaning_solution>
[WALK] <mirror>
[PUTOBJBACK] <cleaning_solution>
[FIND] <rag>
[GRAB] <rag>
[WALK] <mirror>
[WIPE] <mirror>
[WIPE] <mirror>
[WIPE] <mirror>
[PUTOBJBACK] <rag>


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

Here is an example plan to achieve a goal for reference:
Scene_Objects:['pot', 'chair', 'walllamp', 'orchid', 'needle', 'cpuscreen', 'floor', 'ceiling', 'desk', 'keyboard', 'computer', 'clothes_jacket', 'mat', 'ceilinglamp', 'tvstand', 'mousepad', 'closetdrawer', 'pillow', 'wall', 'photoframe', 'coffe_maker', 'television', 'doorjamb', 'mouse', 'kitchen_counter', 'cupboard', 'door', 'sink', 'light', 'table']
Task:Browse internet
response:
{
    "thoughts": I go to my desk. I turn on the computer. I open a web page and look at it.,
    "actions": ['[WALK] <home_office>', '[WALK] <computer>', '[FIND] <computer>', '[SWITCHON] <computer>', '[TURNTO] <computer>', '[LOOKAT] <computer>']
}

Input:
Scene_Objects:['pot', 'filing_cabinet', 'chair', 'freezer', 'walllamp', 'bathroom', 'drawing', 'wallshelf', 'floor', 'ceiling', 'bedroom', 'computer', 'button', 'mat', 'shoe-shine_kit', 'pillow', 'wall', 'oven', 'tape', 'bed', 'photoframe', 'novel', 'food_food', 'curtain', 'coffee_pot', 'mouse', 'pencil', 'conditioner', 'sink', 'coffee']
Task:Read to child
response:

[WALK] <bedroom>
[WALK] <child>
[FIND] <child>
[GREET] <child>
[WALK] <filing_cabinet>
[OPEN] <filing_cabinet>
[FIND] <novel>
[GRAB] <novel>
[WALK] <chair>
[PULL] <chair>
[SIT] <chair>
[TURNTO] <novel>
[LOOKAT] <novel>
[TURNTO] <novel>
[POINTAT] <novel>
[TURNTO] <novel>
[POINTAT] <novel>
[READ] <novel>
[READ] <novel>
[READ] <novel>


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

Here is an example plan to achieve a goal for reference:
Scene_Objects:['food_salt', 'chair', 'ceilingfan', 'drawing', 'floor', 'ceiling', 'phone', 'remote_control', 'food_bacon', 'table_cloth', 'ceilinglamp', 'tvstand', 'balanceball', 'window', 'couch', 'wall', 'powersocket', 'oven', 'cup', 'bed', 'coffe_maker', 'television', 'curtain', 'lighter', 'doorjamb', 'shaving_cream', 'headset', 'cupboard', 'table', 'clothes_shirt']
Task:Watch TV
response:
{
    "thoughts": We recently got a 43 inch TV and have enjoyed watching some of our favorite movies and TV shows. We use a remote to do so.,
    "actions": ['[WALK] <home_office>', '[WALK] <couch>', '[SIT] <couch>', '[FIND] <remote_control>', '[GRAB] <remote_control>', '[TOUCH] <remote_control>', '[FIND] <television>', '[SWITCHON] <television>', '[TURNTO] <television>', '[WATCH] <television>']
}

Input:
Scene_Objects:['crayon', 'chair', 'detergent', 'cat', 'toothbrush', 'phone', 'character', 'purse', 'thread', 'computer', 'ceilinglamp', 'stereo', 'couch', 'food_peanut_butter', 'towel', 'wall', 'cup', 'food_cheese', 'photoframe', 'light_bulb', 'coffe_maker', 'television', 'towel_rack', 'kitchen_counter', 'dishrack', 'comb', 'dresser', 'door', 'sink', 'instrument_violin']
Task:Keep cats out of room
response:

Stand in the doorway and create a loud noise so the cats will stay out.

[WALK] <bedroom>
[WALK] <cat>
[FIND] <cat>
[TURNTO] <cat>
[LOOKAT] <cat>
[FIND] <cat>
[TURNTO] <cat>
[LOOKAT] <cat>


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

Here is an example plan to achieve a goal for reference:
Scene_Objects:['pot', 'filing_cabinet', 'toilet', 'chair', 'walllamp', 'ground_coffee', 'orchid', 'bathroom_counter', 'floor', 'ceiling', 'phone', 'bookshelf', 'stovefan', 'tvstand', 'faucet', 'shower', 'electric_shaver', 'towel', 'wall', 'wall_clock', 'oven', 'television', 'tray', 'rag', 'doorjamb', 'dresser', 'sink', 'bathroom_cabinet', 'clothes_skirt', 'laser_pointer']
Task:Take shower
response:
{
    "thoughts": Walk to Bathroom. Open the Bathroom Cabinet. Grab a Towel. Close the Bathroom Cabinet. Rinse the Shower.,
    "actions": ['[WALK] <bathroom>', '[WALK] <bathroom_cabinet>', '[FIND] <bathroom_cabinet>', '[OPEN] <bathroom_cabinet>', '[FIND] <towel>', '[GRAB] <towel>', '[CLOSE] <bathroom_cabinet>', '[FIND] <shower>', '[RINSE] <shower>']
}

Input:
Scene_Objects:['sheets', 'cpuscreen', 'phone', 'desk', 'cleaning_solution', 'keyboard', 'purse', 'table_cloth', 'stovefan', 'tvstand', 'shower', 'stereo', 'food_noodles', 'towel', 'pillow', 'wall', 'wall_clock', 'oven', 'basket_for_clothes', 'photoframe', 'novel', 'food_rice', 'rag', 'towel_rack', 'mouse', 'dresser', 'cupboard', 'clothes_dress', 'napkin', 'table']
Task:Clean  mirror
response:

GET CLEANING CLOTH, SPRAY CLEANER ON CLOTH, CLEAN MIRROR

[WALK] <bathroom>
[WALK] <cleaning_solution>
[FIND] <cleaning_solution>
[GRAB] <cleaning_solution>
[FIND] <rag>
[GRAB] <rag>
[POUR] <cleaning_solution> <rag>
[PUTOBJBACK] <cleaning_solution>
[WALK] <mirror>
[WIPE] <mirror>
[WIPE] <mirror>
[WIPE] <mirror>
[PUTOBJBACK] <rag>


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:['jelly', 'bathroom', 'trashcan', 'wallshelf', 'clothes_underwear', 'cpuscreen', 'bathroom_counter', 'ceiling', 'character', 'faucet', 'shower', 'window', 'mousepad', 'closetdrawer', 'couch', 'pillow', 'nightstand', 'wall_clock', 'newspaper', 'coffe_maker', 'television', 'curtain', 'centerpiece', 'towel_rack', 'kitchen_counter', 'cupboard', 'bathtub', 'sink', 'clothes_scarf', 'light']
Task:Watch fly
response:
{
    "thoughts": Look around for a fly, often on a wall or ceiling.  Follow it's movements.,
    "actions": ['[WALK] <bedroom>', '[WALK] <fly>', '[FIND] <fly>', '[TURNTO] <fly>', '[LOOKAT] <fly>']
}

Input:
Scene_Objects:['pot', 'tablelamp', 'chair', 'walllamp', 'drawing', 'orchid', 'wallshelf', 'cpuscreen', 'hanger', 'floor', 'ceiling', 'desk', 'keyboard', 'bookshelf', 'computer', 'stovefan', 'mat', 'tvstand', 'ceilinglamp', 'shower', 'mousepad', 'closetdrawer', 'couch', 'pillow', 'wall', 'nightstand', 'powersocket', 'oven', 'photoframe', 'television', 'tray', 'doorjamb', 'towel_rack', 'mouse', 'kitchen_counter', 'dresser', 'cupboard', 'door', 'light', 'table']
Task:Straighten paintings on wall
response:

Go up to the painting and tilt it which ever way it is uneven until it looks straight.

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


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

Here is an example plan to achieve a goal for reference:
Scene_Objects:['water_glass', 'pot', 'microwave', 'toilet', 'band-aids', 'walllamp', 'trashcan', 'knifeblock', 'drawing', 'ceiling', 'desk', 'stovefan', 'faucet', 'mousepad', 'wall', 'nightstand', 'oven', 'check', 'food_food', 'water', 'tray', 'doorjamb', 'kitchen_counter', 'cd', 'cupboard', 'laundry_detergent', 'sink', 'bathroom_cabinet', 'soap', 'laser_pointer']
Task:Drink
response:
{
    "thoughts": I walk to the kitchen. open the cupboard. Find the water glass, grab it. Fill the glass with water and drink water.,
    "actions": ['[WALK] <dining_room>', '[WALK] <cupboard>', '[FIND] <cupboard>', '[OPEN] <cupboard>', '[FIND] <water_glass>', '[GRAB] <water_glass>', '[WALK] <water>', '[FIND] <water>', '[GRAB] <water>', '[POUR] <water> <water_glass>', '[DRINK] <water_glass>']
}

Input:
Scene_Objects:['blender', 'tea', 'microwave', 'jelly', 'band-aids', 'freezer', 'bathroom', 'needle', 'ceiling', 'character', 'keyboard', 'mop_bucket', 'ceilinglamp', 'mat', 'tvstand', 'faucet', 'closetdrawer', 'couch', 'pillow', 'nightstand', 'oven', 'photoframe', 'coffe_maker', 'check', 'television', 'cards', 'laundry_detergent', 'clothes_dress', 'home_office', 'table']
Task:Put umbrella away
response:

Place the umbrella in the umbrella bucket point first.

[WALK] <home_office>
[WALK] <mop_bucket>


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

Here is an example plan to achieve a goal for reference:
Scene_Objects:['pot', 'tablelamp', 'chair', 'walllamp', 'drawing', 'orchid', 'wallshelf', 'cpuscreen', 'hanger', 'floor', 'ceiling', 'phone', 'desk', 'bookshelf', 'keyboard', 'computer', 'mat', 'ceilinglamp', 'tvstand', 'mousepad', 'couch', 'pillow', 'wall', 'nightstand', 'powersocket', 'oven', 'check', 'television', 'tray', 'doorjamb', 'towel_rack', 'mouse', 'kitchen_counter', 'dresser', 'door', 'light']
Task:Work
response:
{
    "thoughts": you go into your office, switch on the light, find chair at desk, sit in the chair, switch on the computer and work.,
    "actions": ['[WALK] <home_office>', '[WALK] <light>', '[FIND] <light>', '[SWITCHON] <light>', '[FIND] <desk>', '[FIND] <chair>', '[SIT] <chair>', '[FIND] <computer>', '[SWITCHON] <computer>']
}

Input:
Scene_Objects:['fork', 'drawing', 'wallshelf', 'hanger', 'bathroom_counter', 'floor', 'ceiling', 'phone', 'character', 'desk', 'tea_bag', 'mat', 'closetdrawer', 'couch', 'pillow', 'wall', 'powersocket', 'toy', 'photoframe', 'check', 'mouthwash', 'food_food', 'food_donut', 'wine', 'curtain', 'doorjamb', 'console', 'dresser', 'door', 'light']
Task:Pick up toys
response:

Bend down and pick up the toys off of the floor.

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


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', 'toothbrush', 'cpuscreen', 'clothes_underwear', 'wallshelf', 'floor', 'phone', 'ceiling', 'character', 'bookshelf', 'computer', 'button', 'pillow', 'dining_room', 'bench', 'food_food', 'television', 'tray', 'curtain', 'doorjamb', 'towel_rack', 'mouse', 'cd', 'dresser', 'cupboard', 'pajamas', 'clothes_dress', 'sink', 'home_office', 'laser_pointer']
Task:Browse internet
response:
{
    "thoughts": Walk to home office. Walk to computer. Switch on Computer.,
    "actions": ['[WALK] <home_office>', '[WALK] <computer>', '[SWITCHON] <computer>']
}

Input:
Scene_Objects:['spectacles', 'filing_cabinet', 'walllamp', 'drawing', 'floor', 'desk', 'tea_bag', 'computer', 'clothes_jacket', 'toaster', 'mat', 'mousepad', 'closetdrawer', 'towel', 'tape', 'basket_for_clothes', 'bed', 'curtain', 'shaving_cream', 'towel_rack', 'mouse', 'kitchen_counter', 'chessboard', 'dresser', 'hair', 'laundry_detergent', 'bathroom_cabinet', 'light', 'board_game', 'dirt']
Task:Open front door
response:

Walk over to the front door, turn the knob, and open the door.


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

Here is an example plan to achieve a goal for reference:
Scene_Objects:['tablelamp', 'chair', 'walllamp', 'detergent', 'cpuscreen', 'hanger', 'floor', 'ceiling', 'character', 'desk', 'keyboard', 'computer', 'button', 'toaster', 'ceilinglamp', 'tvstand', 'mousepad', 'closetdrawer', 'broom', 'wall', 'pasta', 'powersocket', 'shelf', 'check', 'television', 'doorjamb', 'mouse', 'dresser', 'light', 'table']
Task:Work
response:
{
    "thoughts": I walk to the living room. I find the computer and turn it on. I look at the computer screen. I move and click the mouse to select buttons on the screen.,
    "actions": ['[WALK] <home_office>', '[WALK] <computer>', '[FIND] <computer>', '[SWITCHON] <computer>', '[TURNTO] <computer>', '[LOOKAT] <computer>', '[FIND] <mouse>', '[PUSH] <mouse>', '[FIND] <button>', '[PUSH] <button>']
}

Input:
Scene_Objects:['spectacles', 'walllamp', 'nail_polish', 'milk', 'drawing', 'wallshelf', 'floor', 'ceiling', 'computer', 'food_bacon', 'piano_bench', 'mat', 'tvstand', 'stereo', 'couch', 'clothes_hat', 'form', 'pillow', 'dining_room', 'wall', 'wall_clock', 'cup', 'photoframe', 'novel', 'coffe_maker', 'television', 'ice', 'doorjamb', 'mouse', 'scrabble']
Task:Read book
response:

Sit on a couch, grab a book, open it, and scan the pages

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


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

Here is an example plan to achieve a goal for reference:
Scene_Objects:['tablelamp', 'walllamp', 'food_butter', 'toothbrush', 'drawing', 'hanger', 'floor', 'ceiling', 'bookshelf', 'ceilinglamp', 'mousepad', 'closetdrawer', 'oil', 'microphone', 'pillow', 'dining_room', 'broom', 'wall', 'nightstand', 'powersocket', 'bed', 'photoframe', 'razor', 'television', 'doorjamb', 'kettle', 'mouse', 'dresser', 'door', 'light']
Task:Turn off light
response:
{
    "thoughts": Hit the switch.,
    "actions": ['[WALK] <bedroom>', '[WALK] <light>', '[SWITCHOFF] <light>']
}

Input:
Scene_Objects:['beer', 'measuring_cup', 'orchid', 'hanger', 'floor', 'ceiling', 'phone', 'tea_bag', 'keyboard', 'purse', 'computer', 'mat', 'ceilinglamp', 'shower', 'mousepad', 'closetdrawer', 'wall', 'nightstand', 'novel', 'food_food', 'television', 'doorjamb', 'coffee_pot', 'vacuum_cleaner', 'dresser', 'hairbrush', 'door', 'napkin', 'home_office', 'board_game']
Task:Sweep hallway please
response:

Vacuum all the way up and down the hallway.  Get all the dirt and crumbs out of carpet please.

[WALK] <home_office>
[WALK] <dresser>
[OPEN] <dresser>
[FIND] <vacuum_cleaner>
[GRAB] <vacuum_cleaner>
[PULL] <vacuum_cleaner>
[PLUGIN] <vacuum_cleaner>
[SWITCHON] <vacuum_cleaner>
[PULL] <vacuum_cleaner>
[PUSH] <vacuum_cleaner>
[PULL] <vacuum_cleaner>
[PUSH] <vacuum_cleaner>
[PULL] <vacuum_cleaner>
[PUSH] <vacuum_cleaner>
[SWITCHOFF] <vacuum_cleaner>
[PLUGOUT] <vacuum_cleaner>
[WALK] <dresser>
[PUTIN] <vacuum_cleaner> <dresser>
[CLOSE] <dresser>


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', 'toilet', 'dog', 'band-aids', 'walllamp', 'ground_coffee', 'food_carrot', 'drawing', 'bathroom_counter', 'floor', 'phone', 'food_cake', 'computer', 'toaster', 'mat', 'faucet', 'window', 'couch', 'candle', 'pillow', 'wall', 'television', 'curtain', 'doorjamb', 'towel_rack', 'dresser', 'bathroom_cabinet', 'table', 'light', 'scrabble']
Task:Relax on sofa
response:
{
    "thoughts": I walk to the living room and stand in front of the sofa. Then I turn and sit on the sofa and lean my back against the pillow and my feet on the floor.,
    "actions": ['[WALK] <home_office>', '[WALK] <couch>', '[FIND] <couch>', '[TURNTO] <couch>', '[SIT] <couch>']
}

Input:
Scene_Objects:['dry_pasta', 'sponge', 'filing_cabinet', 'measuring_cup', 'bathroom', 'trashcan', 'food_carrot', 'cpuscreen', 'character', 'computer', 'floor_lamp', 'closetdrawer', 'couch', 'food_peanut_butter', 'food_kiwi', 'oven', 'cup', 'bed', 'video_game_controller', 'doorjamb', 'coffee_pot', 'paper_towel', 'dishrack', 'headset', 'hair', 'cupboard', 'spoon', 'bathroom_cabinet', 'table', 'tooth_paste']
Task:Clean
response:

[WALK] <home_office>
[WALK] <paper_towel>
[FIND] <paper_towel>
[GRAB] <paper_towel>
[WALK] <floor_lamp>
[WIPE] <floor_lamp>
[FIND] <trashcan>
[PUTBACK] <paper_towel> <trashcan>
[FIND] <paper_towel>
[GRAB] <paper_towel>
[WALK] <floor_lamp>
[WIPE] <floor_lamp>
[PUTBACK] <paper_towel> <trashcan>


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', 'jelly', 'freezer', 'chair', 'blow_dryer', 'bathroom', 'walllamp', 'knife', 'phone', 'keyboard', 'stovefan', 'homework', 'couch', 'food_jam', 'bench', 'oven', 'toy', 'box', 'food_cheese', 'oven_mitts', 'food_rice', 'tray', 'curtain', 'after_shave', 'dresser', 'clothes_dress', 'conditioner', 'hairdryer', 'vase', 'board_game']
Task:Pet cat
response:
{
    "thoughts": I walk to my living room, find my cat, scrub it using my hand.,
    "actions": ['[WALK] <home_office>', '[WALK] <cat>', '[FIND] <cat>', '[SCRUB] <cat>']
}

Input:
Scene_Objects:['spectacles', 'walllamp', 'bathroom', 'blow_dryer', 'orchid', 'hanger', 'floor', 'ceiling', 'character', 'computer', 'mat', 'mousepad', 'closetdrawer', 'food_orange', 'dining_room', 'wall', 'nightstand', 'basket_for_clothes', 'coffe_maker', 'television', 'tray', 'doorjamb', 'towel_rack', 'mouse', 'kitchen_counter', 'vacuum_cleaner', 'dresser', 'light', 'clothes_skirt', 'laser_pointer']
Task:Vacuum
response:

Plug in the vacuum. Turn it on. Push it back and forth across the floor until all the debris is gone.

[WALK] <home_office>
[WALK] <dresser>
[OPEN] <dresser>
[FIND] <vacuum_cleaner>
[GRAB] <vacuum_cleaner>
[PULL] <vacuum_cleaner>
[PLUGIN] <vacuum_cleaner>
[SWITCHON] <vacuum_cleaner>
[PULL] <vacuum_cleaner>
[PUSH] <vacuum_cleaner>
[PULL] <vacuum_cleaner>
[PUSH] <vacuum_cleaner>
[PULL] <vacuum_cleaner>
[PUSH] <vacuum_cleaner>
[SWITCHOFF] <vacuum_cleaner>
[PLUGOUT] <vacuum_cleaner>
[WALK] <dresser>
[PUTIN] <vacuum_cleaner> <dresser>
[CLOSE] <dresser>


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', 'nail_polish', 'trashcan', 'milk', 'drawing', 'wallshelf', 'bathroom_counter', 'ceiling', 'phone', 'bedroom', 'bookshelf', 'computer', 'faucet', 'pillow', 'wall', 'photoframe', 'toilet_paper', 'check', 'coffe_maker', 'wine', 'after_shave', 'towel_rack', 'comb', 'controller', 'sink', 'bathroom_cabinet', 'light', 'table', 'instrument_violin', 'teeth']
Task:Get toilet paper
response:
{
    "thoughts": There are extra toilet papers in the bottom cabinet.,
    "actions": ['[WALK] <bathroom>', '[WALK] <bathroom_cabinet>', '[FIND] <bathroom_cabinet>', '[OPEN] <bathroom_cabinet>', '[FIND] <toilet_paper>', '[GRAB] <toilet_paper>', '[CLOSE] <bathroom_cabinet>']
}

Input:
Scene_Objects:['pot', 'filing_cabinet', 'tablelamp', 'bathroom', 'drawing', 'orchid', 'floor', 'bookshelf', 'mat', 'tvstand', 'shower', 'oil', 'closetdrawer', 'candle', 'pillow', 'dining_room', 'wall', 'nightstand', 'powersocket', 'cup', 'bed', 'photoframe', 'tray', 'doorjamb', 'pencil', 'cupboard', 'door', 'home_office', 'light', 'soap']
Task:Read book
response:

[WALK] <bedroom>
[WALK] <novel>
[FIND] <novel>
[GRAB] <novel>
[WALK] <bed>
[LIE] <bed>
[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:['chair', 'drawing', 'hanger', 'floor', 'ceiling', 'phone', 'computer', 'ceilinglamp', 'stereo', 'balanceball', 'window', 'clothes_socks', 'food_noodles', 'couch', 'wall', 'oven', 'tape', 'check', 'television', 'doorjamb', 'mouse', 'pencil', 'cd', 'dresser', 'cupboard', 'door', 'clothes_scarf', 'light', 'table', 'instrument_violin']
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:['tablelamp', 'chair', 'walllamp', 'bathroom', 'orchid', 'cpuscreen', 'wallshelf', 'hanger', 'clothes_underwear', 'floor', 'ceiling', 'phone', 'desk', 'keyboard', 'computer', 'ceilinglamp', 'tvstand', 'mat', 'mousepad', 'couch', 'pillow', 'wall', 'nightstand', 'check', 'television', 'doorjamb', 'mouse', 'dresser', 'door', 'light']
Task:Research
response:

I read different articles online to gain a better understanding of a particular business, industry, method, terminology, etc.

[WALK] <home_office>
[WALK] <computer>
[FIND] <computer>
[SWITCHON] <computer>
[TURNTO] <computer>
[LOOKAT] <computer>
[FIND] <check>
[GRAB] <check>
[READ] <check>


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

Here is an example plan to achieve a goal for reference:
Scene_Objects:['fork', 'tablelamp', 'food_ice_cream', 'walllamp', 'bathroom', 'ceilingfan', 'trashcan', 'woman', 'drawing', 'orchid', 'food_egg', 'bathroom_counter', 'floor', 'bedroom', 'man', 'ceilinglamp', 'window', 'couch', 'wall', 'bench', 'cup', 'newspaper', 'novel', 'check', 'television', 'towel_rack', 'clothes_dress', 'table', 'clothes_skirt', 'creditcard']
Task:Hang with friends
response:
{
    "thoughts": Sit with friends. Talk,
    "actions": ['[WALK] <home_office>', '[WALK] <man>', '[FIND] <man>', '[TURNTO] <man>', '[LOOKAT] <man>', '[GREET] <man>', '[FIND] <woman>', '[TURNTO] <woman>', '[LOOKAT] <woman>', '[GREET] <woman>', '[WALK] <couch>', '[SIT] <couch>', '[TURNTO] <man>', '[LOOKAT] <man>', '[GREET] <man>', '[TURNTO] <woman>', '[LOOKAT] <woman>', '[GREET] <woman>']
}

Input:
Scene_Objects:['tablelamp', 'chair', 'walllamp', 'orchid', 'drawing', 'cpuscreen', 'wallshelf', 'hanger', 'floor', 'ceiling', 'phone', 'desk', 'keyboard', 'computer', 'ceilinglamp', 'tvstand', 'mat', 'mousepad', 'couch', 'pillow', 'wall', 'nightstand', 'television', 'fax_machine', 'doorjamb', 'mouse', 'dresser', 'door', 'teeth', 'printing_paper']
Task:Print out papers
response:

Turn on printer and fill with blank paper. Use computer to click on printing option. Take printed page out of print.


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', 'crayon', 'dog', 'freezer', 'knife', 'orchid', 'bathroom_counter', 'character', 'bedroom', 'faucet', 'couch', 'food_orange', 'towel', 'nightstand', 'oven', 'powersocket', 'photoframe', 'check', 'video_game_controller', 'food_donut', 'food_rice', 'food_onion', 'diary', 'dresser', 'hairbrush', 'clothes_scarf', 'napkin', 'bathroom_cabinet', 'colander']
Task:Pet cat
response:
{
    "thoughts": Walk into the living room. Walk up to the cat. Pet the cat with your hand.,
    "actions": ['[WALK] <home_office>', '[WALK] <cat>', '[FIND] <cat>', '[TOUCH] <cat>']
}

Input:
Scene_Objects:['sheets', 'chair', 'walllamp', 'drawing', 'wallshelf', 'cpuscreen', 'hanger', 'bathroom_counter', 'floor', 'ceiling', 'desk', 'keyboard', 'remote_control', 'computer', 'mat', 'tvstand', 'ceilinglamp', 'shower', 'oil', 'closetdrawer', 'couch', 'pillow', 'wall', 'love_seat', 'photoframe', 'television', 'doorjamb', 'dresser', 'door', 'clothes_scarf']
Task:Watch TV
response:

[WALK] <home_office>
[WALK] <remote_control>
[FIND] <remote_control>
[GRAB] <remote_control>
[FIND] <love_seat>
[SIT] <love_seat>
[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:['fork', 'tablelamp', 'crayon', 'microwave', 'drawing', 'bills', 'cpuscreen', 'longboard', 'floor', 'bookshelf', 'computer', 'button', 'table_cloth', 'toaster', 'ceilinglamp', 'faucet', 'window', 'oil', 'couch', 'food_jam', 'food_orange', 'wall', 'bench', 'mouthwash', 'television', 'cupboard', 'table', 'clothes_skirt', 'light', 'tooth_paste']
Task:Relax on sofa
response:
{
    "thoughts": walk into living room, look at the sofa which one is available, sit on the sofa, now take relax on the sofa,
    "actions": ['[WALK] <home_office>', '[WALK] <couch>', '[FIND] <couch>', '[TURNTO] <couch>', '[LOOKAT] <couch>', '[SIT] <couch>']
}

Input:
Scene_Objects:['filing_cabinet', 'blender', 'food_ice_cream', 'toilet', 'walllamp', 'detergent', 'drawing', 'orchid', 'wallshelf', 'floor', 'ceiling', 'computer', 'toaster', 'mat', 'tvstand', 'laptop', 'ceilinglamp', 'brush', 'couch', 'pillow', 'dining_room', 'wall', 'child', 'oven', 'photoframe', 'bed', 'television', 'doorjamb', 'mouse', 'dishwasher']
Task:Let baby learn how to walk
response:

The baby tries to stand up and balances on the couch and there are no sharp edges so it's safe.

[WALK] <home_office>
[WALK] <child>
[FIND] <child>
[TOUCH] <child>
[GREET] <child>
[FIND] <couch>
[TURNTO] <couch>
[POINTAT] <couch>
[TURNTO] <child>
[LOOKAT] <child>


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', 'food_pizza', 'filing_cabinet', 'tablelamp', 'freezer', 'nail_polish', 'cpuscreen', 'desk', 'bookshelf', 'keyboard', 'alcohol', 'computer', 'stovefan', 'ceilinglamp', 'shower', 'mousepad', 'wall', 'wall_clock', 'bed', 'coffe_maker', 'mouthwash', 'video_game_controller', 'television', 'razor', 'check', 'tray', 'curtain', 'cd', 'spoon', 'vase']
Task:Pet cat
response:
{
    "thoughts": Walk to living room. Find the cat. Walk over to the cat. Touch the cat.,
    "actions": ['[WALK] <home_office>', '[WALK] <cat>', '[FIND] <cat>', '[WALK] <cat>', '[TOUCH] <cat>']
}

Input:
Scene_Objects:['pot', 'microwave', 'toilet', 'chair', 'detergent', 'food_butter', 'toothbrush', 'drawing', 'floor', 'ceiling', 'toaster', 'mat', 'plate', 'faucet', 'shower', 'dish_soap', 'wall', 'nightstand', 'cup', 'coffe_maker', 'coffee_filter', 'drinking_glass', 'tray', 'wooden_spoon', 'kitchen_counter', 'cupboard', 'sink', 'coffee_cup', 'dishwasher', 'shoe_rack']
Task:Clean dishes
response:

Wash dishes in the sink then place them in the dishwasher. Put detergent in the dishwasher and turn it on when full.

[WALK] <dining_room>
[WALK] <sink>
[FIND] <faucet>
[SWITCHON] <faucet>
[FIND] <dish_soap>
[GRAB] <dish_soap>
[FIND] <drinking_glass>
[WASH] <drinking_glass>
[FIND] <coffee_cup>
[WASH] <coffee_cup>
[FIND] <plate>
[WASH] <plate>
[GRAB] <coffee_cup>
[PUTBACK] <coffee_cup> <plate>
[FIND] <dishwasher>
[OPEN] <dishwasher>
[GRAB] <drinking_glass>
[PUTBACK] <drinking_glass> <dishwasher>
[GRAB] <plate>
[PUTBACK] <plate> <dishwasher>
[FIND] <detergent>
[GRAB] <detergent>
[PUTBACK] <detergent> <dishwasher>
[CLOSE] <dishwasher>
[SWITCHON] <dishwasher>


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

Here is an example plan to achieve a goal for reference:
Scene_Objects:['microwave', 'chair', 'freezer', 'ground_coffee', 'walllamp', 'trashcan', 'cpuscreen', 'bathroom_counter', 'floor', 'ceiling', 'character', 'food_bacon', 'toaster', 'tvstand', 'window', 'oil', 'couch', 'wall', 'nightstand', 'newspaper', 'coffe_maker', 'television', 'coffee_filter', 'water', 'food_donut', 'kitchen_counter', 'cupboard', 'bathroom_cabinet', 'dishwasher', 'dirt']
Task:Make coffee
response:
{
    "thoughts": Walk to Kitchen and find coffee maker, find coffee filter and place it in coffee maker. Find ground coffee and water. put both in coffee maker. Close the coffee maker and switch it on.,
    "actions": ['[WALK] <dining_room>', '[WALK] <coffe_maker>', '[FIND] <coffe_maker>', '[OPEN] <coffe_maker>', '[FIND] <coffee_filter>', '[GRAB] <coffee_filter>', '[PUTBACK] <coffee_filter> <coffe_maker>', '[FIND] <ground_coffee>', '[GRAB] <ground_coffee>', '[PUTBACK] <ground_coffee> <coffe_maker>', '[WALK] <water>', '[FIND] <water>', '[GRAB] <water>', '[POUR] <water> <coffe_maker>', '[CLOSE] <coffe_maker>', '[SWITCHON] <coffe_maker>']
}

Input:
Scene_Objects:['food_bread', 'filing_cabinet', 'tablelamp', 'walllamp', 'drawing', 'wallshelf', 'floor', 'ceiling', 'bedroom', 'computer', 'toaster', 'mat', 'tvstand', 'shower', 'ceilinglamp', 'floor_lamp', 'stereo', 'closetdrawer', 'couch', 'pillow', 'broom', 'wall', 'oven', 'photoframe', 'novel', 'television', 'doorjamb', 'dresser', 'cupboard', 'light']
Task:Read book
response:

A person brings a book into the living room and sits down in a comfortable chair.  If it is dark in the room the person turns on the lamp. The book is opened to the next page to be read.  The person begins reading the book until they need to stop for some reason.

[WALK] <home_office>
[WALK] <novel>
[FIND] <novel>
[GRAB] <novel>
[FIND] <couch>
[SIT] <couch>
[FIND] <floor_lamp>
[SWITCHON] <floor_lamp>
[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:['sheets', 'pot', 'filing_cabinet', 'tea', 'chair', 'freezer', 'ground_coffee', 'drawing', 'orchid', 'floor', 'purse', 'faucet', 'balanceball', 'food_noodles', 'food_peanut_butter', 'wall', 'powersocket', 'toy', 'bed', 'food_food', 'check', 'food_donut', 'doorjamb', 'pencil', 'laundry_detergent', 'door', 'bag', 'napkin', 'light', 'table']
Task:Pick up toys
response:
{
    "thoughts": Grab toys off floor.  Put it in a container.,
    "actions": ['[WALK] <bedroom>', '[WALK] <toy>', '[FIND] <toy>', '[GRAB] <toy>', '[WALK] <filing_cabinet>', '[OPEN] <filing_cabinet>', '[PUTBACK] <toy> <filing_cabinet>', '[FIND] <toy>', '[GRAB] <toy>', '[WALK] <filing_cabinet>', '[PUTBACK] <toy> <filing_cabinet>', '[FIND] <toy>', '[GRAB] <toy>', '[WALK] <filing_cabinet>', '[PUTBACK] <toy> <filing_cabinet>', '[CLOSE] <filing_cabinet>']
}

Input:
Scene_Objects:['tablelamp', 'chair', 'orchid', 'drawing', 'cpuscreen', 'bathroom_counter', 'floor', 'ceiling', 'desk', 'keyboard', 'computer', 'mat', 'ceilinglamp', 'tvstand', 'mousepad', 'dining_room', 'wall', 'nightstand', 'feet_both', 'photoframe', 'bed', 'television', 'coin', 'curtain', 'towel_rack', 'mouse', 'kitchen_counter', 'shoes', 'hairbrush', 'door']
Task:Put on your shoes
response:

Sit on a chair with your shoes in front of you.  Put them on one at a time.

[WALK] <home_office>
[WALK] <shoes>
[FIND] <shoes>
[GRAB] <shoes>
[FIND] <chair>
[SIT] <chair>
[FIND] <feet_both>
[PUTBACK] <shoes> <feet_both>


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

Here is an example plan to achieve a goal for reference:
Scene_Objects:['filing_cabinet', 'microwave', 'toilet', 'jelly', 'freezer', 'bathroom', 'drawing', 'orchid', 'character', 'folder', 'keyboard', 'mop_bucket', 'stovefan', 'faucet', 'food_noodles', 'couch', 'clothes_hat', 'towel', 'nightstand', 'powersocket', 'rag', 'towel_rack', 'pencil', 'kitchen_counter', 'cupboard', 'pajamas', 'bathroom_cabinet', 'table', 'dishwasher', 'soap']
Task:Wash hands
response:
{
    "thoughts": I walk to the kitchen and get the soap and wash my both hand using the soap and rinse my hands and use towel.,
    "actions": ['[WALK] <dining_room>', '[WALK] <soap>', '[FIND] <soap>', '[GRAB] <soap>', '[SCRUB] <soap>', '[FIND] <towel>', '[RINSE] <towel>']
}

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

A person at a computer desk with coffee on the side by the keyboard typing up a document. The person looks relaxed and is typing while looking at the screen which shows a text editor and the content the person was typing.

[WALK] <home_office>
[WALK] <chair>
[FIND] <chair>
[SIT] <chair>
[FIND] <computer>
[SWITCHON] <computer>
[TURNTO] <computer>
[LOOKAT] <computer>
[FIND] <check>
[GRAB] <check>
[READ] <check>
[FIND] <coffee_cup>
[GRAB] <coffee_cup>
[DRINK] <coffee_cup>
[PUTOBJBACK] <coffee_cup>
[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:['fork', 'tablelamp', 'chair', 'freezer', 'drawing', 'knifeblock', 'cpuscreen', 'needle', 'floor', 'ceiling', 'desk', 'stamp', 'keyboard', 'computer', 'brush', 'mousepad', 'wall', 'nightstand', 'bed', 'photoframe', 'check', 'food_food', 'doorjamb', 'mouse', 'kitchen_counter', 'headset', 'door', 'table', 'light', 'shoe_rack']
Task:Listen to music
response:
{
    "thoughts": I'll walk to my bedroom, where I have my computer. I'll walk to my computer and sit down in front of it. I'll put on my headphones and unlock my computer. I'll then navigate to music stored locally or streamed through the web.,
    "actions": ['[WALK] <bedroom>', '[WALK] <computer>', '[FIND] <computer>', '[TURNTO] <computer>', '[LOOKAT] <computer>', '[WALK] <computer>', '[FIND] <chair>', '[PULL] <chair>', '[SIT] <chair>', '[FIND] <headset>', '[GRAB] <headset>', '[PUTON] <headset>', '[SWITCHON] <computer>', '[FIND] <keyboard>', '[TYPE] <keyboard>']
}

Input:
Scene_Objects:['dry_pasta', 'pot', 'tablelamp', 'microwave', 'chair', 'freezer', 'orchid', 'drawing', 'floor', 'ceiling', 'phone', 'toaster', 'mat', 'ceilinglamp', 'faucet', 'stovefan', 'shower', 'food_peanut_butter', 'wall', 'powersocket', 'oven', 'cup', 'coffe_maker', 'tray', 'doorjamb', 'coffee_pot', 'towel_rack', 'kitchen_counter', 'cupboard', 'door', 'sink', 'table', 'dishwasher', 'light']
Task:Wipe down counter
response:

[WALK] <dining_room>
[WALK] <rag>
[FIND] <rag>
[GRAB] <rag>
[WALK] <sink>
[FIND] <faucet>
[SWITCHON] <faucet>
[RINSE] <rag>
[SQUEEZE] <rag>
[SWITCHOFF] <faucet>
[WALK] <kitchen_counter>
[WIPE] <kitchen_counter>


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

Here is an example plan to achieve a goal for reference:
Scene_Objects:['fork', 'food_bread', 'filing_cabinet', 'tablelamp', 'freezer', 'walllamp', 'trashcan', 'milk', 'knifeblock', 'bills', 'floor', 'ceiling', 'character', 'food_cake', 'piano_bench', 'brush', 'ceilinglamp', 'mousepad', 'towel', 'wall', 'bed', 'food_food', 'food_donut', 'ice', 'curtain', 'kettle', 'dresser', 'light', 'soap', 'coffee']
Task:Put groceries in Fridge
response:
{
    "thoughts": Open the fridge, put the groceries in the fridge and close it.,
    "actions": ['[WALK] <dining_room>', '[WALK] <freezer>', '[FIND] <freezer>', '[OPEN] <freezer>', '[FIND] <food_food>', '[GRAB] <food_food>', '[PUTIN] <food_food> <freezer>', '[CLOSE] <freezer>']
}

Input:
Scene_Objects:['pot', 'tablelamp', 'toilet', 'chair', 'walllamp', 'drawing', 'orchid', 'cpuscreen', 'floor', 'ceiling', 'desk', 'keyboard', 'food_cake', 'computer', 'food_bacon', 'mat', 'ceilinglamp', 'tvstand', 'shower', 'deck_of_cards', 'mousepad', 'couch', 'wall', 'nightstand', 'newspaper', 'television', 'mouse', 'door', 'sink', 'home_office']
Task:Read newspaper
response:

Sit in my chair at my desk. Open up newspaper. Read about current events.

[WALK] <home_office>
[WALK] <chair>
[FIND] <chair>
[SIT] <chair>
[FIND] <newspaper>
[GRAB] <newspaper>
[OPEN] <newspaper>
[READ] <newspaper>


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', 'toothbrush', 'cpuscreen', 'clothes_underwear', 'wallshelf', 'floor', 'phone', 'ceiling', 'character', 'bookshelf', 'computer', 'button', 'pillow', 'dining_room', 'bench', 'food_food', 'television', 'tray', 'curtain', 'doorjamb', 'towel_rack', 'mouse', 'cd', 'dresser', 'cupboard', 'pajamas', 'clothes_dress', 'sink', 'home_office', 'laser_pointer']
Task:Browse internet
response:
{
    "thoughts": Walk to home office. Walk to computer. Switch on Computer.,
    "actions": ['[WALK] <home_office>', '[WALK] <computer>', '[SWITCHON] <computer>']
}

Input:
Scene_Objects:['tablelamp', 'chair', 'bathroom', 'milk', 'drawing', 'orchid', 'cpuscreen', 'wallshelf', 'floor', 'ceiling', 'desk', 'keyboard', 'computer', 'mat', 'ceilinglamp', 'tvstand', 'mousepad', 'oil', 'pillow', 'wall', 'nightstand', 'pasta', 'newspaper', 'television', 'towel_rack', 'mouse', 'headset', 'chessboard', 'door', 'sink']
Task:Read news
response:

[WALK] <home_office>
[WALK] <chair>
[FIND] <chair>
[SIT] <chair>
[FIND] <newspaper>
[GRAB] <newspaper>
[READ] <newspaper>


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

Here is an example plan to achieve a goal for reference:
Scene_Objects:['pot', 'filing_cabinet', 'measuring_cup', 'mop', 'microwave', 'toilet', 'bathroom', 'drawing', 'orchid', 'floor', 'ceiling', 'bedroom', 'computer', 'piano_bench', 'ceilinglamp', 'plate', 'deck_of_cards', 'mat', 'mousepad', 'couch', 'pillow', 'wall', 'bed', 'novel', 'television', 'doorjamb', 'door', 'coffee_cup', 'table', 'light']
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:['jelly', 'walllamp', 'drawing', 'wallshelf', 'floor', 'ceiling', 'bedroom', 'keyboard', 'bookshelf', 'envelope', 'computer', 'toaster', 'mat', 'tvstand', 'shower', 'mousepad', 'closetdrawer', 'couch', 'pillow', 'wall', 'newspaper', 'photoframe', 'check', 'television', 'doorjamb', 'hairbrush', 'pajamas', 'table', 'clothes_shirt', 'dirt']
Task:Read newspaper
response:

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


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', 'toilet', 'freezer', 'walllamp', 'bathroom', 'knifeblock', 'wallshelf', 'cpuscreen', 'floor', 'phone', 'character', 'desk', 'food_cake', 'toaster', 'ceilinglamp', 'couch', 'pillow', 'powersocket', 'basket_for_clothes', 'cup', 'newspaper', 'food_food', 'check', 'oven_mitts', 'wooden_spoon', 'centerpiece', 'kitchen_counter', 'door', 'light']
Task:Pick up phone
response:
{
    "thoughts": I walk to the home office, find where the phone is and lift the reciever.,
    "actions": ['[WALK] <home_office>', '[WALK] <phone>', '[FIND] <phone>', '[GRAB] <phone>']
}

Input:
Scene_Objects:['glue', 'filing_cabinet', 'tea', 'walllamp', 'bathroom', 'drawing', 'orchid', 'wallshelf', 'clothes_underwear', 'food_egg', 'floor', 'ceiling', 'bedroom', 'keyboard', 'computer', 'bookmark', 'mat', 'tvstand', 'couch', 'pillow', 'wall', 'cup', 'photoframe', 'bed', 'toilet_paper', 'television', 'doorjamb', 'dresser', 'light', 'creditcard']
Task:Read book
response:

Pick up a book and open to the last page you were on. Read the book.

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


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

Here is an example plan to achieve a goal for reference:
Scene_Objects:['tablelamp', 'toilet', 'chair', 'walllamp', 'trashcan', 'ceilingfan', 'drawing', 'cpuscreen', 'hanger', 'floor', 'ceiling', 'phone', 'desk', 'keyboard', 'bookshelf', 'computer', 'ceilinglamp', 'balanceball', 'mousepad', 'oil', 'wall', 'nightstand', 'photoframe', 'doorjamb', 'mouse', 'dresser', 'cupboard', 'clothes_dress', 'door', 'light']
Task:Browse internet
response:
{
    "thoughts": I want to surf the internet and look around at funny pictures.,
    "actions": ['[WALK] <home_office>', '[WALK] <light>', '[FIND] <light>', '[SWITCHON] <light>', '[FIND] <keyboard>', '[GRAB] <keyboard>', '[FIND] <desk>', '[OPEN] <desk>', '[PUTBACK] <keyboard> <desk>', '[FIND] <mouse>', '[GRAB] <mouse>', '[FIND] <mousepad>', '[PUTBACK] <mouse> <mousepad>', '[PLUGIN] <keyboard>', '[PLUGIN] <mouse>', '[FIND] <computer>', '[SWITCHON] <computer>', '[FIND] <chair>', '[SIT] <chair>', '[TURNTO] <computer>', '[LOOKAT] <computer>', '[GRAB] <mouse>', '[TOUCH] <mouse>', '[TYPE] <keyboard>', '[TURNTO] <computer>', '[LOOKAT] <computer>']
}

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

I log onto my computer and then go to the e-mail app, I click on each new email and read them

[WALK] <home_office>
[WALK] <chair>
[FIND] <chair>
[SIT] <chair>
[FIND] <computer>
[SWITCHON] <computer>
[TURNTO] <computer>
[LOOKAT] <computer>
[FIND] <mail>
[GRAB] <mail>
[READ] <mail>


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

Here is an example plan to achieve a goal for reference:
Scene_Objects:['microwave', 'toilet', 'detergent', 'food_butter', 'dough', 'orchid', 'drawing', 'bathroom_counter', 'floor', 'ceiling', 'purse', 'faucet', 'stereo', 'picture', 'dustpan', 'bowl', 'dining_room', 'wall', 'oven', 'powersocket', 'photoframe', 'wine', 'tray', 'console', 'pencil', 'sink', 'bathroom_cabinet', 'dishwasher', 'hands_both', 'shoe_rack']
Task:Wash hands
response:
{
    "thoughts": I go to the bathroom, walk to the sink, turn on the faucet and then wash my hands under the water.,
    "actions": ['[WALK] <bathroom>', '[WALK] <sink>', '[FIND] <faucet>', '[TURNTO] <faucet>', '[FIND] <hands_both>', '[WASH] <hands_both>']
}

Input:
Scene_Objects:['chair', 'walllamp', 'woman', 'toothbrush', 'drawing', 'wallshelf', 'hanger', 'floor', 'ceiling', 'desk', 'stamp', 'bookshelf', 'computer', 'mat', 'tvstand', 'ceilinglamp', 'stereo', 'closetdrawer', 'couch', 'pillow', 'wall', 'child', 'box', 'photoframe', 'television', 'oven_mitts', 'doorjamb', 'cd', 'dresser', 'table']
Task:Watch movie
response:

Sitting and watching  a movie with family

[WALK] <home_office>
[WALK] <child>
[FIND] <child>
[TURNTO] <child>
[LOOKAT] <child>
[GREET] <child>
[FIND] <woman>
[TURNTO] <woman>
[LOOKAT] <woman>
[GREET] <woman>
[WALK] <television>
[SWITCHON] <television>
[TURNTO] <television>
[LOOKAT] <television>
[TOUCH] <television>
[TURNTO] <television>
[LOOKAT] <television>
[TOUCH] <television>
[TURNTO] <television>
[LOOKAT] <television>
[TOUCH] <television>
[WALK] <couch>
[SIT] <couch>
[TURNTO] <television>
[LOOKAT] <television>
[WATCH] <television>
[WATCH] <television>
[WATCH] <television>


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', 'trashcan', 'ceilingfan', 'drawing', 'cpuscreen', 'floor', 'ceiling', 'phone', 'desk', 'keyboard', 'bookshelf', 'computer', 'ceilinglamp', 'balanceball', 'mousepad', 'dustpan', 'dining_room', 'wall', 'nightstand', 'pasta', 'tape', 'photoframe', 'tray', 'rag', 'doorjamb', 'towel_rack', 'mouse', 'bathroom_cabinet', 'light']
Task:Turn on computer
response:
{
    "thoughts": Press the power button on the computer to turn it on,
    "actions": ['[WALK] <home_office>', '[WALK] <computer>', '[SWITCHON] <computer>']
}

Input:
Scene_Objects:['filing_cabinet', 'tablelamp', 'freezer', 'orchid', 'floor', 'bedroom', 'keyboard', 'stovefan', 'stereo', 'shower', 'closetdrawer', 'couch', 'dining_room', 'tape', 'cup', 'bed', 'novel', 'television', 'toothbrush_holder', 'doorjamb', 'mouse', 'kitchen_counter', 'chessboard', 'cupboard', 'door', 'spoon', 'instrument_guitar', 'table', 'clothes_shirt', 'shoe_rack']
Task:Look out window
response:

I head into my child's room and look out the window to view the neighborhood from a different area in the house.

[WALK] <bedroom>
[WALK] <window>
[TURNTO] <window>
[LOOKAT] <window>


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

Here is an example plan to achieve a goal for reference:
Scene_Objects:['spectacles', 'food_bread', 'crayon', 'measuring_cup', 'chair', 'walllamp', 'trashcan', 'bedroom', 'bookshelf', 'purse', 'table_cloth', 'faucet', 'clothes_socks', 'pillow', 'wall', 'oven', 'newspaper', 'photoframe', 'coffe_maker', 'food_food', 'check', 'coffee_filter', 'shaving_cream', 'pencil', 'headset', 'dishrack', 'comb', 'dresser', 'spoon', 'instrument_guitar']
Task:Turn on light
response:
{
    "thoughts": walk to living room, find lamp, switch on.,
    "actions": ['[WALK] <home_office>', '[WALK] <floor_lamp>', '[FIND] <floor_lamp>']
}

Input:
Scene_Objects:['scissors', 'tablelamp', 'drawing', 'wallshelf', 'hanger', 'floor', 'ceiling', 'bookshelf', 'alcohol', 'mat', 'tvstand', 'stereo', 'closetdrawer', 'couch', 'clothes_pants', 'food_jam', 'pillow', 'microphone', 'dining_room', 'wall', 'powersocket', 'photoframe', 'television', 'doorjamb', 'dresser', 'door', 'hairdryer', 'light', 'instrument_violin', 'clothes_shirt']
Task:Getting  dresses
response:

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


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

Here is an example plan to achieve a goal for reference:
Scene_Objects:['juice', 'food_ice_cream', 'blow_dryer', 'detergent', 'ceilingfan', 'drawing', 'hanger', 'longboard', 'floor', 'ceiling', 'phone', 'bedroom', 'keyboard', 'remote_control', 'ceilinglamp', 'tvstand', 'balanceball', 'faucet', 'window', 'shoe-shine_kit', 'couch', 'food_orange', 'wall', 'tape', 'television', 'curtain', 'kitchen_counter', 'conditioner', 'bathroom_cabinet', 'table']
Task:Relax on sofa
response:
{
    "thoughts": For relaxing walk to living room. Find the sofa to relax. Arrange the sofa to relax. Sit on the sofa to relaxing.,
    "actions": ['[WALK] <home_office>', '[WALK] <couch>', '[FIND] <couch>', '[FIND] <conditioner>', '[FIND] <remote_control>', '[FIND] <television>', '[SWITCHON] <television>', '[LIE] <couch>']
}

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

Sit at my computer desk, Turn on Computer. Get online. Work.

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


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

Here is an example plan to achieve a goal for reference:
Scene_Objects:['walllamp', 'ceilingfan', 'drawing', 'needle', 'cpuscreen', 'hanger', 'bathroom_counter', 'floor', 'ceiling', 'bookshelf', 'remote_control', 'ceilinglamp', 'tvstand', 'balanceball', 'window', 'homework', 'clothes_socks', 'couch', 'pillow', 'wall', 'powersocket', 'food_cheese', 'bed', 'television', 'wooden_spoon', 'curtain', 'doorjamb', 'bathroom_cabinet', 'table', 'laser_pointer']
Task:Watch TV
response:
{
    "thoughts": Walk into the living room. Sit down on the sofa. Pick up the remote control. Turn on the television with the remote control. Put down the remote control. Watch the television.,
    "actions": ['[WALK] <home_office>', '[WALK] <couch>', '[SIT] <couch>', '[FIND] <remote_control>', '[GRAB] <remote_control>', '[FIND] <television>', '[SWITCHON] <television>', '[PUTOBJBACK] <remote_control>', '[TURNTO] <television>', '[WATCH] <television>']
}

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

I sit at my desk and work on the computer.

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


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

Here is an example plan to achieve a goal for reference:
Scene_Objects:['chair', 'band-aids', 'trashcan', 'dough', 'knifeblock', 'cpuscreen', 'hanger', 'floor', 'ceiling', 'shampoo', 'dvd_player', 'desk', 'bookshelf', 'keyboard', 'computer', 'stovefan', 'mat', 'tvstand', 'shower', 'mousepad', 'food_orange', 'wall', 'oven', 'keys', 'mouse', 'shoes', 'hair', 'dishwasher', 'vase', 'coffee']
Task:Read book
response:
{
    "thoughts": find a book to read. sit down. read the book.,
    "actions": ['[WALK] <home_office>', '[WALK] <novel>', '[FIND] <novel>', '[GRAB] <novel>', '[WALK] <chair>', '[SIT] <chair>', '[READ] <novel>']
}

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

Check my bills, on the computer, open the appropriate sites, pay my due bills

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


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

Here is an example plan to achieve a goal for reference:
Scene_Objects:['filing_cabinet', 'chair', 'walllamp', 'ground_coffee', 'nail_polish', 'orchid', 'drawing', 'cpuscreen', 'bathroom_counter', 'floor', 'ceiling', 'desk', 'keyboard', 'bookshelf', 'computer', 'alcohol', 'toaster', 'ceilinglamp', 'mat', 'faucet', 'stovefan', 'mousepad', 'oil', 'wall', 'bed', 'mouse', 'cupboard', 'door', 'hairdryer', 'table']
Task:Work
response:
{
    "thoughts": Go to office, find computer, switch on computer, type on keyboard, use mouse, switch off computer,
    "actions": ['[WALK] <home_office>', '[WALK] <computer>', '[FIND] <computer>', '[SWITCHON] <computer>', '[FIND] <keyboard>', '[TYPE] <keyboard>', '[FIND] <mouse>', '[PUSH] <mouse>', '[SWITCHOFF] <computer>']
}

Input:
Scene_Objects:['sheets', 'microwave', 'chair', 'walllamp', 'drawing', 'wallshelf', 'hanger', 'floor', 'ceiling', 'shampoo', 'desk', 'keyboard', 'computer', 'mat', 'tvstand', 'ceilinglamp', 'stereo', 'closetdrawer', 'couch', 'pillow', 'wall', 'child', 'photoframe', 'food_food', 'television', 'after_shave', 'doorjamb', 'dresser', 'sink', 'bathroom_cabinet']
Task:Watch TV
response:

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


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

Here is an example plan to achieve a goal for reference:
Scene_Objects:['walllamp', 'drawing', 'orchid', 'wallshelf', 'floor', 'ceiling', 'phone', 'bookshelf', 'remote_control', 'mat', 'tvstand', 'ceilinglamp', 'shower', 'window', 'couch', 'pillow', 'wall', 'powersocket', 'photoframe', 'coffee_table', 'television', 'wooden_spoon', 'curtain', 'doorjamb', 'centerpiece', 'door', 'bathroom_cabinet', 'table', 'light', 'board_game']
Task:Watch TV
response:
{
    "thoughts": 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.,
    "actions": ['[WALK] <home_office>', '[WALK] <couch>', '[FIND] <couch>', '[SIT] <couch>', '[FIND] <remote_control>', '[GRAB] <remote_control>', '[FIND] <television>', '[SWITCHON] <television>', '[FIND] <coffee_table>', '[PUTBACK] <remote_control> <coffee_table>', '[TURNTO] <television>', '[LOOKAT] <television>']
}

Input:
Scene_Objects:['filing_cabinet', 'microwave', 'chair', 'walllamp', 'drawing', 'wallshelf', 'floor', 'ceiling', 'bookshelf', 'computer', 'bookmark', 'stovefan', 'mat', 'tvstand', 'faucet', 'couch', 'food_jam', 'pillow', 'dining_room', 'wall', 'nightstand', 'photoframe', 'television', 'doorjamb', 'coffee_pot', 'dresser', 'bathroom_cabinet', 'dishwasher', 'laser_pointer', 'shoe_rack']
Task:Read book
response:

[WALK] <home_office>
[WALK] <novel>
[GRAB] <novel>
[WALK] <couch>
[LIE] <couch>
[READ] <novel>


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

Here is an example plan to achieve a goal for reference:
Scene_Objects:['pot', 'filing_cabinet', 'tablelamp', 'microwave', 'freezer', 'detergent', 'drawing', 'floor', 'ceiling', 'stamp', 'bedroom', 'thread', 'computer', 'toaster', 'faucet', 'mousepad', 'food_peanut_butter', 'wall', 'powersocket', 'toy', 'cup', 'newspaper', 'doorjamb', 'chessboard', 'comb', 'door', 'sink', 'bag', 'light', 'board_game']
Task:Clean
response:
{
    "thoughts": Enter inside kid's room, begin picking up toys from the floor and putting them in a toy box, leave once once.,
    "actions": ['[WALK] <bedroom>', '[WALK] <toy>', '[FIND] <toy>', '[GRAB] <toy>', '[WALK] <filing_cabinet>', '[OPEN] <filing_cabinet>', '[PUTBACK] <toy> <filing_cabinet>', '[FIND] <toy>', '[GRAB] <toy>', '[WALK] <filing_cabinet>', '[PUTBACK] <toy> <filing_cabinet>', '[FIND] <toy>', '[GRAB] <toy>', '[WALK] <filing_cabinet>', '[PUTBACK] <toy> <filing_cabinet>', '[CLOSE] <filing_cabinet>']
}

Input:
Scene_Objects:['tablelamp', 'chair', 'orchid', 'drawing', 'cpuscreen', 'floor', 'ceiling', 'phone', 'desk', 'keyboard', 'food_cake', 'thread', 'computer', 'laptop', 'mat', 'ceilinglamp', 'tvstand', 'mousepad', 'wall', 'nightstand', 'oven', 'pasta', 'television', 'tray', 'doorjamb', 'mouse', 'headset', 'chessboard', 'cupboard', 'door']
Task:Watch movie
response:

Sit in my deck chair with my laptop, find a good movie on You Tube to watch, plug in earphones and listen to movie quietly so I don't disturb my upstairs neighbor.

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


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

Here is an example plan to achieve a goal for reference:
Scene_Objects:['spectacles', 'food_bread', 'filing_cabinet', 'tablelamp', 'chair', 'trashcan', 'ceilingfan', 'drawing', 'cpuscreen', 'floor', 'ceiling', 'phone', 'desk', 'keyboard', 'bookshelf', 'computer', 'ceilinglamp', 'deck_of_cards', 'balanceball', 'mousepad', 'food_noodles', 'pillow', 'wall', 'nightstand', 'oven', 'basket_for_clothes', 'doorjamb', 'towel_rack', 'mouse', 'light']
Task:Work
response:
{
    "thoughts": walk to home office ,find computer ,switch on computer and work,
    "actions": ['[WALK] <home_office>', '[WALK] <computer>', '[FIND] <computer>', '[SWITCHON] <computer>']
}

Input:
Scene_Objects:['pot', 'filing_cabinet', 'tablelamp', 'crayon', 'chair', 'walllamp', 'drawing', 'orchid', 'wallshelf', 'cpuscreen', 'floor', 'ceiling', 'phone', 'desk', 'bookshelf', 'keyboard', 'computer', 'bookmark', 'mat', 'ceilinglamp', 'tvstand', 'mousepad', 'couch', 'pillow', 'wall', 'nightstand', 'powersocket', 'oven', 'photoframe', 'television', 'tray', 'doorjamb', 'towel_rack', 'mouse', 'kitchen_counter', 'door', 'clothes_scarf', 'light']
Task:Re arrange office
response:

Walk in.Turn on light.Move furniture. Change the room

[WALK] <home_office>
[WALK] <light>
[FIND] <light>
[SWITCHON] <light>
[WALK] <desk>
[PUSH] <desk>
[WALK] <chair>
[PUSH] <chair>
[WALK] <couch>
[PUSH] <couch>
[WALK] <filing_cabinet>
[PUSH] <filing_cabinet>


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

Here is an example plan to achieve a goal for reference:
Scene_Objects:['glue', 'tablelamp', 'tea', 'toilet', 'walllamp', 'drawing', 'orchid', 'floor', 'desk', 'bedroom', 'computer', 'ceilinglamp', 'tvstand', 'window', 'couch', 'pillow', 'wall', 'powersocket', 'food_cheese', 'bed', 'food_donut', 'curtain', 'food_onion', 'mouse', 'pajamas', 'controller', 'table', 'dishwasher', 'light', 'board_game']
Task:Relax on sofa
response:
{
    "thoughts": lie in the sofa, relax,
    "actions": ['[WALK] <home_office>', '[WALK] <couch>', '[FIND] <couch>', '[LIE] <couch>']
}

Input:
Scene_Objects:['sheets', 'pot', 'microwave', 'bathroom', 'drawing', 'wallshelf', 'floor', 'ceiling', 'bedroom', 'toaster', 'stovefan', 'deck_of_cards', 'shower', 'pillow', 'wall', 'powersocket', 'cup', 'coffe_maker', 'check', 'wine', 'food_onion', 'curtain', 'lighter', 'kitchen_counter', 'cupboard', 'hair', 'controller', 'table', 'dishwasher', 'colander']
Task:Take dishes out of dishwasher
response:

Take clean dishes out of the dishwasher and put away

[WALK] <dining_room>
[WALK] <dishwasher>
[OPEN] <dishwasher>
[CLOSE] <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:['tablelamp', 'chair', 'freezer', 'walllamp', 'bathroom', 'orchid', 'cpuscreen', 'wallshelf', 'hanger', 'bathroom_counter', 'floor', 'ceiling', 'phone', 'dvd_player', 'desk', 'keyboard', 'computer', 'ceilinglamp', 'tvstand', 'mat', 'mousepad', 'couch', 'pillow', 'wall', 'nightstand', 'television', 'doorjamb', 'mouse', 'dresser', 'door']
Task:Write an email
response:
{
    "thoughts": Find the computer.  Turn on the computer.  Open the e-mail program.  Create a new message.  Write the message.,
    "actions": ['[WALK] <home_office>', '[WALK] <computer>', '[FIND] <computer>', '[SWITCHON] <computer>']
}

Input:
Scene_Objects:['sheets', 'filing_cabinet', 'measuring_cup', 'toilet', 'chair', 'cat', 'milk', 'orchid', 'phone', 'video_game_console', 'bookshelf', 'keyboard', 'purse', 'table_cloth', 'brush', 'mat', 'iron', 'couch', 'cup', 'basket_for_clothes', 'video_game_controller', 'oven_mitts', 'food_donut', 'doorjamb', 'console', 'dresser', 'laundry_detergent', 'sink', 'bathroom_cabinet', 'home_office']
Task:Playing video game
response:

Playing  video games  on various video game  systems such as wii u  and  xbox

[WALK] <home_office>
[WALK] <video_game_console>
[FIND] <video_game_console>
[SWITCHON] <video_game_console>
[FIND] <video_game_controller>
[GRAB] <video_game_controller>
[PUTOBJBACK] <video_game_controller>
[SWITCHOFF] <video_game_console>
[FIND] <video_game_console>
[SWITCHON] <video_game_console>
[FIND] <video_game_controller>
[GRAB] <video_game_controller>


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_oatmeal', 'microwave', 'freezer', 'bathroom', 'nail_polish', 'dough', 'food_carrot', 'orchid', 'drawing', 'knife', 'kitchen_cabinet', 'floor', 'ceiling', 'desk', 'brush', 'mat', 'couch', 'pillow', 'food_cereal', 'wall', 'food_vegetable', 'food_food', 'television', 'console', 'cards', 'kitchen_counter', 'cupboard', 'hair', 'door', 'light']
Task:Put groceries in Fridge
response:
{
    "thoughts": Walk to kitchen, find groceries in cabinet and move them to fridge and close fridge.,
    "actions": ['[WALK] <dining_room>', '[WALK] <kitchen_cabinet>', '[FIND] <kitchen_cabinet>', '[FIND] <food_vegetable>', '[GRAB] <food_vegetable>', '[FIND] <freezer>', '[OPEN] <freezer>', '[PUTIN] <food_vegetable> <freezer>', '[FIND] <food_carrot>', '[GRAB] <food_carrot>', '[PUTIN] <food_carrot> <freezer>', '[FIND] <food_cereal>', '[GRAB] <food_cereal>', '[PUTIN] <food_cereal> <freezer>', '[FIND] <food_oatmeal>', '[GRAB] <food_oatmeal>', '[PUTIN] <food_oatmeal> <freezer>', '[FIND] <food_food>', '[GRAB] <food_food>', '[PUTIN] <food_food> <freezer>', '[FIND] <freezer>', '[CLOSE] <freezer>']
}

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

Logging on to  things like  facebook  and  twitter

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