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', 'sheets', 'filing_cabinet', 'food_bread', 'food_salt', 'microwave', 'chair', 'orchid', 'drawing', 'bathroom_counter', 'floor', 'mail', 'stovefan', 'ceilinglamp', 'mat', 'stereo', 'couch', 'wall', 'powersocket', 'cup', 'check', 'mouthwash', 'food_donut', 'tray', 'kitchen_counter', 'cd', 'cupboard', 'controller', 'table', 'teeth']
Task:Play games
response:
{
    "thoughts": I either bring out monopoly, uno, chess, checkers or playing cards and lay them out on the dining room table. We then play the games for a couple of hours.,
    "actions": ['[WALK] <home_office>', '[WALK] <board_game>', '[FIND] <board_game>', '[GRAB] <board_game>', '[WALK] <dining_room>', '[WALK] <table>', '[PUTBACK] <board_game> <table>']
}

Input:
Scene_Objects:['tablelamp', 'chair', 'walllamp', 'drawing', 'orchid', 'wallshelf', 'cpuscreen', 'hanger', 'floor', 'ceiling', 'desk', 'keyboard', 'remote_control', 'computer', 'mop_bucket', 'mat', 'tvstand', 'ceilinglamp', 'mousepad', 'closetdrawer', 'couch', 'pillow', 'wall', 'nightstand', 'photoframe', 'television', 'doorjamb', 'mouse', 'dresser', 'door']
Task:Change TV channel
response:

its time for my favorite show and im going change with the help of remote control and watch

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


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

Here is an example plan to achieve a goal for reference:
Scene_Objects:['tablelamp', 'detergent', 'ceilingfan', 'drawing', 'needle', 'knifeblock', 'floor', 'ceiling', 'phone', 'bedroom', 'computer', 'toaster', 'ceilinglamp', 'tvstand', 'balanceball', 'shower', 'window', 'couch', 'wall', 'bench', 'check', 'television', 'oven_mitts', 'curtain', 'conditioner', 'food_steak', 'home_office', 'table', 'vase', 'clothes_shirt']
Task:Watch TV
response:
{
    "thoughts": I walk into the living room and sit on the sofa to watch tv,
    "actions": ['[WALK] <home_office>', '[WALK] <couch>', '[FIND] <couch>', '[SIT] <couch>', '[FIND] <television>', '[TURNTO] <television>', '[WATCH] <television>']
}

Input:
Scene_Objects:['filing_cabinet', 'tablelamp', 'blender', 'measuring_cup', 'toilet', 'drawing', 'needle', 'hanger', 'floor', 'computer', 'mat', 'mousepad', 'wall', 'nightstand', 'powersocket', 'cutting_board', 'bed', 'novel', 'food_food', 'video_game_controller', 'coffe_maker', 'tray', 'food_onion', 'doorjamb', 'lighter', 'cd', 'clothes_dress', 'bathroom_cabinet', 'light', 'soap']
Task:Read book
response:

I would go lie down in my bed and open the book and start reading.

[WALK] <bedroom>
[WALK] <bed>
[FIND] <bed>
[LIE] <bed>
[FIND] <novel>
[GRAB] <novel>
[READ] <novel>


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

Here is an example plan to achieve a goal for reference:
Scene_Objects:['pot', 'microwave', 'chair', 'freezer', 'walllamp', 'bathroom', 'food_butter', 'floor', 'ceiling', 'stovefan', 'faucet', 'dustpan', 'food_jam', 'wall', 'oven', 'cutting_board', 'newspaper', 'coffe_maker', 'water', 'drinking_glass', 'tray', 'doorjamb', 'kitchen_counter', 'vacuum_cleaner', 'pajamas', 'home_office', 'bathroom_cabinet', 'clothes_skirt', 'vase', 'scrabble']
Task:Drink
response:
{
    "thoughts": go to the kitchen,
    "actions": ['[WALK] <dining_room>', '[WALK] <freezer>', '[FIND] <freezer>', '[OPEN] <freezer>', '[FIND] <drinking_glass>', '[GRAB] <drinking_glass>', '[FIND] <water>', '[DRINK] <drinking_glass>']
}

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

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.

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


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

Here is an example plan to achieve a goal for reference:
Scene_Objects:['pot', 'microwave', 'toilet', 'freezer', 'trashcan', 'drawing', 'wallshelf', 'cpuscreen', 'floor', 'desk', 'bookshelf', 'toaster', 'mat', 'ceilinglamp', 'plate', 'window', 'couch', 'pillow', 'wall', 'nightstand', 'bench', 'photoframe', 'coffe_maker', 'food_rice', 'dresser', 'cupboard', 'bathroom_cabinet', 'table', 'dishwasher', 'home_office']
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:['sheets', 'filing_cabinet', 'blender', 'toilet', 'jelly', 'chair', 'drawing', 'bathroom_counter', 'floor', 'character', 'food_bacon', 'mat', 'shoe-shine_kit', 'shower', 'clothes_pants', 'pillow', 'dining_room', 'wall', 'pasta', 'oven', 'newspaper', 'check', 'television', 'ice', 'tray', 'doorjamb', 'pencil', 'comb', 'dresser', 'bathroom_cabinet']
Task:Go to toilet
response:

Walk to the bathroom. Pull down pants. Use the toilet.

[WALK] <bathroom>
[WALK] <clothes_pants>
[FIND] <clothes_pants>
[PULL] <clothes_pants>
[FIND] <toilet>
[SIT] <toilet>


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', 'orchid', 'wallshelf', 'hanger', 'floor', 'ceiling', 'desk', 'remote_control', 'computer', 'toaster', 'mat', 'tvstand', 'ceilinglamp', 'stereo', 'closetdrawer', 'couch', 'pillow', 'wall', 'oven', 'toy', 'photoframe', 'bed', 'television', 'doorjamb', 'towel_rack', 'dresser', 'dishwasher', 'shoe_rack']
Task:Watch movie
response:
{
    "thoughts": Sit down on couch in front of TV.  Use remote to turn on the TV,
    "actions": ['[WALK] <home_office>', '[WALK] <couch>', '[FIND] <couch>', '[SIT] <couch>', '[FIND] <remote_control>', '[GRAB] <remote_control>', '[FIND] <television>', '[SWITCHON] <television>', '[TURNTO] <television>', '[WATCH] <television>']
}

Input:
Scene_Objects:['sheets', 'scissors', 'juice', 'toilet', 'freezer', 'bathroom', 'bills', 'orchid', 'shampoo', 'ceiling', 'stamp', 'desk', 'keyboard', 'tvstand', 'couch', 'dustpan', 'dining_room', 'powersocket', 'newspaper', 'check', 'video_game_controller', 'television', 'coffe_maker', 'ice', 'tray', 'doorjamb', 'shoes', 'controller', 'door', 'napkin']
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:['pot', 'scissors', 'chair', 'drawing', 'needle', 'hanger', 'ceiling', 'phone', 'toaster', 'ceilinglamp', 'laptop', 'iron', 'mat', 'deck_of_cards', 'mousepad', 'oil', 'wall', 'basket_for_clothes', 'food_donut', 'food_rice', 'tray', 'curtain', 'doorjamb', 'pencil', 'kitchen_counter', 'dresser', 'cupboard', 'door', 'clothes_scarf', 'light']
Task:Put on coat
response:
{
    "thoughts": I remove my scarf from a coat peg in the entrance hall.  I wrap the scarf around my neck,
    "actions": ['[WALK] <home_office>', '[WALK] <hanger>', '[TURNTO] <hanger>', '[LOOKAT] <hanger>', '[FIND] <clothes_scarf>', '[GRAB] <clothes_scarf>', '[PUTON] <clothes_scarf>']
}

Input:
Scene_Objects:['sponge', 'filing_cabinet', 'tablelamp', 'toilet', 'freezer', 'detergent', 'drawing', 'orchid', 'hanger', 'floor', 'ceiling', 'bookshelf', 'computer', 'stovefan', 'mat', 'microphone', 'pillow', 'nightstand', 'wall', 'powersocket', 'bed', 'novel', 'television', 'doorjamb', 'headset', 'shoes', 'controller', 'door', 'light', 'table']
Task:Read book
response:

Go to the bedroom. Grab the book out of the nightstand. Lay down in bed. Open the book. Read the book.

[WALK] <bedroom>
[WALK] <nightstand>
[FIND] <nightstand>
[OPEN] <nightstand>
[FIND] <novel>
[GRAB] <novel>
[FIND] <bed>
[TURNTO] <bed>
[SIT] <bed>
[READ] <novel>


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

Here is an example plan to achieve a goal for reference:
Scene_Objects:['dog', 'freezer', 'bathroom', 'food_carrot', 'knifeblock', 'food_egg', 'hanger', 'floor', 'phone', 'stovefan', 'mat', 'plate', 'stereo', 'dish_soap', 'food_noodles', 'closetdrawer', 'mousepad', 'dustpan', 'cup', 'food_food', 'coffe_maker', 'check', 'oven_mitts', 'water', 'food_rice', 'curtain', 'mouse', 'hairbrush', 'sink', 'home_office']
Task:Wash dishes by hand
response:
{
    "thoughts": walk to kitchen, fins soap, arrange dishes, wash dishes,
    "actions": ['[WALK] <dining_room>', '[WALK] <plate>', '[FIND] <plate>', '[FIND] <dish_soap>', '[FIND] <water>', '[GRAB] <plate>', '[GRAB] <dish_soap>', '[WASH] <plate>', '[RINSE] <plate>', '[DROP] <plate>']
}

Input:
Scene_Objects:['filing_cabinet', 'tablelamp', 'tea', 'chair', 'orchid', 'drawing', 'wallshelf', 'cpuscreen', 'clothes_underwear', 'floor', 'ceiling', 'desk', 'bookshelf', 'keyboard', 'computer', 'mat', 'ceilinglamp', 'tvstand', 'mousepad', 'wall', 'nightstand', 'powersocket', 'television', 'food_rice', 'doorjamb', 'diary', 'mouse', 'kitchen_counter', 'door', 'light']
Task:Turn on light
response:

[WALK] <home_office>
[WALK] <light>
[FIND] <light>
[PLUGIN] <light>
[SWITCHON] <light>
[FIND] <chair>
[SIT] <chair>


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

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

