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

Here is an example plan to achieve a goal for reference:
Scene_Objects:['chair', 'walllamp', 'bills', 'drawing', 'cpuscreen', 'floor', 'ceiling', 'character', 'desk', 'keyboard', 'bookshelf', 'computer', 'ceilinglamp', 'mousepad', 'closetdrawer', 'wall', 'powersocket', 'shelf', 'cup', 'television', 'doorjamb', 'mouse', 'address_book', 'dresser', 'conditioner', 'bathtub', 'spoon', 'light', 'table', 'soap']
Task:Work
response:
{
    "thoughts": Walk to home office. Walk to computer. Switch on computer. Open the address book.,
    "actions": ['[WALK] <home_office>', '[WALK] <computer>', '[SWITCHON] <computer>', '[FIND] <address_book>']
}

Input:
Scene_Objects:['chair', 'walllamp', 'drawing', 'wallshelf', 'hanger', 'floor', 'ceiling', 'desk', 'keyboard', 'computer', 'bookmark', 'mat', 'tvstand', 'ceilinglamp', 'shower', 'mousepad', 'closetdrawer', 'couch', 'microphone', 'clothes_pants', 'pillow', 'wall', 'nightstand', 'photoframe', 'keys', 'television', 'tray', 'doorjamb', 'dresser', 'bathroom_cabinet']
Task:Change TV channel
response:

Walk to the living room. Find remote control. Grab remote control. Walk to television. Look at television. Switch on remote control.

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


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

Here is an example plan to achieve a goal for reference:
Scene_Objects:['food_pizza', 'chair', 'walllamp', 'orchid', 'wallshelf', 'clothes_underwear', 'floor', 'ceiling', 'bookshelf', 'remote_control', 'button', 'toaster', 'mat', 'tvstand', 'ceilinglamp', 'shower', 'window', 'wall', 'powersocket', 'oven', 'bench', 'photoframe', 'television', 'curtain', 'food_onion', 'doorjamb', 'towel_rack', 'bathroom_cabinet', 'light', 'home_office']
Task:Watch TV
response:
{
    "thoughts": Walk to living room.  Find remote control.  Find television.  Point remote at television.  Press "on" button.  Watch.,
    "actions": ['[WALK] <home_office>', '[WALK] <television>', '[FIND] <television>', '[FIND] <remote_control>', '[TURNTO] <television>', '[POINTAT] <television>', '[FIND] <button>', '[PUSH] <button>', '[TURNTO] <television>', '[WATCH] <television>']
}

Input:
Scene_Objects:['pot', 'chair', 'walllamp', 'bathroom', 'toothbrush', 'drawing', 'wallshelf', 'hanger', 'floor', 'ceiling', 'desk', 'computer', 'button', 'mat', 'tvstand', 'ceilinglamp', 'closetdrawer', 'couch', 'pillow', 'wall', 'box', 'photoframe', 'coffe_maker', 'television', 'doorjamb', 'comb', 'dresser', 'laundry_detergent', 'instrument_guitar', 'dishwasher']
Task:Watch TV
response:

I walk to the living room. I reach for the remote. I push the on button on the remote. I sit down on the couch and watch television.

