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', '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:
{
    "thoughts": Walk in.Turn on light.Move furniture. Change the room,
    "actions": ['[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>']
}

Input:
Scene_Objects:['tablelamp', 'chair', 'walllamp', 'drawing', 'orchid', 'cpuscreen', 'wallshelf', 'hanger', 'floor', 'ceiling', 'phone', 'desk', 'keyboard', 'computer', 'mat', 'ceilinglamp', 'tvstand', 'mousepad', 'couch', 'pillow', 'wall', 'nightstand', 'oven', 'cup', 'check', 'television', 'doorjamb', 'mouse', 'dresser', 'door']
Task:Complete surveys on amazon turk
response:

Sit down at computer, Turn computer on. Go online to Amazon mechanical turk, Browse through surveys, Select a survey.

[WALK] <chair>
[SIT] <chair>
[FIND] <computer>
[SWITCHON] <computer>
[TURNTO] <computer>
[LOOKAT] <computer>
[FIND] <mouse>
[GRAB] <mouse>
[TURNTO] <computer>
[POINTAT] <computer>
[FIND] <check>
[GRAB] <check>
[READ] <check>
[PUTOBJBACK] <mouse>
[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:['tea', 'chair', 'walllamp', 'orchid', 'cpuscreen', 'bathroom_counter', 'floor', 'ceiling', 'desk', 'keyboard', 'computer', 'mat', 'ceilinglamp', 'tvstand', 'shoe-shine_kit', 'mousepad', 'closetdrawer', 'pillow', 'wall', 'cutting_board', 'cup', 'coffe_maker', 'television', 'doorjamb', 'mouse', 'vacuum_cleaner', 'controller', 'door', 'light', '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:['filing_cabinet', 'tablelamp', 'chair', 'walllamp', 'drawing', 'wallshelf', 'hanger', 'floor', 'ceiling', 'phone', 'desk', 'remote_control', 'computer', 'stovefan', 'mat', 'tvstand', 'ceilinglamp', 'closetdrawer', 'couch', 'pillow', 'wall', 'photoframe', 'television', 'curtain', 'doorjamb', 'kitchen_counter', 'dresser', 'door', 'table', 'light']
Task:Watch TV
response:

I sit down on the couch, get the tv remote, click the on button, and change the channel to the show i want to watch

[WALK] <home_office>
[WALK] <television>
[FIND] <television>
[SWITCHON] <television>
[WALK] <couch>
[SIT] <couch>
[FIND] <remote_control>
[GRAB] <remote_control>
[TURNTO] <television>
[POINTAT] <television>
[PUTOBJBACK] <remote_control>
[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:['filing_cabinet', 'toilet', 'band-aids', 'freezer', 'food_carrot', 'toothbrush', 'orchid', 'floor', 'mail', 'button', 'faucet', 'foundation', 'oil', 'pillow', 'towel', 'food_food', 'toothbrush_holder', 'doorjamb', 'lighter', 'kettle', 'headset', 'cd', 'dresser', 'hairbrush', 'controller', 'napkin', 'light', 'dishwasher', 'tooth_paste', 'teeth']
Task:Brush teeth
response:
{
    "thoughts": walk to bathroom, look at the toothbrush holder, take toothbrush from the toothbrush holder, find the toothpaste, squeeze the toothpaste into toothbrush, now brush teeth,
    "actions": ['[WALK] <bathroom>', '[WALK] <toothbrush_holder>', '[FIND] <toothbrush_holder>', '[TURNTO] <toothbrush_holder>', '[LOOKAT] <toothbrush_holder>', '[FIND] <toothbrush>', '[TURNTO] <toothbrush>', '[LOOKAT] <toothbrush>', '[FIND] <tooth_paste>', '[SQUEEZE] <tooth_paste>']
}

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

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


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

Here is an example plan to achieve a goal for reference:
Scene_Objects:['water_glass', 'tablelamp', 'microwave', 'toilet', 'freezer', 'walllamp', 'trashcan', 'drawing', 'wallshelf', 'floor', 'ceiling', 'phone', 'toaster', 'stovefan', 'mat', 'faucet', 'shower', 'window', 'wall', 'wall_clock', 'oven', 'coffe_maker', 'water', 'tray', 'doorjamb', 'towel_rack', 'kitchen_counter', 'cupboard', 'door', 'sink']
Task:Drink
response:
{
    "thoughts": I need to go to Kitchen.  Get a cup.  Fill cup.  Drink,
    "actions": ['[WALK] <dining_room>', '[WALK] <cupboard>', '[FIND] <cupboard>', '[OPEN] <cupboard>', '[FIND] <water_glass>', '[GRAB] <water_glass>', '[WALK] <freezer>', '[WALK] <water>', '[FIND] <water>', '[GRAB] <water>', '[POUR] <water> <water_glass>', '[DRINK] <water_glass>']
}

Input:
Scene_Objects:['sponge', 'crayon', 'chair', 'walllamp', 'hanger', 'floor', 'ceiling', 'phone', 'tea_bag', 'clothes_jacket', 'toaster', 'mat', 'ceilinglamp', 'faucet', 'dish_soap', 'mousepad', 'dustpan', 'clothes_hat', 'wall', 'cup', 'coffe_maker', 'coffee_filter', 'curtain', 'coffee_pot', 'mouse', 'kitchen_counter', 'dishrack', 'cupboard', 'sink', 'napkin']
Task:Wash dishes
response:

Place all of the dirty dishes in a sink full of clean, soapy water.  Wash them.  Rinse them in fresh, running water.  Place them in the strainer to dry.

[WALK] <dining_room>
[WALK] <sink>
[FIND] <faucet>
[SWITCHON] <faucet>
[SWITCHOFF] <faucet>
[FIND] <dish_soap>
[GRAB] <dish_soap>
[POUR] <dish_soap> <sink>
[PUTOBJBACK] <dish_soap>
[FIND] <sponge>
[GRAB] <sponge>
[FIND] <cup>
[GRAB] <cup>
[SCRUB] <cup>
[PUTOBJBACK] <cup>
[FIND] <cup>
[GRAB] <cup>
[SCRUB] <cup>
[PUTOBJBACK] <cup>
[PUTBACK] <sponge> <sink>
[SWITCHON] <faucet>
[RINSE] <cup>
[GRAB] <cup>
[FIND] <dishrack>
[PUTBACK] <cup> <dishrack>
[RINSE] <cup>
[GRAB] <cup>
[PUTBACK] <cup> <dishrack>
[RINSE] <sponge>
[SWITCHOFF] <faucet>
[GRAB] <sponge>
[PUTOBJBACK] <sponge>


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

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

Input:
Scene_Objects:['sheets', 'filing_cabinet', 'juice', 'microwave', 'jelly', 'bathroom', 'cat', 'dough', 'drawing', 'hanger', 'phone', 'character', 'bookshelf', 'food_bacon', 'ceilinglamp', 'tvstand', 'shower', 'clothes_hat', 'bowl', 'oven', 'toy', 'bed', 'photoframe', 'razor', 'curtain', 'vacuum_cleaner', 'cupboard', 'bathroom_cabinet', 'teeth', 'electrical_outlet']
Task:Vacuum
response:

Plug vacuum into the wall. Turn on the vacuum. Move vacuum around the floor to clean it. Unplug vacuum.

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

Input:
Scene_Objects:['scissors', 'chair', 'walllamp', 'drawing', 'wallshelf', 'hanger', 'floor', 'ceiling', 'desk', 'remote_control', 'computer', 'mat', 'tvstand', 'ceilinglamp', 'food_noodles', 'closetdrawer', 'couch', 'candle', 'pillow', 'dining_room', 'wall', 'food_cheese', 'photoframe', 'television', 'curtain', 'doorjamb', 'mouse', 'headset', 'dresser', 'creditcard']
Task:Watch TV
response:

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


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

Here is an example plan to achieve a goal for reference:
Scene_Objects:['sheets', 'tea', 'chair', 'drawing', 'knifeblock', 'cpuscreen', 'floor', 'desk', 'keyboard', 'bookshelf', 'computer', 'mat', 'plate', 'mousepad', 'couch', 'clothes_hat', 'wall', 'nightstand', 'cup', 'food_food', 'check', 'coffe_maker', 'after_shave', 'rag', 'doorjamb', 'mouse', 'kitchen_counter', 'comb', 'hairdryer', 'table']
Task:Read book
response:
{
    "thoughts": go to living room,find the text book on the self ,sat on the chair ,open and read the book,
    "actions": ['[WALK] <home_office>', '[WALK] <novel>', '[FIND] <novel>', '[GRAB] <novel>', '[WALK] <home_office>', '[WALK] <chair>', '[FIND] <chair>', '[SIT] <chair>', '[READ] <novel>']
}

Input:
Scene_Objects:['scissors', 'microwave', 'freezer', 'character', 'bedroom', 'computer', 'stovefan', 'mat', 'plate', 'homework', 'closetdrawer', 'clothes_hat', 'dining_room', 'powersocket', 'basket_for_clothes', 'cup', 'bed', 'keys', 'coffe_maker', 'check', 'television', 'towel_rack', 'dishrack', 'dresser', 'napkin', 'home_office', 'light', 'table', 'instrument_violin', 'shoe_rack']
Task:Dust
response:

Get a broom or duster with long handle. Dust blades of ceiling fan.

[WALK] <bedroom>
[WALK] <duster>
[FIND] <duster>
[GRAB] <duster>
[PUTOBJBACK] <duster>


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:['blow_dryer', 'trashcan', 'hanger', 'floor', 'ceiling', 'bedroom', 'bookmark', 'toaster', 'stovefan', 'tvstand', 'food_jam', 'pillow', 'dining_room', 'bowl', 'wall', 'powersocket', 'clothes_gloves', 'novel', 'coffe_maker', 'coffee_filter', 'tray', 'after_shave', 'curtain', 'cd', 'chessboard', 'cupboard', 'sink', 'dishwasher', 'scrabble', 'coffee']
Task:Make coffee
response:
{
    "thoughts": Enter kitchen, find coffee maker, find coffee filter, pick up coffee filter, put it in coffee maker, find coffee, pour coffee into filter, turn on.,
    "actions": ['[WALK] <dining_room>', '[WALK] <coffe_maker>', '[FIND] <coffe_maker>', '[FIND] <coffee_filter>', '[GRAB] <coffee_filter>', '[OPEN] <coffe_maker>', '[PUTBACK] <coffee_filter> <coffe_maker>', '[WALK] <coffee>', '[FIND] <coffee>', '[GRAB] <coffee>', '[POUR] <coffee> <coffe_maker>', '[SWITCHON] <coffe_maker>']
}

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

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


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

Here is an example plan to achieve a goal for reference:
Scene_Objects:['food_bread', 'drawing', 'orchid', 'knifeblock', 'bills', 'floor', 'ceiling', 'desk', 'bedroom', 'keyboard', 'shower', 'stereo', 'mousepad', 'couch', 'pillow', 'wall', 'oven', 'photoframe', 'television', 'food_rice', 'tray', 'curtain', 'doorjamb', 'pencil', 'kitchen_counter', 'door', 'home_office', 'table', 'light', 'bathroom_cabinet']
Task:Relax on sofa
response:
{
    "thoughts": Walk into the living room. Walk up to the sofa. Sit down on the sofa.,
    "actions": ['[WALK] <home_office>', '[WALK] <couch>', '[SIT] <couch>']
}

Input:
Scene_Objects:['tablelamp', 'measuring_cup', 'chair', 'orchid', 'drawing', 'cpuscreen', 'wallshelf', 'floor', 'ceiling', 'desk', 'tea_bag', 'keyboard', 'bookshelf', 'computer', 'alcohol', 'stovefan', 'mat', 'ceilinglamp', 'tvstand', 'stereo', 'floor_lamp', 'mousepad', 'wall', 'nightstand', 'novel', 'video_game_controller', 'television', 'mouse', 'door', 'napkin']
Task:Study
response:

[WALK] <home_office>
[WALK] <floor_lamp>
[FIND] <floor_lamp>
[SWITCHON] <floor_lamp>
[FIND] <novel>
[GRAB] <novel>
[FIND] <chair>
[SIT] <chair>
[READ] <novel>


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

Here is an example plan to achieve a goal for reference:
Scene_Objects:['chair', 'food_carrot', 'drawing', 'hanger', 'floor', 'ceiling', 'phone', 'dvd_player', 'character', 'bedroom', 'keyboard', 'piano_bench', 'bookmark', 'laptop', 'electric_shaver', 'food_kiwi', 'wall', 'powersocket', 'toothbrush_holder', 'curtain', 'rag', 'doorjamb', 'shaving_cream', 'cards', 'dresser', 'cupboard', 'door', 'bathroom_cabinet', 'light', 'coffee']
Task:Turn on light
response:
{
    "thoughts": I walk into the dining room and turn on the lights,
    "actions": ['[WALK] <dining_room>', '[WALK] <light>', '[FIND] <light>', '[SWITCHON] <light>']
}

Input:
Scene_Objects:['pot', 'tablelamp', 'chair', 'walllamp', 'drawing', 'orchid', 'cpuscreen', 'wallshelf', 'hanger', 'floor', 'phone', 'ceiling', 'desk', 'keyboard', 'computer', 'mat', 'ceilinglamp', 'tvstand', 'mousepad', 'couch', 'pillow', 'wall', 'nightstand', 'oven', 'powersocket', 'television', 'tray', 'doorjamb', 'towel_rack', 'mouse', 'dresser', 'door', 'light']
Task:Surf web for money legitimate making opportunities
response:

Sit down in front of computer. Turn computer on. Go online. Surf the web.

[WALK] <home_office>
[WALK] <desk>
[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:['dry_pasta', 'pot', 'filing_cabinet', 'tablelamp', 'blender', 'drawing', 'cpuscreen', 'floor', 'ceiling', 'character', 'desk', 'bookshelf', 'keyboard', 'computer', 'bookmark', 'mat', 'balanceball', 'clothes_socks', 'dustpan', 'wall', 'powersocket', 'food_cheese', 'after_shave', 'doorjamb', 'towel_rack', 'dresser', 'door', 'bathroom_cabinet', 'light', 'home_office']
Task:Turn on light
response:
{
    "thoughts": Hit light switch,
    "actions": ['[WALK] <bedroom>', '[WALK] <light>', '[SWITCHON] <light>']
}

Input:
Scene_Objects:['pot', 'food_pizza', 'tablelamp', 'toilet', 'dog', 'freezer', 'bathroom', 'orchid', 'bathroom_counter', 'phone', 'character', 'tea_bag', 'bookshelf', 'keyboard', 'stovefan', 'mat', 'plate', 'mousepad', 'oil', 'wall', 'newspaper', 'novel', 'food_food', 'television', 'rag', 'lighter', 'pencil', 'shoes', 'sink', 'home_office']
Task:Open window
response:

Unlock the latch at the top. Push the bottom half of the window upwards.

[WALK] <home_office>
[WALK] <window>
[OPEN] <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:['measuring_cup', 'drawing', 'orchid', 'cpuscreen', 'bathroom_counter', 'floor', 'ceiling', 'keyboard', 'computer', 'ceilinglamp', 'faucet', 'teeth', 'towel', 'wall', 'nightstand', 'powersocket', 'basket_for_clothes', 'photoframe', 'light_bulb', 'toilet_paper', 'television', 'food_donut', 'tray', 'cards', 'towel_rack', 'laundry_detergent', 'sink', 'bathroom_cabinet', 'soap', 'hands_both']
Task:Hand washing
response:
{
    "thoughts": Turn on the faucet. Soap up your hands. Then rinse under the running water of the faucet. Turn off faucet and dry hands.,
    "actions": ['[WALK] <bathroom>', '[WALK] <sink>', '[FIND] <faucet>', '[SWITCHON] <faucet>', '[FIND] <soap>', '[GRAB] <soap>', '[FIND] <hands_both>', '[SCRUB] <hands_both>', '[PUTOBJBACK] <soap>', '[WASH] <hands_both>', '[SWITCHOFF] <faucet>', '[FIND] <towel>', '[GRAB] <towel>', '[WIPE] <hands_both>']
}

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

I have my desktop computer set up on my desk and complete the paperwork I brought home with me from work.

[WALK] <home_office>
[WALK] <chair>
[FIND] <chair>
[SIT] <chair>
[FIND] <computer>
[SWITCHON] <computer>
[FIND] <check>
[GRAB] <check>
[READ] <check>
[FIND] <desk>
[OPEN] <desk>
[PUTBACK] <check> <desk>
[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', 'crayon', 'dog', 'toothbrush', 'drawing', 'knifeblock', 'hanger', 'bathroom_counter', 'floor', 'ceiling', 'character', 'faucet', 'shower', 'balanceball', 'mousepad', 'wall', 'pasta', 'powersocket', 'oven', 'nightstand', 'photoframe', 'video_game_controller', 'coffee_filter', 'wooden_spoon', 'console', 'shoes', 'sink', 'bathroom_cabinet', 'tooth_paste', 'teeth']
Task:Brush teeth
response:
{
    "thoughts": Put toothpaste on toothbrush, brush teeth, rinse mouth,
    "actions": ['[WALK] <bathroom>', '[WALK] <toothbrush>', '[FIND] <toothbrush>', '[GRAB] <toothbrush>', '[FIND] <tooth_paste>', '[GRAB] <tooth_paste>', '[POUR] <tooth_paste> <toothbrush>', '[PUTOBJBACK] <tooth_paste>', '[WALK] <sink>', '[FIND] <teeth>', '[SCRUB] <teeth>', '[SCRUB] <teeth>', '[SCRUB] <teeth>', '[PUTBACK] <toothbrush> <sink>', '[FIND] <faucet>', '[SWITCHON] <faucet>', '[RINSE] <toothbrush>', '[RINSE] <teeth>', '[SWITCHOFF] <faucet>', '[GRAB] <toothbrush>', '[PUTOBJBACK] <toothbrush>']
}

Input:
Scene_Objects:['blender', 'tea', 'microwave', 'orchid', 'bathroom_counter', 'character', 'desk', 'mat', 'shower', 'closetdrawer', 'couch', 'clothes_pants', 'food_orange', 'tape', 'cup', 'basket_for_clothes', 'bed', 'food_food', 'coin', 'wooden_spoon', 'towel_rack', 'shoes', 'dishrack', 'hairbrush', 'controller', 'door', 'sink', 'table', 'board_game', 'shoe_rack']
Task:Walk through
response:

[WALK] <home_office>
[WALK] <dining_room>
[WALK] <home_office>


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

Here is an example plan to achieve a goal for reference:
Scene_Objects:['microwave', 'toilet', 'ground_coffee', 'bathroom', 'trashcan', 'food_butter', 'knifeblock', 'needle', 'floor', 'ceiling', 'character', 'clothes_jacket', 'toaster', 'ceilinglamp', 'balanceball', 'mousepad', 'broom', 'wall', 'pasta', 'photoframe', 'coffe_maker', 'coffee_filter', 'water', 'rag', 'coffee_pot', 'laundry_detergent', 'maindoor', 'napkin', 'table', 'dishwasher']
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:['tablelamp', 'juice', 'chair', 'walllamp', 'drawing', 'wallshelf', 'cpuscreen', 'floor', 'ceiling', 'phone', 'desk', 'keyboard', 'food_cake', 'envelope', 'computer', 'mop_bucket', 'laptop', 'mat', 'tvstand', 'mousepad', 'couch', 'pillow', 'wall', 'oven', 'photoframe', 'television', 'doorjamb', 'mouse', 'controller', 'door']
Task:Surf internet
response:

SIT ON COUCH OR CHAIR AND SURF SHOPPING AN SOCIAL MEDIA SITES

[WALK] <home_office>
[WALK] <laptop>
[FIND] <laptop>
[GRAB] <laptop>
[FIND] <couch>
[SIT] <couch>
[SWITCHON] <laptop>
[TURNTO] <laptop>
[LOOKAT] <laptop>
[FIND] <keyboard>
[TYPE] <keyboard>


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

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

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

find computer, find shopping website, pick items, get credit card, make a purchase

[WALK] <home_office>
[WALK] <chair>
[FIND] <chair>
[SIT] <chair>
[FIND] <computer>
[SWITCHON] <computer>
[TURNTO] <computer>
[LOOKAT] <computer>
[FIND] <keyboard>
[TYPE] <keyboard>
[FIND] <creditcard>
[GRAB] <creditcard>
[TURNTO] <creditcard>
[LOOKAT] <creditcard>
[FIND] <desk>
[OPEN] <desk>
[PUTBACK] <creditcard> <desk>
[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:['crayon', 'toilet', 'chair', 'bathroom', 'detergent', 'dough', 'knife', 'drawing', 'floor', 'ceiling', 'tea_bag', 'ceilinglamp', 'tvstand', 'shower', 'plate', 'mousepad', 'clothes_socks', 'pillow', 'wall', 'cup', 'doorjamb', 'console', 'shoes', 'dresser', 'door', 'hairdryer', 'napkin', 'light', 'soap', 'laser_pointer']
Task:Turn on light
response:
{
    "thoughts": Walk over to light switch. Turn on lights.,
    "actions": ['[WALK] <light>', '[SWITCHON] <light>']
}

Input:
Scene_Objects:['chair', 'walllamp', 'nail_polish', 'cat', 'drawing', 'wallshelf', 'hanger', 'floor', 'ceiling', 'desk', 'computer', 'mat', 'tvstand', 'ceilinglamp', 'closetdrawer', 'couch', 'pillow', 'wall', 'photoframe', 'television', 'tray', 'doorjamb', 'dresser', 'cupboard', 'controller', 'door', 'sink', 'bathroom_cabinet', 'tooth_paste', 'creditcard']
Task:Watch TV
response:

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


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

Here is an example plan to achieve a goal for reference:
Scene_Objects:['pot', 'ground_coffee', 'walllamp', 'detergent', 'knifeblock', 'longboard', 'floor', 'ceiling', 'toaster', 'stovefan', 'plate', 'faucet', 'candle', 'wall', 'box', 'coffe_maker', 'food_food', 'television', 'coffee_filter', 'water', 'towel_rack', 'kitchen_counter', 'chessboard', 'cupboard', 'hair', 'maindoor', 'sink', 'napkin', 'dishwasher', 'tooth_paste']
Task:Make coffee
response:
{
    "thoughts": I walk to the kitchen and find the coffee machine. I open the coffee machine and pour a filter in it. I open the cupboard and grab ground coffee. I put ground coffee in the filter and water in the coffee machine. I close the coffee machine. I switch on the coffee machine and wait,
    "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] <cupboard>', '[OPEN] <cupboard>', '[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:['pot', 'tablelamp', 'chair', 'walllamp', 'drawing', 'orchid', 'cpuscreen', 'wallshelf', 'hanger', 'floor', 'ceiling', 'phone', 'desk', 'keyboard', 'computer', 'mat', 'ceilinglamp', 'tvstand', 'mousepad', 'couch', 'pillow', 'wall', 'nightstand', 'oven', 'television', 'doorjamb', 'mouse', 'dresser', 'door', 'sink']
Task:Use computer
response:

[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:['scissors', 'mop', 'ground_coffee', 'ceilingfan', 'trashcan', 'toothbrush', 'drawing', 'needle', 'bookshelf', 'keyboard', 'laptop', 'balanceball', 'stereo', 'mousepad', 'wall_clock', 'bench', 'coffe_maker', 'food_food', 'toothbrush_holder', 'television', 'curtain', 'doorjamb', 'kettle', 'controller', 'napkin', 'home_office', 'light', 'vase', 'soap', 'tooth_paste']
Task:Brush teeth
response:
{
    "thoughts": walk to bathroom, look at the toothbrush holder, take toothbrush from the toothbrush holder, find the toothpaste, squeeze the toothpaste into toothbrush, now brush teeth,
    "actions": ['[WALK] <bathroom>', '[WALK] <toothbrush_holder>', '[FIND] <toothbrush_holder>', '[TURNTO] <toothbrush_holder>', '[LOOKAT] <toothbrush_holder>', '[FIND] <toothbrush>', '[TURNTO] <toothbrush>', '[LOOKAT] <toothbrush>', '[FIND] <tooth_paste>', '[SQUEEZE] <tooth_paste>']
}

Input:
Scene_Objects:['food_pizza', 'freezer', 'trashcan', 'drawing', 'bathroom_counter', 'ceiling', 'phone', 'thread', 'computer', 'stovefan', 'faucet', 'shower', 'food_jam', 'dining_room', 'wall', 'powersocket', 'tape', 'coffe_maker', 'food_food', 'mirror', 'doorjamb', 'mouse', 'paper_towel', 'dresser', 'cupboard', 'sink', 'clothes_scarf', 'bathroom_cabinet', 'home_office', 'dirt']
Task:Clean  mirror
response:

Spray Windex or glass and mirror cleaner onto mirror. Use paper towel to wipe off cleaner until mirror is dry and has no streaks.

[WALK] <bathroom>
[WALK] <bathroom_cabinet>
[FIND] <bathroom_cabinet>
[OPEN] <bathroom_cabinet>
[FIND] <paper_towel>
[GRAB] <paper_towel>
[CLOSE] <bathroom_cabinet>
[WALK] <mirror>
[WIPE] <mirror>
[FIND] <trashcan>
[PUTBACK] <paper_towel> <trashcan>


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', 'orchid', 'drawing', 'cpuscreen', 'wallshelf', 'hanger', 'floor', 'ceiling', 'phone', 'desk', 'keyboard', 'computer', 'ceilinglamp', 'tvstand', 'mat', 'faucet', 'mousepad', 'couch', 'pillow', 'wall', 'nightstand', 'television', 'curtain', 'doorjamb', 'mouse', 'dresser', 'door']
Task:Work
response:
{
    "thoughts": Find home office. Walk to home office. Find computer. Find chair at desk. Sit in chair. Switch on computer. Work on computer.,
    "actions": ['[WALK] <home_office>', '[WALK] <computer>', '[FIND] <computer>', '[FIND] <chair>', '[SIT] <chair>', '[SWITCHON] <computer>']
}

Input:
Scene_Objects:['tablelamp', 'chair', 'ground_coffee', 'orchid', 'drawing', 'cpuscreen', 'floor', 'ceiling', 'phone', 'desk', 'keyboard', 'computer', 'mail', 'bookmark', 'toaster', 'mat', 'ceilinglamp', 'tvstand', 'laptop', 'mousepad', 'dining_room', 'wall', 'nightstand', 'oven', 'cup', 'bed', 'television', 'coffee_filter', 'mouse', 'door']
Task:Answer emails
response:

Open email application.  Open new emails.  Respond accordingly

[WALK] <home_office>
[WALK] <chair>
[FIND] <chair>
[SIT] <chair>
[FIND] <laptop>
[SWITCHON] <laptop>
[TURNTO] <laptop>
[LOOKAT] <laptop>
[FIND] <mail>
[GRAB] <mail>
[READ] <mail>
[FIND] <keyboard>
[TYPE] <keyboard>
[SWITCHOFF] <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:['freezer', 'bathroom', 'detergent', 'cat', 'trashcan', 'cpuscreen', 'floor', 'ceiling', 'character', 'desk', 'keyboard', 'computer', 'stovefan', 'ceilinglamp', 'mousepad', 'form', 'wall', 'powersocket', 'photoframe', 'food_food', 'check', 'coffee_filter', 'doorjamb', 'cards', 'mouse', 'kitchen_counter', 'controller', 'door', 'light', 'coffee']
Task:Put groceries in Fridge
response:
{
    "thoughts": I take the groceries out of the grocery bags, throw away grocery bags, categorize the food so that I know where it goes in the fridge, open the fridge, and place each item in the fridge before closing the fridge.,
    "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:['filing_cabinet', 'chair', 'walllamp', 'drawing', 'wallshelf', 'hanger', 'floor', 'ceiling', 'desk', 'keyboard', 'computer', 'stovefan', 'mat', 'tvstand', 'ceilinglamp', 'closetdrawer', 'couch', 'candle', 'pillow', 'wall', 'photoframe', 'bed', 'television', 'food_rice', 'doorjamb', 'centerpiece', 'dresser', 'napkin', 'light', 'coffee']
Task:Watch TV
response:

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


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

Here is an example plan to achieve a goal for reference:
Scene_Objects:['freezer', 'bathroom', 'detergent', 'orchid', 'cpuscreen', 'floor', 'phone', 'desk', 'bedroom', 'purse', 'computer', 'table_cloth', 'bookmark', 'stovefan', 'stereo', 'oil', 'closetdrawer', 'coffe_maker', 'television', 'food_donut', 'food_rice', 'tray', 'centerpiece', 'doorjamb', 'pencil', 'maindoor', 'sink', 'home_office', 'table', 'clothes_skirt']
Task:Read book
response:
{
    "thoughts": Walk to living room. Find book. Grab book. Open book. Read book.,
    "actions": ['[WALK] <home_office>', '[WALK] <novel>', '[FIND] <novel>', '[GRAB] <novel>', '[READ] <novel>']
}

Input:
Scene_Objects:['sheets', 'food_bread', 'juice', 'food_salt', 'toilet', 'walllamp', 'detergent', 'dough', 'wallshelf', 'cpuscreen', 'bathroom_counter', 'character', 'tea_bag', 'toaster', 'mat', 'broom', 'powersocket', 'love_seat', 'newspaper', 'photoframe', 'keys', 'food_food', 'coffe_maker', 'toilet_paper', 'ice', 'tray', 'lighter', 'kettle', 'home_office', 'dirt']
Task:Read
response:

[WALK] <home_office>
[WALK] <newspaper>
[FIND] <newspaper>
[GRAB] <newspaper>
[FIND] <love_seat>
[SIT] <love_seat>
[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:['tablelamp', 'chair', 'walllamp', 'drawing', 'orchid', 'cpuscreen', 'wallshelf', 'hanger', 'floor', 'ceiling', 'phone', 'desk', 'keyboard', 'purse', 'computer', 'mat', 'ceilinglamp', 'tvstand', 'electric_shaver', 'mousepad', 'couch', 'pillow', 'wall', 'nightstand', 'oven', 'television', 'doorjamb', 'mouse', 'dresser', 'door']
Task:Work
response:
{
    "thoughts": Walk to home office. Sit on chair. Switch on computer. type in keyboard.,
    "actions": ['[WALK] <home_office>', '[WALK] <chair>', '[FIND] <chair>', '[SIT] <chair>', '[FIND] <computer>', '[SWITCHON] <computer>', '[FIND] <keyboard>', '[TYPE] <keyboard>']
}

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

[WALK] <home_office>
[WALK] <desk>
[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:['tablelamp', 'scissors', 'drawing', 'floor', 'ceiling', 'bookshelf', 'remote_control', 'button', 'ceilinglamp', 'tvstand', 'shower', 'electric_shaver', 'food_kiwi', 'wall', 'bench', 'food_cheese', 'photoframe', 'newspaper', 'bed', 'food_food', 'standingmirror', 'television', 'curtain', 'doorjamb', 'shaving_cream', 'door', 'soap', 'clothes_shirt', 'scrabble', 'coffee']
Task:Change TV channel
response:
{
    "thoughts": Walk to TV, grab remote control, press change channel button, repeat pressing change channel button util find the channel wanted, put back remote control,
    "actions": ['[WALK] <television>', '[FIND] <remote_control>', '[GRAB] <remote_control>', '[FIND] <button>', '[TOUCH] <button>', '[TURNTO] <television>', '[WATCH] <television>', '[TOUCH] <button>', '[TURNTO] <television>', '[WATCH] <television>', '[PUTOBJBACK] <remote_control>']
}

Input:
Scene_Objects:['tablelamp', 'chair', 'walllamp', 'drawing', 'wallshelf', 'hanger', 'floor', 'ceiling', 'desk', 'bedroom', 'remote_control', 'thread', 'computer', 'mat', 'tvstand', 'ceilinglamp', 'closetdrawer', 'couch', 'pillow', 'dining_room', 'wall', 'wall_clock', 'basket_for_clothes', 'photoframe', 'television', 'food_onion', 'doorjamb', 'dresser', 'door', 'clothes_scarf']
Task:Watch TV
response:

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


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

Here is an example plan to achieve a goal for reference:
Scene_Objects:['pot', 'tablelamp', 'chair', 'drawing', 'orchid', 'cpuscreen', 'floor', 'phone', 'ceiling', 'desk', 'keyboard', 'computer', 'mat', 'laptop', 'ceilinglamp', 'tvstand', 'mousepad', 'wall', 'nightstand', 'oven', 'powersocket', 'television', 'tray', 'doorjamb', 'towel_rack', 'mouse', 'dishrack', 'door', 'light', 'shoe_rack']
Task:Browse internet
response:
{
    "thoughts": Walk to home office, walk to desk, sit in chair, turn on laptop, grab mouse, open a web page to look at it, move mouse, keep looking at laptop screen.,
    "actions": ['[WALK] <home_office>', '[WALK] <desk>', '[FIND] <chair>', '[SIT] <chair>', '[FIND] <laptop>', '[SWITCHON] <laptop>', '[FIND] <mouse>', '[GRAB] <mouse>', '[TURNTO] <laptop>', '[LOOKAT] <laptop>', '[TOUCH] <mouse>', '[TURNTO] <laptop>', '[LOOKAT] <laptop>']
}

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

[WALK] <home_office>
[WALK] <chair>
[FIND] <chair>
[SIT] <chair>
[FIND] <computer>
[SWITCHON] <computer>
[FIND] <mouse>
[GRAB] <mouse>
[TURNTO] <computer>
[LOOKAT] <computer>
[TURNTO] <computer>
[POINTAT] <computer>
[PUTOBJBACK] <mouse>
[FIND] <keyboard>
[TYPE] <keyboard>
[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:['sheets', 'freezer', 'bathroom', 'ceilingfan', 'drawing', 'bills', 'floor', 'ceiling', 'phone', 'bedroom', 'desk', 'remote_control', 'button', 'ceilinglamp', 'tvstand', 'balanceball', 'shower', 'window', 'couch', 'wall', 'toy', 'tape', 'bed', 'television', 'curtain', 'comb', 'hair', 'home_office', 'table', 'soap']
Task:Watch TV
response:
{
    "thoughts": Go to the living room and sit on the couch. Turn on television using remote control. Use remote control buttons to navigate to desired channel. Watch television.,
    "actions": ['[WALK] <home_office>', '[WALK] <couch>', '[FIND] <couch>', '[SIT] <couch>', '[FIND] <remote_control>', '[GRAB] <remote_control>', '[FIND] <television>', '[SWITCHON] <television>', '[FIND] <button>', '[PUSH] <button>', '[TURNTO] <television>', '[WATCH] <television>']
}

Input:
Scene_Objects:['pot', 'tablelamp', 'chair', 'freezer', 'hanger', 'floor', 'ceiling', 'cleaning_solution', 'mail', 'computer', 'toaster', 'mat', 'plate', 'faucet', 'brush', 'oil', 'candle', 'broom', 'wall', 'tape', 'bed', 'coffe_maker', 'ice', 'rag', 'console', 'kitchen_counter', 'cupboard', 'sink', 'bathroom_cabinet', 'colander']
Task:Clean sink
response:

Squirt soap into the sink. Get a wet rag. Wipe out the sink. Rinse out the sink and the rag. Hang the rag out to dry.

[WALK] <dining_room>
[WALK] <rag>
[FIND] <rag>
[GRAB] <rag>
[FIND] <cleaning_solution>
[GRAB] <cleaning_solution>
[FIND] <cleaning_solution>
[WALK] <sink>
[POUR] <cleaning_solution> <sink>
[PUTOBJBACK] <cleaning_solution>
[WIPE] <sink>
[FIND] <faucet>
[SWITCHON] <faucet>
[RINSE] <sink>
[RINSE] <rag>
[SWITCHOFF] <faucet>
[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:['fork', 'dry_pasta', 'food_salt', 'chair', 'drawing', 'bills', 'hanger', 'floor', 'phone', 'ceiling', 'toaster', 'plate', 'wall', 'bench', 'powersocket', 'tape', 'cup', 'bed', 'check', 'food_food', 'tray', 'doorjamb', 'pencil', 'dishrack', 'dresser', 'cupboard', 'door', 'table', 'light', 'laser_pointer']
Task:Eat
response:
{
    "thoughts": Serve food on dinning table in appropriate utensils, sit on the chair, eat,
    "actions": ['[WALK] <dining_room>', '[WALK] <table>', '[FIND] <table>', '[TURNTO] <table>', '[FIND] <chair>', '[SIT] <chair>', '[FIND] <food_food>', '[GRAB] <food_food>', '[FIND] <plate>', '[PUTBACK] <food_food> <plate>', '[GRAB] <food_food>', '[PUTOBJBACK] <food_food>', '[FIND] <fork>', '[GRAB] <fork>', '[EAT] <plate>']
}

Input:
Scene_Objects:['filing_cabinet', 'tablelamp', 'microwave', 'chair', 'detergent', 'drawing', 'floor', 'phone', 'bedroom', 'keyboard', 'mat', 'tvstand', 'stereo', 'clothes_socks', 'candle', 'towel', 'dining_room', 'wall', 'nightstand', 'powersocket', 'bed', 'check', 'food_food', 'razor', 'kitchen_counter', 'vacuum_cleaner', 'dresser', 'door', 'sink', 'light']
Task:Listen to music
response:

Turn on radio, put on favorite channel, listen to music.

[WALK] <bedroom>
[WALK] <stereo>
[FIND] <stereo>
[SWITCHON] <stereo>
[FIND] <bed>
[LIE] <bed>


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

Here is an example plan to achieve a goal for reference:
Scene_Objects:['filing_cabinet', 'tea', 'bathroom', 'ceilingfan', 'milk', 'drawing', 'hanger', 'floor', 'ceiling', 'phone', 'desk', 'bookshelf', 'computer', 'ceilinglamp', 'tvstand', 'balanceball', 'mat', 'window', 'shoe-shine_kit', 'couch', 'food_jam', 'microphone', 'wall', 'nightstand', 'oven', 'cutting_board', 'television', 'curtain', 'pencil', 'table']
Task:Watch TV
response:
{
    "thoughts": We sit all around the television and watch a program.,
    "actions": ['[WALK] <home_office>', '[WALK] <television>', '[FIND] <television>', '[SWITCHON] <television>', '[FIND] <couch>', '[SIT] <couch>', '[WATCH] <television>']
}

Input:
Scene_Objects:['fork', 'chair', 'walllamp', 'milk', 'drawing', 'wallshelf', 'hanger', 'floor', 'ceiling', 'desk', 'remote_control', 'computer', 'mat', 'tvstand', 'ceilinglamp', 'faucet', 'closetdrawer', 'couch', 'candle', 'pillow', 'wall', 'cup', 'photoframe', 'television', 'curtain', 'doorjamb', 'mouse', 'dresser', 'bathroom_cabinet', 'teeth']
Task:Watch TV
response:

SIT ON THE COUCH, TURN TV ON WITH REMOTE, FIND A SHOW

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


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

Here is an example plan to achieve a goal for reference:
Scene_Objects:['spectacles', 'pot', 'scissors', 'microwave', 'jelly', 'trashcan', 'drawing', 'orchid', 'cpuscreen', 'hanger', 'shampoo', 'ceiling', 'keyboard', 'mail', 'brush', 'toaster', 'stovefan', 'plate', 'picture', 'oil', 'form', 'bowl', 'photoframe', 'newspaper', 'bed', 'kitchen_counter', 'shoes', 'dishrack', 'cupboard', 'home_office']
Task:Read book
response:
{
    "thoughts": Walk to living room. Find book. Grab book. Open book. Read book.,
    "actions": ['[WALK] <home_office>', '[WALK] <novel>', '[FIND] <novel>', '[GRAB] <novel>', '[READ] <novel>']
}

Input:
Scene_Objects:['tablelamp', 'microwave', 'chair', 'dog', 'drawing', 'cpuscreen', 'floor', 'phone', 'desk', 'keyboard', 'computer', 'laptop', 'mat', 'mousepad', 'wall', 'oven', 'love_seat', 'bed', 'coffe_maker', 'food_food', 'doorjamb', 'centerpiece', 'coffee_pot', 'mouse', 'pencil', 'hairbrush', 'controller', 'door', 'dishwasher', 'electrical_outlet']
Task:Write book
response:

[WALK] <home_office>
[WALK] <laptop>
[FIND] <laptop>
[GRAB] <laptop>
[FIND] <electrical_outlet>
[PLUGIN] <laptop>
[WALK] <love_seat>
[SIT] <love_seat>
[SWITCHON] <laptop>
[FIND] <keyboard>
[TYPE] <keyboard>


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

Here is an example plan to achieve a goal for reference:
Scene_Objects:['microwave', 'walllamp', 'drawing', 'orchid', 'wallshelf', 'floor', 'ceiling', 'shampoo', 'computer', 'mail', 'table_cloth', 'mat', 'tvstand', 'plate', 'couch', 'pillow', 'dining_room', 'food_kiwi', 'wall', 'nightstand', 'photoframe', 'check', 'television', 'curtain', 'after_shave', 'doorjamb', 'cards', 'mouse', 'shoes', 'sink']
Task:Relax on sofa
response:
{
    "thoughts": I walk to the living room. I sit in the sofa and I relax.,
    "actions": ['[WALK] <home_office>', '[WALK] <couch>', '[FIND] <couch>', '[SIT] <couch>']
}

Input:
Scene_Objects:['glue', 'pot', 'spectacles', 'food_ice_cream', 'crayon', 'microwave', 'toilet', 'band-aids', 'bathroom', 'needle', 'bathroom_counter', 'man', 'alcohol', 'mat', 'plate', 'stereo', 'faucet', 'mousepad', 'couch', 'pillow', 'dining_room', 'light_bulb', 'tray', 'doorjamb', 'towel_rack', 'dresser', 'bathroom_cabinet', 'home_office', 'table', 'board_game']
Task:Greet guests
response:

When someone knocks I n the door walk through the hallway and greet them.

[RUN] <home_office>
[WALK] <man>
[FIND] <man>
[GREET] <man>
[FIND] <man>
[GREET] <man>


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

Here is an example plan to achieve a goal for reference:
Scene_Objects:['filing_cabinet', 'juice', 'food_salt', 'microwave', 'detergent', 'trashcan', 'drawing', 'cpuscreen', 'bathroom_counter', 'floor', 'ceiling', 'phone', 'folder', 'desk', 'keyboard', 'food_cake', 'purse', 'shoe-shine_kit', 'faucet', 'wall', 'nightstand', 'powersocket', 'photoframe', 'check', 'coffe_maker', 'doorjamb', 'hair', 'sink', 'bathroom_cabinet', 'table']
Task:Clean sink
response:
{
    "thoughts": Take a premoistened cleaning wipe and wipe down top of sink and faucet.  Next clean the sink bowl.  Let air dry.,
    "actions": ['[WALK] <bathroom>', '[WALK] <rag>', '[FIND] <rag>', '[GRAB] <rag>', '[WALK] <sink>', '[FIND] <faucet>', '[WIPE] <faucet>', '[WIPE] <sink>', '[PUTOBJBACK] <rag>']
}

Input:
Scene_Objects:['chair', 'walllamp', 'drawing', 'wallshelf', 'hanger', 'floor', 'ceiling', 'desk', 'computer', 'stovefan', 'mat', 'tvstand', 'ceilinglamp', 'shower', 'toaster', 'closetdrawer', 'couch', 'food_jam', 'pillow', 'wall', 'cup', 'photoframe', 'coffee_table', 'novel', 'television', 'doorjamb', 'shoes', 'comb', 'dresser', 'instrument_violin']
Task:Watch TV
response:

I sit down on the couch, get the tv remote, click the on button, and change the channel to the show i want to watch


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', 'chair', 'ground_coffee', 'bathroom', 'detergent', 'bathroom_counter', 'bedroom', 'bookshelf', 'button', 'toaster', 'mat', 'ceilinglamp', 'window', 'mousepad', 'couch', 'dining_room', 'photoframe', 'bed', 'novel', 'coffe_maker', 'food_food', 'mouse', 'pencil', 'kitchen_counter', 'dresser', 'sink', 'dishwasher', 'clothes_skirt', 'soap']
Task:Pick up phone
response:
{
    "thoughts": walk to living room , find phone ,pick up phone 3,
    "actions": ['[WALK] <home_office>', '[WALK] <phone>', '[FIND] <phone>']
}

Input:
Scene_Objects:['sponge', 'chair', 'detergent', 'bathroom_counter', 'floor', 'ceiling', 'phone', 'bookshelf', 'toaster', 'mat', 'plate', 'faucet', 'ceilinglamp', 'dish_soap', 'wall', 'food_cheese', 'light_bulb', 'novel', 'coffe_maker', 'food_food', 'television', 'coffee_pot', 'towel_rack', 'kitchen_counter', 'shoes', 'dishrack', 'dresser', 'cupboard', 'sink', 'home_office']
Task:Wash dishes
response:

Put all dirty dishes on one side. Take sponge and cover it in soap. Soap each dish. Rinse each dish with water. Put on drying rack.

[WALK] <dining_room>
[WALK] <sink>
[FIND] <sponge>
[GRAB] <sponge>
[FIND] <dish_soap>
[GRAB] <dish_soap>
[POUR] <dish_soap> <sponge>
[PUTOBJBACK] <dish_soap>
[FIND] <plate>
[GRAB] <plate>
[SCRUB] <plate>
[FIND] <faucet>
[SWITCHON] <faucet>
[RINSE] <plate>
[FIND] <dishrack>
[PUTBACK] <plate> <dishrack>
[FIND] <plate>
[GRAB] <plate>
[SCRUB] <plate>
[RINSE] <plate>
[PUTBACK] <plate> <dishrack>
[FIND] <plate>
[GRAB] <plate>
[SCRUB] <plate>
[RINSE] <plate>
[PUTBACK] <plate> <dishrack>
[RINSE] <sponge>
[SQUEEZE] <sponge>
[SWITCHOFF] <faucet>
[PUTOBJBACK] <sponge>


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', 'crayon', 'chair', 'cat', 'dough', 'milk', 'hanger', 'floor', 'keyboard', 'mail', 'table_cloth', 'stovefan', 'plate', 'faucet', 'tvstand', 'window', 'couch', 'form', 'dining_room', 'cutting_board', 'photoframe', 'check', 'wine', 'dresser', 'hairbrush', 'pajamas', 'conditioner', 'home_office', 'bathroom_cabinet', 'table']
Task:Give milk to cat
response:
{
    "thoughts": Grab milk and pour it into the plate so that the cat can drink,
    "actions": ['[WALK] <home_office>', '[WALK] <cat>', '[FIND] <cat>', '[TURNTO] <cat>', '[POINTAT] <cat>', '[PULL] <cat>', '[FIND] <milk>', '[GRAB] <milk>', '[FIND] <plate>', '[POUR] <milk> <plate>', '[TOUCH] <cat>', '[SCRUB] <cat>']
}

Input:
Scene_Objects:['pot', 'microwave', 'chair', 'drawing', 'floor', 'ceiling', 'bedroom', 'alcohol', 'toaster', 'stovefan', 'mat', 'shower', 'faucet', 'deck_of_cards', 'shoe-shine_kit', 'pillow', 'wall', 'oven', 'cup', 'coffe_maker', 'tray', 'doorjamb', 'towel_rack', 'mouse', 'kitchen_counter', 'cupboard', 'sink', 'home_office', 'table', 'dishwasher']
Task:Drink
response:

Turn on the faucet.  Place glass under tap and fill with water.  Turn off faucet.  Drink water.

[WALK] <dining_room>
[WALK] <cupboard>
[FIND] <cupboard>
[OPEN] <cupboard>
[FIND] <cup>
[GRAB] <cup>
[CLOSE] <cupboard>
[WALK] <sink>
[FIND] <faucet>
[SWITCHON] <faucet>
[PUTBACK] <cup> <sink>
[GRAB] <cup>
[SWITCHOFF] <faucet>
[DRINK] <cup>


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

Here is an example plan to achieve a goal for reference:
Scene_Objects:['pot', 'filing_cabinet', 'toilet', 'chair', 'walllamp', 'orchid', 'wallshelf', 'bathroom_counter', 'floor', 'ceiling', 'bookshelf', 'keyboard', 'toaster', 'mat', 'tvstand', 'ceilinglamp', 'shower', 'window', 'plate', 'mousepad', 'pillow', 'wall', 'powersocket', 'photoframe', 'bed', 'television', 'wine', 'curtain', 'doorjamb', 'light']
Task:Watch TV
response:
{
    "thoughts": Walk to the room, in which the TV is located. Turn on TV pressing the power button for the TV. Watch TV.,
    "actions": ['[WALK] <home_office>', '[WALK] <television>', '[FIND] <television>', '[SWITCHON] <television>']
}

Input:
Scene_Objects:['pot', 'food_bread', 'chair', 'freezer', 'drawing', 'orchid', 'knife', 'kitchen_cabinet', 'floor', 'ceiling', 'ceilinglamp', 'plate', 'mat', 'stereo', 'shower', 'couch', 'pillow', 'food_kiwi', 'wall', 'pasta', 'bed', 'novel', 'food_food', 'check', 'television', 'console', 'pencil', 'kitchen_counter', 'cupboard', 'table']
Task:Cut bread
response:

I get a slice of bread, grab a knife, and then cut the piece of bread in half.

[WALK] <dining_room>
[WALK] <kitchen_cabinet>
[FIND] <kitchen_cabinet>
[OPEN] <kitchen_cabinet>
[FIND] <knife>
[GRAB] <knife>
[FIND] <plate>
[GRAB] <plate>
[CLOSE] <kitchen_cabinet>
[FIND]

[PUTBACK] <plate>

[PUTBACK] <knife>

[FIND] <freezer>
[OPEN] <freezer>
[FIND] <food_bread>
[GRAB] <food_bread>
[CLOSE] <freezer>
[PUTBACK] <food_bread> <plate>
[GRAB] <knife>
[CUT] <food_bread>
[PUTOBJBACK] <knife>


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

Here is an example plan to achieve a goal for reference:
Scene_Objects:['tablelamp', 'microwave', 'walllamp', 'nail_polish', 'trashcan', 'drawing', 'orchid', 'floor', 'desk', 'computer', 'food_bacon', 'stovefan', 'mat', 'tvstand', 'ceilinglamp', 'faucet', 'window', 'mousepad', 'couch', 'pillow', 'wall', 'bench', 'coffe_maker', 'television', 'curtain', 'mouse', 'bathtub', 'home_office', 'table', 'bathroom_cabinet']
Task:Relax on sofa
response:
{
    "thoughts": Open coffee maker. Put filter in main basket, put ground coffee in filter, fill reservoir with water, turn on coffee maker.,
    "actions": ['[WALK] <home_office>', '[WALK] <couch>', '[FIND] <couch>', '[SIT] <couch>']
}

Input:
Scene_Objects:['pot', 'food_bread', 'juice', 'microwave', 'chair', 'freezer', 'detergent', 'drawing', 'orchid', 'floor', 'ceiling', 'toaster', 'stovefan', 'plate', 'shower', 'mat', 'ceilinglamp', 'couch', 'pillow', 'wall', 'pasta', 'oven', 'cup', 'newspaper', 'coffe_maker', 'television', 'ice', 'wine', 'tray', 'towel_rack', 'kitchen_counter', 'headset', 'cupboard', 'table', 'dishwasher', 'creditcard']
Task:Grab some juice
response:

I go to the fridge, and grab some juice out of it. I then get a glass, and pour the juice into the glass.

[WALK] <dining_room>
[WALK] <cupboard>
[FIND] <cupboard>
[OPEN] <cupboard>
[FIND] <cup>
[GRAB] <cup>
[CLOSE] <cupboard>
[WALK] <freezer>
[OPEN] <freezer>
[FIND] <juice>
[GRAB] <juice>
[POUR] <juice> <cup>
[PUTOBJBACK] <juice>
[CLOSE] <freezer>
[FIND] <table>
[PUTBACK] <cup> <table>


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

Here is an example plan to achieve a goal for reference:
Scene_Objects:['tablelamp', 'microwave', 'chair', 'freezer', 'detergent', 'tea_bag', 'food_bacon', 'mop_bucket', 'stereo', 'iron', 'couch', 'pasta', 'powersocket', 'oven', 'wall_clock', 'photoframe', 'coffe_maker', 'mouthwash', 'television', 'food_rice', 'tray', 'after_shave', 'towel_rack', 'kitchen_counter', 'cd', 'dishrack', 'comb', 'dresser', 'clothes_skirt', 'creditcard']
Task:Listen to music
response:
{
    "thoughts": I walk to the radio.  I switch on the radio and listen,
    "actions": ['[WALK] <home_office>', '[WALK] <stereo>', '[SWITCHON] <stereo>']
}

Input:
Scene_Objects:['mop', 'chair', 'jelly', 'walllamp', 'drawing', 'wallshelf', 'food_egg', 'hanger', 'floor', 'ceiling', 'character', 'desk', 'remote_control', 'computer', 'mat', 'tvstand', 'ceilinglamp', 'shower', 'closetdrawer', 'couch', 'pillow', 'wall', 'photoframe', 'television', 'food_rice', 'doorjamb', 'diary', 'kitchen_counter', 'dresser', 'coffee']
Task:Watch  horror  movie
response:

I would  find something  scary  to  watch on dvd

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


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

Here is an example plan to achieve a goal for reference:
Scene_Objects:['sheets', 'tablelamp', 'food_ice_cream', 'walllamp', 'trashcan', 'ceilingfan', 'drawing', 'longboard', 'floor', 'bookshelf', 'computer', 'faucet', 'balanceball', 'window', 'iron', 'food_peanut_butter', 'food_jam', 'wall', 'nightstand', 'bench', 'powersocket', 'basket_for_clothes', 'novel', 'check', 'coffee_filter', 'shaving_cream', 'pencil', 'maindoor', 'sink', 'hairdryer']
Task:Pick up phone
response:
{
    "thoughts": Enter the Home office, then walk to the phone, pickup the phone.,
    "actions": ['[WALK] <home_office>', '[WALK] <phone>', '[GRAB] <phone>']
}

Input:
Scene_Objects:['chair', 'walllamp', 'drawing', 'wallshelf', 'hanger', 'floor', 'ceiling', 'desk', 'bookshelf', 'computer', 'mat', 'tvstand', 'ceilinglamp', 'stereo', 'closetdrawer', 'couch', 'pillow', 'wall', 'photoframe', 'bed', 'television', 'doorjamb', 'shaving_cream', 'mouse', 'coffee', 'dresser', 'hairbrush', 'clothes_scarf', 'soap', 'teeth']
Task:Watch TV
response:

Sitting on the couch watching my favorite television show.

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


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

Here is an example plan to achieve a goal for reference:
Scene_Objects:['spectacles', 'filing_cabinet', 'tea', 'microwave', 'dog', 'freezer', 'walllamp', 'drawing', 'orchid', 'hanger', 'keyboard', 'button', 'ceilinglamp', 'stereo', 'homework', 'mousepad', 'closetdrawer', 'food_peanut_butter', 'food_jam', 'wall', 'oven', 'food_cheese', 'keys', 'tray', 'lighter', 'mouse', 'kitchen_counter', 'cd', 'clothes_dress', 'bathroom_cabinet']
Task:Pet cat
response:
{
    "thoughts": Petting the cat,
    "actions": ['[WALK] <home_office>', '[WALK] <cat>', '[FIND] <cat>', '[TOUCH] <cat>']
}

Input:
Scene_Objects:['pot', 'microwave', 'freezer', 'dough', 'milk', 'drawing', 'floor', 'ceiling', 'keyboard', 'food_bacon', 'toaster', 'stovefan', 'mat', 'shower', 'couch', 'pillow', 'bowl', 'wall', 'oven', 'cup', 'coffe_maker', 'check', 'television', 'tray', 'curtain', 'towel_rack', 'kitchen_counter', 'cupboard', 'light', 'dishwasher']
Task:Get something to drink
response:

Walk into the kitchen and to the cupboard to get a cup, walk to the fridge to look for a beverage to enjoy, open the freezer and get ice, pour beverage and enjoy

[WALK] <dining_room>
[WALK] <cupboard>
[FIND] <cupboard>
[OPEN] <cupboard>
[FIND] <cup>
[GRAB] <cup>
[CLOSE] <cupboard>
[WALK] <freezer>
[OPEN] <freezer>
[FIND] <milk>
[GRAB] <milk>
[CLOSE] <freezer>
[POUR] <milk> <cup>
[DRINK] <cup>


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

Here is an example plan to achieve a goal for reference:
Scene_Objects:['spectacles', 'tablelamp', 'beer', 'chair', 'walllamp', 'bathroom', 'wallshelf', 'floor', 'ceiling', 'ceilinglamp', 'mat', 'stereo', 'couch', 'pillow', 'bowl', 'wall', 'nightstand', 'powersocket', 'cup', 'toilet_paper', 'television', 'after_shave', 'rag', 'doorjamb', 'coffee_pot', 'dishrack', 'instrument_guitar', 'table', 'soap', 'laser_pointer']
Task:Relax on sofa
response:
{
    "thoughts": walk to living room, walk to sofa, sit in sofa,
    "actions": ['[WALK] <home_office>', '[WALK] <couch>', '[SIT] <couch>']
}

Input:
Scene_Objects:['glue', 'filing_cabinet', 'blow_dryer', 'walllamp', 'knife', 'orchid', 'cpuscreen', 'floor', 'computer', 'button', 'ceilinglamp', 'oil', 'mousepad', 'cup', 'bed', 'keys', 'novel', 'check', 'coffe_maker', 'toothbrush_holder', 'coffee_filter', 'food_food', 'curtain', 'pencil', 'shoes', 'controller', 'hairdryer', 'bathroom_cabinet', 'table', 'board_game']
Task:Get ready to leave
response:

Get your jacket and shoes on, locate the keys off the side table, walk out the front door and secure building with keys when you leave

[WALK] <home_office>
[WALK] <shoes>
[FIND] <shoes>
[GRAB] <shoes>
[PUTON] <shoes>
[FIND] <keys>
[GRAB] <keys>


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', 'trashcan', 'dough', 'orchid', 'knife', 'clothes_underwear', 'phone', 'tea_bag', 'envelope', 'mat', 'faucet', 'clothes_socks', 'clothes_pants', 'clothes_hat', 'bench', 'powersocket', 'basket_for_clothes', 'food_food', 'food_rice', 'tray', 'curtain', 'after_shave', 'doorjamb', 'pencil', 'laundry_detergent', 'bathroom_cabinet', 'table', 'light', 'clothes_shirt', 'washing_machine']
Task:Wash clothes
response:
{
    "thoughts": I go to the bathroom and open the washing machine there. I take my laundry basket and put each item of laundry into the machine. Then I take the laundry detergent and pour some into the machine. Finally I close the machine and switch it on.,
    "actions": ['[WALK] <bathroom>', '[WALK] <washing_machine>', '[FIND] <washing_machine>', '[OPEN] <washing_machine>', '[FIND] <basket_for_clothes>', '[GRAB] <basket_for_clothes>', '[FIND] <clothes_pants>', '[GRAB] <clothes_pants>', '[PUTBACK] <clothes_pants> <washing_machine>', '[FIND] <clothes_shirt>', '[GRAB] <clothes_shirt>', '[PUTBACK] <clothes_shirt> <washing_machine>', '[FIND] <clothes_underwear>', '[GRAB] <clothes_underwear>', '[PUTBACK] <clothes_underwear> <washing_machine>', '[FIND] <clothes_socks>', '[GRAB] <clothes_socks>', '[PUTBACK] <clothes_socks> <washing_machine>', '[PUTOBJBACK] <basket_for_clothes>', '[FIND] <laundry_detergent>', '[GRAB] <laundry_detergent>', '[POUR] <laundry_detergent> <washing_machine>', '[CLOSE] <washing_machine>', '[SWITCHON] <washing_machine>']
}

Input:
Scene_Objects:['filing_cabinet', 'walllamp', 'bathroom', 'drawing', 'cpuscreen', 'wallshelf', 'floor', 'ceiling', 'character', 'tea_bag', 'computer', 'table_cloth', 'toaster', 'mat', 'tvstand', 'stovefan', 'electric_shaver', 'couch', 'pillow', 'wall', 'basket_for_clothes', 'newspaper', 'coffee_table', 'photoframe', 'video_game_controller', 'television', 'doorjamb', 'dresser', 'cupboard', 'dishwasher']
Task:Read magazine
response:

Get magazine off coffee table. Sit in arm chair. Open magazine to first page. Read until finished.

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


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', 'band-aids', 'walllamp', 'detergent', 'orchid', 'drawing', 'floor', 'ceiling', 'phone', 'video_game_console', 'computer', 'ceilinglamp', 'tvstand', 'mat', 'plate', 'window', 'closetdrawer', 'couch', 'pillow', 'nightstand', 'wall', 'photoframe', 'video_game_controller', 'television', 'curtain', 'dresser', 'table', 'dishwasher']
Task:Play games
response:
{
    "thoughts": Turn on game.  Use controller,
    "actions": ['[WALK] <home_office>', '[WALK] <television>', '[PLUGIN] <television>', '[SWITCHON] <television>', '[FIND] <video_game_console>', '[PLUGIN] <video_game_console>', '[SWITCHON] <video_game_console>', '[FIND] <video_game_console>', '[FIND] <video_game_controller>', '[GRAB] <video_game_controller>', '[WALK] <couch>', '[SIT] <couch>']
}

Input:
Scene_Objects:['tablelamp', 'chair', 'walllamp', 'drawing', 'wallshelf', 'cpuscreen', 'bathroom_counter', 'floor', 'ceiling', 'phone', 'desk', 'keyboard', 'computer', 'laptop', 'mat', 'tvstand', 'mousepad', 'closetdrawer', 'couch', 'pillow', 'dining_room', 'wall', 'oven', 'cup', 'photoframe', 'television', 'doorjamb', 'mouse', 'door', 'creditcard']
Task:Play on laptop
response:

Sit down on the couch. Place laptop on lap. Open laptop. Turn on laptop. Choose selected program. Play selected program. Close game. Close laptop.

[WALK] <home_office>
[WALK] <laptop>
[FIND] <laptop>
[GRAB] <laptop>
[FIND] <couch>
[SIT] <couch>
[SWITCHON] <laptop>
[FIND] <keyboard>
[TYPE] <keyboard>
[SWITCHOFF] <laptop>
[PUTOBJBACK] <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:['filing_cabinet', 'microwave', 'walllamp', 'trashcan', 'knifeblock', 'floor', 'character', 'desk', 'bedroom', 'keyboard', 'thread', 'toaster', 'plate', 'couch', 'wall', 'light_bulb', 'novel', 'coffe_maker', 'food_rice', 'tray', 'food_onion', 'after_shave', 'curtain', 'kettle', 'kitchen_counter', 'shoes', 'cupboard', 'conditioner', 'door', 'dishwasher']
Task:Wash dishes with dishwasher
response:
{
    "thoughts": In the kitchen, open up the dishwasher. Take plates from the sink and put them in the dishwasher one by one. Close the dishwasher. Program it. Push start.,
    "actions": ['[WALK] <dining_room>', '[WALK] <dishwasher>', '[FIND] <dishwasher>', '[OPEN] <dishwasher>', '[FIND] <plate>', '[GRAB] <plate>', '[PUTBACK] <plate> <dishwasher>', '[FIND] <plate>', '[GRAB] <plate>', '[PUTBACK] <plate> <dishwasher>', '[FIND] <plate>', '[GRAB] <plate>', '[PUTBACK] <plate> <dishwasher>', '[CLOSE] <dishwasher>', '[SWITCHON] <dishwasher>']
}

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', 'oven', 'television', 'doorjamb', 'mouse', 'dresser', 'door', 'home_office']
Task:Check email
response:

Turn on the computer.  Wait for it to load.  Get online.  Go to the email service.  Open the email.  Read the email.

[WALK] <home_office>
[WALK] <chair>
[FIND] <chair>
[SIT] <chair>
[FIND] <computer>
[SWITCHON] <computer>
[FIND] <keyboard>
[TYPE] <keyboard>
[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:['tablelamp', 'microwave', 'toilet', 'walllamp', 'bathroom', 'drawing', 'orchid', 'knifeblock', 'floor', 'ceiling', 'bookshelf', 'stovefan', 'couch', 'pillow', 'wall', 'nightstand', 'powersocket', 'toy', 'novel', 'coffe_maker', 'television', 'wooden_spoon', 'doorjamb', 'kitchen_counter', 'shoes', 'cupboard', 'door', 'home_office', 'table', 'light']
Task:Read book
response:
{
    "thoughts": Go to the living room and find the book you want to read. Take it and then go to the couch. Sit on it, open the book and start reading.,
    "actions": ['[WALK] <home_office>', '[WALK] <novel>', '[FIND] <novel>', '[GRAB] <novel>', '[FIND] <couch>', '[SIT] <couch>', '[READ] <novel>']
}

Input:
Scene_Objects:['spectacles', 'juice', 'nail_polish', 'wallshelf', 'floor', 'ceiling', 'face', 'mat', 'iron', 'shower', 'stereo', 'clothes_socks', 'food_jam', 'wall_clock', 'light_bulb', 'food_food', 'razor', 'mirror', 'food_rice', 'curtain', 'centerpiece', 'towel_rack', 'hair', 'clothes_dress', 'napkin', 'bathroom_cabinet', 'home_office', 'table', 'soap', 'shoe_rack']
Task:Check appearance in mirror
response:

Walk to full-length mirror. Look in mirror. Make sure everything about your appearance is adequate. Adjust clothes as needed.

[WALK] <bedroom>
[WALK] <mirror>
[FIND] <mirror>
[TURNTO] <mirror>
[LOOKAT] <mirror>
[FIND] <face>
[TURNTO] <face>
[LOOKAT] <face>
[FIND] <hair>
[TURNTO] <hair>
[LOOKAT] <hair>
[FIND] <clothes_dress>
[TURNTO] <clothes_dress>
[LOOKAT] <clothes_dress>


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

Here is an example plan to achieve a goal for reference:
Scene_Objects:['sheets', 'microwave', 'cpuscreen', 'hanger', 'floor', 'bookshelf', 'bookmark', 'stovefan', 'mat', 'faucet', 'window', 'couch', 'pillow', 'wall', 'wall_clock', 'cutting_board', 'cup', 'newspaper', 'novel', 'video_game_controller', 'television', 'curtain', 'doorjamb', 'hair', 'clothes_dress', 'door', 'sink', 'bathtub', 'bathroom_cabinet', 'table']
Task:Relax on sofa
response:
{
    "thoughts": Go to the living room and relax on the sofa with a book,
    "actions": ['[RUN] <home_office>', '[WALK] <novel>', '[FIND] <novel>', '[GRAB] <novel>', '[WALK] <couch>', '[SIT] <couch>', '[TURNTO] <novel>', '[LOOKAT] <novel>', '[FIND] <bookmark>', '[GRAB] <bookmark>', '[DROP] <bookmark>', '[TURNTO] <novel>', '[LOOKAT] <novel>', '[READ] <novel>', '[READ] <novel>', '[READ] <novel>']
}

Input:
Scene_Objects:['wallshelf', 'phone', 'dvd_player', 'character', 'computer', 'ceilinglamp', 'foundation', 'mousepad', 'bowl', 'wall', 'cutting_board', 'box', 'cup', 'food_cheese', 'bed', 'photoframe', 'coffe_maker', 'food_food', 'doorjamb', 'centerpiece', 'mouse', 'shoes', 'comb', 'dresser', 'conditioner', 'clothes_dress', 'hairdryer', 'spoon', 'bathroom_cabinet', 'light']
Task:Leave home
response:

Put on shoes. Put on coat. Open door and exit through it. Lock door behind you.

[WALK] <home_office>
[WALK] <shoes>
[FIND] <shoes>
[GRAB] <shoes>
[PUTON] <shoes>


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

Here is an example plan to achieve a goal for reference:
Scene_Objects:['dry_pasta', 'microwave', 'freezer', 'walllamp', 'detergent', 'dough', 'floor', 'phone', 'ceiling', 'tea_bag', 'bookshelf', 'keyboard', 'toaster', 'laptop', 'tvstand', 'faucet', 'mousepad', 'dining_room', 'wall', 'box', 'cup', 'photoframe', 'coffe_maker', 'tray', 'doorjamb', 'kitchen_counter', 'dishrack', 'cupboard', 'sink', 'dishwasher']
Task:Make popcorn
response:
{
    "thoughts": Lay popcorn bag flat inside microwave and press popcorn button to start.,
    "actions": ['[WALK] <dining_room>', '[WALK] <food_food>', '[FIND] <food_food>', '[GRAB] <food_food>', '[WALK] <microwave>', '[TURNTO] <microwave>', '[OPEN] <microwave>', '[PUTIN] <food_food> <microwave>', '[CLOSE] <microwave>', '[SWITCHON] <microwave>']
}

Input:
Scene_Objects:['sheets', 'pot', 'food_pizza', 'jelly', 'freezer', 'bathroom', 'detergent', 'food_butter', 'food_carrot', 'cpuscreen', 'bedroom', 'stovefan', 'ceilinglamp', 'toaster', 'faucet', 'mousepad', 'food_noodles', 'food_orange', 'nightstand', 'cup', 'check', 'coffe_maker', 'doorjamb', 'mouse', 'kitchen_counter', 'napkin', 'spoon', 'table', 'home_office', 'soap']
Task:Open door
response:

Open the door when leaving or coming in.


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

Here is an example plan to achieve a goal for reference:
Scene_Objects:['toilet', 'cat', 'floor', 'character', 'stamp', 'table_cloth', 'piano_bench', 'mat', 'window', 'couch', 'food_jam', 'pillow', 'wall', 'nightstand', 'bench', 'toy', 'cup', 'mouthwash', 'television', 'coffee_filter', 'tray', 'curtain', 'doorjamb', 'towel_rack', 'clothes_dress', 'door', 'food_steak', 'bathtub', 'bag', 'table']
Task:Pet cat
response:
{
    "thoughts": I see my cat on the couch so I walk over, sit down and pet the cat.,
    "actions": ['[WALK] <home_office>', '[WALK] <cat>', '[FIND] <cat>', '[TURNTO] <cat>', '[LOOKAT] <cat>', '[FIND] <couch>', '[SIT] <couch>', '[TOUCH] <cat>']
}

Input:
Scene_Objects:['tablelamp', 'toilet', 'chair', 'bathroom', 'drawing', 'orchid', 'cpuscreen', 'floor', 'ceiling', 'desk', 'keyboard', 'computer', 'mat', 'ceilinglamp', 'tvstand', 'mousepad', 'closetdrawer', 'couch', 'pillow', 'wall', 'nightstand', 'novel', 'food_food', 'television', 'doorjamb', 'mouse', 'pencil', 'dresser', 'door', 'shoe_rack']
Task:Put in chair
response:

Take a comfortable chair. Place it in the entrance hall

[WALK] <home_office>
[WALK] <chair>
[FIND] <chair>
[GRAB] <chair>
[WALK] <home_office>
[WALK] <floor>
[FIND] <floor>
[PUTBACK] <chair> <floor>


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', 'ground_coffee', 'walllamp', 'trashcan', 'orchid', 'bathroom_counter', 'floor', 'ceiling', 'phone', 'dvd_player', 'toaster', 'shoe-shine_kit', 'faucet', 'clothes_pants', 'dining_room', 'wall', 'photoframe', 'clothes_gloves', 'coffe_maker', 'coffee_filter', 'centerpiece', 'kitchen_counter', 'cd', 'cupboard', 'controller', 'clothes_scarf', 'home_office', 'table', 'dishwasher']
Task:Make coffee
response:
{
    "thoughts": Open the coffee maker and put a filer, grab ground coffee and put it in the coffee maker, then 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>', '[FIND] <ground_coffee>', '[PUTBACK] <ground_coffee> <coffe_maker>', '[CLOSE] <coffe_maker>', '[SWITCHON] <coffe_maker>']
}

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

Sit in desk chair, press power button, let computer power on

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


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

Here is an example plan to achieve a goal for reference:
Scene_Objects:['spectacles', 'toilet', 'chair', 'walllamp', 'bathroom', 'orchid', 'floor', 'ceiling', 'bookshelf', 'table_cloth', 'bookmark', 'ceilinglamp', 'mat', 'stereo', 'shower', 'floor_lamp', 'food_noodles', 'clothes_hat', 'dining_room', 'wall', 'television', 'food_donut', 'doorjamb', 'kitchen_counter', 'dresser', 'door', 'bathtub', 'bathroom_cabinet', 'light', 'coffee']
Task:Turn on light
response:
{
    "thoughts": walk to wall, find light switch, turn on lights,
    "actions": ['[WALK] <home_office>', '[WALK] <light>', '[FIND] <light>', '[PLUGIN] <light>', '[FIND] <floor_lamp>', '[SWITCHON] <floor_lamp>', '[WALK] <bedroom>', '[WALK] <light>', '[SWITCHON] <light>']
}

Input:
Scene_Objects:['food_bread', 'freezer', 'walllamp', 'drawing', 'needle', 'floor', 'ceiling', 'bookshelf', 'toaster', 'mat', 'faucet', 'mousepad', 'closetdrawer', 'couch', 'pillow', 'food_kiwi', 'wall', 'cup', 'coffe_maker', 'television', 'food_donut', 'wine', 'towel_rack', 'kitchen_counter', 'dresser', 'cupboard', 'food_steak', 'sink', 'dishwasher', 'electrical_outlet']
Task:Toast bread
response:

Place two slices of bread in the toaster. Select medium toast on toaster.  Push down button to begin toasting.

[WALK] <dining_room>
[WALK] <freezer>
[FIND] <freezer>
[OPEN] <freezer>
[FIND] <food_bread>
[GRAB] <food_bread>
[CLOSE] <freezer>
[WALK] <electrical_outlet>
[FIND] <toaster>
[PLUGIN] <toaster>
[PUTBACK] <food_bread> <toaster>
[SWITCHON] <electrical_outlet>
[TURNTO] <toaster>
[LOOKAT] <toaster>
[SWITCHON] <toaster>


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', 'jelly', 'bathroom', 'knife', 'dvd_player', 'character', 'bedroom', 'thread', 'computer', 'toaster', 'shoe-shine_kit', 'deck_of_cards', 'shower', 'electric_shaver', 'homework', 'food_peanut_butter', 'form', 'powersocket', 'food_cheese', 'photoframe', 'bed', 'novel', 'light_bulb', 'food_food', 'curtain', 'coffee_pot', 'food_steak', 'door', 'light']
Task:Listen to music
response:
{
    "thoughts": Go to the living room. Find the radio. Turn on the radio.,
    "actions": ['[WALK] <home_office>', '[WALK] <stereo>', '[FIND] <stereo>', '[SWITCHON] <stereo>']
}

Input:
Scene_Objects:['scissors', 'chair', 'food_butter', 'drawing', 'orchid', 'bills', 'wallshelf', 'cpuscreen', 'floor', 'shampoo', 'character', 'thread', 'alcohol', 'piano_bench', 'brush', 'ceilinglamp', 'mat', 'iron', 'dining_room', 'wall', 'wall_clock', 'pasta', 'newspaper', 'food_food', 'television', 'console', 'kitchen_counter', 'pajamas', 'table', 'shoe_rack']
Task:Put down bags
response:

When walking into the house, putting down the things i am carrying

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


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', 'trashcan', 'toothbrush', 'drawing', 'orchid', 'needle', 'hanger', 'bathroom_counter', 'floor', 'ceiling', 'stamp', 'bookshelf', 'remote_control', 'button', 'toaster', 'ceilinglamp', 'tvstand', 'mat', 'wall', 'powersocket', 'television', 'food_rice', 'doorjamb', 'pencil', 'chessboard', 'door', 'hairdryer', 'bathroom_cabinet', 'table', 'scrabble']
Task:Change TV channel
response:
{
    "thoughts": I go to the livingroom. The TV is on. I pick up the remote and press the next channel button. I look at the television, and see that the channel has changed.,
    "actions": ['[WALK] <home_office>', '[WALK] <television>', '[FIND] <television>', '[TURNTO] <television>', '[LOOKAT] <television>', '[FIND] <remote_control>', '[GRAB] <remote_control>', '[FIND] <button>', '[PUSH] <button>', '[TURNTO] <television>', '[LOOKAT] <television>']
}

Input:
Scene_Objects:['pot', 'tablelamp', 'beer', 'detergent', 'food_butter', 'orchid', 'hanger', 'floor', 'ceiling', 'computer', 'toaster', 'mat', 'closetdrawer', 'broom', 'wall', 'nightstand', 'toy', 'newspaper', 'toilet_paper', 'television', 'wine', 'doorjamb', 'kitchen_counter', 'shoes', 'chessboard', 'dresser', 'door', 'dishwasher', 'instrument_violin', 'laser_pointer']
Task:Put away shoes
response:

Pick up shoes from entry hall. Open entry way closet. Put shoes in closet. Close closet door.

[WALK] <home_office>
[WALK] <shoes>
[FIND] <shoes>
[GRAB] <shoes>
[FIND] <dresser>
[OPEN] <dresser>
[PUTIN] <shoes> <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:['blow_dryer', 'bathroom', 'food_carrot', 'bathroom_counter', 'floor', 'ceiling', 'desk', 'stamp', 'bedroom', 'food_cake', 'computer', 'shower', 'picture', 'oven', 'basket_for_clothes', 'photoframe', 'food_food', 'check', 'towel_rack', 'mouse', 'pencil', 'shoes', 'comb', 'hairbrush', 'cupboard', 'laundry_detergent', 'sink', 'napkin', 'light', 'washing_machine']
Task:Wash clothes
response:
{
    "thoughts": Pick up my dirty clothes, load the washer, add detergent, turn on washer,
    "actions": ['[WALK] <bedroom>', '[WALK] <basket_for_clothes>', '[GRAB] <basket_for_clothes>', '[WALK] <home_office>', '[WALK] <washing_machine>', '[OPEN] <washing_machine>', '[PUTBACK] <basket_for_clothes> <washing_machine>', '[FIND] <laundry_detergent>', '[GRAB] <laundry_detergent>', '[PUTBACK] <laundry_detergent> <washing_machine>', '[RUN] <washing_machine>']
}

Input:
Scene_Objects:['chair', 'walllamp', 'drawing', 'wallshelf', 'floor', 'ceiling', 'desk', 'keyboard', 'bookshelf', 'mat', 'ceilinglamp', 'tvstand', 'faucet', 'shower', 'mousepad', 'couch', 'pillow', 'dining_room', 'wall', 'powersocket', 'food_food', 'television', 'doorjamb', 'mouse', 'cupboard', 'conditioner', 'door', 'bathroom_cabinet', 'light', 'table']
Task:Look at painting
response:

Walk to the painting.  Look up at the painting.  Admire it on the wall.

[WALK] <home_office>
[WALK] <drawing>
[FIND] <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:['tablelamp', 'beer', 'toilet', 'dough', 'toothbrush', 'drawing', 'floor', 'ceiling', 'computer', 'ceilinglamp', 'tvstand', 'stereo', 'shower', 'window', 'oil', 'couch', 'bowl', 'wall', 'oven', 'toy', 'cup', 'bed', 'food_food', 'television', 'wooden_spoon', 'towel_rack', 'comb', 'cupboard', 'table', 'dishwasher']
Task:Relax on sofa
response:
{
    "thoughts": Walk to living room. Find couch. Sit on couch,
    "actions": ['[WALK] <home_office>', '[WALK] <couch>', '[FIND] <couch>', '[SIT] <couch>']
}

Input:
Scene_Objects:['dry_pasta', 'freezer', 'walllamp', 'bathroom', 'dough', 'knife', 'orchid', 'thread', 'computer', 'ceilinglamp', 'deck_of_cards', 'shower', 'clothes_socks', 'food_noodles', 'dustpan', 'nightstand', 'photoframe', 'light_bulb', 'television', 'coffee_filter', 'mirror', 'curtain', 'doorjamb', 'laundry_detergent', 'sink', 'bag', 'table', 'soap', 'clothes_shirt', 'creditcard']
Task:Look at mirror
response:

I look at my reflection to check my cleanliness.

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