Input:
Scene_Objects:['pot', 'chair', 'walllamp', 'drawing', 'orchid', 'wallshelf', 'hanger', 'floor', 'ceiling', 'desk', 'bedroom', 'remote_control', 'computer', 'mat', 'tvstand', 'ceilinglamp', 'picture', 'closetdrawer', 'couch', 'pillow', 'wall', 'oven', 'photoframe', 'bed', 'check', 'mouthwash', 'television', 'doorjamb', 'dresser', 'dishwasher']
Task:Watch TV
response:

walk to living room. look at remote control. grab remote control. plug in television. switch on television. lie in sofa. point at remote control. watch television.

[WALK] <home_office>
[WALK] <remote_control>
[FIND] <remote_control>
[TURNTO] <remote_control>
[LOOKAT] <remote_control>
[GRAB] <remote_control>
[FIND] <television>
[PLUGIN] <television>
[SWITCHON] <television>
[FIND] <couch>
[LIE] <couch>
[TURNTO] <remote_control>
[POINTAT] <remote_control>
[TURNTO] <television>
[WATCH] <television>


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

Here is an example plan to achieve a goal for reference:
Scene_Objects:['sponge', 'fork', 'filing_cabinet', 'tablelamp', 'chair', 'band-aids', 'floor', 'ceiling', 'stamp', 'alcohol', 'toaster', 'mat', 'plate', 'faucet', 'dish_soap', 'towel', 'wall', 'toy', 'bed', 'keys', 'photoframe', 'coffe_maker', 'television', 'coin', 'kitchen_counter', 'dresser', 'cupboard', 'food_steak', 'sink', 'table']
Task:Wash dishes
response:
{
    "thoughts": Run warm water in the sink. Pour dish washing liquid on the dishes. Pick up dishes and wash them individually with a sponge. Rinse suds off under running water. Dry dishes with towel.,
    "actions": ['[WALK] <dining_room>', '[WALK] <sink>', '[FIND] <faucet>', '[SWITCHON] <faucet>', '[FIND] <dish_soap>', '[GRAB] <dish_soap>', '[FIND] <sponge>', '[GRAB] <sponge>', '[POUR] <dish_soap> <sponge>', '[PUTOBJBACK] <dish_soap>', '[FIND] <plate>', '[GRAB] <plate>', '[SCRUB] <plate>', '[WASH] <plate>', '[RINSE] <plate>', '[RINSE] <sponge>', '[SWITCHOFF] <faucet>', '[PUTOBJBACK] <sponge>', '[FIND] <towel>', '[GRAB] <towel>', '[WIPE] <plate>', '[PUTOBJBACK] <towel>', '[WALK] <kitchen_cabinet>', '[OPEN] <kitchen_cabinet>', '[PUTIN] <plate> <kitchen_cabinet>', '[CLOSE] <kitchen_cabinet>']
}

Input:
Scene_Objects:['sheets', 'pot', 'microwave', 'chair', 'freezer', 'food_carrot', 'drawing', 'cpuscreen', 'floor', 'ceiling', 'clothes_jacket', 'table_cloth', 'mat', 'tvstand', 'shower', 'stereo', 'couch', 'pillow', 'wall', 'oven', 'cup', 'food_food', 'television', 'coffee_filter', 'mouse', 'kitchen_counter', 'cupboard', 'door', 'food_steak', 'dishwasher']
Task:Cook some food
response:

Walk Into Kitchen. Open Refrigerator. Grab Food. Walk to Microwave. Insert food into microwave. Cook until warm.

[WALK] <dining_room>
[WALK] <freezer>
[OPEN] <freezer>
[FIND] <food_food>
[CLOSE] <freezer>
[WALK] <microwave>
[SWITCHON] <microwave>
[SWITCHOFF] <microwave>


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', 'walllamp', 'drawing', 'orchid', 'wallshelf', 'floor', 'ceiling', 'bookshelf', 'stovefan', 'mat', 'tvstand', 'ceilinglamp', 'shower', 'window', 'couch', 'pillow', 'dining_room', 'wall', 'nightstand', 'powersocket', 'photoframe', 'coffe_maker', 'television', 'coin', 'curtain', 'doorjamb', 'coffee_pot', 'door', 'table', 'light']
Task:Watch TV
response:
{
    "thoughts": I walk to the living room. I grab the remote control. I walk to the sofa. I sit down, and press the on button on the remote.,
    "actions": ['[WALK] <home_office>', '[WALK] <remote_control>', '[FIND] <remote_control>', '[GRAB] <remote_control>', '[WALK] <couch>', '[SIT] <couch>', '[TOUCH] <remote_control>', '[FIND] <television>', '[SWITCHON] <television>']
}

Input:
Scene_Objects:['chair', 'walllamp', 'drawing', 'knife', 'wallshelf', 'orchid', 'hanger', 'bathroom_counter', 'floor', 'ceiling', 'desk', 'remote_control', 'computer', 'mat', 'tvstand', 'ceilinglamp', 'oil', 'closetdrawer', 'couch', 'pillow', 'wall', 'box', 'photoframe', 'television', 'coffee_filter', 'after_shave', 'doorjamb', 'diary', 'kitchen_counter', 'dresser']
Task:Change TV channel
response:

Walk to livingroom, grab remote and change the channel on television.

[WALK] <home_office>
[WALK] <remote_control>
[FIND] <remote_control>
[GRAB] <remote_control>
[FIND] <television>
[SWITCHON] <television>
[PUTOBJBACK] <remote_control>


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

Here is an example plan to achieve a goal for reference:
Scene_Objects:['scissors', 'freezer', 'walllamp', 'knifeblock', 'wallshelf', 'clothes_underwear', 'ceiling', 'bookshelf', 'keyboard', 'ceilinglamp', 'plate', 'stereo', 'clothes_socks', 'clothes_pants', 'pillow', 'bowl', 'powersocket', 'cutting_board', 'basket_for_clothes', 'razor', 'coin', 'wine', 'curtain', 'pencil', 'kitchen_counter', 'cd', 'dresser', 'laundry_detergent', 'clothes_shirt', 'washing_machine']
Task:Wash clothes
response:
{
    "thoughts": I go to the bathroom and open the washing machine there. I take my laundry basket and put each item of laundry into the machine. Then I take the laundry detergent and pour some into the machine. Finally I close the machine and switch it on.,
    "actions": ['[WALK] <bathroom>', '[WALK] <washing_machine>', '[FIND] <washing_machine>', '[OPEN] <washing_machine>', '[FIND] <basket_for_clothes>', '[GRAB] <basket_for_clothes>', '[FIND] <clothes_pants>', '[GRAB] <clothes_pants>', '[PUTBACK] <clothes_pants> <washing_machine>', '[FIND] <clothes_shirt>', '[GRAB] <clothes_shirt>', '[PUTBACK] <clothes_shirt> <washing_machine>', '[FIND] <clothes_underwear>', '[GRAB] <clothes_underwear>', '[PUTBACK] <clothes_underwear> <washing_machine>', '[FIND] <clothes_socks>', '[GRAB] <clothes_socks>', '[PUTBACK] <clothes_socks> <washing_machine>', '[PUTOBJBACK] <basket_for_clothes>', '[FIND] <laundry_detergent>', '[GRAB] <laundry_detergent>', '[POUR] <laundry_detergent> <washing_machine>', '[CLOSE] <washing_machine>', '[SWITCHON] <washing_machine>']
}

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

Walk to the Home office. Sit on the chair. Switch on the computer. Type with keyboard for internet.

[WALK] <home_office>
[WALK] <chair>
[FIND] <chair>
[SIT] <chair>
[FIND] <computer>
[SWITCHON] <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:['pot', 'microwave', 'chair', 'freezer', 'wallshelf', 'cpuscreen', 'floor', 'phone', 'desk', 'remote_control', 'computer', 'button', 'toaster', 'mat', 'shower', 'food_peanut_butter', 'food_kiwi', 'nightstand', 'oven', 'photoframe', 'television', 'oven_mitts', 'tray', 'kettle', 'cards', 'pencil', 'kitchen_counter', 'towel_rack', 'bathtub', 'table']
Task:Change TV channel
response:
{
    "thoughts": Walk into living room. Find television remote control. Pick up remote control. Press button.,
    "actions": ['[WALK] <home_office>', '[WALK] <remote_control>', '[FIND] <remote_control>', '[GRAB] <remote_control>', '[FIND] <button>', '[PUSH] <button>']
}

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

I go to my home office, sit on the chair and turn on the computer. I open my email account to look for all the information I need.I pull up my online task on the computer to look at what the assigned task is.

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


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

Here is an example plan to achieve a goal for reference:
Scene_Objects:['fork', 'beer', 'microwave', 'freezer', 'walllamp', 'dough', 'floor', 'ceiling', 'phone', 'stovefan', 'mat', 'ceilinglamp', 'window', 'couch', 'pillow', 'wall', 'oven', 'cutting_board', 'shelf', 'coffe_maker', 'food_food', 'television', 'tray', 'curtain', 'doorjamb', 'cards', 'kitchen_counter', 'maindoor', 'bathtub', 'table']
Task:Drink
response:
{
    "thoughts": Get a can of beer, open it, sit on couch, relax,
    "actions": ['[WALK] <dining_room>', '[WALK] <freezer>', '[FIND] <freezer>', '[OPEN] <freezer>', '[FIND] <beer>', '[GRAB] <beer>', '[CLOSE] <freezer>', '[WALK] <home_office>', '[WALK] <couch>', '[FIND] <couch>', '[SIT] <couch>', '[DRINK] <beer>']
}

Input:
Scene_Objects:['tablelamp', 'freezer', 'walllamp', 'detergent', 'drawing', 'knife', 'wallshelf', 'hanger', 'floor', 'ceiling', 'computer', 'mop_bucket', 'bookmark', 'mat', 'tvstand', 'ceilinglamp', 'faucet', 'couch', 'clothes_hat', 'pillow', 'wall', 'box', 'photoframe', 'bed', 'coffe_maker', 'television', 'coin', 'doorjamb', 'door', 'sink']
Task:Relax on sofa
response:

walk to living room ,find sofa ,sit on sofa

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


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