[WALK] <home_office>
[WALK] <button>
[FIND] <button>
[PUSH] <button>
[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:['sheets', 'pot', 'shoe_rack', 'toilet', 'chair', 'band-aids', 'freezer', 'walllamp', 'cat', 'trashcan', 'folder', 'bookshelf', 'deck_of_cards', 'shower', 'mousepad', 'food_kiwi', 'wall', 'powersocket', 'cup', 'bed', 'clothes_gloves', 'keys', 'television', 'kitchen_counter', 'dishrack', 'controller', 'napkin', 'light', 'soap', 'creditcard']
Task:Pet cat
response:
{
    "thoughts": I go to the living room then go to the cat and touch it.,
    "actions": ['[WALK] <home_office>', '[WALK] <cat>', '[FIND] <cat>', '[TOUCH] <cat>']
}

Input:
Scene_Objects:['tablelamp', 'drawing', 'wallshelf', 'floor', 'ceiling', 'shampoo', 'character', 'desk', 'bookshelf', 'mat', 'deck_of_cards', 'couch', 'pillow', 'wall', 'powersocket', 'cup', 'food_cheese', 'photoframe', 'bed', 'coffee_filter', 'wine', 'curtain', 'doorjamb', 'kitchen_counter', 'pajamas', 'door', 'food_steak', 'bag', 'light', 'electrical_outlet']
Task:Turn on light
response:

I walk to the living room. I find the electric outlet. I switch on the light.

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


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

Here is an example plan to achieve a goal for reference:
Scene_Objects:['beer', 'bathroom', 'orchid', 'knifeblock', 'food_egg', 'clothes_underwear', 'shampoo', 'bedroom', 'tvstand', 'shoe-shine_kit', 'pillow', 'dining_room', 'bench', 'powersocket', 'coffe_maker', 'video_game_controller', 'television', 'food_rice', 'tray', 'after_shave', 'food_onion', 'doorjamb', 'diary', 'towel_rack', 'mouse', 'comb', 'cupboard', 'bathroom_cabinet', 'light', 'tooth_paste']
Task:Turn on light
response:
{
    "thoughts": I go to bedroom and locate a lamp. This lamp can be turned on by touch, as it has capacitive sensing. So I do it.,
    "actions": ['[WALK] <bedroom>', '[WALK] <floor_lamp>', '[FIND] <floor_lamp>', '[TOUCH] <floor_lamp>', '[SWITCHON] <floor_lamp>']
}

Input:
Scene_Objects:['spectacles', 'microwave', 'freezer', 'walllamp', 'drawing', 'orchid', 'cpuscreen', 'wallshelf', 'floor', 'ceiling', 'mat', 'ceilinglamp', 'tvstand', 'faucet', 'closetdrawer', 'couch', 'food_orange', 'pillow', 'wall', 'food_food', 'television', 'rag', 'doorjamb', 'kitchen_counter', 'headset', 'cupboard', 'food_steak', 'light', 'laser_pointer', 'clothes_shirt']
Task:Put groceries in Fridge
response:

Find groceries. Grab groceries. Walk to refrigerator. Open refrigerator door. Place groceries into refrigerator. Close refrigerator door.

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


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

Here is an example plan to achieve a goal for reference:
Scene_Objects:['filing_cabinet', 'tablelamp', 'microwave', 'toilet', 'chair', 'bathroom', 'detergent', 'trashcan', 'toothbrush', 'knifeblock', 'bathroom_counter', 'character', 'keyboard', 'computer', 'food_bacon', 'tvstand', 'nightstand', 'oven', 'bench', 'powersocket', 'cup', 'bed', 'ice', 'diary', 'cards', 'dresser', 'hairbrush', 'home_office', 'dishwasher', 'scrabble']
Task:Listen to music
response:
{
    "thoughts": go to radio. run on radio.,
    "actions": ['[WALK] <stereo>', '[SWITCHON] <stereo>']
}

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', 'photoframe', 'check', 'television', 'doorjamb', 'mouse', 'dresser', 'door']
Task:Write an email
response:

go to home office,switch on computer and send the mail by typing with keyboard

[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:['fork', 'food_pizza', 'filing_cabinet', 'tablelamp', 'freezer', 'nail_polish', 'cat', 'food_carrot', 'drawing', 'orchid', 'hanger', 'kitchen_cabinet', 'floor', 'ceiling', 'stamp', 'ceilinglamp', 'plate', 'candle', 'dining_room', 'wall', 'bench', 'food_vegetable', 'newspaper', 'food_food', 'television', 'after_shave', 'cards', 'cd', 'clothes_dress', 'table']
Task:Fix snack
response:
{
    "thoughts": Open fridge. Take out carrots and other vegetables. Put vegetables on a plate. Put away carrots and celery. Close fridge.,
    "actions": ['[WALK] <dining_room>', '[WALK] <kitchen_cabinet>', '[FIND] <kitchen_cabinet>', '[OPEN] <kitchen_cabinet>', '[FIND] <plate>', '[GRAB] <plate>', '[CLOSE] <kitchen_cabinet>', '[WALK] <freezer>', '[OPEN] <freezer>', '[FIND] <food_carrot>', '[GRAB] <food_carrot>', '[PUTBACK] <food_carrot> <plate>', '[FIND] <food_vegetable>', '[GRAB] <food_vegetable>', '[PUTBACK] <food_vegetable> <plate>', '[CLOSE] <freezer>', '[WALK] <table>', '[PUTBACK] <plate> <table>']
}

Input:
Scene_Objects:['sheets', 'pot', 'filing_cabinet', 'bathroom', 'toothbrush', 'clothes_underwear', 'character', 'stamp', 'clothes_jacket', 'table_cloth', 'stovefan', 'oil', 'clothes_socks', 'clothes_pants', 'towel', 'wall', 'powersocket', 'basket_for_clothes', 'photoframe', 'coffee_filter', 'wooden_spoon', 'kitchen_counter', 'laundry_detergent', 'conditioner', 'napkin', 'bathroom_cabinet', 'soap', 'tooth_paste', 'clothes_shirt', 'washing_machine']
Task:Wash clothes
response:

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.


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

Here is an example plan to achieve a goal for reference:
Scene_Objects:['filing_cabinet', 'chair', 'band-aids', 'freezer', 'trashcan', 'drawing', 'orchid', 'cpuscreen', 'floor', 'ceiling', 'desk', 'keyboard', 'envelope', 'computer', 'bookmark', 'brush', 'ceilinglamp', 'mat', 'electric_shaver', 'mousepad', 'towel', 'wall', 'powersocket', 'light_bulb', 'novel', 'curtain', 'doorjamb', 'mouse', 'door', 'light', 'colander', 'board_game']
Task:Read to child
response:
{
    "thoughts": Read a book out loud to a child,
    "actions": ['[WALK] <bedroom>', '[WALK] <child>', '[FIND] <child>', '[GREET] <child>', '[WALK] <filing_cabinet>', '[OPEN] <filing_cabinet>', '[FIND] <novel>', '[GRAB] <novel>', '[WALK] <chair>', '[PULL] <chair>', '[SIT] <chair>', '[TURNTO] <novel>', '[LOOKAT] <novel>', '[TURNTO] <novel>', '[POINTAT] <novel>', '[TURNTO] <novel>', '[POINTAT] <novel>', '[READ] <novel>', '[READ] <novel>', '[READ] <novel>']
}

Input:
Scene_Objects:['beer', 'microwave', 'cd_player', 'walllamp', 'bathroom', 'detergent', 'drawing', 'wallshelf', 'clothes_underwear', 'floor', 'ceiling', 'phone', 'computer', 'mat', 'tvstand', 'shower', 'couch', 'pillow', 'wall', 'powersocket', 'photoframe', 'clothes_gloves', 'television', 'doorjamb', 'cd', 'hair', 'controller', 'instrument_guitar', 'clothes_skirt', 'instrument_violin']
Task:Listen to music
response:

I go to the living room, switch on the CD player (then choose the music cd and insert into the player) and sit on the sofa

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


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

Here is an example plan to achieve a goal for reference:
Scene_Objects:['fork', 'crayon', 'chair', 'food_butter', 'food_carrot', 'ceilingfan', 'drawing', 'knife', 'hanger', 'bathroom_counter', 'floor', 'phone', 'ceiling', 'thread', 'brush', 'plate', 'wall', 'bench', 'powersocket', 'oven', 'check', 'food_food', 'doorjamb', 'console', 'dresser', 'cupboard', 'door', 'maindoor', 'table', 'light']
Task:Eat
response:
{
    "thoughts": I get my prepared dinner set on the dining table, sit down on chair, pick up utensils, eat food,
    "actions": ['[WALK] <dining_room>', '[WALK] <food_food>', '[FIND] <food_food>', '[GRAB] <food_food>', '[WALK] <dining_room>', '[WALK] <table>', '[FIND] <table>', '[PUTBACK] <food_food> <table>', '[FIND] <chair>', '[SIT] <chair>', '[FIND] <fork>', '[GRAB] <fork>', '[FIND] <knife>', '[GRAB] <knife>', '[FIND] <plate>', '[EAT] <plate>']
}

Input:
Scene_Objects:['pot', 'tablelamp', 'microwave', 'chair', 'detergent', 'orchid', 'drawing', 'floor', 'ceiling', 'desk', 'mail', 'toaster', 'ceilinglamp', 'plate', 'mat', 'shower', 'homework', 'stovefan', 'dish_soap', 'wall', 'wall_clock', 'oven', 'check', 'coffe_maker', 'tray', 'console', 'towel_rack', 'kitchen_counter', 'cupboard', 'controller', 'table', 'dishwasher', 'light']
Task:Wash dishes with dishwasher
response:

Put the dishes on dinner table in the dishwasher and wash them

[WALK] <dining_room>
[WALK]

[FIND] <plate>
[GRAB] <plate>
[WALK] <dishwasher>
[OPEN] <dishwasher>
[PUTBACK] <plate> <dishwasher>
[WALK]

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


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

Here is an example plan to achieve a goal for reference:
Scene_Objects:['dry_pasta', 'food_bread', 'freezer', 'food_carrot', 'milk', 'cpuscreen', 'floor', 'ceiling', 'desk', 'keyboard', 'computer', 'piano_bench', 'ceilinglamp', 'mousepad', 'garbage_can', 'clothes_hat', 'food_orange', 'food_dessert', 'wall', 'powersocket', 'food_vegetable', 'food_cheese', 'doorjamb', 'lighter', 'mouse', 'coffee', 'door', 'light', 'colander', 'teeth']
Task:Rotate stock in refrigerator
response:
{
    "thoughts": Throw out expired items, put older items in front.,
    "actions": ['[WALK] <freezer>', '[OPEN] <freezer>', '[FIND] <food_bread>', '[GRAB] <food_bread>', '[TURNTO] <food_bread>', '[LOOKAT] <food_bread>', '[PUTOBJBACK] <food_bread>', '[FIND] <food_cheese>', '[GRAB] <food_cheese>', '[TURNTO] <food_cheese>', '[LOOKAT] <food_cheese>', '[FIND] <garbage_can>', '[PUTBACK] <food_cheese> <garbage_can>', '[FIND] <food_cheese>', '[GRAB] <food_cheese>', '[TURNTO] <food_cheese>', '[LOOKAT] <food_cheese>', '[PUTOBJBACK] <food_cheese>', '[FIND] <food_dessert>', '[TURNTO] <food_dessert>', '[LOOKAT] <food_dessert>', '[PUSH] <food_dessert>', '[FIND] <food_vegetable>', '[GRAB] <food_vegetable>', '[TURNTO] <food_vegetable>', '[LOOKAT] <food_vegetable>', '[PUTBACK] <food_vegetable> <garbage_can>', '[FIND] <milk>', '[GRAB] <milk>', '[TURNTO] <milk>', '[LOOKAT] <milk>', '[PUTOBJBACK] <milk>', '[CLOSE] <freezer>']
}

Input:
Scene_Objects:['sheets', 'tablelamp', 'microwave', 'toilet', 'chair', 'walllamp', 'food_butter', 'drawing', 'cpuscreen', 'hanger', 'floor', 'phone', 'desk', 'stamp', 'keyboard', 'computer', 'alcohol', 'toaster', 'laptop', 'mat', 'mousepad', 'wall', 'oven', 'bed', 'mouthwash', 'doorjamb', 'mouse', 'chessboard', 'door', 'clothes_scarf']
Task:Write an email
response:

walk to home office and switch on laptop and with the useof mouse and keyboard send mail

[WALK] <home_office>
[WALK] <laptop>
[FIND] <laptop>
[SWITCHON] <laptop>
[FIND] <mouse>
[GRAB] <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:['tablelamp', 'chair', 'cat', 'drawing', 'orchid', 'floor', 'ceiling', 'keyboard', 'computer', 'stovefan', 'brush', 'window', 'couch', 'pillow', 'dining_room', 'food_kiwi', 'wall', 'oven', 'coffe_maker', 'curtain', 'doorjamb', 'towel_rack', 'mouse', 'shaving_cream', 'cards', 'door', 'table', 'light', 'tooth_paste', 'laser_pointer']
Task:Pet cat
response:
{
    "thoughts": The cat is laying on the couch in the living room. I want to pet it, so I am going to walk to the living room, sit on the couch, and pet the cat.,
    "actions": ['[WALK] <home_office>', '[WALK] <couch>', '[SIT] <couch>', '[FIND] <cat>', '[TURNTO] <cat>', '[LOOKAT] <cat>', '[TOUCH] <cat>']
}

Input:
Scene_Objects:['sheets', 'pot', 'food_bread', 'filing_cabinet', 'tablelamp', 'hanger', 'ceiling', 'computer', 'bookmark', 'stovefan', 'mat', 'plate', 'shower', 'dish_soap', 'mousepad', 'closetdrawer', 'candle', 'food_orange', 'food_cheese', 'photoframe', 'food_food', 'food_rice', 'water', 'tray', 'doorjamb', 'towel_rack', 'headset', 'table', 'light', 'tooth_paste']
Task:Wash dishes by hand
response:

walk to kitchen, fins soap, arrange dishes, wash dishes

[WALK] <dining_room>
[WALK] <plate>
[FIND] <plate>
[FIND] <dish_soap>
[FIND] <water>
[GRAB] <plate>
[GRAB] <dish_soap>
[WASH] <plate>
[RINSE] <plate>
[DROP] <plate>


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

Here is an example plan to achieve a goal for reference:
Scene_Objects:['pot', 'food_salt', 'beer', 'chair', 'freezer', 'knifeblock', 'bathroom_counter', 'longboard', 'phone', 'keyboard', 'computer', 'food_bacon', 'tvstand', 'balanceball', 'stereo', 'mousepad', 'clothes_pants', 'nightstand', 'bench', 'bed', 'photoframe', 'novel', 'television', 'pencil', 'kitchen_counter', 'vacuum_cleaner', 'food_steak', 'sink', 'hairdryer', 'vase']
Task:Read book
response:
{
    "thoughts": Go to the book shelf, get a book, open the book and read the book.,
    "actions": ['[WALK] <home_office>', '[WALK] <novel>', '[FIND] <novel>', '[GRAB] <novel>', '[READ] <novel>']
}

Input:
Scene_Objects:['glue', 'pot', 'tablelamp', 'microwave', 'dog', 'milk', 'orchid', 'floor', 'ceiling', 'computer', 'toaster', 'plate', 'shower', 'dish_soap', 'wall', 'food_cheese', 'coffe_maker', 'check', 'coffee_filter', 'oven_mitts', 'cards', 'towel_rack', 'pencil', 'kitchen_counter', 'comb', 'cupboard', 'conditioner', 'door', 'bathroom_cabinet', 'dishwasher']
Task:Wash dishes with dishwasher
response:

Walk to the  kitchen. Open the dishwasher. Put plates into the dishwasher. Put dish soap into the dishwasher. Close the dishwasher. Turn on the dishwasher.

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


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', 'water_glass', 'pot', 'spectacles', 'walllamp', 'food_carrot', 'kitchen_cabinet', 'shampoo', 'longboard', 'computer', 'bookmark', 'mat', 'stereo', 'shower', 'homework', 'oil', 'clothes_socks', 'dining_room', 'wall_clock', 'oven', 'powersocket', 'water', 'food_onion', 'headset', 'cd', 'dresser', 'controller', 'sink', 'napkin', 'clothes_skirt']
Task:Drink
response:
{
    "thoughts": Go to kitchen. Open the the cabinet. Locate the water glass. Pour water into glass. Drag the bottle close to mouth. Drink water.,
    "actions": ['[WALK] <dining_room>', '[WALK] <kitchen_cabinet>', '[FIND] <kitchen_cabinet>', '[OPEN] <kitchen_cabinet>', '[FIND] <water>', '[GRAB] <water>', '[FIND] <water_glass>', '[POUR] <water> <water_glass>', '[CLOSE] <kitchen_cabinet>', '[GRAB] <water_glass>', '[DRINK] <water_glass>']
}

Input:
Scene_Objects:['microwave', 'toilet', 'milk', 'floor', 'ceiling', 'bookshelf', 'keyboard', 'button', 'toaster', 'shower', 'oil', 'closetdrawer', 'clothes_hat', 'pillow', 'wall', 'toy', 'box', 'coffe_maker', 'television', 'toothbrush_holder', 'razor', 'wine', 'food_sugar', 'kitchen_counter', 'cupboard', 'pajamas', 'sink', 'coffee_cup', 'dishwasher', 'shoe_rack']
Task:Make coffee
response:

walk to kitchen, look at the coffee maker, open the coffee maker, find milk, suger and water, mix that all, put into coffee maker, switch on the coffee maker, wait for few mins, push the coffee button in coffee maker, we get coffee in coffee cup, drink coffee

[WALK] <dining_room>
[WALK] <coffe_maker>
[FIND] <coffe_maker>
[TURNTO] <coffe_maker>
[LOOKAT] <coffe_maker>
[OPEN] <coffe_maker>
[FIND] <milk>
[GRAB] <milk>
[PUTBACK] <milk> <coffe_maker>
[FIND] <food_sugar>
[FIND] <coffee_cup>
[GRAB] <coffee_cup>
[PUTBACK] <coffee_cup> <coffe_maker>
[SWITCHON] <coffe_maker>
[FIND] <button>
[PUSH] <button>
[GRAB] <coffee_cup>
[DRINK] <coffee_cup>


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

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

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

Go to home office and open door.  Walk to desk and sit in computer chair.  Look at computer.

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


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

Here is an example plan to achieve a goal for reference:
Scene_Objects:['tablelamp', 'walllamp', 'trashcan', 'knife', 'cpuscreen', 'bathroom_counter', 'floor', 'keyboard', 'face', 'ceilinglamp', 'mat', 'faucet', 'shower', 'mousepad', 'closetdrawer', 'towel', 'bench', 'oven', 'bed', 'coffe_maker', 'television', 'wine', 'tray', 'towel_rack', 'kitchen_counter', 'chessboard', 'hair', 'controller', 'bathtub', 'bathroom_cabinet']
Task:Rain welcome
response:
{
    "thoughts": The robot would greet me and then hand me a towel.  It would make an appropriate quip about the weather while I dried off.  It would receive the wet towel when I was done.,
    "actions": ['[WALK] <bedroom>', '[WALK] <towel>', '[FIND] <towel>', '[GRAB] <towel>', '[FIND] <face>', '[WIPE] <face>', '[FIND] <hair>', '[WIPE] <hair>', '[PUTOBJBACK] <towel>']
}

Input:
Scene_Objects:['food_salt', 'chair', 'walllamp', 'drawing', 'orchid', 'wallshelf', 'hanger', 'floor', 'ceiling', 'phone', 'desk', 'remote_control', 'computer', 'stovefan', 'mat', 'tvstand', 'ceilinglamp', 'closetdrawer', 'couch', 'pillow', 'wall', 'photoframe', 'food_food', 'television', 'coin', 'tray', 'doorjamb', 'towel_rack', 'dresser', 'table']
Task:Watch TV
response:

[WALK] <home_office>
[WALK] <television>
[TURNTO] <television>
[LOOKAT] <television>
[FIND] <remote_control>
[GRAB] <remote_control>
[SWITCHON] <television>
[FIND] <couch>
[TURNTO] <couch>
[SIT] <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:['food_salt', 'microwave', 'trashcan', 'hanger', 'floor', 'bedroom', 'computer', 'button', 'brush', 'mat', 'shower', 'faucet', 'window', 'clothes_hat', 'wall', 'child', 'oven', 'bed', 'newspaper', 'novel', 'curtain', 'centerpiece', 'doorjamb', 'mouse', 'cd', 'dresser', 'hairdryer', 'clothes_scarf', 'vase', 'board_game']
Task:Story reading time
response:
{
    "thoughts": Sit on bed with child, open mother goose, pick story, read book, point at the pretty pictures,
    "actions": ['[WALK] <bedroom>', '[WALK] <child>', '[FIND] <child>', '[GREET] <child>', '[FIND] <novel>', '[GRAB] <novel>', '[FIND] <bed>', '[SIT] <bed>', '[TURNTO] <child>', '[LOOKAT] <child>', '[TURNTO] <novel>', '[POINTAT] <novel>', '[READ] <novel>']
}

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

walk to living room. look at computer. switch on computer. sit in chair. watch computer. switch off computer.

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


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

Here is an example plan to achieve a goal for reference:
Scene_Objects:['chair', 'freezer', 'walllamp', 'cpuscreen', 'hanger', 'floor', 'ceiling', 'desk', 'keyboard', 'computer', 'toaster', 'ceilinglamp', 'shoe-shine_kit', 'tvstand', 'mat', 'shower', 'mousepad', 'wall', 'powersocket', 'oven', 'bench', 'television', 'tray', 'curtain', 'doorjamb', 'mouse', 'door', 'table', 'light', 'coffee']
Task:Browse internet
response:
{
    "thoughts": I go in my office, sit at my desk turn on the computer, then type on my keyboard and open my web browser.,
    "actions": ['[WALK] <home_office>', '[WALK] <desk>', '[FIND] <chair>', '[SIT] <chair>', '[FIND] <computer>', '[SWITCHON] <computer>', '[FIND] <keyboard>', '[TYPE] <keyboard>']
}

Input:
Scene_Objects:['drawing', 'bathroom_counter', 'floor', 'ceiling', 'phone', 'desk', 'food_cake', 'computer', 'toaster', 'mat', 'pillow', 'wall', 'powersocket', 'cup', 'coffe_maker', 'coffee_filter', 'water', 'console', 'kitchen_counter', 'hairbrush', 'cupboard', 'conditioner', 'hairdryer', 'sink', 'instrument_violin', 'door', 'bathroom_cabinet', 'dishwasher', 'board_game', 'coffee']
Task:Make coffee
response:

I find the coffee machine, fill it with water and coffee then press the button to make the coffee

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


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

Here is an example plan to achieve a goal for reference:
Scene_Objects:['scissors', 'microwave', 'toilet', 'freezer', 'ceilingfan', 'drawing', 'knifeblock', 'food_egg', 'cpuscreen', 'clothes_underwear', 'tea_bag', 'keyboard', 'faucet', 'clothes_socks', 'food_noodles', 'dining_room', 'bench', 'cup', 'bed', 'check', 'toilet_paper', 'television', 'after_shave', 'console', 'comb', 'hairbrush', 'cupboard', 'bathroom_cabinet', 'board_game', 'teeth']
Task:Pet cat
response:
{
    "thoughts": I walk to my cat, and I pet him,
    "actions": ['[WALK] <cat>', '[TOUCH] <cat>']
}

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

switch on the computer,  grab a chair and sit in front of the computer. type with keyboard and browse the internet.

[WALK] <home_office>
[WALK] <computer>
[FIND] <computer>
[FIND] <chair>
[SIT] <chair>
[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:['chair', 'walllamp', 'orchid', 'cpuscreen', 'clothes_underwear', 'floor', 'ceiling', 'phone', 'desk', 'keyboard', 'computer', 'mat', 'ceilinglamp', 'stereo', 'tvstand', 'mousepad', 'couch', 'broom', 'wall', 'bed', 'check', 'toilet_paper', 'television', 'ice', 'kettle', 'mouse', 'door', 'sink', 'home_office', 'table']
Task:Browse internet
response:
{
    "thoughts": I go in my office, sit at my desk turn on the computer, then type on my keyboard and open my web browser.,
    "actions": ['[WALK] <home_office>', '[WALK] <desk>', '[FIND] <chair>', '[SIT] <chair>', '[FIND] <computer>', '[SWITCHON] <computer>', '[FIND] <keyboard>', '[TYPE] <keyboard>']
}

Input:
Scene_Objects:['glue', 'food_salt', 'microwave', 'drawing', 'wallshelf', 'hanger', 'floor', 'ceiling', 'stovefan', 'ceilinglamp', 'tvstand', 'stereo', 'closetdrawer', 'food_orange', 'pillow', 'wall', 'nightstand', 'powersocket', 'oven', 'photoframe', 'coffe_maker', 'television', 'coffee_filter', 'tray', 'doorjamb', 'towel_rack', 'dresser', 'pajamas', 'door', 'light']
Task:Turn on light
response:

I walk into the kitchen, I find the light switch, and then i switch on the lights in the kitchen.

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


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

Here is an example plan to achieve a goal for reference:
Scene_Objects:['beer', 'microwave', 'drawing', 'floor', 'purse', 'computer', 'plate', 'balanceball', 'shower', 'stereo', 'dustpan', 'clothes_hat', 'microphone', 'bench', 'basket_for_clothes', 'cup', 'bed', 'check', 'coffe_maker', 'food_onion', 'after_shave', 'cards', 'pencil', 'chessboard', 'maindoor', 'napkin', 'table', 'board_game', 'clothes_shirt', 'coffee']
Task:Set up table
response:
{
    "thoughts": Get dishes. Place dishes neatly around table. Get food. Place food on middle of table.,
    "actions": ['[WALK] <dining_room>', '[WALK] <plate>', '[FIND] <plate>', '[GRAB] <plate>', '[WALK] <dining_room>', '[WALK] <table>', '[PUTBACK] <plate> <table>', '[WALK] <dining_room>', '[WALK] <plate>', '[FIND] <plate>', '[GRAB] <plate>', '[WALK] <dining_room>', '[WALK] <table>', '[PUTBACK] <plate> <table>', '[WALK] <dining_room>', '[WALK] <plate>', '[FIND] <plate>', '[GRAB] <plate>', '[WALK] <dining_room>', '[WALK] <table>', '[PUTBACK] <plate> <table>', '[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>']
}

Input:
Scene_Objects:['tablelamp', 'walllamp', 'drawing', 'hanger', 'floor', 'ceiling', 'phone', 'desk', 'bedroom', 'bookshelf', 'keyboard', 'food_cake', 'closetdrawer', 'pillow', 'wall', 'nightstand', 'powersocket', 'bed', 'razor', 'television', 'wine', 'tray', 'doorjamb', 'dresser', 'hair', 'controller', 'door', 'clothes_scarf', 'light', 'instrument_violin']
Task:Turn on light
response:

[WALK] <bedroom>
[WALK] <light>
[FIND] <light>
[SWITCHON] <light>
[WALK] <bathroom>


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

Here is an example plan to achieve a goal for reference:
Scene_Objects:['filing_cabinet', 'tablelamp', 'mop', 'measuring_cup', 'microwave', 'chair', 'freezer', 'ground_coffee', 'bathroom', 'floor', 'ceiling', 'dvd_player', 'bookshelf', 'toaster', 'stovefan', 'faucet', 'iron', 'wall', 'wall_clock', 'cutting_board', 'shelf', 'clothes_gloves', 'coffe_maker', 'coffee_filter', 'food_rice', 'curtain', 'kitchen_counter', 'controller', 'sink', 'clothes_shirt']
Task:Make coffee
response:
{
    "thoughts": You walk into the kitchen and turn to the coffee maker. You grab the coffee filter and put into the coffee machine, you also grab the ground coffee and put it into the coffee machine. You turn on the coffee machine.,
    "actions": ['[WALK] <dining_room>', '[WALK] <coffe_maker>', '[FIND] <coffe_maker>', '[TURNTO] <coffe_maker>', '[FIND] <coffee_filter>', '[GRAB] <coffee_filter>', '[OPEN] <coffe_maker>', '[PUTBACK] <coffee_filter> <coffe_maker>', '[FIND] <ground_coffee>', '[GRAB] <ground_coffee>', '[PUTBACK] <ground_coffee> <coffe_maker>', '[SWITCHON] <coffe_maker>']
}

Input:
Scene_Objects:['chair', 'walllamp', 'drawing', 'wallshelf', 'hanger', 'floor', 'ceiling', 'folder', 'desk', 'character', 'tea_bag', 'remote_control', 'purse', 'computer', 'button', 'mat', 'tvstand', 'ceilinglamp', 'closetdrawer', 'couch', 'pillow', 'wall', 'oven', 'photoframe', 'television', 'doorjamb', 'dresser', 'hairbrush', 'spoon', 'table']
Task:Watch TV
response:

Walk to living room.  Find remote control.  Find television.  Point remote at television.  Press "on" button.  Watch.

[WALK] <home_office>
[WALK] <television>
[FIND] <television>
[FIND] <remote_control>
[TURNTO] <television>
[POINTAT] <television>
[FIND] <button>
[PUSH] <button>
[TURNTO] <television>
[WATCH] <television>


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

Here is an example plan to achieve a goal for reference:
Scene_Objects:['tablelamp', 'toilet', 'chair', 'walllamp', 'cat', 'food_carrot', 'cpuscreen', 'hanger', 'floor', 'ceiling', 'desk', 'keyboard', 'bookshelf', 'computer', 'laptop', 'ceilinglamp', 'homework', 'mousepad', 'wall', 'coffe_maker', 'video_game_controller', 'ice', 'doorjamb', 'diary', 'mouse', 'kitchen_counter', 'shoes', 'comb', 'dresser', 'hairdryer']
Task:Write an email
response:
{
    "thoughts": I open my laptop and then login to Windows. Then I open Google Chrome, and type gmail.com into the address bar. My email automatically logs in, then I click the Compose button, type in the address of the recipient, then the subject of the email, and then start typing my email,
    "actions": ['[WALK] <laptop>', '[SWITCHON] <laptop>', '[FIND] <keyboard>', '[TYPE] <keyboard>']
}

Input:
Scene_Objects:['sponge', 'tablelamp', 'beer', 'chair', 'walllamp', 'bathroom', 'cat', 'drawing', 'wallshelf', 'cpuscreen', 'hanger', 'floor', 'ceiling', 'desk', 'keyboard', 'computer', 'mat', 'tvstand', 'ceilinglamp', 'tooth_paste', 'closetdrawer', 'couch', 'pillow', 'wall', 'photoframe', 'television', 'coin', 'doorjamb', 'dresser', 'board_game']
Task:Watch TV
response:

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


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

Here is an example plan to achieve a goal for reference:
Scene_Objects:['food_ice_cream', 'chair', 'walllamp', 'trashcan', 'bills', 'knife', 'floor', 'desk', 'mail', 'button', 'toaster', 'plate', 'faucet', 'shower', 'foundation', 'couch', 'bowl', 'wall', 'nightstand', 'oven', 'bed', 'clothes_gloves', 'novel', 'coffe_maker', 'check', 'tray', 'sink', 'table', 'dishwasher', 'shoe_rack']
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:['toilet', 'drawing', 'wallshelf', 'bathroom_counter', 'floor', 'ceiling', 'desk', 'bookshelf', 'table_cloth', 'bookmark', 'mat', 'shower', 'faucet', 'closetdrawer', 'dining_room', 'wall', 'powersocket', 'oven', 'keys', 'coffe_maker', 'television', 'tray', 'doorjamb', 'pencil', 'kitchen_counter', 'door', 'hairdryer', 'bathroom_cabinet', 'light', 'home_office']
Task:Turn on light
response:

I open the room door and press the light button on

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


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

Here is an example plan to achieve a goal for reference:
Scene_Objects:['pot', 'filing_cabinet', 'food_bread', 'microwave', 'freezer', 'drawing', 'knifeblock', 'cpuscreen', 'floor', 'ceiling', 'desk', 'bookshelf', 'keyboard', 'couch', 'clothes_hat', 'pillow', 'wall', 'nightstand', 'powersocket', 'box', 'oven_mitts', 'food_onion', 'doorjamb', 'kitchen_counter', 'chessboard', 'dresser', 'cupboard', 'door', 'light', 'soap']
Task:Turn on light
response:
{
    "thoughts": Turning on lights,
    "actions": ['[WALK] <bedroom>', '[WALK] <light>', '[FIND] <light>', '[SWITCHON] <light>', '[WALK] <bathroom>']
}

Input:
Scene_Objects:['fork', 'filing_cabinet', 'food_ice_cream', 'chair', 'freezer', 'detergent', 'cpuscreen', 'hanger', 'bookshelf', 'bookmark', 'stovefan', 'mat', 'faucet', 'stereo', 'couch', 'candle', 'dining_room', 'nightstand', 'novel', 'coffe_maker', 'ice', 'doorjamb', 'shaving_cream', 'cd', 'laundry_detergent', 'clothes_dress', 'hairdryer', 'light', 'table', 'colander']
Task:Listen to music
response:

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


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

Here is an example plan to achieve a goal for reference:
Scene_Objects:['microwave', 'chair', 'freezer', 'walllamp', 'bathroom', 'orchid', 'cpuscreen', 'clothes_underwear', 'bathroom_counter', 'floor', 'ceiling', 'desk', 'keyboard', 'computer', 'mat', 'shower', 'mousepad', 'pillow', 'dining_room', 'wall', 'wall_clock', 'nightstand', 'tape', 'bed', 'console', 'mouse', 'clothes_scarf', 'light', 'soap', 'teeth']
Task:Check email
response:
{
    "thoughts": Sit in teak deck chair, have wooden drawing board on lap, laptop on wooden drawing board, log in to my two email accounts, go through new emails and respond.,
    "actions": ['[WALK] <home_office>', '[WALK] <laptop>', '[FIND] <laptop>', '[GRAB] <laptop>', '[WALK] <chair>', '[SIT] <chair>', '[SWITCHON] <laptop>', '[TURNTO] <laptop>', '[LOOKAT] <laptop>', '[TOUCH] <laptop>', '[TURNTO] <laptop>', '[LOOKAT] <laptop>', '[TOUCH] <laptop>', '[TURNTO] <laptop>', '[LOOKAT] <laptop>', '[TOUCH] <laptop>', '[TURNTO] <laptop>', '[LOOKAT] <laptop>', '[TOUCH] <laptop>']
}

Input:
Scene_Objects:['pot', 'food_bread', 'tablelamp', 'food_salt', 'microwave', 'chair', 'freezer', 'ground_coffee', 'dough', 'drawing', 'orchid', 'cpuscreen', 'kitchen_cabinet', 'floor', 'ceiling', 'phone', 'desk', 'keyboard', 'toaster', 'mat', 'ceilinglamp', 'stovefan', 'faucet', 'shower', 'oil', 'couch', 'pillow', 'wall', 'pasta', 'oven', 'powersocket', 'food_food', 'coffe_maker', 'television', 'wine', 'tray', 'doorjamb', 'towel_rack', 'kitchen_counter', 'cupboard', 'food_steak', 'door', 'sink', 'table', 'dishwasher', 'light']
Task:Cook some food
response:

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

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


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

Here is an example plan to achieve a goal for reference:
Scene_Objects:['filing_cabinet', 'blender', 'band-aids', 'freezer', 'orchid', 'cpuscreen', 'floor', 'bookshelf', 'envelope', 'toaster', 'stovefan', 'plate', 'shower', 'faucet', 'foundation', 'oil', 'mousepad', 'food_jam', 'microphone', 'dining_room', 'bench', 'oven', 'toy', 'box', 'food_food', 'food_onion', 'diary', 'kitchen_counter', 'cupboard', 'colander']
Task:Get out dish
response:
{
    "thoughts": Open cupboard.  Get out the dish.,
    "actions": ['[WALK] <dining_room>', '[WALK] <cupboard>', '[OPEN] <cupboard>', '[FIND] <plate>', '[GRAB] <plate>', '[CLOSE] <cupboard>']
}

Input:
Scene_Objects:['tablelamp', 'food_salt', 'toilet', 'drawing', 'orchid', 'wallshelf', 'cpuscreen', 'hanger', 'bathroom_counter', 'floor', 'ceiling', 'bedroom', 'bookshelf', 'tvstand', 'foundation', 'closetdrawer', 'pillow', 'wall', 'nightstand', 'powersocket', 'bed', 'coffe_maker', 'television', 'food_rice', 'doorjamb', 'shoes', 'dresser', 'door', 'light', 'clothes_skirt']
Task:Turn on light
response:

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

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


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

Here is an example plan to achieve a goal for reference:
Scene_Objects:['spectacles', 'pot', 'freezer', 'walllamp', 'detergent', 'cpuscreen', 'floor', 'ceiling', 'bedroom', 'stamp', 'button', 'stovefan', 'ceilinglamp', 'tvstand', 'couch', 'food_peanut_butter', 'form', 'pillow', 'wall', 'bench', 'novel', 'food_food', 'oven_mitts', 'food_rice', 'diary', 'towel_rack', 'controller', 'maindoor', 'light', 'clothes_skirt']
Task:Put groceries in Fridge
response:
{
    "thoughts": Walk to kitchen. Find groceries. Grab groceries. Find fridge. Walk to fridge. Put groceries in fridge.,
    "actions": ['[WALK] <dining_room>', '[WALK] <food_food>', '[FIND] <food_food>', '[GRAB] <food_food>', '[FIND] <freezer>', '[WALK] <freezer>', '[OPEN] <freezer>', '[PUTIN] <food_food> <freezer>']
}

Input:
Scene_Objects:['food_salt', 'chair', 'orchid', 'bills', 'drawing', 'floor', 'ceiling', 'table_cloth', 'toaster', 'mat', 'faucet', 'mousepad', 'pillow', 'dining_room', 'broom', 'wall', 'nightstand', 'cup', 'keys', 'coffe_maker', 'food_food', 'check', 'water', 'wine', 'curtain', 'kitchen_counter', 'cupboard', 'sink', 'light', 'board_game']
Task:Drink
response:

[RUN] <dining_room>
[WALK] <cup>
[FIND] <cup>
[GRAB] <cup>
[WALK] <sink>
[FIND] <faucet>
[SWITCHON] <faucet>
[PUTBACK] <cup> <sink>
[FIND] <water>
[GRAB] <cup>
[PUTBACK] <cup> <sink>
[GRAB] <cup>
[SWITCHOFF] <faucet>
[DRINK] <cup>
[PUTBACK] <cup> <sink>


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', 'ceilingfan', 'drawing', 'food_egg', 'floor', 'ceiling', 'bookshelf', 'remote_control', 'button', 'ceilinglamp', 'tvstand', 'balanceball', 'window', 'couch', 'food_jam', 'pillow', 'dining_room', 'wall', 'nightstand', 'photoframe', 'television', 'food_rice', 'curtain', 'kitchen_counter', 'hair', 'home_office', 'table', 'light', 'dishwasher', 'dirt']
Task:Change TV channel
response:
{
    "thoughts": I go to the living room where the TV is located. I plug in the TV to the outlet. I search for the remote control. I point the remote control directly to the TV, turn it on and push the number of the channel that I want.,
    "actions": ['[WALK] <home_office>', '[WALK] <television>', '[FIND] <television>', '[PLUGIN] <television>', '[FIND] <remote_control>', '[TURNTO] <television>', '[POINTAT] <television>', '[SWITCHON] <television>', '[FIND] <button>', '[PUSH] <button>']
}

Input:
Scene_Objects:['fork', 'pot', 'crayon', 'microwave', 'walllamp', 'drawing', 'knife', 'wallshelf', 'food_egg', 'floor', 'ceiling', 'bedroom', 'keyboard', 'computer', 'mat', 'tvstand', 'stereo', 'couch', 'clothes_hat', 'pillow', 'dining_room', 'wall', 'oven', 'photoframe', 'television', 'razor', 'oven_mitts', 'doorjamb', 'home_office', 'scrabble']
Task:Relax on sofa
response:

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

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


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

Here is an example plan to achieve a goal for reference:
Scene_Objects:['drawing', 'cpuscreen', 'wallshelf', 'floor', 'ceiling', 'bedroom', 'toaster', 'mat', 'tvstand', 'shower', 'shoe-shine_kit', 'window', 'mousepad', 'clothes_socks', 'couch', 'food_noodles', 'pillow', 'wall', 'bed', 'tray', 'doorjamb', 'kitchen_counter', 'dresser', 'cupboard', 'door', 'bathtub', 'sink', 'home_office', 'light', 'table']
Task:Turn on light
response:
{
    "thoughts": Walk into the bedroom and walk to the light switch. Flip the switch.,
    "actions": ['[WALK] <bedroom>', '[WALK] <light>', '[FIND] <light>', '[SWITCHON] <light>']
}

Input:
Scene_Objects:['pot', 'scissors', 'toilet', 'dog', 'freezer', 'band-aids', 'chair', 'drawing', 'wallshelf', 'floor', 'ceiling', 'bedroom', 'toaster', 'couch', 'wall', 'nightstand', 'cup', 'basket_for_clothes', 'photoframe', 'food_food', 'coffe_maker', 'check', 'lighter', 'pencil', 'dishrack', 'dresser', 'cupboard', 'door', 'clothes_scarf', 'colander']
Task:Listen to music
response:

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

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


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

Here is an example plan to achieve a goal for reference:
Scene_Objects:['filing_cabinet', 'food_ice_cream', 'chair', 'freezer', 'bathroom', 'trashcan', 'orchid', 'cpuscreen', 'hanger', 'character', 'computer', 'mail', 'stovefan', 'mat', 'shower', 'couch', 'pillow', 'nightstand', 'wall', 'powersocket', 'bed', 'coffe_maker', 'television', 'tray', 'curtain', 'doorjamb', 'towel_rack', 'cupboard', 'sink', 'light']
Task:Pet cat
response:
{
    "thoughts": I walk to the living room. I find the cat. I pet the cat.,
    "actions": ['[WALK] <home_office>', '[WALK] <cat>', '[FIND] <cat>', '[TOUCH] <cat>']
}

Input:
Scene_Objects:['sheets', 'filing_cabinet', 'toilet', 'detergent', 'dough', 'bills', 'wallshelf', 'clothes_underwear', 'ceiling', 'keyboard', 'table_cloth', 'faucet', 'electric_shaver', 'mousepad', 'couch', 'dustpan', 'form', 'dining_room', 'newspaper', 'photoframe', 'food_food', 'coffe_maker', 'check', 'wooden_spoon', 'tray', 'rag', 'instrument_guitar', 'soap', 'washing_machine', 'coffee']
Task:Wash clothes
response:

Walk to bathroom. Open washer. Put clothes in washer. Put soap in washer. Close washer. Turn washer on.


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

Here is an example plan to achieve a goal for reference:
Scene_Objects:['tablelamp', 'chair', 'walllamp', 'orchid', 'drawing', 'cpuscreen', 'wallshelf', 'hanger', 'floor', 'ceiling', 'phone', 'desk', 'tea_bag', 'keyboard', 'computer', 'ceilinglamp', 'tvstand', 'mat', 'mousepad', 'couch', 'pillow', 'wall', 'nightstand', 'oven', 'television', 'doorjamb', 'mouse', 'dresser', 'hair', 'door']
Task:Write an email
response:
{
    "thoughts": I walk to the Home Office then find the computer and sit in the chair. I switch on the computer and start typing the email. I switch the computer off.,
    "actions": ['[WALK] <home_office>', '[WALK] <computer>', '[FIND] <computer>', '[FIND] <chair>', '[SIT] <chair>', '[SWITCHON] <computer>', '[TURNTO] <computer>', '[LOOKAT] <computer>', '[FIND] <keyboard>', '[TYPE] <keyboard>', '[SWITCHOFF] <computer>']
}

Input:
Scene_Objects:['food_oatmeal', 'microwave', 'freezer', 'bathroom', 'nail_polish', 'dough', 'food_carrot', 'orchid', 'drawing', 'knife', 'kitchen_cabinet', 'floor', 'ceiling', 'desk', 'brush', 'mat', 'couch', 'pillow', 'food_cereal', 'wall', 'food_vegetable', 'food_food', 'television', 'console', 'cards', 'kitchen_counter', 'cupboard', 'hair', 'door', 'light']
Task:Put groceries in Fridge
response:

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

[WALK] <dining_room>
[WALK] <kitchen_cabinet>
[FIND] <kitchen_cabinet>
[FIND] <food_vegetable>
[GRAB] <food_vegetable>
[FIND] <freezer>
[OPEN] <freezer>
[PUTIN] <food_vegetable> <freezer>
[FIND] <food_carrot>
[GRAB] <food_carrot>
[PUTIN] <food_carrot> <freezer>
[FIND] <food_cereal>
[GRAB] <food_cereal>
[PUTIN] <food_cereal> <freezer>
[FIND] <food_oatmeal>
[GRAB] <food_oatmeal>
[PUTIN] <food_oatmeal> <freezer>
[FIND] <food_food>
[GRAB] <food_food>
[PUTIN] <food_food> <freezer>
[FIND] <freezer>
[CLOSE] <freezer>


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

Here is an example plan to achieve a goal for reference:
Scene_Objects:['tablelamp', 'chair', 'walllamp', 'orchid', 'drawing', 'cpuscreen', 'wallshelf', 'hanger', 'floor', 'ceiling', 'phone', 'desk', 'keyboard', 'computer', 'ceilinglamp', 'tvstand', 'mat', 'mousepad', 'couch', 'pillow', 'wall', 'nightstand', 'television', 'fax_machine', 'doorjamb', 'mouse', 'dresser', 'door', 'teeth', 'printing_paper']
Task:Print out papers
response:
{
    "thoughts": Turn on printer and fill with blank paper. Use computer to click on printing option. Take printed page out of print.,
    "actions": ['[WALK] <home_office>', '[WALK] <fax_machine>', '[FIND] <fax_machine>', '[SWITCHON] <fax_machine>', '[FIND] <printing_paper>', '[GRAB] <printing_paper>', '[PUTBACK] <printing_paper> <fax_machine>', '[FIND] <computer>', '[FIND] <mouse>', '[GRAB] <mouse>', '[GRAB] <printing_paper>']
}

Input:
Scene_Objects:['freezer', 'drawing', 'wallshelf', 'bathroom_counter', 'floor', 'ceiling', 'character', 'mat', 'faucet', 'food_noodles', 'couch', 'pillow', 'food_kiwi', 'wall', 'powersocket', 'toy', 'photoframe', 'newspaper', 'food_food', 'coffe_maker', 'television', 'check', 'ice', 'curtain', 'kitchen_counter', 'cupboard', 'food_steak', 'sink', 'dishwasher', 'teeth']
Task:Put groceries in Fridge
response:

Open the fridge, and put groceries in the fridge. Close the fridge.

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


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

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

Input:
Scene_Objects:['filing_cabinet', 'tablelamp', 'blender', 'food_salt', 'toilet', 'chair', 'drawing', 'hanger', 'floor', 'ceiling', 'bookshelf', 'food_bacon', 'tvstand', 'closetdrawer', 'pillow', 'wall', 'nightstand', 'powersocket', 'bed', 'check', 'food_food', 'food_donut', 'doorjamb', 'kitchen_counter', 'dresser', 'cupboard', 'door', 'sink', 'napkin', 'light']
Task:Turn on light
response:

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

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


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

Here is an example plan to achieve a goal for reference:
Scene_Objects:['food_bread', 'food_pizza', 'tablelamp', 'microwave', 'floor', 'ceiling', 'desk', 'bookshelf', 'stovefan', 'mat', 'ceilinglamp', 'laptop', 'window', 'homework', 'oil', 'closetdrawer', 'couch', 'nightstand', 'wall', 'cup', 'bed', 'food_food', 'mouthwash', 'toothbrush_holder', 'oven_mitts', 'razor', 'food_donut', 'check', 'clothes_scarf', 'bathroom_cabinet']
Task:Go to sleep
response:
{
    "thoughts": Walk to bedroom. Walk to bed, lie in bed.,
    "actions": ['[WALK] <bedroom>', '[WALK] <bed>', '[LIE] <bed>']
}

Input:
Scene_Objects:['pot', 'scissors', 'tablelamp', 'chair', 'drawing', 'cpuscreen', 'floor', 'phone', 'character', 'desk', 'keyboard', 'computer', 'mat', 'deck_of_cards', 'tvstand', 'mousepad', 'form', 'pillow', 'wall', 'oven', 'powersocket', 'check', 'television', 'tray', 'doorjamb', 'towel_rack', 'mouse', 'cards', 'door', 'light']
Task:Pick up phone
response:

Enter office. Go to desk. Pick up phone.

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


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

Here is an example plan to achieve a goal for reference:
Scene_Objects:['tablelamp', 'blender', 'chair', 'trashcan', 'ceilingfan', 'drawing', 'knifeblock', 'cpuscreen', 'bathroom_counter', 'floor', 'ceiling', 'phone', 'shampoo', 'desk', 'keyboard', 'bookshelf', 'computer', 'ceilinglamp', 'balanceball', 'mousepad', 'couch', 'wall', 'nightstand', 'powersocket', 'coin', 'doorjamb', 'mouse', 'sink', 'light', 'soap']
Task:Write  school paper
response:
{
    "thoughts": Writing  and drafting a paper for  class work,
    "actions": ['[WALK] <home_office>', '[WALK] <computer>', '[SWITCHON] <computer>', '[SWITCHOFF] <computer>']
}

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

[WALK] <home_office>
[WALK] <home_office>
[WALK] <computer>
[FIND] <computer>
[SWITCHON] <computer>
[FIND] <button>
[TURNTO] <button>
[LOOKAT] <button>
[FIND] <mouse>
[GRAB] <mouse>
[GRAB] <button>
[FIND] <chair>
[SIT] <chair>
[SWITCHOFF] <computer>


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

Here is an example plan to achieve a goal for reference:
Scene_Objects:['walllamp', 'drawing', 'orchid', 'wallshelf', 'knifeblock', 'knife', 'bathroom_counter', 'floor', 'ceiling', 'bookshelf', 'mat', 'tvstand', 'ceilinglamp', 'shower', 'window', 'couch', 'pillow', 'wall', 'powersocket', 'photoframe', 'light_bulb', 'television', 'curtain', 'doorjamb', 'cd', 'pajamas', 'door', 'table', 'light', 'dishwasher']
Task:Watch TV
response:
{
    "thoughts": Sitting on the couch watching my favorite television show.,
    "actions": ['[WALK] <home_office>', '[WALK] <couch>', '[FIND] <couch>', '[SIT] <couch>', '[FIND] <television>', '[TURNTO] <television>', '[WATCH] <television>']
}

Input:
Scene_Objects:['chair', 'blow_dryer', 'walllamp', 'food_butter', 'dough', 'drawing', 'orchid', 'bathroom_counter', 'floor', 'ceiling', 'character', 'tea_bag', 'computer', 'mat', 'tvstand', 'faucet', 'dining_room', 'wall', 'powersocket', 'tape', 'bed', 'towel_rack', 'hairbrush', 'conditioner', 'door', 'sink', 'bag', 'bathroom_cabinet', 'table', 'hands_both']
Task:Wash hands
response:

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

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


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

Here is an example plan to achieve a goal for reference:
Scene_Objects:['pot', 'tablelamp', 'walllamp', 'woman', 'drawing', 'phone', 'desk', 'man', 'toaster', 'laptop', 'mat', 'shower', 'electric_shaver', 'oil', 'form', 'pillow', 'dining_room', 'oven', 'shelf', 'bed', 'standingmirror', 'toothbrush_holder', 'tray', 'curtain', 'doorjamb', 'mouse', 'door', 'bathroom_cabinet', 'tooth_paste', 'scrabble']
Task:Greet guests
response:
{
    "thoughts": Answer the door. Smile and give a warm hello, or other appropriate greeting. With newcomers to your home, offer your hand to be shook. With old friends it is appropriate to hug, or kiss one another on the cheek.,
    "actions": ['[WALK] <home_office>', '[WALK] <man>', '[FIND] <man>', '[GREET] <man>', '[FIND] <woman>', '[GREET] <woman>']
}

Input:
Scene_Objects:['pot', 'chair', 'walllamp', 'floor', 'phone', 'stamp', 'bedroom', 'keyboard', 'table_cloth', 'tvstand', 'closetdrawer', 'food_peanut_butter', 'dustpan', 'clothes_hat', 'bowl', 'nightstand', 'cup', 'food_cheese', 'novel', 'video_game_controller', 'television', 'doorjamb', 'towel_rack', 'mouse', 'cupboard', 'door', 'napkin', 'bathroom_cabinet', 'laser_pointer', 'creditcard']
Task:Pet cat
response:

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

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


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

Here is an example plan to achieve a goal for reference:
Scene_Objects:['chair', 'walllamp', 'drawing', 'cpuscreen', 'hanger', 'floor', 'ceiling', 'desk', 'keyboard', 'computer', 'mat', 'ceilinglamp', 'window', 'mousepad', 'closetdrawer', 'couch', 'oil', 'pillow', 'dining_room', 'wall', 'wall_clock', 'bench', 'standingmirror', 'television', 'curtain', 'doorjamb', 'mouse', 'headset', 'napkin', 'table']
Task:Watch TV
response:
{
    "thoughts": Go to entrance hall, switch on TV, sit back in a chair and using remote watch your favorite program.,
    "actions": ['[WALK] <home_office>', '[WALK] <television>', '[FIND] <television>', '[SWITCHON] <television>', '[WALK] <chair>', '[SIT] <chair>', '[TURNTO] <television>', '[WATCH] <television>', '[SWITCHOFF] <television>']
}

Input:
Scene_Objects:['tea', 'chair', 'walllamp', 'drawing', 'wallshelf', 'hanger', 'floor', 'ceiling', 'desk', 'remote_control', 'computer', 'mat', 'tvstand', 'ceilinglamp', 'deck_of_cards', 'closetdrawer', 'couch', 'pillow', 'wall', 'powersocket', 'oven', 'photoframe', 'video_game_controller', 'television', 'doorjamb', 'lighter', 'dresser', 'bathroom_cabinet', 'soap', 'scrabble']
Task:Watch TV
response:

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

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


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

Here is an example plan to achieve a goal for reference:
Scene_Objects:['chair', 'ground_coffee', 'nail_polish', 'orchid', 'hanger', 'floor', 'ceiling', 'dvd_player', 'character', 'keyboard', 'food_cake', 'bookshelf', 'mail', 'toaster', 'plate', 'homework', 'pillow', 'dining_room', 'wall', 'bed', 'coffe_maker', 'coffee_filter', 'water', 'tray', 'curtain', 'kitchen_counter', 'cupboard', 'bathroom_cabinet', 'light', 'dishwasher']
Task:Make coffee
response:
{
    "thoughts": Open coffee maker. Put filter in main basket, put ground coffee in filter, fill reservoir with water, turn on coffee maker.,
    "actions": ['[WALK] <dining_room>', '[WALK] <coffe_maker>', '[FIND] <coffe_maker>', '[OPEN] <coffe_maker>', '[FIND] <coffee_filter>', '[GRAB] <coffee_filter>', '[PUTBACK] <coffee_filter> <coffe_maker>', '[FIND] <ground_coffee>', '[GRAB] <ground_coffee>', '[PUTBACK] <ground_coffee> <coffe_maker>', '[GRAB] <ground_coffee>', '[PUTOBJBACK] <ground_coffee>', '[WALK] <water>', '[FIND] <water>', '[GRAB] <water>', '[POUR] <water> <coffe_maker>', '[CLOSE] <coffe_maker>', '[SWITCHON] <coffe_maker>']
}

Input:
Scene_Objects:['sheets', 'food_pizza', 'filing_cabinet', 'chair', 'jelly', 'walllamp', 'cat', 'orchid', 'drawing', 'hanger', 'bathroom_counter', 'floor', 'dvd_player', 'character', 'food_bacon', 'bookmark', 'stovefan', 'mat', 'ceilinglamp', 'faucet', 'oil', 'closetdrawer', 'dustpan', 'towel', 'wall', 'check', 'doorjamb', 'cupboard', 'laundry_detergent', 'soap']
Task:Wash hands
response:

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

[WALK] <dining_room>
[WALK] <soap>
[FIND] <soap>
[GRAB] <soap>
[SCRUB] <soap>
[FIND] <towel>
[RINSE] <towel>


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

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

Input:
Scene_Objects:['sponge', 'chair', 'walllamp', 'dough', 'drawing', 'wallshelf', 'hanger', 'floor', 'ceiling', 'phone', 'desk', 'remote_control', 'computer', 'mat', 'tvstand', 'ceilinglamp', 'shoe-shine_kit', 'closetdrawer', 'couch', 'pillow', 'wall', 'photoframe', 'novel', 'television', 'doorjamb', 'diary', 'shoes', 'dresser', 'door', 'clothes_shirt']
Task:Watch TV
response:

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

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


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

Here is an example plan to achieve a goal for reference:
Scene_Objects:['glue', 'dry_pasta', 'crayon', 'band-aids', 'detergent', 'drawing', 'clothes_underwear', 'table_cloth', 'stovefan', 'laptop', 'toaster', 'faucet', 'ceilinglamp', 'closetdrawer', 'wall', 'nightstand', 'oven', 'keys', 'food_food', 'tray', 'coffee_pot', 'pencil', 'headset', 'door', 'hairdryer', 'sink', 'table', 'dishwasher', 'clothes_shirt', 'creditcard']
Task:Pet cat
response:
{
    "thoughts": You walk to the living room and find the cat. You look at the cat and touch it to pet it.,
    "actions": ['[WALK] <home_office>', '[WALK] <cat>', '[FIND] <cat>', '[TURNTO] <cat>', '[LOOKAT] <cat>', '[TOUCH] <cat>']
}

Input:
Scene_Objects:['crayon', 'chair', 'walllamp', 'cat', 'drawing', 'wallshelf', 'hanger', 'floor', 'ceiling', 'desk', 'remote_control', 'computer', 'button', 'alcohol', 'mat', 'tvstand', 'ceilinglamp', 'closetdrawer', 'couch', 'clothes_hat', 'microphone', 'pillow', 'wall', 'photoframe', 'novel', 'coffe_maker', 'television', 'doorjamb', 'coffee_pot', 'dresser']
Task:Watch TV
response:

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

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


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

Here is an example plan to achieve a goal for reference:
Scene_Objects:['pot', 'food_ice_cream', 'microwave', 'freezer', 'walllamp', 'blow_dryer', 'detergent', 'knifeblock', 'bathroom_counter', 'floor', 'ceiling', 'table_cloth', 'stovefan', 'toaster', 'faucet', 'mousepad', 'wall', 'wall_clock', 'oven', 'cup', 'coffe_maker', 'food_food', 'water', 'tray', 'cards', 'kitchen_counter', 'cupboard', 'sink', 'light', 'dishwasher']
Task:Drink
response:
{
    "thoughts": Walk to kitchen, grab a cup, fill with water and then drink it.,
    "actions": ['[WALK] <dining_room>', '[WALK] <cupboard>', '[FIND] <cupboard>', '[OPEN] <cupboard>', '[FIND] <cup>', '[GRAB] <cup>', '[FIND] <faucet>', '[SWITCHON] <faucet>', '[FIND] <water>', '[FIND] <sink>', '[PUTBACK] <cup> <sink>', '[GRAB] <cup>', '[DRINK] <cup>']
}

Input:
Scene_Objects:['chair', 'walllamp', 'drawing', 'wallshelf', 'hanger', 'floor', 'ceiling', 'shampoo', 'desk', 'tea_bag', 'computer', 'bookmark', 'mat', 'tvstand', 'ceilinglamp', 'faucet', 'closetdrawer', 'couch', 'pillow', 'wall', 'oven', 'powersocket', 'cup', 'photoframe', 'television', 'after_shave', 'doorjamb', 'kettle', 'dresser', 'pajamas']
Task:Watch TV
response:

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

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


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

Here is an example plan to achieve a goal for reference:
Scene_Objects:['juice', 'crayon', 'walllamp', 'trashcan', 'dough', 'floor', 'phone', 'bedroom', 'tea_bag', 'toaster', 'mat', 'plate', 'ceilinglamp', 'dish_soap', 'wall', 'pasta', 'oven', 'cutting_board', 'food_cheese', 'newspaper', 'coffe_maker', 'check', 'food_food', 'tray', 'towel_rack', 'pencil', 'dresser', 'conditioner', 'home_office', 'dishwasher']
Task:Wash dishes with dishwasher
response:
{
    "thoughts": I walk to the kitchen. I search and find dishwasher. I search dishes. I put dishes inside the dishwasher. I put dish soap in dishwasher. I switch on dishwasher and wait for dishes to be washed.,
    "actions": ['[WALK] <dining_room>', '[WALK] <dishwasher>', '[FIND] <dishwasher>', '[FIND] <plate>', '[GRAB] <plate>', '[OPEN] <dishwasher>', '[PUTBACK] <plate> <dishwasher>', '[FIND] <dish_soap>', '[GRAB] <dish_soap>', '[PUTBACK] <dish_soap> <dishwasher>', '[CLOSE] <dishwasher>', '[SWITCHON] <dishwasher>']
}

Input:
Scene_Objects:['tablelamp', 'chair', 'walllamp', 'orchid', 'cpuscreen', 'wallshelf', 'hanger', 'bathroom_counter', 'floor', 'ceiling', 'phone', 'desk', 'keyboard', 'computer', 'ceilinglamp', 'tvstand', 'mat', 'mousepad', 'couch', 'pillow', 'broom', 'wall', 'nightstand', 'television', 'doorjamb', 'towel_rack', 'mouse', 'dresser', 'hairbrush', 'door']
Task:Browse internet
response:

Turn on computer, pull up browser, browse the internet

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


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

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

Input:
Scene_Objects:['spectacles', 'pot', 'food_pizza', 'chair', 'ground_coffee', 'orchid', 'needle', 'cpuscreen', 'hanger', 'desk', 'food_cake', 'computer', 'closetdrawer', 'clothes_pants', 'dining_room', 'oven', 'powersocket', 'cup', 'photoframe', 'coffe_maker', 'television', 'coin', 'tray', 'after_shave', 'doorjamb', 'diary', 'towel_rack', 'cupboard', 'door', 'bathroom_cabinet']
Task:Turn on light
response:

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

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


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

Here is an example plan to achieve a goal for reference:
Scene_Objects:['dog', 'freezer', 'bathroom', 'detergent', 'shampoo', 'desk', 'stamp', 'food_bacon', 'brush', 'ceilinglamp', 'oil', 'soap', 'food_orange', 'towel', 'nightstand', 'video_game_controller', 'razor', 'television', 'wine', 'food_onion', 'mouse', 'shoes', 'hair', 'door', 'sink', 'home_office', 'light', 'vase', 'colander', 'teeth']
Task:Open door
response:
{
    "thoughts": I walk up to the door.  I use my hand to turn the door knob to the left.  I pull the door open with the same hand I used to turn the door knob,
    "actions": ['[RUN] <home_office>']
}

Input:
Scene_Objects:['tablelamp', 'microwave', 'toilet', 'freezer', 'walllamp', 'detergent', 'drawing', 'cpuscreen', 'floor', 'phone', 'character', 'bedroom', 'bookshelf', 'keyboard', 'brush', 'stereo', 'oven', 'cup', 'food_donut', 'curtain', 'kettle', 'towel_rack', 'pencil', 'kitchen_counter', 'laundry_detergent', 'sink', 'bathroom_cabinet', 'home_office', 'dishwasher', 'teeth']
Task:Listen to music
response:

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

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


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

Here is an example plan to achieve a goal for reference:
Scene_Objects:['pot', 'filing_cabinet', 'scissors', 'mop', 'microwave', 'toilet', 'walllamp', 'drawing', 'orchid', 'cpuscreen', 'floor', 'desk', 'bookshelf', 'tvstand', 'shower', 'stereo', 'mousepad', 'wall', 'powersocket', 'photoframe', 'bed', 'food_food', 'television', 'curtain', 'doorjamb', 'coffee_pot', 'chessboard', 'laundry_detergent', 'door', 'board_game']
Task:Go to toilet
response:
{
    "thoughts": walk to bathroom , run to toilet,
    "actions": ['[WALK] <bathroom>', '[RUN] <toilet>']
}

Input:
Scene_Objects:['food_pizza', 'food_salt', 'drawing', 'wallshelf', 'hanger', 'floor', 'ceiling', 'character', 'desk', 'bookshelf', 'computer', 'mat', 'faucet', 'closetdrawer', 'pillow', 'dining_room', 'wall', 'nightstand', 'powersocket', 'toy', 'novel', 'toothbrush_holder', 'wine', 'doorjamb', 'shaving_cream', 'kitchen_counter', 'door', 'sink', 'clothes_scarf', 'light']
Task:Turn on light
response:

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

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


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

Here is an example plan to achieve a goal for reference:
Scene_Objects:['beer', 'measuring_cup', 'orchid', 'hanger', 'floor', 'ceiling', 'phone', 'tea_bag', 'keyboard', 'purse', 'computer', 'mat', 'ceilinglamp', 'shower', 'mousepad', 'closetdrawer', 'wall', 'nightstand', 'novel', 'food_food', 'television', 'doorjamb', 'coffee_pot', 'vacuum_cleaner', 'dresser', 'hairbrush', 'door', 'napkin', 'home_office', 'board_game']
Task:Sweep hallway please
response:
{
    "thoughts": Vacuum all the way up and down the hallway.  Get all the dirt and crumbs out of carpet please.,
    "actions": ['[WALK] <home_office>', '[WALK] <dresser>', '[OPEN] <dresser>', '[FIND] <vacuum_cleaner>', '[GRAB] <vacuum_cleaner>', '[PULL] <vacuum_cleaner>', '[PLUGIN] <vacuum_cleaner>', '[SWITCHON] <vacuum_cleaner>', '[PULL] <vacuum_cleaner>', '[PUSH] <vacuum_cleaner>', '[PULL] <vacuum_cleaner>', '[PUSH] <vacuum_cleaner>', '[PULL] <vacuum_cleaner>', '[PUSH] <vacuum_cleaner>', '[SWITCHOFF] <vacuum_cleaner>', '[PLUGOUT] <vacuum_cleaner>', '[WALK] <dresser>', '[PUTIN] <vacuum_cleaner> <dresser>', '[CLOSE] <dresser>']
}

Input:
Scene_Objects:['freezer', 'bathroom', 'food_carrot', 'drawing', 'cpuscreen', 'wallshelf', 'bathroom_counter', 'floor', 'ceiling', 'character', 'mat', 'stereo', 'closetdrawer', 'couch', 'food_jam', 'clothes_hat', 'pillow', 'food_kiwi', 'wall', 'food_food', 'television', 'diary', 'mouse', 'pencil', 'kitchen_counter', 'shoes', 'dishrack', 'comb', 'dresser', 'cupboard']
Task:Put groceries in Fridge
response:

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

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


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

Here is an example plan to achieve a goal for reference:
Scene_Objects:['spectacles', 'drawing', 'knife', 'orchid', 'hanger', 'floor', 'keyboard', 'purse', 'bookshelf', 'mail', 'toaster', 'ceilinglamp', 'shower', 'balanceball', 'window', 'couch', 'clothes_pants', 'wall', 'oven', 'powersocket', 'television', 'coin', 'diary', 'cd', 'dresser', 'hairbrush', 'hair', 'conditioner', 'table', 'soap']
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:['dry_pasta', 'tablelamp', 'nail_polish', 'cpuscreen', 'hanger', 'ceiling', 'phone', 'bedroom', 'thread', 'mail', 'ceilinglamp', 'foundation', 'food_peanut_butter', 'dustpan', 'dining_room', 'powersocket', 'cup', 'newspaper', 'bed', 'coffe_maker', 'check', 'tray', 'wooden_spoon', 'kitchen_counter', 'bathroom_cabinet', 'table', 'home_office', 'soap', 'washing_machine', 'creditcard']
Task:Wash clothes
response:

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


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

Here is an example plan to achieve a goal for reference:
Scene_Objects:['tea', 'microwave', 'toilet', 'walllamp', 'detergent', 'trashcan', 'floor', 'ceiling', 'envelope', 'toaster', 'plate', 'shower', 'stereo', 'dish_soap', 'wall', 'powersocket', 'basket_for_clothes', 'coffe_maker', 'food_food', 'mouthwash', 'check', 'curtain', 'kitchen_counter', 'cupboard', 'pajamas', 'conditioner', 'sink', 'spoon', 'home_office', 'dishwasher']
Task:Wash dishes with dishwasher
response:
{
    "thoughts": Walk to the kitchen. Find the dishwasher. Walk to the dishwasher. Open the dishwasher. Find plate no.1. Grab plate no.1. Put plate no.1 into the dishwasher. Find plate no.2. Grab plate no.2. Put plate no.2 into the dishwasher. Find the spoon. Grab the spoon. Put the spoon into the dishwasher. Find the dish soap. Put the dish soap into the dishwasher. Close the dishwasher. Switch on the dishwasher.,
    "actions": ['[WALK] <dining_room>', '[WALK] <dishwasher>', '[FIND] <dishwasher>', '[WALK] <dishwasher>', '[OPEN] <dishwasher>', '[FIND] <plate>', '[GRAB] <plate>', '[PUTBACK] <plate> <dishwasher>', '[FIND] <plate>', '[GRAB] <plate>', '[PUTBACK] <plate> <dishwasher>', '[FIND] <spoon>', '[GRAB] <spoon>', '[PUTBACK] <spoon> <dishwasher>', '[FIND] <dish_soap>', '[GRAB] <dish_soap>', '[PUTBACK] <dish_soap> <dishwasher>', '[CLOSE] <dishwasher>', '[SWITCHON] <dishwasher>']
}

Input:
Scene_Objects:['food_bread', 'tablelamp', 'food_ice_cream', 'freezer', 'bathroom', 'orchid', 'bills', 'cpuscreen', 'bathroom_counter', 'floor', 'phone', 'stereo', 'closetdrawer', 'nightstand', 'oven', 'photoframe', 'clothes_gloves', 'toilet_paper', 'video_game_controller', 'television', 'doorjamb', 'mouse', 'cupboard', 'controller', 'door', 'spoon', 'bathroom_cabinet', 'light', 'dishwasher', 'instrument_violin']
Task:Browse internet
response:

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

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


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

Here is an example plan to achieve a goal for reference:
Scene_Objects:['pot', 'detergent', 'drawing', 'floor', 'ceiling', 'bookshelf', 'computer', 'stovefan', 'ceilinglamp', 'laptop', 'shower', 'window', 'oil', 'clothes_socks', 'couch', 'food_orange', 'pillow', 'wall', 'novel', 'coffe_maker', 'television', 'food_rice', 'rag', 'doorjamb', 'cupboard', 'door', 'sink', 'napkin', 'table', 'light']
Task:Relax
response:
{
    "thoughts": Lie down on the couch.,
    "actions": ['[WALK] <home_office>', '[WALK] <couch>', '[LIE] <couch>']
}

Input:
Scene_Objects:['microwave', 'nail_polish', 'drawing', 'wallshelf', 'hanger', 'floor', 'ceiling', 'shampoo', 'bedroom', 'tea_bag', 'laptop', 'tvstand', 'clothes_socks', 'closetdrawer', 'couch', 'clothes_hat', 'wall', 'nightstand', 'powersocket', 'photoframe', 'coffe_maker', 'check', 'television', 'doorjamb', 'towel_rack', 'cards', 'dresser', 'door', 'home_office', 'light']
Task:Turn on light
response:

I walk into the dining room and turn on the lights

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


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

Here is an example plan to achieve a goal for reference:
Scene_Objects:['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:['tablelamp', 'chair', 'band-aids', 'walllamp', 'orchid', 'cpuscreen', 'wallshelf', 'hanger', 'floor', 'ceiling', 'phone', 'desk', 'keyboard', 'computer', 'ceilinglamp', 'tvstand', 'mat', 'iron', 'mousepad', 'couch', 'pillow', 'wall', 'nightstand', 'novel', 'television', 'doorjamb', 'coffee_pot', 'mouse', 'dresser', 'door']
Task:Browse internet
response:

Go to home office, turn on the computer, open the internet and browse around the internet.

[WALK] <home_office>
[WALK] <computer>
[SWITCHON] <computer>
[TURNTO] <computer>
[LOOKAT] <computer>