Here is an example plan to achieve a goal for reference:
Scene_Objects:['blender', 'chair', 'walllamp', 'drawing', 'cpuscreen', 'wallshelf', 'floor', 'ceiling', 'desk', 'keyboard', 'computer', 'ceilinglamp', 'foundation', 'mousepad', 'closetdrawer', 'pillow', 'wall', 'nightstand', 'powersocket', 'toy', 'television', 'doorjamb', 'mouse', 'kitchen_counter', 'dresser', 'bathtub', 'napkin', 'light', 'table', 'dirt']
Task:Work
response:
{
    "thoughts": go to home office. turn the computer on. begin working,
    "actions": ['[WALK] <home_office>', '[WALK] <computer>', '[FIND] <computer>', '[SWITCHON] <computer>']
}

Input:
Scene_Objects:['dry_pasta', 'filing_cabinet', 'tablelamp', 'chair', 'cpuscreen', 'floor', 'ceiling', 'character', 'keyboard', 'computer', 'toaster', 'mat', 'stovefan', 'faucet', 'shower', 'mousepad', 'broom', 'wall', 'powersocket', 'cup', 'novel', 'coffe_maker', 'mouthwash', 'tray', 'kitchen_counter', 'cupboard', 'conditioner', 'sink', 'napkin', 'soap']
Task:Drink
response:

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


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

Here is an example plan to achieve a goal for reference:
Scene_Objects:['pot', 'toilet', 'freezer', 'food_carrot', 'drawing', 'hanger', 'floor', 'ceiling', 'shampoo', 'stovefan', 'mat', 'shower', 'window', 'nightstand', 'wall', 'powersocket', 'food_cheese', 'photoframe', 'bed', 'newspaper', 'food_food', 'drinking_glass', 'water', 'curtain', 'doorjamb', 'dresser', 'food_steak', 'door', 'home_office', 'light']
Task:Drink
response:
{
    "thoughts": im feeling thirsty im going to kitchen and open the freezer where i can find some cold water and im going to drink it to end up my thirst,
    "actions": ['[WALK] <dining_room>', '[WALK] <freezer>', '[FIND] <freezer>', '[OPEN] <freezer>', '[FIND] <drinking_glass>', '[GRAB] <drinking_glass>', '[WALK] <water>', '[FIND] <water>', '[GRAB] <water>', '[POUR] <water> <drinking_glass>', '[DRINK] <drinking_glass>']
}

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

walk to Office,Walk to desk ,sit down in chair, turn on computer, start homework.

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


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:['cd_player', 'freezer', 'ground_coffee', 'bathroom', 'milk', 'orchid', 'cpuscreen', 'hanger', 'dvd_player', 'character', 'ceilinglamp', 'stereo', 'faucet', 'dustpan', 'clothes_hat', 'nightstand', 'wall', 'newspaper', 'check', 'mouthwash', 'video_game_controller', 'food_food', 'tray', 'doorjamb', 'pencil', 'cupboard', 'door', 'sink', 'home_office', 'dishwasher']
Task:Listen to music
response:

I walk in the living room, then I go the the stereo and the cd player and turn them on.

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


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:['ceilingfan', 'drawing', 'knifeblock', 'floor', 'ceiling', 'remote_control', 'computer', 'toaster', 'ceilinglamp', 'tvstand', 'balanceball', 'faucet', 'window', 'couch', 'wall', 'powersocket', 'oven', 'coffe_maker', 'television', 'coffee_filter', 'food_rice', 'tray', 'curtain', 'pencil', 'kitchen_counter', 'cupboard', 'sink', 'napkin', 'table', 'dirt']
Task:Watch TV
response:
{
    "thoughts": I like to set on my sofa.Turn on the tv. And watch Perry Mason. Monday's through Friday's.,
    "actions": ['[WALK] <home_office>', '[WALK] <couch>', '[FIND] <couch>', '[SIT] <couch>', '[FIND] <television>', '[SWITCHON] <television>', '[FIND] <remote_control>', '[GRAB] <remote_control>']
}

Input:
Scene_Objects:['tablelamp', 'chair', 'dog', 'orchid', 'drawing', 'cpuscreen', 'hanger', 'floor', 'ceiling', 'desk', 'keyboard', 'bookshelf', 'computer', 'bookmark', 'mat', 'ceilinglamp', 'tvstand', 'laptop', 'mousepad', 'wall', 'nightstand', 'oven', 'photoframe', 'novel', 'television', 'lighter', 'towel_rack', 'mouse', 'dresser', 'door']
Task:Read book
response:

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


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

Here is an example plan to achieve a goal for reference:
Scene_Objects:['pot', 'food_salt', 'microwave', 'drawing', 'orchid', 'wallshelf', 'floor', 'table_cloth', 'toaster', 'ceilinglamp', 'plate', 'shower', 'faucet', 'dish_soap', 'closetdrawer', 'pillow', 'wall', 'novel', 'coffe_maker', 'food_rice', 'doorjamb', 'cards', 'mouse', 'kitchen_counter', 'dishrack', 'dresser', 'cupboard', 'clothes_scarf', 'bathroom_cabinet', 'dishwasher']
Task:Wash dishes with dishwasher
response:
{
    "thoughts": Walk to kitchen. Find dishwasher. Open dishwasher. Find dishrack. Find plate 1. Grab plate 1. Put plate 1 in dishrack. Repeat for dish 2. Find dish soap. Grab dish soap. Put dish soap to dishwasher. Close dishwasher. Switch on dishwasher.,
    "actions": ['[WALK] <dining_room>', '[WALK] <dishwasher>', '[FIND] <dishwasher>', '[OPEN] <dishwasher>', '[FIND] <dishrack>', '[FIND] <plate>', '[GRAB] <plate>', '[PUTBACK] <plate> <dishrack>', '[FIND] <plate>', '[GRAB] <plate>', '[PUTBACK] <plate> <dishrack>', '[FIND] <dish_soap>', '[GRAB] <dish_soap>', '[PUTBACK] <dish_soap> <dishwasher>', '[CLOSE] <dishwasher>', '[SWITCHON] <dishwasher>']
}

Input:
Scene_Objects:['pot', 'chair', 'walllamp', 'drawing', 'orchid', 'wallshelf', 'clothes_underwear', 'hanger', 'floor', 'ceiling', 'desk', 'remote_control', 'computer', 'button', 'piano_bench', 'mat', 'tvstand', 'ceilinglamp', 'iron', 'closetdrawer', 'couch', 'pillow', 'wall', 'photoframe', 'newspaper', 'food_food', 'television', 'doorjamb', 'dresser', 'conditioner']
Task:Change TV channel
response:

Walk into the Living room.  Find the television remote.  Use it to turn on the television.  Point the remote at the television. Press the channel button on the remote.

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


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

Here is an example plan to achieve a goal for reference:
Scene_Objects:['fork', 'chair', 'walllamp', 'milk', 'drawing', 'wallshelf', 'hanger', 'floor', 'ceiling', 'desk', 'remote_control', 'computer', 'mat', 'tvstand', 'ceilinglamp', 'faucet', 'closetdrawer', 'couch', 'candle', 'pillow', 'wall', 'cup', 'photoframe', 'television', 'curtain', 'doorjamb', 'mouse', 'dresser', 'bathroom_cabinet', 'teeth']
Task:Watch TV
response:
{
    "thoughts": SIT ON THE COUCH, TURN TV ON WITH REMOTE, FIND A SHOW,
    "actions": ['[WALK] <home_office>', '[WALK] <remote_control>', '[FIND] <remote_control>', '[GRAB] <remote_control>', '[FIND] <couch>', '[SIT] <couch>', '[FIND] <television>', '[SWITCHON] <television>', '[PUTBACK] <remote_control> <couch>', '[TURNTO] <television>', '[WATCH] <television>']
}

Input:
Scene_Objects:['sheets', 'water_glass', 'food_salt', 'freezer', 'walllamp', 'blow_dryer', 'detergent', 'drawing', 'wallshelf', 'floor', 'ceiling', 'phone', 'desk', 'stovefan', 'mat', 'iron', 'oil', 'closetdrawer', 'couch', 'pillow', 'wall', 'newspaper', 'keys', 'food_food', 'television', 'kitchen_counter', 'cupboard', 'door', 'bathroom_cabinet', 'tooth_paste']
Task:Drink
response:

walk to kitchen ,find fridge ,open fridge ,find water  glass , drink from water glass

[WALK] <dining_room>
[WALK] <freezer>
[FIND] <freezer>
[OPEN] <freezer>
[FIND] <water_glass>
[GRAB] <water_glass>
[DRINK] <water_glass>


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

Here is an example plan to achieve a goal for reference:
Scene_Objects:['microwave', 'walllamp', 'drawing', 'wallshelf', 'hanger', 'bathroom_counter', 'floor', 'ceiling', 'phone', 'character', 'mat', 'tvstand', 'ceilinglamp', 'window', 'closetdrawer', 'couch', 'pillow', 'wall', 'nightstand', 'novel', 'television', 'tray', 'curtain', 'dresser', 'bathtub', 'sink', 'bathroom_cabinet', 'coffee_cup', 'table', 'light']
Task:Relax on sofa
response:
{
    "thoughts": you walk to the living room, open the door, find a comfy sofa, sit on it, read a book or sip a cup of coffee and relax.,
    "actions": ['[WALK] <home_office>', '[WALK] <couch>', '[FIND] <couch>', '[FIND] <coffee_cup>', '[GRAB] <coffee_cup>', '[SIT] <couch>', '[FIND] <novel>', '[GRAB] <novel>', '[READ] <novel>', '[DRINK] <coffee_cup>']
}

Input:
Scene_Objects:['pot', 'chair', 'walllamp', 'drawing', 'orchid', 'wallshelf', 'hanger', 'floor', 'ceiling', 'desk', 'remote_control', 'computer', 'mat', 'tvstand', 'ceilinglamp', 'closetdrawer', 'couch', 'pillow', 'wall', 'photoframe', 'television', 'curtain', 'doorjamb', 'coffee_pot', 'mouse', 'dresser', 'conditioner', 'door', 'table', 'shoe_rack']
Task:Relax on sofa
response:

For relaxing walk to living room. Find the sofa to relax. Arrange the sofa to relax. Sit on the sofa to relaxing.

[WALK] <home_office>
[WALK] <couch>
[FIND] <couch>
[FIND] <conditioner>
[FIND] <remote_control>
[FIND] <television>
[SWITCHON] <television>
[LIE] <couch>


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

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

Input:
Scene_Objects:['filing_cabinet', 'toilet', 'bathroom', 'food_butter', 'drawing', 'knife', 'bathroom_counter', 'ceiling', 'phone', 'desk', 'bedroom', 'clothes_jacket', 'faucet', 'shower', 'mousepad', 'couch', 'clothes_pants', 'wall', 'powersocket', 'food_donut', 'tray', 'curtain', 'after_shave', 'pencil', 'vacuum_cleaner', 'clothes_dress', 'sink', 'napkin', 'bathroom_cabinet', 'washing_machine']
Task:Wash clothes
response:

Walk to bathroom, open cabinet and collect clothes and put them into washing machine and wash clothes


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:['trashcan', 'ceilingfan', 'drawing', 'bathroom_counter', 'floor', 'ceiling', 'character', 'folder', 'keyboard', 'remote_control', 'alcohol', 'button', 'stovefan', 'ceilinglamp', 'tvstand', 'balanceball', 'window', 'foundation', 'couch', 'pillow', 'wall', 'nightstand', 'cup', 'television', 'curtain', 'food_steak', 'napkin', 'table', 'clothes_shirt', 'creditcard']
Task:Change TV channel
response:
{
    "thoughts": Take TV remote to change TV Channel. Press channel/program +/- button on TV remote.,
    "actions": ['[WALK] <home_office>', '[WALK] <television>', '[FIND] <television>', '[SWITCHON] <television>', '[FIND] <remote_control>', '[GRAB] <remote_control>', '[FIND] <button>', '[TOUCH] <button>']
}

Input:
Scene_Objects:['sponge', 'pot', 'tablelamp', 'microwave', 'hanger', 'floor', 'ceiling', 'toaster', 'mat', 'faucet', 'shower', 'mousepad', 'couch', 'candle', 'wall', 'powersocket', 'box', 'coffe_maker', 'television', 'drinking_glass', 'wooden_spoon', 'curtain', 'tray', 'doorjamb', 'kitchen_counter', 'paper_towel', 'cupboard', 'sink', 'table', 'dishwasher']
Task:Wash dishes with dishwasher
response:

wipe loose dirt, place in the dishwasher, turn on the dishwasher

[WALK] <dining_room>
[WALK] <faucet>
[FIND] <faucet>
[SWITCHON] <faucet>
[FIND] <dishwasher>
[OPEN] <dishwasher>
[FIND] <drinking_glass>
[GRAB] <drinking_glass>
[FIND] <paper_towel>
[GRAB] <paper_towel>
[WIPE] <drinking_glass>
[RINSE] <drinking_glass>
[PUTBACK] <drinking_glass> <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:['glue', 'blender', 'microwave', 'toilet', 'bathroom', 'food_carrot', 'milk', 'wallshelf', 'cpuscreen', 'toaster', 'window', 'clothes_socks', 'pillow', 'wall', 'standingmirror', 'food_food', 'mouthwash', 'razor', 'ice', 'rag', 'lighter', 'cards', 'mouse', 'cd', 'hairbrush', 'pajamas', 'dresser', 'laundry_detergent', 'sink', 'light']
Task:Read book
response:
{
    "thoughts": walk to living room ,find a book ,open the book ,read the book,
    "actions": ['[WALK] <home_office>', '[WALK] <novel>', '[FIND] <novel>', '[GRAB] <novel>', '[READ] <novel>']
}

Input:
Scene_Objects:['microwave', 'toilet', 'milk', 'toothbrush', 'drawing', 'orchid', 'cpuscreen', 'character', 'bedroom', 'stovefan', 'toaster', 'mousepad', 'clothes_pants', 'food_kiwi', 'wall_clock', 'bed', 'television', 'toothbrush_holder', 'water', 'tray', 'curtain', 'pencil', 'kitchen_counter', 'shoes', 'hairbrush', 'cupboard', 'bathroom_cabinet', 'home_office', 'tooth_paste', 'dirt']
Task:Brush teeth
response:

today morning i went to bathroom and took my toothbrush and paste from tooth brush holder and brushed and cleaned my teeth well


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', 'filing_cabinet', 'microwave', 'chair', 'jelly', 'bathroom', 'detergent', 'knife', 'floor', 'toaster', 'mat', 'plate', 'shower', 'faucet', 'dish_soap', 'bowl', 'wall', 'cup', 'coffe_maker', 'food_food', 'after_shave', 'kitchen_counter', 'cupboard', 'hair', 'sink', 'spoon', 'home_office', 'table', 'dishwasher']
Task:Wash dishes with dishwasher
response:
{
    "thoughts": I walk to the kitchen and find the dishwasher. I open it. I find the sink and grab the dirty plates, cups, bowls, and utensils. I rinse off the dirty dishes under the faucet. I then place the dirty dishes into the dishwasher. I add soap to the dishwasher and close the lid. I turn it on and wait.,
    "actions": ['[WALK] <dining_room>', '[WALK] <dishwasher>', '[FIND] <dishwasher>', '[OPEN] <dishwasher>', '[FIND] <sink>', '[FIND] <bowl>', '[GRAB] <bowl>', '[RINSE] <bowl>', '[PUTBACK] <bowl> <dishwasher>', '[FIND] <cup>', '[GRAB] <cup>', '[RINSE] <cup>', '[PUTBACK] <cup> <dishwasher>', '[FIND] <fork>', '[GRAB] <fork>', '[RINSE] <fork>', '[PUTBACK] <fork> <dishwasher>', '[FIND] <knife>', '[GRAB] <knife>', '[RINSE] <knife>', '[PUTBACK] <knife> <dishwasher>', '[FIND] <plate>', '[GRAB] <plate>', '[RINSE] <plate>', '[PUTBACK] <plate> <dishwasher>', '[FIND] <spoon>', '[GRAB] <spoon>', '[RINSE] <spoon>', '[PUTBACK] <spoon> <dishwasher>', '[FIND] <dish_soap>', '[GRAB] <dish_soap>', '[PUTBACK] <dish_soap> <dishwasher>', '[CLOSE] <dishwasher>', '[TURNTO] <dishwasher>']
}

Input:
Scene_Objects:['fork', 'filing_cabinet', 'crayon', 'microwave', 'chair', 'orchid', 'drawing', 'wallshelf', 'floor', 'character', 'table_cloth', 'ceilinglamp', 'plate', 'stereo', 'mat', 'tvstand', 'wall', 'oven', 'cup', 'bed', 'food_food', 'razor', 'oven_mitts', 'tray', 'kitchen_counter', 'spoon', 'table', 'dishwasher', 'teeth', 'creditcard']
Task:Set up table
response:

Place your plate on the placemat. The forks will be placed on the left side of the plate and the knife and spoon on the right and place the spoon to the right of the knife. If you want to set out food, place them above the plate.

[WALK] <table>
[FIND] <plate>
[GRAB] <plate>
[DROP] <plate>
[FIND] <fork>
[GRAB] <fork>
[DROP] <fork>
[FIND] <spoon>
[GRAB] <spoon>
[DROP] <spoon>


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

Here is an example plan to achieve a goal for reference:
Scene_Objects:['pot', 'walllamp', 'trashcan', 'drawing', 'knifeblock', 'cpuscreen', 'floor', 'ceiling', 'toaster', 'laptop', 'plate', 'stovefan', 'shower', 'dish_soap', 'wall', 'bench', 'oven', 'powersocket', 'photoframe', 'food_food', 'coffe_maker', 'tray', 'kettle', 'pencil', 'kitchen_counter', 'cupboard', 'home_office', 'table', 'dishwasher', 'coffee']
Task:Wash dishes with dishwasher
response:
{
    "thoughts": Put the dishes on dinner table in the dishwasher and wash them,
    "actions": ['[WALK] <dining_room>', '[WALK] <table>', '[FIND] <plate>', '[GRAB] <plate>', '[WALK] <dishwasher>', '[OPEN] <dishwasher>', '[PUTBACK] <plate> <dishwasher>', '[WALK] <table>', '[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>']
}

Input:
Scene_Objects:['sheets', 'tablelamp', 'microwave', 'toilet', 'chair', 'drawing', 'orchid', 'cpuscreen', 'hanger', 'floor', 'ceiling', 'desk', 'keyboard', 'computer', 'mat', 'ceilinglamp', 'tvstand', 'mousepad', 'wall', 'nightstand', 'box', 'novel', 'toilet_paper', 'television', 'mouse', 'dresser', 'door', 'food_steak', 'clothes_skirt', 'tooth_paste']
Task:Read book
response:

"walk to entrance" "walk to living room" "look for book" "find book" "pick up book" "look for chair" "find chair" "sit in chair" "read book"

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


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

Here is an example plan to achieve a goal for reference:
Scene_Objects:['sheets', 'pot', 'mop', 'walllamp', 'orchid', 'wallshelf', 'floor', 'ceiling', 'phone', 'bedroom', 'bookshelf', 'remote_control', 'piano_bench', 'mat', 'tvstand', 'ceilinglamp', 'shower', 'window', 'wall', 'powersocket', 'box', 'love_seat', 'photoframe', 'television', 'curtain', 'doorjamb', 'dresser', 'clothes_dress', 'bathtub', 'light']
Task:Watch TV
response:
{
    "thoughts": I'll watch TV,
    "actions": ['[WALK] <home_office>', '[WALK] <remote_control>', '[FIND] <remote_control>', '[GRAB] <remote_control>', '[FIND] <television>', '[SWITCHON] <television>', '[PUTOBJBACK] <remote_control>', '[FIND] <love_seat>', '[SIT] <love_seat>', '[TURNTO] <television>', '[WATCH] <television>']
}

Input:
Scene_Objects:['measuring_cup', 'microwave', 'chair', 'walllamp', 'cat', 'wallshelf', 'floor', 'character', 'desk', 'tea_bag', 'toaster', 'plate', 'couch', 'dining_room', 'box', 'newspaper', 'bed', 'toilet_paper', 'curtain', 'coffee_pot', 'mouse', 'kettle', 'cupboard', 'controller', 'clothes_dress', 'sink', 'bathroom_cabinet', 'table', 'dishwasher', 'soap']
Task:Pet cat
response:

Find Cat in living room.  Walk to cat.  Pet cat.

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


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

Here is an example plan to achieve a goal for reference:
Scene_Objects:['fork', 'filing_cabinet', 'tablelamp', 'chair', 'walllamp', 'ground_coffee', 'drawing', 'orchid', 'needle', 'cpuscreen', 'floor', 'ceiling', 'bookshelf', 'remote_control', 'ceilinglamp', 'tvstand', 'mat', 'mousepad', 'wall', 'powersocket', 'bed', 'television', 'curtain', 'doorjamb', 'hair', 'clothes_dress', 'door', 'table', 'clothes_skirt', 'scrabble']
Task:Watch TV
response:
{
    "thoughts": Walk into the living room/den. Turn on the television. Switch channels to find a program with remote. I find a program and look at the screen.,
    "actions": ['[WALK] <home_office>', '[WALK] <television>', '[FIND] <television>', '[SWITCHON] <television>', '[FIND] <remote_control>', '[TURNTO] <remote_control>', '[TURNTO] <television>', '[LOOKAT] <television>']
}

Input:
Scene_Objects:['spectacles', 'mop', 'dog', 'freezer', 'drawing', 'bathroom_counter', 'floor', 'ceiling', 'keyboard', 'toaster', 'mat', 'closetdrawer', 'couch', 'food_jam', 'food_orange', 'pillow', 'dining_room', 'food_kiwi', 'wall', 'food_cheese', 'keys', 'food_food', 'video_game_controller', 'television', 'ice', 'curtain', 'kitchen_counter', 'cupboard', 'sink', 'dishwasher']
Task:Put groceries in Fridge
response:

Walk to kitchen. Open fridge. Put groceries in fridge.

[WALK] <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:['spectacles', 'chair', 'bathroom', 'food_carrot', 'knifeblock', 'floor', 'phone', 'bedroom', 'envelope', 'mail', 'clothes_jacket', 'table_cloth', 'ceilinglamp', 'tvstand', 'shower', 'window', 'candle', 'microphone', 'pillow', 'basket_for_clothes', 'toilet_paper', 'check', 'rag', 'chessboard', 'laundry_detergent', 'bathroom_cabinet', 'home_office', 'tooth_paste', 'washing_machine', 'coffee']
Task:Wash clothes
response:
{
    "thoughts": Pick up my dirty clothes, load the washer, add detergent, turn on washer,
    "actions": ['[WALK] <bedroom>', '[WALK] <basket_for_clothes>', '[GRAB] <basket_for_clothes>', '[WALK] <home_office>', '[WALK] <washing_machine>', '[OPEN] <washing_machine>', '[PUTBACK] <basket_for_clothes> <washing_machine>', '[FIND] <laundry_detergent>', '[GRAB] <laundry_detergent>', '[PUTBACK] <laundry_detergent> <washing_machine>', '[RUN] <washing_machine>']
}

Input:
Scene_Objects:['pot', 'blender', 'toilet', 'bathroom', 'detergent', 'food_butter', 'cpuscreen', 'floor', 'ceiling', 'toaster', 'mousepad', 'couch', 'food_kiwi', 'wall', 'oven', 'toy', 'coffe_maker', 'television', 'oven_mitts', 'coffee_filter', 'ice', 'coffee_pot', 'shaving_cream', 'kitchen_counter', 'cd', 'cupboard', 'sink', 'home_office', 'dishwasher', 'coffee']
Task:Make coffee
response:

Enter kitchen, find coffee maker, find coffee filter, pick up coffee filter, put it in coffee maker, find coffee, pour coffee into filter, turn on.

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


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_salt', 'chair', 'bathroom', 'drawing', 'food_egg', 'floor', 'desk', 'bookshelf', 'computer', 'mat', 'stereo', 'shower', 'couch', 'food_peanut_butter', 'wall', 'powersocket', 'oven', 'cup', 'doorjamb', 'mouse', 'kitchen_counter', 'pajamas', 'controller', 'door', 'clothes_scarf', 'light', 'dishwasher', 'board_game']
Task:Pull up carpet
response:
{
    "thoughts": Pry up a corner of your old dirty carpet.  Tug as hard as you can until it comes off the tacs. Pull up the pad. Try not to be sick at all the dirt.,
    "actions": ['[WALK] <home_office>', '[WALK] <mat>', '[FIND] <mat>', '[TOUCH] <mat>', '[PULL] <mat>']
}

Input:
Scene_Objects:['pot', 'food_salt', 'chair', 'freezer', 'walllamp', 'detergent', 'orchid', 'phone', 'bookshelf', 'computer', 'toaster', 'tvstand', 'stereo', 'closetdrawer', 'food_peanut_butter', 'clothes_pants', 'form', 'wall', 'oven', 'cup', 'bed', 'mouthwash', 'rag', 'towel_rack', 'kitchen_counter', 'pajamas', 'food_steak', 'door', 'napkin', 'bathroom_cabinet']
Task:Listen to music
response:

Find the playback device you want to listen to. turn on. press play. enjoyu music.

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


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

Here is an example plan to achieve a goal for reference:
Scene_Objects:['water_glass', 'food_salt', 'microwave', 'freezer', 'orchid', 'cpuscreen', 'ceiling', 'character', 'bedroom', 'desk', 'food_bacon', 'bookmark', 'toaster', 'stovefan', 'faucet', 'shower', 'mousepad', 'wall', 'wall_clock', 'oven', 'bench', 'coffe_maker', 'television', 'water', 'tray', 'doorjamb', 'kitchen_counter', 'cupboard', 'sink', 'light']
Task:Drink
response:
{
    "thoughts": I go to the kitchen, take a glass from the cupboard, fill with water and drink,
    "actions": ['[WALK] <dining_room>', '[WALK] <cupboard>', '[FIND] <cupboard>', '[OPEN] <cupboard>', '[FIND] <water_glass>', '[GRAB] <water_glass>', '[WALK] <water>', '[FIND] <water>', '[GRAB] <water>', '[POUR] <water> <water_glass>', '[DRINK] <water_glass>', '[RINSE] <water_glass>', '[PUTBACK] <water_glass> <cupboard>']
}

Input:
Scene_Objects:['tablelamp', 'chair', 'walllamp', 'drawing', 'wallshelf', 'cpuscreen', 'hanger', 'floor', 'ceiling', 'desk', 'keyboard', 'remote_control', 'computer', 'button', 'mat', 'tvstand', 'ceilinglamp', 'stereo', 'closetdrawer', 'couch', 'pillow', 'wall', 'photoframe', 'toilet_paper', 'television', 'doorjamb', 'dresser', 'cupboard', 'light', 'clothes_shirt']
Task:Change TV channel
response:

Go to the living room, Switch on the television. Find the remote and press the change channel button, change the channel

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


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

Here is an example plan to achieve a goal for reference:
Scene_Objects:['pot', 'tablelamp', 'cpuscreen', 'clothes_underwear', 'hanger', 'shampoo', 'bookshelf', 'alcohol', 'table_cloth', 'faucet', 'shower', 'clothes_socks', 'clothes_pants', 'wall', 'wall_clock', 'oven', 'nightstand', 'basket_for_clothes', 'newspaper', 'clothes_gloves', 'tray', 'doorjamb', 'lighter', 'cards', 'clothes_dress', 'laundry_detergent', 'napkin', 'clothes_skirt', 'clothes_shirt', 'washing_machine']
Task:Wash clothes
response:
{
    "thoughts": I go to the bathroom, take the dirt clothes and put into the washing machine, then put the soap, set the cleaning program and switch on the machine,
    "actions": ['[WALK] <bathroom>', '[WALK] <washing_machine>', '[FIND] <washing_machine>', '[OPEN] <washing_machine>', '[FIND] <basket_for_clothes>', '[OPEN] <basket_for_clothes>', '[FIND] <clothes_dress>', '[GRAB] <clothes_dress>', '[PUTBACK] <clothes_dress> <washing_machine>', '[FIND] <clothes_pants>', '[GRAB] <clothes_pants>', '[PUTBACK] <clothes_pants> <washing_machine>', '[FIND] <clothes_shirt>', '[GRAB] <clothes_shirt>', '[PUTBACK] <clothes_shirt> <washing_machine>', '[FIND] <clothes_skirt>', '[GRAB] <clothes_skirt>', '[PUTBACK] <clothes_skirt> <washing_machine>', '[FIND] <clothes_underwear>', '[GRAB] <clothes_underwear>', '[PUTBACK] <clothes_underwear> <washing_machine>', '[FIND] <clothes_socks>', '[GRAB] <clothes_socks>', '[PUTBACK] <clothes_socks> <washing_machine>', '[CLOSE] <basket_for_clothes>', '[WALK] <laundry_detergent>', '[FIND] <laundry_detergent>', '[GRAB] <laundry_detergent>', '[POUR] <laundry_detergent> <washing_machine>', '[CLOSE] <washing_machine>', '[SWITCHON] <washing_machine>']
}

Input:
Scene_Objects:['pot', 'tablelamp', 'food_salt', 'mop', 'toilet', 'freezer', 'bathroom', 'dough', 'drawing', 'clothes_underwear', 'floor', 'ceiling', 'desk', 'mat', 'ceilinglamp', 'couch', 'food_orange', 'pillow', 'wall', 'oven', 'tape', 'food_cheese', 'food_food', 'coffe_maker', 'television', 'tray', 'kitchen_counter', 'dishrack', 'cupboard', 'light']
Task:Put groceries in Fridge
response:

[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:['water_glass', 'filing_cabinet', 'juice', 'milk', 'hanger', 'kitchen_cabinet', 'bathroom_counter', 'button', 'food_bacon', 'stovefan', 'mat', 'shoe-shine_kit', 'tvstand', 'electric_shaver', 'food_peanut_butter', 'form', 'dining_room', 'cutting_board', 'cup', 'photoframe', 'coffe_maker', 'television', 'water', 'wooden_spoon', 'kettle', 'kitchen_counter', 'chessboard', 'dresser', 'sink', 'spoon']
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:['pot', 'tablelamp', 'microwave', 'drawing', 'cpuscreen', 'kitchen_cabinet', 'floor', 'desk', 'keyboard', 'computer', 'stovefan', 'ceilinglamp', 'shower', 'wall', 'pasta', 'oven', 'powersocket', 'box', 'water', 'tray', 'doorjamb', 'towel_rack', 'kitchen_counter', 'sauce_pan', 'cupboard', 'door', 'light', 'dishwasher', 'tooth_paste', 'teeth']
Task:Cook some food
response:

[WALK] <dining_room>
[WALK] <kitchen_cabinet>
[FIND] <kitchen_cabinet>
[OPEN] <kitchen_cabinet>
[FIND] <pasta>
[GRAB] <pasta>
[FIND] <water>
[GRAB] <water>
[FIND] <sauce_pan>
[POUR] <water> <sauce_pan>
[FIND] <oven>
[SWITCHON] <oven>
[PUTBACK] <pasta> <sauce_pan>
[FIND] <sauce_pan>
[GRAB] <sauce_pan>
[PUTBACK] <sauce_pan> <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:['sheets', 'juice', 'microwave', 'freezer', 'detergent', 'drawing', 'cpuscreen', 'bathroom_counter', 'floor', 'tea_bag', 'keyboard', 'computer', 'button', 'stovefan', 'mat', 'ceilinglamp', 'homework', 'closetdrawer', 'couch', 'wall', 'oven', 'cutting_board', 'toilet_paper', 'television', 'curtain', 'diary', 'pencil', 'shoes', 'dresser', 'table']
Task:Put out flowers
response:
{
    "thoughts": Place a flower centrepiece on the entrance hall table.,
    "actions": ['[WALK] <home_office>', '[WALK] <centerpiece>', '[FIND] <centerpiece>', '[GRAB] <centerpiece>', '[WALK] <table>', '[PUTBACK] <centerpiece> <table>']
}

Input:
Scene_Objects:['chair', 'walllamp', 'drawing', 'wallshelf', 'hanger', 'bathroom_counter', 'floor', 'ceiling', 'desk', 'remote_control', 'computer', 'mat', 'tvstand', 'ceilinglamp', 'closetdrawer', 'couch', 'pillow', 'towel', 'dining_room', 'wall', 'nightstand', 'cup', 'photoframe', 'television', 'food_rice', 'doorjamb', 'mouse', 'dresser', 'clothes_scarf', 'light']
Task:Watch TV
response:

Walk to the living room. Sit on the sofa. Grab the remote and turn on the television.

[WALK] <home_office>
[WALK] <couch>
[SIT] <couch>
[FIND] <remote_control>
[GRAB] <remote_control>
[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:['tablelamp', 'measuring_cup', 'walllamp', 'orchid', 'floor', 'ceiling', 'phone', 'keyboard', 'remote_control', 'bookshelf', 'computer', 'tvstand', 'window', 'closetdrawer', 'couch', 'pillow', 'dining_room', 'broom', 'nightstand', 'wall', 'television', 'curtain', 'doorjamb', 'pencil', 'dresser', 'pajamas', 'laundry_detergent', 'clothes_dress', 'bag', 'table']
Task:Watch TV
response:
{
    "thoughts": walk into the living room walk to the remote pick it up and turn in the tv and watch,
    "actions": ['[WALK] <home_office>', '[WALK] <remote_control>', '[GRAB] <remote_control>', '[FIND] <television>', '[TURNTO] <television>', '[POINTAT] <television>', '[SWITCHON] <television>', '[WATCH] <television>']
}

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

I need to finish some work on my computer in my home office to meet a deadline for tomorrow.

[WALK] <home_office>
[WALK] <light>
[FIND] <light>
[SWITCHON] <light>
[FIND] <keyboard>
[GRAB] <keyboard>
[FIND] <desk>
[OPEN] <desk>
[PUTBACK] <keyboard> <desk>
[FIND] <mouse>
[GRAB] <mouse>
[FIND] <mousepad>
[PUTBACK] <mouse> <mousepad>
[PLUGIN] <keyboard>
[PLUGIN] <mouse>
[FIND] <computer>
[SWITCHON] <computer>
[FIND] <chair>
[SIT] <chair>
[TURNTO] <computer>
[TYPE] <keyboard>
[GRAB] <mouse>
[TOUCH] <mouse>
[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:['tablelamp', 'toilet', 'walllamp', 'trashcan', 'drawing', 'knife', 'wallshelf', 'bathroom_counter', 'floor', 'ceiling', 'bookshelf', 'computer', 'toaster', 'ceilinglamp', 'stereo', 'faucet', 'mousepad', 'wall_clock', 'powersocket', 'oven', 'photoframe', 'check', 'curtain', 'doorjamb', 'mouse', 'kitchen_counter', 'controller', 'bathtub', 'home_office', 'light']
Task:Pet cat
response:
{
    "thoughts": Walk to living room. Find cat. Walk to cat. Pull cat.,
    "actions": ['[WALK] <home_office>', '[WALK] <cat>', '[FIND] <cat>', '[WALK] <cat>', '[PULL] <cat>']
}

Input:
Scene_Objects:['microwave', 'freezer', 'ground_coffee', 'cat', 'drawing', 'wallshelf', 'bathroom_counter', 'floor', 'ceiling', 'food_bacon', 'mat', 'iron', 'couch', 'food_peanut_butter', 'food_orange', 'pillow', 'dining_room', 'food_kiwi', 'wall', 'clothes_gloves', 'food_food', 'television', 'doorjamb', 'kitchen_counter', 'comb', 'cupboard', 'hair', 'clothes_dress', 'light', 'table']
Task:Put groceries in Fridge
response:

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


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

Here is an example plan to achieve a goal for reference:
Scene_Objects:['filing_cabinet', 'tablelamp', 'freezer', 'orchid', 'floor', 'bedroom', 'keyboard', 'stovefan', 'stereo', 'shower', 'closetdrawer', 'couch', 'dining_room', 'tape', 'cup', 'bed', 'novel', 'television', 'toothbrush_holder', 'doorjamb', 'mouse', 'kitchen_counter', 'chessboard', 'cupboard', 'door', 'spoon', 'instrument_guitar', 'table', 'clothes_shirt', 'shoe_rack']
Task:Look out window
response:
{
    "thoughts": I head into my child's room and look out the window to view the neighborhood from a different area in the house.,
    "actions": ['[WALK] <bedroom>', '[WALK] <window>', '[TURNTO] <window>', '[LOOKAT] <window>']
}

Input:
Scene_Objects:['tablelamp', 'chair', 'bathroom', 'drawing', 'orchid', 'cpuscreen', 'floor', 'ceiling', 'desk', 'keyboard', 'computer', 'food_bacon', 'bookmark', 'mat', 'ceilinglamp', 'tvstand', 'mousepad', 'closetdrawer', 'couch', 'pillow', 'wall', 'nightstand', 'powersocket', 'television', 'doorjamb', 'mouse', 'pencil', 'dresser', 'door', 'dishwasher']
Task:Read book
response:

[RUN] <home_office>
[WALK] <novel>
[FIND] <novel>
[GRAB] <novel>
[WALK] <chair>
[SIT] <chair>
[FIND] <bookmark>
[GRAB] <bookmark>
[FIND] <floor>
[PUTBACK] <bookmark> <floor>
[TURNTO] <novel>
[LOOKAT] <novel>
[READ] <novel>
[TURNTO] <novel>
[LOOKAT] <novel>
[READ] <novel>


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

Here is an example plan to achieve a goal for reference:
Scene_Objects:['sponge', 'fork', 'filing_cabinet', 'tablelamp', 'chair', 'band-aids', 'floor', 'ceiling', 'stamp', 'alcohol', 'toaster', 'mat', 'plate', 'faucet', 'dish_soap', 'towel', 'wall', 'toy', 'bed', 'keys', 'photoframe', 'coffe_maker', 'television', 'coin', 'kitchen_counter', 'dresser', 'cupboard', 'food_steak', 'sink', 'table']
Task:Wash dishes
response:
{
    "thoughts": Run warm water in the sink. Pour dish washing liquid on the dishes. Pick up dishes and wash them individually with a sponge. Rinse suds off under running water. Dry dishes with towel.,
    "actions": ['[WALK] <dining_room>', '[WALK] <sink>', '[FIND] <faucet>', '[SWITCHON] <faucet>', '[FIND] <dish_soap>', '[GRAB] <dish_soap>', '[FIND] <sponge>', '[GRAB] <sponge>', '[POUR] <dish_soap> <sponge>', '[PUTOBJBACK] <dish_soap>', '[FIND] <plate>', '[GRAB] <plate>', '[SCRUB] <plate>', '[WASH] <plate>', '[RINSE] <plate>', '[RINSE] <sponge>', '[SWITCHOFF] <faucet>', '[PUTOBJBACK] <sponge>', '[FIND] <towel>', '[GRAB] <towel>', '[WIPE] <plate>', '[PUTOBJBACK] <towel>', '[WALK] <kitchen_cabinet>', '[OPEN] <kitchen_cabinet>', '[PUTIN] <plate> <kitchen_cabinet>', '[CLOSE] <kitchen_cabinet>']
}

Input:
Scene_Objects:['fork', 'pot', 'filing_cabinet', 'microwave', 'walllamp', 'drawing', 'food_egg', 'wallshelf', 'floor', 'stamp', 'computer', 'alcohol', 'toaster', 'plate', 'shower', 'wall', 'nightstand', 'photoframe', 'coffe_maker', 'water', 'doorjamb', 'towel_rack', 'kitchen_counter', 'cupboard', 'spoon', 'instrument_guitar', 'light', 'dishwasher', 'soap', 'scrabble']
Task:Wash dishes with dishwasher
response:

first i will take all the dishes to the dish washer and with the help of dishwasher and water i will clean all the dishes

[WALK] <dining_room>
[WALK] <dishwasher>
[FIND] <dishwasher>
[OPEN] <dishwasher>
[FIND] <fork>
[GRAB] <fork>
[PUTBACK] <fork> <dishwasher>
[FIND] <plate>
[GRAB] <plate>
[PUTBACK] <plate> <dishwasher>
[FIND] <spoon>
[GRAB] <spoon>
[PUTBACK] <spoon> <dishwasher>
[FIND] <water>
[TURNTO] <water>
[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:['water_glass', 'food_pizza', 'chair', 'drawing', 'food_egg', 'hanger', 'floor', 'phone', 'ceiling', 'mail', 'table_cloth', 'stovefan', 'ceilinglamp', 'stereo', 'homework', 'couch', 'microphone', 'form', 'food_orange', 'bowl', 'oven', 'box', 'newspaper', 'tray', 'kitchen_counter', 'cupboard', 'controller', 'bathroom_cabinet', 'table', 'shoe_rack']
Task:Drink
response:
{
    "thoughts": walk to kitchen, walk to table, grab water glass and drink water,
    "actions": ['[WALK] <dining_room>', '[WALK] <table>', '[FIND] <water_glass>', '[GRAB] <water_glass>', '[DRINK] <water_glass>', '[PUTBACK] <water_glass> <table>']
}

Input:
Scene_Objects:['toilet', 'chair', 'freezer', 'floor', 'ceiling', 'dvd_player', 'desk', 'keyboard', 'toaster', 'mat', 'faucet', 'stereo', 'food_jam', 'food_orange', 'pillow', 'towel', 'wall', 'food_cheese', 'coffe_maker', 'check', 'coffee_filter', 'water', 'drinking_glass', 'curtain', 'kitchen_counter', 'shoes', 'cupboard', 'sink', 'bathroom_cabinet', 'home_office']
Task:Drink
response:

Walk to kitchen. Walk to faucet. Switch on faucet. Pour water into drinking glass. Switch off faucet. Drink water.

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


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

Here is an example plan to achieve a goal for reference:
Scene_Objects:['sheets', 'fork', 'pot', 'tablelamp', 'measuring_cup', 'freezer', 'detergent', 'cat', 'bathroom_counter', 'keyboard', 'purse', 'bookshelf', 'toaster', 'brush', 'faucet', 'stereo', 'homework', 'toy', 'box', 'basket_for_clothes', 'coin', 'curtain', 'rag', 'centerpiece', 'dishrack', 'clothes_dress', 'bag', 'table', 'clothes_shirt', 'washing_machine']
Task:Wash clothes
response:
{
    "thoughts": Walk to the kitchen. Find the washing machine. Open the washing machine. Find the basket for clothes. Find the clothes_dress. Grab the clothes_dress. Put the clothes_dress into the washing machine. Find the clothes_shirt. Grab the clothes_shirt. Put the clothes_shirt into the washing machine. Close the washing machine. Switch on the washing machine.,
    "actions": ['[WALK] <dining_room>', '[WALK] <washing_machine>', '[FIND] <washing_machine>', '[OPEN] <washing_machine>', '[FIND] <basket_for_clothes>', '[FIND] <clothes_dress>', '[GRAB] <clothes_dress>', '[PUTBACK] <clothes_dress> <washing_machine>', '[FIND] <clothes_shirt>', '[GRAB] <clothes_shirt>', '[PUTBACK] <clothes_shirt> <basket_for_clothes>', '[CLOSE] <washing_machine>', '[SWITCHON] <washing_machine>']
}

Input:
Scene_Objects:['pot', 'water_glass', 'food_ice_cream', 'microwave', 'freezer', 'drawing', 'floor', 'ceiling', 'toaster', 'stovefan', 'mat', 'shower', 'closetdrawer', 'couch', 'food_orange', 'pillow', 'wall', 'oven', 'powersocket', 'cutting_board', 'coffe_maker', 'television', 'water', 'tray', 'towel_rack', 'kitchen_counter', 'cupboard', 'hair', 'door', 'dishwasher']
Task:Drink
response:

I enter the kitchen and grab a waterglass from the cupboard. I open the fridge and grap some water. I pour the water into the cup and drink it.

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


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

Here is an example plan to achieve a goal for reference:
Scene_Objects:['dry_pasta', 'toilet', 'chair', 'freezer', 'walllamp', 'drawing', 'orchid', 'knifeblock', 'wallshelf', 'cpuscreen', 'floor', 'ceiling', 'desk', 'tea_bag', 'computer', 'deck_of_cards', 'mousepad', 'couch', 'pillow', 'wall', 'child', 'bed', 'coin', 'coffee_filter', 'doorjamb', 'centerpiece', 'door', 'table', 'light', 'dishwasher']
Task:Let baby learn how to walk
response:
{
    "thoughts": The baby tries to stand up and balances on the couch and there are no sharp edges so it's safe.,
    "actions": ['[WALK] <home_office>', '[WALK] <child>', '[FIND] <child>', '[TOUCH] <child>', '[GREET] <child>', '[FIND] <couch>', '[TURNTO] <couch>', '[POINTAT] <couch>', '[TURNTO] <child>', '[LOOKAT] <child>']
}

Input:
Scene_Objects:['food_salt', 'chair', 'blow_dryer', 'nail_polish', 'ground_coffee', 'milk', 'knife', 'wallshelf', 'hanger', 'character', 'desk', 'keyboard', 'stovefan', 'mat', 'plate', 'food_jam', 'nightstand', 'wall', 'toy', 'bed', 'coffe_maker', 'wine', 'rag', 'centerpiece', 'pencil', 'dresser', 'door', 'bathroom_cabinet', 'table', 'dishwasher']
Task:Read book
response:

Pick up the book, open to current page, read the words.

[WALK] <home_office>
[WALK] <novel>
[FIND] <novel>
[GRAB] <novel>
[READ] <novel>


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

Here is an example plan to achieve a goal for reference:
Scene_Objects:['sponge', 'pot', 'sheets', 'food_ice_cream', 'food_salt', 'measuring_cup', 'microwave', 'toilet', 'detergent', 'ceilingfan', 'drawing', 'hanger', 'floor', 'keyboard', 'clothes_jacket', 'ceilinglamp', 'plate', 'window', 'floor_lamp', 'mousepad', 'couch', 'pillow', 'wall', 'clothes_gloves', 'novel', 'check', 'television', 'food_rice', 'doorjamb', 'table']
Task:Read book
response:
{
    "thoughts": A person brings a book into the living room and sits down in a comfortable chair.  If it is dark in the room the person turns on the lamp. The book is opened to the next page to be read.  The person begins reading the book until they need to stop for some reason.,
    "actions": ['[WALK] <home_office>', '[WALK] <novel>', '[FIND] <novel>', '[GRAB] <novel>', '[FIND] <couch>', '[SIT] <couch>', '[FIND] <floor_lamp>', '[SWITCHON] <floor_lamp>', '[READ] <novel>']
}

Input:
Scene_Objects:['tablelamp', 'beer', 'tea', 'ground_coffee', 'drawing', 'wallshelf', 'bathroom_counter', 'floor', 'ceiling', 'desk', 'bookshelf', 'button', 'mat', 'deck_of_cards', 'plate', 'tvstand', 'closetdrawer', 'couch', 'food_jam', 'dining_room', 'wall', 'powersocket', 'basket_for_clothes', 'doorjamb', 'cards', 'mouse', 'kitchen_counter', 'chessboard', 'door', 'light']
Task:Turn on light
response:

walk into living room, walk to light, turn on light switch.

[WALK] <home_office>
[WALK] <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', 'microwave', 'toilet', 'chair', 'detergent', 'food_butter', 'toothbrush', 'drawing', 'floor', 'ceiling', 'toaster', 'mat', 'plate', 'faucet', 'shower', 'dish_soap', 'wall', 'nightstand', 'cup', 'coffe_maker', 'coffee_filter', 'drinking_glass', 'tray', 'wooden_spoon', 'kitchen_counter', 'cupboard', 'sink', 'coffee_cup', 'dishwasher', 'shoe_rack']
Task:Clean dishes
response:
{
    "thoughts": Wash dishes in the sink then place them in the dishwasher. Put detergent in the dishwasher and turn it on when full.,
    "actions": ['[WALK] <dining_room>', '[WALK] <sink>', '[FIND] <faucet>', '[SWITCHON] <faucet>', '[FIND] <dish_soap>', '[GRAB] <dish_soap>', '[FIND] <drinking_glass>', '[WASH] <drinking_glass>', '[FIND] <coffee_cup>', '[WASH] <coffee_cup>', '[FIND] <plate>', '[WASH] <plate>', '[GRAB] <coffee_cup>', '[PUTBACK] <coffee_cup> <plate>', '[FIND] <dishwasher>', '[OPEN] <dishwasher>', '[GRAB] <drinking_glass>', '[PUTBACK] <drinking_glass> <dishwasher>', '[GRAB] <plate>', '[PUTBACK] <plate> <dishwasher>', '[FIND] <detergent>', '[GRAB] <detergent>', '[PUTBACK] <detergent> <dishwasher>', '[CLOSE] <dishwasher>', '[SWITCHON] <dishwasher>']
}

Input:
Scene_Objects:['microwave', 'walllamp', 'nail_polish', 'cat', 'drawing', 'knife', 'wallshelf', 'floor', 'ceiling', 'character', 'computer', 'mat', 'tvstand', 'ceilinglamp', 'mousepad', 'couch', 'pillow', 'dining_room', 'wall', 'photoframe', 'toilet_paper', 'check', 'television', 'doorjamb', 'towel_rack', 'mouse', 'vacuum_cleaner', 'dresser', 'cupboard', 'home_office']
Task:Pet cat
response:

I walk into the living room. I see my cat on the couch. I go sit next to the cat on the couch. I pet the cat on the back.

[WALK] <home_office>
[WALK] <cat>
[FIND] <cat>
[TURNTO] <cat>
[LOOKAT] <cat>
[FIND] <couch>
[SIT] <couch>
[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:['pot', 'mop', 'microwave', 'walllamp', 'detergent', 'food_carrot', 'knifeblock', 'wallshelf', 'hanger', 'floor', 'ceiling', 'keyboard', 'stovefan', 'toaster', 'stereo', 'window', 'oil', 'clothes_socks', 'wall', 'oven', 'food_vegetable', 'bed', 'photoframe', 'television', 'food_donut', 'water', 'tray', 'kitchen_counter', 'cupboard', 'dishwasher']
Task:Cook some food
response:
{
    "thoughts": walk to kicthen , find stove , find cooking pot , find vegetables , find water  ,put vegetables in cooking pot, pour water to cooking pot,put cooking pot on stove, switch on stove,
    "actions": ['[WALK] <dining_room>', '[WALK] <oven>', '[FIND] <oven>', '[FIND] <pot>', '[FIND] <food_vegetable>', '[FIND] <water>', '[GRAB] <water>', '[WASH] <food_vegetable>', '[POUR] <water> <pot>', '[FIND] <pot>', '[GRAB] <pot>', '[PUTBACK] <pot> <oven>', '[SWITCHON] <oven>']
}

Input:
Scene_Objects:['pot', 'microwave', 'jelly', 'walllamp', 'drawing', 'floor', 'ceiling', 'computer', 'stovefan', 'mat', 'shower', 'microphone', 'wall', 'oven', 'cup', 'photoframe', 'coffe_maker', 'television', 'tray', 'curtain', 'wooden_spoon', 'doorjamb', 'towel_rack', 'kitchen_counter', 'dresser', 'cupboard', 'table', 'dishwasher', 'board_game', 'dirt']
Task:Take shower
response:

Walk to the bathroom and wash with the shower.

[WALK] <bathroom>
[WALK] <shower>
[FIND] <shower>
[WASH] <shower>


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

Here is an example plan to achieve a goal for reference:
Scene_Objects:['dry_pasta', 'sheets', 'pot', 'freezer', 'cpuscreen', 'floor', 'ceiling', 'desk', 'keyboard', 'computer', 'mail', 'tvstand', 'stereo', 'window', 'mousepad', 'clothes_socks', 'wall', 'nightstand', 'powersocket', 'pasta', 'oven', 'light_bulb', 'coffe_maker', 'food_rice', 'doorjamb', 'shaving_cream', 'mouse', 'kitchen_counter', 'door', 'light']
Task:Turn light off
response:
{
    "thoughts": Put the light switch into the down, or off, position.,
    "actions": ['[WALK] <dining_room>', '[WALK] <light>', '[FIND] <light>', '[SWITCHOFF] <light>']
}

Input:
Scene_Objects:['tablelamp', 'chair', 'freezer', 'walllamp', 'bathroom', 'orchid', 'cpuscreen', 'wallshelf', 'hanger', 'bathroom_counter', 'floor', 'ceiling', 'phone', 'dvd_player', 'desk', 'keyboard', 'computer', 'ceilinglamp', 'tvstand', 'mat', 'mousepad', 'couch', 'pillow', 'wall', 'nightstand', 'television', 'doorjamb', 'mouse', 'dresser', 'door']
Task:Write an email
response:

Find the computer.  Turn on the computer.  Open the e-mail program.  Create a new message.  Write the message.

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


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

Here is an example plan to achieve a goal for reference:
Scene_Objects:['spectacles', 'crayon', 'microwave', 'toilet', 'knife', 'bathroom_counter', 'floor', 'ceiling', 'phone', 'shampoo', 'computer', 'mat', 'tvstand', 'picture', 'oil', 'couch', 'pillow', 'wall', 'powersocket', 'cup', 'food_food', 'tray', 'doorjamb', 'mouse', 'kitchen_counter', 'shoes', 'cupboard', 'bathroom_cabinet', 'light', 'instrument_violin']
Task:Pick up phone
response:
{
    "thoughts": I walk over to the phone. .I reach my arm out. I open my hand. I place my hand on the phone. I close my fingers around the phone. I pick up the phone.,
    "actions": ['[WALK] <phone>', '[TOUCH] <phone>', '[GRAB] <phone>']
}

Input:
Scene_Objects:['pot', 'food_pizza', 'tablelamp', 'mop', 'chair', 'detergent', 'cat', 'phone', 'stamp', 'keyboard', 'stovefan', 'ceilinglamp', 'shoe-shine_kit', 'tvstand', 'deck_of_cards', 'toaster', 'mousepad', 'closetdrawer', 'dining_room', 'food_kiwi', 'wall', 'check', 'coffe_maker', 'curtain', 'rag', 'mouse', 'comb', 'bathroom_cabinet', 'dishwasher', 'soap']
Task:Pet cat
response:

I go looking for the cat in the living room where he usually sleeps. Once I find the cat I just pet him for a few minutes.

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


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

Here is an example plan to achieve a goal for reference:
Scene_Objects:['sheets', 'spectacles', 'filing_cabinet', 'food_salt', 'walllamp', 'drawing', 'bathroom_counter', 'floor', 'character', 'shower', 'stereo', 'microphone', 'wall', 'toy', 'cutting_board', 'cup', 'novel', 'food_food', 'check', 'food_onion', 'coffee_pot', 'console', 'shaving_cream', 'towel_rack', 'shoes', 'cd', 'hairbrush', 'maindoor', 'soap', 'coffee']
Task:Read
response:
{
    "thoughts": Read a book in the living room,
    "actions": ['[WALK] <home_office>', '[WALK] <filing_cabinet>', '[OPEN] <filing_cabinet>', '[FIND] <novel>', '[GRAB] <novel>', '[CLOSE] <filing_cabinet>', '[READ] <novel>']
}

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

I need to write an e-mail to my boss about the meeting at work tomorrow.

[WALK] <home_office>
[WALK] <desk>
[FIND] <keyboard>
[GRAB] <keyboard>
[OPEN] <desk>
[PUTBACK] <keyboard> <desk>
[FIND] <mouse>
[GRAB] <mouse>
[FIND] <mousepad>
[PUTBACK] <mouse> <mousepad>
[PLUGIN] <keyboard>
[PLUGIN] <mouse>
[FIND] <computer>
[SWITCHON] <computer>
[FIND] <chair>
[SIT] <chair>
[TURNTO] <computer>
[LOOKAT] <computer>
[TYPE] <keyboard>
[GRAB] <mouse>
[TOUCH] <mouse>
[TURNTO] <computer>
[LOOKAT] <computer>


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

Here is an example plan to achieve a goal for reference:
Scene_Objects:['pot', 'food_bread', 'toilet', 'chair', 'freezer', 'floor', 'ceiling', 'thread', 'table_cloth', 'ceilinglamp', 'faucet', 'food_peanut_butter', 'dining_room', 'wall', 'nightstand', 'powersocket', 'tape', 'photoframe', 'bed', 'food_food', 'cards', 'kitchen_counter', 'dishrack', 'dresser', 'hair', 'pajamas', 'door', 'home_office', 'dishwasher', 'vase']
Task:Put groceries in Fridge
response:
{
    "thoughts": go to the kitchen and put the groceries in the fridge,
    "actions": ['[WALK] <dining_room>', '[WALK] <freezer>', '[FIND] <freezer>', '[OPEN] <freezer>', '[FIND] <food_food>', '[GRAB] <food_food>', '[PUTIN] <food_food> <freezer>']
}

Input:
Scene_Objects:['pot', 'filing_cabinet', 'food_pizza', 'beer', 'tea', 'microwave', 'toilet', 'chair', 'freezer', 'toothbrush', 'cpuscreen', 'piano_bench', 'faucet', 'mousepad', 'couch', 'nightstand', 'powersocket', 'food_food', 'coffe_maker', 'curtain', 'shaving_cream', 'shoes', 'dishrack', 'dresser', 'door', 'sink', 'napkin', 'bathroom_cabinet', 'table', 'light']
Task:Pick up phone
response:

walk to living room, walk to the phone reach for the phone and pick up the phone.

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


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

Here is an example plan to achieve a goal for reference:
Scene_Objects:['filing_cabinet', 'beer', 'crayon', 'freezer', 'walllamp', 'bathroom', 'detergent', 'wallshelf', 'floor', 'ceiling', 'purse', 'computer', 'mat', 'tvstand', 'shower', 'window', 'couch', 'food_peanut_butter', 'dining_room', 'wall', 'photoframe', 'bed', 'television', 'curtain', 'diary', 'cupboard', 'controller', 'bathroom_cabinet', 'table', 'dishwasher']
Task:Wipe down baseboards please
response:
{
    "thoughts": Use a rag to get all the dust off the baseboards please.,
    "actions": ['[WALK] <home_office>', '[WALK] <rag>', '[FIND] <rag>', '[GRAB] <rag>', '[WALK] <wall>', '[PUTOBJBACK] <rag>']
}

Input:
Scene_Objects:['pot', 'tablelamp', 'microwave', 'walllamp', 'bathroom', 'drawing', 'wallshelf', 'floor', 'ceiling', 'bedroom', 'bookshelf', 'computer', 'brush', 'mat', 'tvstand', 'couch', 'clothes_hat', 'pillow', 'wall', 'nightstand', 'powersocket', 'cup', 'photoframe', 'food_food', 'television', 'doorjamb', 'bag', 'light', 'dishwasher', 'table']
Task:Relax on sofa
response:

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

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


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

Here is an example plan to achieve a goal for reference:
Scene_Objects:['filing_cabinet', 'tablelamp', 'food_ice_cream', 'microwave', 'walllamp', 'orchid', 'bills', 'knife', 'wallshelf', 'floor', 'ceiling', 'remote_control', 'computer', 'tvstand', 'faucet', 'shower', 'window', 'closetdrawer', 'couch', 'pillow', 'nightstand', 'wall', 'light_bulb', 'coffe_maker', 'television', 'curtain', 'lighter', 'vacuum_cleaner', 'dresser', 'table']
Task:Watch TV
response:
{
    "thoughts": I grab the remote.  I find the red power circular button. I point the remote at the television.   I push button down and TV screen lights up. I sit and watch.,
    "actions": ['[WALK] <home_office>', '[WALK] <remote_control>', '[FIND] <remote_control>', '[GRAB] <remote_control>', '[TURNTO] <remote_control>', '[LOOKAT] <remote_control>', '[FIND] <television>', '[TURNTO] <television>', '[POINTAT] <television>', '[SWITCHON] <television>', '[PUTOBJBACK] <remote_control>']
}

Input:
Scene_Objects:['tablelamp', 'food_ice_cream', 'jelly', 'chair', 'blow_dryer', 'bathroom', 'wallshelf', 'shampoo', 'phone', 'desk', 'clothes_jacket', 'stovefan', 'faucet', 'oil', 'closetdrawer', 'food_noodles', 'mousepad', 'microphone', 'towel', 'broom', 'bed', 'newspaper', 'after_shave', 'centerpiece', 'console', 'dresser', 'bathroom_cabinet', 'soap', 'tooth_paste', 'scrabble']
Task:Read book
response:

Walk to living room. Find book. Grab book. Open book. Read book.

[WALK] <home_office>
[WALK] <novel>
[FIND] <novel>
[GRAB] <novel>
[READ] <novel>