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

Here is an example plan to achieve a goal for reference:
Scene_Objects:['food_pizza', 'microwave', 'chair', 'food_butter', 'drawing', 'bathroom_counter', 'floor', 'stamp', 'desk', 'bookmark', 'stovefan', 'tvstand', 'shower', 'microphone', 'towel', 'dining_room', 'bowl', 'nightstand', 'oven', 'bench', 'shelf', 'food_cheese', 'photoframe', 'light_bulb', 'tray', 'kitchen_counter', 'dresser', 'hair', 'door', 'bathtub']
Task:Pet cat
response:
{
    "thoughts": Go into the living room and pet the cat,
    "actions": ['[WALK] <home_office>', '[WALK] <cat>', '[FIND] <cat>', '[WALK] <cat>', '[TURNTO] <cat>', '[LOOKAT] <cat>', '[TOUCH] <cat>', '[TOUCH] <cat>', '[TOUCH] <cat>']
}

Input:
Scene_Objects:['filing_cabinet', 'tablelamp', 'microwave', 'toilet', 'freezer', 'bathroom', 'needle', 'cpuscreen', 'hanger', 'bathroom_counter', 'phone', 'character', 'desk', 'bedroom', 'bookshelf', 'mat', 'ceilinglamp', 'faucet', 'couch', 'pillow', 'wall_clock', 'basket_for_clothes', 'cup', 'bed', 'tray', 'kitchen_counter', 'cupboard', 'door', 'soap', 'washing_machine']
Task:Wash clothes
response:

put clothes and soap in the washing machine, turn it on

[WALK] <dining_room>
[WALK] <washing_machine>
[FIND] <washing_machine>
[FIND] <basket_for_clothes>
[OPEN] <basket_for_clothes>
[FIND] <soap>
[GRAB] <soap>
[OPEN] <washing_machine>
[PUTBACK] <soap> <washing_machine>
[CLOSE] <washing_machine>
[SWITCHON] <washing_machine>


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

Here is an example plan to achieve a goal for reference:
Scene_Objects:['tablelamp', 'chair', 'walllamp', 'orchid', 'drawing', 'cpuscreen', 'wallshelf', 'hanger', 'floor', 'ceiling', 'phone', 'desk', 'keyboard', 'computer', 'button', 'ceilinglamp', 'tvstand', 'mat', 'mousepad', 'couch', 'pillow', 'wall', 'nightstand', 'food_food', 'television', 'doorjamb', 'mouse', 'dresser', 'door', 'sink']
Task:Work
response:
{
    "thoughts": working on computer,
    "actions": ['[WALK] <home_office>', '[WALK] <home_office>', '[WALK] <computer>', '[FIND] <computer>', '[SWITCHON] <computer>', '[FIND] <button>', '[TURNTO] <button>', '[LOOKAT] <button>', '[FIND] <mouse>', '[GRAB] <mouse>', '[GRAB] <button>', '[FIND] <chair>', '[SIT] <chair>', '[SWITCHOFF] <computer>']
}

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

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.

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


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

Here is an example plan to achieve a goal for reference:
Scene_Objects:['spectacles', 'tablelamp', 'blender', 'microwave', 'chair', 'walllamp', 'cpuscreen', 'bathroom_counter', 'ceiling', 'character', 'mail', 'food_bacon', 'mat', 'stereo', 'faucet', 'homework', 'shower', 'dining_room', 'wall', 'oven', 'keys', 'television', 'food_onion', 'coffee_pot', 'towel_rack', 'kitchen_counter', 'laundry_detergent', 'bag', 'spoon', 'table']
Task:Put away keys
response:
{
    "thoughts": Return keys into a bag,
    "actions": ['[WALK] <home_office>', '[WALK] <keys>', '[FIND] <keys>', '[GRAB] <keys>', '[FIND] <bag>', '[OPEN] <bag>', '[PUTBACK] <keys> <bag>', '[CLOSE] <bag>']
}

Input:
Scene_Objects:['sheets', 'freezer', 'walllamp', 'trashcan', 'drawing', 'orchid', 'ceiling', 'phone', 'bedroom', 'stovefan', 'mat', 'tvstand', 'shower', 'faucet', 'iron', 'food_noodles', 'couch', 'towel', 'pillow', 'dining_room', 'wall_clock', 'bench', 'bed', 'television', 'after_shave', 'doorjamb', 'door', 'bathtub', 'spoon', 'bathroom_cabinet']
Task:Pick up phone
response:

Walk to home office 1. Walk over to phone 1 on table 1.  Grab phone 1.  lift phone 1.

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


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

Here is an example plan to achieve a goal for reference:
Scene_Objects:['fork', 'filing_cabinet', 'scissors', 'juice', 'food_salt', 'microwave', 'chair', 'food_butter', 'toothbrush', 'drawing', 'wallshelf', 'bathroom_counter', 'floor', 'button', 'brush', 'ceilinglamp', 'plate', 'wall', 'tape', 'food_food', 'check', 'food_donut', 'wooden_spoon', 'rag', 'door', 'clothes_scarf', 'napkin', 'table', 'light', 'dishwasher']
Task:Eat
response:
{
    "thoughts": Serve food on dinning table in appropriate utensils, sit on the chair, eat,
    "actions": ['[WALK] <dining_room>', '[WALK] <table>', '[FIND] <table>', '[TURNTO] <table>', '[FIND] <chair>', '[SIT] <chair>', '[FIND] <food_food>', '[GRAB] <food_food>', '[FIND] <plate>', '[PUTBACK] <food_food> <plate>', '[GRAB] <food_food>', '[PUTOBJBACK] <food_food>', '[FIND] <fork>', '[GRAB] <fork>', '[EAT] <plate>']
}

Input:
Scene_Objects:['blender', 'microwave', 'chair', 'freezer', 'bathroom', 'drawing', 'orchid', 'floor', 'ceiling', 'desk', 'ceilinglamp', 'tvstand', 'stereo', 'picture', 'mat', 'closetdrawer', 'couch', 'dining_room', 'wall_clock', 'bench', 'food_food', 'coffe_maker', 'tray', 'doorjamb', 'towel_rack', 'mouse', 'dresser', 'cupboard', 'home_office', 'instrument_guitar']
Task:Turn on light
response:

I walk into the living room and then I walk to the light switch in there and turn the lights on

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


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

Here is an example plan to achieve a goal for reference:
Scene_Objects:['fork', 'tablelamp', 'chair', 'walllamp', 'detergent', 'food_carrot', 'cpuscreen', 'hanger', 'floor', 'ceiling', 'table_cloth', 'mop_bucket', 'ceilinglamp', 'tvstand', 'mat', 'couch', 'dustpan', 'pillow', 'wall', 'nightstand', 'oven', 'food_food', 'check', 'television', 'tray', 'wooden_spoon', 'kettle', 'controller', 'food_steak', 'sink']
Task:Relax on sofa
response:
{
    "thoughts": go to the living room and sit on the couch, ease into the sofa and relax.,
    "actions": ['[WALK] <home_office>', '[WALK] <couch>', '[LIE] <couch>']
}

Input:
Scene_Objects:['microwave', 'toilet', 'freezer', 'walllamp', 'drawing', 'orchid', 'bathroom_counter', 'floor', 'ceiling', 'computer', 'toaster', 'ceilinglamp', 'plate', 'faucet', 'shower', 'dish_soap', 'mousepad', 'pillow', 'wall', 'oven', 'photoframe', 'bed', 'coffe_maker', 'curtain', 'mouse', 'kitchen_counter', 'cupboard', 'sink', 'bathroom_cabinet', 'light']
Task:Wash dishes by hand
response:

i go to the kitchen, i find the faucet. I turn the faucet on, i grab the plate to wash , i then get the soap. I wash the dishes by hand

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


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

Here is an example plan to achieve a goal for reference:
Scene_Objects:['spectacles', 'filing_cabinet', 'blender', 'walllamp', 'orchid', 'cpuscreen', 'hanger', 'floor', 'bedroom', 'bookshelf', 'stovefan', 'food_peanut_butter', 'clothes_hat', 'clothes_pants', 'dining_room', 'nightstand', 'wall_clock', 'video_game_controller', 'food_donut', 'curtain', 'kettle', 'shoes', 'dresser', 'cupboard', 'hairbrush', 'controller', 'home_office', 'light', 'clothes_skirt', 'soap']
Task:Listen to music
response:
{
    "thoughts": Walk into the living room. Walk up to the radio. Turn on the radio. Listen to the radio.,
    "actions": ['[WALK] <home_office>', '[WALK] <stereo>', '[SWITCHON] <stereo>']
}

Input:
Scene_Objects:['food_salt', 'toilet', 'walllamp', 'drawing', 'orchid', 'floor', 'phone', 'character', 'computer', 'mat', 'tvstand', 'ceilinglamp', 'faucet', 'window', 'closetdrawer', 'couch', 'pillow', 'wall', 'nightstand', 'wall_clock', 'bed', 'television', 'curtain', 'doorjamb', 'towel_rack', 'kitchen_counter', 'hairdryer', 'sink', 'home_office', 'table']
Task:Relax on sofa
response:

Walk into the living room. Walk up to the sofa. Sit down on the sofa.

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


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

Here is an example plan to achieve a goal for reference:
Scene_Objects:['chair', 'freezer', 'walllamp', 'orchid', 'cpuscreen', 'floor', 'ceiling', 'desk', 'keyboard', 'computer', 'toaster', 'ceilinglamp', 'tvstand', 'faucet', 'stereo', 'window', 'shower', 'mousepad', 'wall', 'powersocket', 'bench', 'clothes_gloves', 'television', 'tray', 'rag', 'doorjamb', 'towel_rack', 'mouse', 'bathtub', 'table']
Task:Work
response:
{
    "thoughts": I walk into home office. I walk to desk. I sit at chair. I turn on computer.,
    "actions": ['[WALK] <home_office>', '[WALK] <desk>', '[FIND] <chair>', '[SIT] <chair>', '[FIND] <computer>', '[SWITCHON] <computer>']
}

Input:
Scene_Objects:['sponge', 'sheets', 'tablelamp', 'toilet', 'freezer', 'bathroom', 'orchid', 'wallshelf', 'hanger', 'bathroom_counter', 'floor', 'phone', 'bedroom', 'bookshelf', 'computer', 'ceilinglamp', 'tvstand', 'faucet', 'closetdrawer', 'couch', 'pillow', 'oven', 'bed', 'coffe_maker', 'doorjamb', 'mouse', 'dresser', 'door', 'bathroom_cabinet', 'home_office']
Task:Pet cat
response:

I enter the room where the cat is. I look for the cat. I find the cat. I walk over to the cat. I use my hand to pet the cat.

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


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

Here is an example plan to achieve a goal for reference:
Scene_Objects:['sheets', 'glue', 'chair', 'milk', 'toothbrush', 'orchid', 'drawing', 'bathroom_counter', 'floor', 'ceiling', 'phone', 'bookshelf', 'alcohol', 'mop_bucket', 'table_cloth', 'mat', 'faucet', 'homework', 'clothes_socks', 'closetdrawer', 'teeth', 'mousepad', 'wall', 'powersocket', 'doorjamb', 'shaving_cream', 'sink', 'bathroom_cabinet', 'light', 'hands_both']
Task:Wash hands
response:
{
    "thoughts": I go to the bathroom, walk to the sink, turn on the faucet and then wash my hands under the water.,
    "actions": ['[WALK] <bathroom>', '[WALK] <sink>', '[FIND] <faucet>', '[TURNTO] <faucet>', '[FIND] <hands_both>', '[WASH] <hands_both>']
}

Input:
Scene_Objects:['tablelamp', 'microwave', 'toilet', 'walllamp', 'bathroom', 'drawing', 'wallshelf', 'bathroom_counter', 'floor', 'ceiling', 'computer', 'stovefan', 'ceilinglamp', 'faucet', 'closetdrawer', 'couch', 'form', 'wall', 'powersocket', 'photoframe', 'video_game_controller', 'television', 'tray', 'kitchen_counter', 'cupboard', 'sink', 'bathroom_cabinet', 'light', 'soap', 'hands_both']
Task:Wash hands
response:

I walk in to the bathroom. I find the soap. I find the faucet. I turn on the faucet. I wash my hands. I put the soap back. I rinse my hands. I turn the faucet off.

[WALK] <bathroom>
[WALK] <faucet>
[FIND] <faucet>
[SWITCHON] <faucet>
[FIND] <soap>
[GRAB] <soap>
[FIND] <hands_both>
[WASH] <hands_both>
[PUTOBJBACK] <soap>
[RINSE] <hands_both>
[SWITCHOFF] <faucet>


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

Here is an example plan to achieve a goal for reference:
Scene_Objects:['food_pizza', 'mop', 'walllamp', 'drawing', 'bathroom_counter', 'floor', 'ceiling', 'bedroom', 'bookshelf', 'envelope', 'faucet', 'picture', 'homework', 'window', 'mousepad', 'clothes_hat', 'towel', 'wall', 'photoframe', 'hands_both', 'food_food', 'doorjamb', 'kettle', 'dresser', 'door', 'sink', 'bathroom_cabinet', 'light', 'vase', 'teeth']
Task:Wash teeth
response:
{
    "thoughts": I need to rinse my dentures off and put them back in my mouth.,
    "actions": ['[WALK] <bathroom>', '[WALK] <light>', '[FIND] <light>', '[SWITCHON] <light>', '[WALK] <sink>', '[FIND] <faucet>', '[SWITCHON] <faucet>', '[FIND] <teeth>', '[GRAB] <teeth>', '[WASH] <teeth>', '[PUTOBJBACK] <teeth>', '[SWITCHOFF] <faucet>', '[FIND] <towel>', '[GRAB] <towel>', '[FIND] <hands_both>', '[SCRUB] <hands_both>', '[PUTOBJBACK] <towel>', '[SWITCHOFF] <light>']
}

Input:
Scene_Objects:['chair', 'walllamp', 'bathroom', 'drawing', 'cpuscreen', 'hanger', 'floor', 'ceiling', 'desk', 'bedroom', 'keyboard', 'computer', 'table_cloth', 'ceilinglamp', 'tvstand', 'window', 'mousepad', 'wall', 'wall_clock', 'powersocket', 'check', 'television', 'tray', 'curtain', 'doorjamb', 'mouse', 'kitchen_counter', 'bathtub', 'sink', 'table']
Task:Browse internet
response:

I go to the office and sit in a chair, I turn on the computer and grab the mouse. I type on the keyboard and starting working on the computer.

[WALK] <home_office>
[WALK] <desk>
[FIND] <desk>
[FIND] <chair>
[SIT] <chair>
[FIND] <computer>
[SWITCHON] <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:['filing_cabinet', 'crayon', 'microwave', 'detergent', 'drawing', 'orchid', 'bathroom_counter', 'floor', 'ceiling', 'computer', 'alcohol', 'toaster', 'shower', 'couch', 'clothes_hat', 'pillow', 'wall', 'pasta', 'bench', 'oven', 'photoframe', 'newspaper', 'coffe_maker', 'tray', 'doorjamb', 'hairbrush', 'cupboard', 'door', 'table', 'light']
Task:Relax on sofa
response:
{
    "thoughts": Walk to the living room. Find the sofa. Walk to the sofa. Lie in the sofa.,
    "actions": ['[WALK] <home_office>', '[WALK] <couch>', '[FIND] <couch>', '[WALK] <couch>', '[LIE] <couch>']
}

Input:
Scene_Objects:['dry_pasta', 'trashcan', 'toothbrush', 'drawing', 'needle', 'floor', 'ceiling', 'phone', 'computer', 'button', 'piano_bench', 'plate', 'faucet', 'pillow', 'wall', 'wall_clock', 'powersocket', 'nightstand', 'bed', 'food_food', 'television', 'doorjamb', 'mouse', 'kitchen_counter', 'conditioner', 'door', 'food_steak', 'bathtub', 'light', 'teeth']
Task:Turn on light
response:

Walk over to light switch. Turn on lights.


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

Here is an example plan to achieve a goal for reference:
Scene_Objects:['microwave', 'toilet', 'chair', 'freezer', 'drawing', 'keyboard', 'bookmark', 'stovefan', 'ceilinglamp', 'stereo', 'shower', 'foundation', 'couch', 'food_peanut_butter', 'pillow', 'dining_room', 'broom', 'wall', 'nightstand', 'bed', 'check', 'television', 'wine', 'curtain', 'towel_rack', 'vacuum_cleaner', 'maindoor', 'door', 'dishwasher', 'vase']
Task:Pick up phone
response:
{
    "thoughts": Enter living room. Walk to telephone. Pick up from hook.,
    "actions": ['[WALK] <home_office>', '[WALK] <phone>', '[GRAB] <phone>']
}

Input:
Scene_Objects:['filing_cabinet', 'walllamp', 'drawing', 'wallshelf', 'food_egg', 'hanger', 'cpuscreen', 'floor', 'ceiling', 'character', 'keyboard', 'stovefan', 'mat', 'tvstand', 'ceilinglamp', 'faucet', 'window', 'toaster', 'closetdrawer', 'couch', 'pillow', 'wall', 'nightstand', 'bed', 'television', 'curtain', 'doorjamb', 'dresser', 'light', 'table']
Task:Relax on sofa
response:

I walk into the living room and turn on the light. I walk to the couch then sit on the couch.

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


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

Here is an example plan to achieve a goal for reference:
Scene_Objects:['sponge', 'sheets', 'pot', 'blender', 'microwave', 'chair', 'nail_polish', 'detergent', 'milk', 'bathroom_counter', 'floor', 'ceiling', 'ceilinglamp', 'clothes_socks', 'broom', 'wall', 'food_kiwi', 'powersocket', 'cup', 'photoframe', 'keys', 'newspaper', 'curtain', 'lighter', 'pencil', 'pajamas', 'clothes_dress', 'sink', 'table', 'light']
Task:Sit in chair
response:
{
    "thoughts": I sit in a chair to rest and eat.,
    "actions": ['[WALK] <dining_room>', '[WALK] <chair>', '[FIND] <chair>', '[PULL] <chair>', '[SIT] <chair>']
}

Input:
Scene_Objects:['chair', 'band-aids', 'walllamp', 'bathroom', 'cpuscreen', 'hanger', 'floor', 'ceiling', 'desk', 'keyboard', 'bookshelf', 'computer', 'ceilinglamp', 'tvstand', 'mousepad', 'pillow', 'dining_room', 'wall', 'wall_clock', 'powersocket', 'bed', 'food_food', 'check', 'television', 'doorjamb', 'mouse', 'sink', 'napkin', 'table', 'light']
Task:Write an email
response:

go to the home office and write an email

[RUN] <home_office>
[WALK] <computer>
[SWITCHON] <computer>
[FIND] <chair>
[SIT] <chair>
[FIND] <mouse>
[GRAB] <mouse>
[TOUCH] <mouse>
[TURNTO] <computer>
[LOOKAT] <computer>
[FIND] <keyboard>
[GRAB] <keyboard>
[TOUCH] <keyboard>
[TYPE] <keyboard>
[TURNTO] <computer>
[LOOKAT] <computer>
[TYPE] <keyboard>
[TURNTO] <computer>
[LOOKAT] <computer>
[TYPE] <keyboard>
[TOUCH] <mouse>
[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:['sheets', 'tablelamp', 'crayon', 'freezer', 'bathroom', 'toothbrush', 'drawing', 'knifeblock', 'floor', 'phone', 'mail', 'brush', 'ceilinglamp', 'picture', 'window', 'couch', 'bowl', 'wall', 'pasta', 'bench', 'tape', 'newspaper', 'light_bulb', 'television', 'toothbrush_holder', 'shaving_cream', 'vacuum_cleaner', 'spoon', 'bathroom_cabinet', 'table']
Task:Relax on sofa
response:
{
    "thoughts": I get home from work and walk into the living room. I see the couch and go to sit on it.,
    "actions": ['[WALK] <home_office>', '[WALK] <home_office>', '[WALK] <couch>', '[FIND] <couch>', '[TURNTO] <couch>', '[LOOKAT] <couch>', '[WALK] <couch>', '[SIT] <couch>', '[LIE] <couch>']
}

Input:
Scene_Objects:['microwave', 'walllamp', 'bathroom', 'drawing', 'hanger', 'bathroom_counter', 'floor', 'ceiling', 'character', 'bedroom', 'remote_control', 'computer', 'mat', 'ceilinglamp', 'tvstand', 'closetdrawer', 'couch', 'pillow', 'dining_room', 'wall', 'bench', 'photoframe', 'television', 'coffee_filter', 'curtain', 'towel_rack', 'dresser', 'cupboard', 'table', 'light']
Task:Watch TV
response:

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.

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


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

Here is an example plan to achieve a goal for reference:
Scene_Objects:['filing_cabinet', 'toilet', 'bathroom', 'drawing', 'bathroom_counter', 'floor', 'ceiling', 'character', 'keyboard', 'computer', 'stovefan', 'faucet', 'window', 'mousepad', 'closetdrawer', 'couch', 'towel', 'wall', 'nightstand', 'curtain', 'towel_rack', 'mouse', 'coffee_pot', 'dresser', 'sink', 'bathtub', 'bathroom_cabinet', 'home_office', 'soap', 'hands_both']
Task:Wash hands
response:
{
    "thoughts": I go to the bathroom and locate the sink. I turn the faucet so that water is running, and rinse my hands briefly. Then I grab the soap and squeeze some onto my hands. I spend a few minutes rubbing my hands together, then I rinse them again. Finally, I turn the faucet off and wipe my hands on a towel.,
    "actions": ['[WALK] <bathroom>', '[WALK] <sink>', '[FIND] <sink>', '[TURNTO] <sink>', '[FIND] <faucet>', '[SWITCHON] <faucet>', '[FIND] <hands_both>', '[RINSE] <hands_both>', '[FIND] <soap>', '[GRAB] <soap>', '[SQUEEZE] <soap>', '[WASH] <hands_both>', '[RINSE] <hands_both>', '[SWITCHOFF] <faucet>', '[FIND] <towel>', '[GRAB] <towel>', '[WIPE] <hands_both>']
}

Input:
Scene_Objects:['tablelamp', 'toilet', 'walllamp', 'drawing', 'orchid', 'wallshelf', 'bathroom_counter', 'floor', 'keyboard', 'bookshelf', 'computer', 'mat', 'tvstand', 'ceilinglamp', 'window', 'mousepad', 'couch', 'pillow', 'wall', 'nightstand', 'bench', 'bed', 'check', 'television', 'tray', 'curtain', 'mouse', 'cupboard', 'door', 'table']
Task:Relax on sofa
response:

Walk to the living room. Find the sofa. Walk to the sofa. Lie in the sofa.

[WALK] <home_office>
[WALK] <couch>
[FIND] <couch>
[WALK] <couch>
[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:['fork', 'scissors', 'chair', 'drawing', 'wallshelf', 'floor', 'bookshelf', 'envelope', 'piano_bench', 'toaster', 'ceilinglamp', 'plate', 'shower', 'picture', 'oil', 'closetdrawer', 'microphone', 'food_cheese', 'newspaper', 'bed', 'food_food', 'wine', 'wooden_spoon', 'kitchen_counter', 'cupboard', 'sink', 'napkin', 'bathroom_cabinet', 'table', 'light']
Task:Set up table
response:
{
    "thoughts": I walk to the table. I put down the dish. I put down the silverware. I put down the napkin.,
    "actions": ['[WALK] <table>', '[FIND] <fork>', '[GRAB] <fork>', '[PUTBACK] <fork> <table>', '[FIND] <fork>', '[GRAB] <fork>', '[PUTBACK] <fork> <table>', '[FIND] <fork>', '[GRAB] <fork>', '[PUTBACK] <fork> <table>', '[FIND] <fork>', '[GRAB] <fork>', '[PUTBACK] <fork> <table>', '[FIND] <fork>', '[GRAB] <fork>', '[PUTBACK] <fork> <table>', '[FIND] <plate>', '[GRAB] <plate>', '[PUTBACK] <plate> <table>', '[FIND] <plate>', '[GRAB] <plate>', '[PUTBACK] <plate> <table>', '[GRAB] <plate>', '[PUTBACK] <plate> <table>', '[GRAB] <plate>', '[PUTBACK] <plate> <table>', '[GRAB] <plate>', '[PUTBACK] <plate> <table>']
}

Input:
Scene_Objects:['filing_cabinet', 'tablelamp', 'chair', 'drawing', 'wallshelf', 'cpuscreen', 'floor', 'ceiling', 'phone', 'desk', 'bookshelf', 'toaster', 'mat', 'ceilinglamp', 'shower', 'faucet', 'food_jam', 'dining_room', 'nightstand', 'wall', 'bench', 'powersocket', 'video_game_controller', 'television', 'doorjamb', 'mouse', 'dresser', 'door', 'sink', 'soap']
Task:Pick up phone
response:

I'll enter the location containing the phone. Once there, I'll locate the phone, and move close to it. I'll then use my hand to pick up the phone such that I can then use it.

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


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

Here is an example plan to achieve a goal for reference:
Scene_Objects:['tablelamp', 'chair', 'walllamp', 'cat', 'orchid', 'wallshelf', 'bathroom_counter', 'floor', 'ceiling', 'desk', 'clothes_jacket', 'stovefan', 'ceilinglamp', 'shower', 'mousepad', 'couch', 'food_jam', 'form', 'pillow', 'wall', 'nightstand', 'box', 'food_food', 'television', 'coffee_pot', 'kettle', 'cards', 'mouse', 'home_office', 'dishwasher']
Task:Pet cat
response:
{
    "thoughts": I walk to the living room.  I locate the cat.  I walk to the couch and sit down beside the cat.  I pet the cat.,
    "actions": ['[WALK] <home_office>', '[WALK] <cat>', '[FIND] <cat>', '[WALK] <couch>', '[SIT] <couch>', '[TOUCH] <cat>']
}

Input:
Scene_Objects:['pot', 'water_glass', 'microwave', 'toilet', 'chair', 'freezer', 'bathroom', 'wallshelf', 'bookshelf', 'clothes_jacket', 'toaster', 'ceilinglamp', 'faucet', 'window', 'closetdrawer', 'dining_room', 'nightstand', 'wall', 'wall_clock', 'powersocket', 'basket_for_clothes', 'novel', 'coffe_maker', 'tray', 'doorjamb', 'console', 'dishrack', 'hairdryer', 'door', 'bathtub']
Task:Drink
response:

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


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

Here is an example plan to achieve a goal for reference:
Scene_Objects:['scissors', 'bathroom', 'ceilingfan', 'drawing', 'bathroom_counter', 'floor', 'ceiling', 'character', 'bookshelf', 'remote_control', 'toaster', 'ceilinglamp', 'tvstand', 'balanceball', 'laptop', 'window', 'couch', 'dining_room', 'food_kiwi', 'wall', 'toilet_paper', 'razor', 'television', 'curtain', 'diary', 'towel_rack', 'door', 'bathroom_cabinet', 'table', 'creditcard']
Task:Watch TV
response:
{
    "thoughts": Sit on the couch and use the remote control 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>', '[PUTOBJBACK] <remote_control>', '[TURNTO] <television>', '[WATCH] <television>']
}

Input:
Scene_Objects:['filing_cabinet', 'toilet', 'bathroom', 'drawing', 'bathroom_counter', 'floor', 'ceiling', 'character', 'keyboard', 'computer', 'stovefan', 'faucet', 'window', 'mousepad', 'closetdrawer', 'couch', 'towel', 'wall', 'nightstand', 'curtain', 'towel_rack', 'mouse', 'coffee_pot', 'dresser', 'sink', 'bathtub', 'bathroom_cabinet', 'home_office', 'soap', 'hands_both']
Task:Wash hands
response:

I go to the bathroom and locate the sink. I turn the faucet so that water is running, and rinse my hands briefly. Then I grab the soap and squeeze some onto my hands. I spend a few minutes rubbing my hands together, then I rinse them again. Finally, I turn the faucet off and wipe my hands on a towel.

[WALK] <bathroom>
[WALK] <sink>
[FIND] <sink>
[TURNTO] <sink>
[FIND] <faucet>
[SWITCHON] <faucet>
[FIND] <hands_both>
[RINSE] <hands_both>
[FIND] <soap>
[GRAB] <soap>
[SQUEEZE] <soap>
[WASH] <hands_both>
[RINSE] <hands_both>
[SWITCHOFF] <faucet>
[FIND] <towel>
[GRAB] <towel>
[WIPE] <hands_both>


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

Here is an example plan to achieve a goal for reference:
Scene_Objects:['sheets', 'tablelamp', 'microwave', 'toilet', 'chair', 'dog', 'walllamp', 'trashcan', 'cpuscreen', 'floor', 'ceiling', 'folder', 'desk', 'bookshelf', 'keyboard', 'thread', 'computer', 'mail', 'bookmark', 'mousepad', 'wall', 'nightstand', 'photoframe', 'novel', 'toilet_paper', 'tray', 'towel_rack', 'mouse', 'door', 'light']
Task:Read book
response:
{
    "thoughts": Walk to the living room. Find a desk and grab a book. Walk to the chair, sit in the chair and read a book.,
    "actions": ['[WALK] <home_office>', '[WALK] <desk>', '[FIND] <desk>', '[FIND] <novel>', '[GRAB] <novel>', '[WALK] <chair>', '[SIT] <chair>', '[READ] <novel>']
}

Input:
Scene_Objects:['tablelamp', 'microwave', 'chair', 'walllamp', 'hanger', 'floor', 'ceiling', 'bookshelf', 'keyboard', 'table_cloth', 'stovefan', 'mat', 'tvstand', 'shower', 'closetdrawer', 'microphone', 'wall', 'nightstand', 'oven', 'wall_clock', 'coffe_maker', 'television', 'doorjamb', 'towel_rack', 'mouse', 'cupboard', 'door', 'bathroom_cabinet', 'light', 'table']
Task:Turn on light
response:


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

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

Input:
Scene_Objects:['chair', 'dough', 'drawing', 'orchid', 'cpuscreen', 'bathroom_counter', 'floor', 'ceiling', 'phone', 'character', 'desk', 'keyboard', 'bookshelf', 'computer', 'tvstand', 'stereo', 'mousepad', 'pillow', 'food_kiwi', 'wall', 'powersocket', 'photoframe', 'television', 'curtain', 'doorjamb', 'mouse', 'door', 'sink', 'bathtub', 'light']
Task:Listen to music
response:

I go to the bedroom and sit at my desk. I turn my radio on and listen to music.

[WALK] <bedroom>
[WALK] <light>
[FIND] <light>
[SWITCHON] <light>
[WALK] <desk>
[FIND] <chair>
[SIT] <chair>
[FIND] <stereo>
[SWITCHON] <stereo>


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

Here is an example plan to achieve a goal for reference:
Scene_Objects:['filing_cabinet', 'bathroom', 'detergent', 'food_carrot', 'drawing', 'orchid', 'bathroom_counter', 'floor', 'ceiling', 'phone', 'desk', 'thread', 'stereo', 'window', 'couch', 'pillow', 'dining_room', 'wall', 'nightstand', 'cup', 'coffe_maker', 'curtain', 'doorjamb', 'kitchen_counter', 'hair', 'door', 'sink', 'spoon', 'table', 'light']
Task:Relax on sofa
response:
{
    "thoughts": Walk to the living room, turn to the sofa. Sit on the sofa and relax.,
    "actions": ['[WALK] <home_office>', '[WALK] <couch>', '[FIND] <couch>', '[TURNTO] <couch>', '[SIT] <couch>']
}

Input:
Scene_Objects:['dry_pasta', 'filing_cabinet', 'mop', 'microwave', 'trashcan', 'drawing', 'ceiling', 'character', 'bedroom', 'bookshelf', 'computer', 'stovefan', 'tvstand', 'shower', 'faucet', 'mousepad', 'closetdrawer', 'form', 'pillow', 'nightstand', 'newspaper', 'bed', 'curtain', 'towel_rack', 'dishrack', 'home_office', 'light', 'dishwasher', 'table', 'scrabble']
Task:Wash dishes by hand
response:

walk to kitchen , find dish washer , wash the dishe rack , put dishes in dish washer , switch on dish washer

[WALK] <dining_room>
[WALK] <dishwasher>
[FIND] <dishwasher>
[FIND] <dishrack>
[FIND] <dishrack>
[GRAB] <dishrack>
[FIND] <dishwasher>
[OPEN] <dishwasher>
[PUTBACK] <dishrack> <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:['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:
{
    "thoughts": 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.,
    "actions": ['[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>']
}

Input:
Scene_Objects:['tablelamp', 'walllamp', 'trashcan', 'bathroom_counter', 'floor', 'phone', 'keyboard', 'computer', 'clothes_jacket', 'table_cloth', 'mat', 'ceilinglamp', 'faucet', 'shower', 'towel', 'dining_room', 'wall', 'powersocket', 'bed', 'check', 'wooden_spoon', 'cards', 'mouse', 'dresser', 'door', 'sink', 'bathroom_cabinet', 'table', 'soap', 'hands_both']
Task:Wash hands
response:

Go to the bathroom. turn on the water in the sink. apply soap to hands. rub hands together. rinse hands with water. turn off the water.

[WALK] <bathroom>
[WALK] <sink>
[FIND] <sink>
[FIND] <soap>
[GRAB] <soap>
[FIND] <hands_both>
[SCRUB] <hands_both>
[RINSE] <hands_both>
[WIPE] <hands_both>


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

Here is an example plan to achieve a goal for reference:
Scene_Objects:['sponge', 'filing_cabinet', 'cat', 'food_butter', 'hanger', 'floor', 'ceiling', 'food_cake', 'ceilinglamp', 'deck_of_cards', 'tvstand', 'homework', 'mousepad', 'closetdrawer', 'teeth', 'food_jam', 'nightstand', 'powersocket', 'bed', 'check', 'video_game_controller', 'mouthwash', 'towel_rack', 'mouse', 'console', 'cd', 'cupboard', 'instrument_guitar', 'coffee', 'shoe_rack']
Task:Clean
response:
{
    "thoughts": Clean the welcome mat,
    "actions": ['[WALK] <home_office>', '[WALK] <vacuum_cleaner>', '[FIND] <vacuum_cleaner>', '[GRAB] <vacuum_cleaner>', '[SWITCHON] <vacuum_cleaner>', '[SWITCHOFF] <vacuum_cleaner>']
}

Input:
Scene_Objects:['filing_cabinet', 'microwave', 'orchid', 'drawing', 'hanger', 'floor', 'phone', 'character', 'keyboard', 'toaster', 'plate', 'faucet', 'shower', 'window', 'mousepad', 'closetdrawer', 'dining_room', 'oven', 'powersocket', 'cup', 'bed', 'food_food', 'coffe_maker', 'tray', 'doorjamb', 'dresser', 'sink', 'bathtub', 'home_office', 'table']
Task:Drink
response:

I go to the kitchen. I get a glass. I fill it with water. I take a drink from the glass.

[WALK] <dining_room>
[WALK] <cup>
[FIND] <cup>
[GRAB] <cup>
[WALK] <water>
[FIND] <water>
[GRAB] <water>
[POUR] <water> <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:['sheets', 'food_pizza', 'toilet', 'freezer', 'ground_coffee', 'bathroom', 'drawing', 'knifeblock', 'floor', 'ceiling', 'desk', 'bookshelf', 'alcohol', 'mat', 'shower', 'window', 'dining_room', 'food_kiwi', 'nightstand', 'wall', 'powersocket', 'photoframe', 'food_food', 'television', 'doorjamb', 'mouse', 'door', 'light', 'colander', 'coffee']
Task:Put groceries in Fridge
response:
{
    "thoughts": I get my groceries and go to the fridge. I open the fridge and put the groceries there.,
    "actions": ['[WALK] <dining_room>', '[WALK] <food_food>', '[FIND] <food_food>', '[GRAB] <food_food>', '[FIND] <freezer>', '[OPEN] <freezer>', '[PUTIN] <food_food> <freezer>', '[CLOSE] <freezer>']
}

Input:
Scene_Objects:['microwave', 'toilet', 'freezer', 'walllamp', 'bathroom', 'orchid', 'drawing', 'wallshelf', 'hanger', 'bathroom_counter', 'ceiling', 'desk', 'computer', 'ceilinglamp', 'shower', 'window', 'mousepad', 'closetdrawer', 'pillow', 'wall', 'wall_clock', 'powersocket', 'photoframe', 'bed', 'food_food', 'mouse', 'vacuum_cleaner', 'bathtub', 'sink', 'table']
Task:Pick up phone
response:

Walk into the living room, walk over to phone, grab the phone, put it to your ear .

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


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

Here is an example plan to achieve a goal for reference:
Scene_Objects:['pot', 'mop', 'toilet', 'freezer', 'walllamp', 'bathroom', 'cat', 'food_butter', 'drawing', 'wallshelf', 'hanger', 'floor', 'ceiling', 'computer', 'mat', 'tvstand', 'iron', 'mousepad', 'couch', 'pillow', 'wall', 'nightstand', 'toy', 'tape', 'photoframe', 'television', 'food_rice', 'doorjamb', 'cards', 'door']
Task:Relax on sofa
response:
{
    "thoughts": walk into living room, look at the sofa which one is available, sit on the sofa, now take relax on the sofa,
    "actions": ['[WALK] <home_office>', '[WALK] <couch>', '[FIND] <couch>', '[TURNTO] <couch>', '[LOOKAT] <couch>', '[SIT] <couch>']
}

Input:
Scene_Objects:['chair', 'walllamp', 'drawing', 'cpuscreen', 'wallshelf', 'bathroom_counter', 'floor', 'ceiling', 'desk', 'keyboard', 'computer', 'toaster', 'ceilinglamp', 'tvstand', 'stovefan', 'mousepad', 'wall', 'wall_clock', 'powersocket', 'nightstand', 'tape', 'newspaper', 'bed', 'television', 'doorjamb', 'mouse', 'sink', 'home_office', 'table', 'light']
Task:Work
response:

Walk to home office. Sit on chair. Switch on computer. type in keyboard.

[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:['food_bread', 'orchid', 'wallshelf', 'cpuscreen', 'bathroom_counter', 'floor', 'ceiling', 'character', 'bedroom', 'bookshelf', 'ceilinglamp', 'faucet', 'closetdrawer', 'couch', 'pillow', 'wall', 'nightstand', 'powersocket', 'bench', 'food_food', 'water', 'doorjamb', 'towel_rack', 'door', 'sink', 'bathtub', 'bathroom_cabinet', 'table', 'hands_both', 'shoe_rack']
Task:Wash hands
response:

I turn on faucet. I hold out my hands. I get my hands wet.

[WALK] <bathroom>
[WALK] <faucet>
[FIND] <faucet>
[TURNTO] <faucet>
[FIND] <water>
[GRAB] <water>
[FIND] <hands_both>
[POUR] <water> <hands_both>


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

Here is an example plan to achieve a goal for reference:
Scene_Objects:['sheets', 'microwave', 'toilet', 'chair', 'freezer', 'walllamp', 'detergent', 'hanger', 'floor', 'ceiling', 'phone', 'keyboard', 'computer', 'food_bacon', 'alcohol', 'ceilinglamp', 'pillow', 'wall', 'powersocket', 'bed', 'curtain', 'doorjamb', 'kettle', 'mouse', 'dresser', 'cupboard', 'door', 'maindoor', 'light', 'creditcard']
Task:Turn on light
response:
{
    "thoughts": I open the room door and press the light button on,
    "actions": ['[WALK] <home_office>', '[WALK] <light>', '[FIND] <light>', '[SWITCHON] <light>']
}

Input:
Scene_Objects:['pot', 'food_salt', 'drawing', 'wallshelf', 'bathroom_counter', 'floor', 'ceiling', 'phone', 'computer', 'stovefan', 'ceilinglamp', 'tvstand', 'faucet', 'shower', 'stereo', 'couch', 'wall', 'nightstand', 'bench', 'powersocket', 'tape', 'bed', 'coffe_maker', 'check', 'tray', 'curtain', 'sink', 'bathroom_cabinet', 'soap', 'hands_both']
Task:Wash hands
response:

Go to the bathroom and to the sink, turn the faucet on, push the bottle of soap onto your hands and scrub them. Then rinse your hands out and turn the faucet off.

[WALK] <bathroom>
[WALK] <sink>
[FIND] <sink>
[FIND] <faucet>
[SWITCHON] <faucet>
[FIND] <soap>
[PUSH] <soap>
[FIND] <hands_both>
[SCRUB] <hands_both>
[RINSE] <hands_both>
[SWITCHOFF] <faucet>


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

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

Input:
Scene_Objects:['tablelamp', 'food_salt', 'walllamp', 'cat', 'drawing', 'hanger', 'bathroom_counter', 'floor', 'computer', 'stovefan', 'mat', 'tvstand', 'ceilinglamp', 'toaster', 'window', 'couch', 'pillow', 'dining_room', 'wall', 'oven', 'powersocket', 'bed', 'television', 'tray', 'curtain', 'towel_rack', 'mouse', 'kitchen_counter', 'home_office', 'table']
Task:Pet cat
response:

The cat is laying on the couch in the living room. I want to pet it, so I am going to walk to the living room, sit on the couch, and pet the cat.

[WALK] <home_office>
[WALK] <couch>
[SIT] <couch>
[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:['sponge', 'microwave', 'toilet', 'walllamp', 'trashcan', 'bathroom_counter', 'floor', 'phone', 'character', 'piano_bench', 'bookmark', 'toaster', 'mat', 'shower', 'dish_soap', 'couch', 'wall', 'photoframe', 'novel', 'coffe_maker', 'check', 'cards', 'kitchen_counter', 'dresser', 'cupboard', 'controller', 'sink', 'home_office', 'bathroom_cabinet', 'dishwasher']
Task:Wash dishes with dishwasher
response:
{
    "thoughts": walk to kitchen, find the dishwasher, apply dish soap into vessels or dishwasher, wash the dishes with a dishwasher,
    "actions": ['[WALK] <dining_room>', '[WALK] <dishwasher>', '[FIND] <dishwasher>', '[FIND] <dish_soap>', '[GRAB] <dish_soap>', '[OPEN] <dishwasher>', '[PUTBACK] <dish_soap> <dishwasher>', '[WASH] <dishwasher>']
}

Input:
Scene_Objects:['freezer', 'walllamp', 'cat', 'drawing', 'cpuscreen', 'floor', 'bedroom', 'keyboard', 'bookshelf', 'mat', 'tvstand', 'ceilinglamp', 'shower', 'window', 'couch', 'pillow', 'wall', 'nightstand', 'oven', 'check', 'coffe_maker', 'television', 'curtain', 'cupboard', 'food_steak', 'sink', 'home_office', 'table', 'light', 'instrument_guitar']
Task:Relax on sofa
response:

Go 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:['sheets', 'toilet', 'chair', 'jelly', 'walllamp', 'cat', 'trashcan', 'hanger', 'floor', 'ceiling', 'phone', 'food_bacon', 'toaster', 'ceilinglamp', 'tvstand', 'faucet', 'clothes_socks', 'couch', 'wall', 'oven', 'bed', 'tray', 'kitchen_counter', 'shoes', 'dishrack', 'dresser', 'cupboard', 'bathroom_cabinet', 'light', 'teeth']
Task:Put away shoes
response:
{
    "thoughts": Pick up shoes from entry hall. Open entry way closet. Put shoes in closet. Close closet door.,
    "actions": ['[WALK] <home_office>', '[WALK] <shoes>', '[FIND] <shoes>', '[GRAB] <shoes>', '[FIND] <dresser>', '[OPEN] <dresser>', '[PUTIN] <shoes> <dresser>', '[CLOSE] <dresser>']
}

Input:
Scene_Objects:['sheets', 'tablelamp', 'walllamp', 'cpuscreen', 'bathroom_counter', 'floor', 'ceiling', 'phone', 'bookshelf', 'keyboard', 'computer', 'clothes_jacket', 'mat', 'faucet', 'shower', 'towel', 'pillow', 'wall', 'nightstand', 'oven', 'food_food', 'tray', 'dresser', 'door', 'sink', 'bathroom_cabinet', 'home_office', 'soap', 'board_game', 'hands_both']
Task:Wash hands
response:

I go to the bathroom, open the faucet rinse the hands, wash the hands with soap and rinse again, then wipe with a towel.

[WALK] <bathroom>
[WALK] <faucet>
[FIND] <faucet>
[TURNTO] <faucet>
[FIND] <hands_both>
[RINSE] <hands_both>
[FIND] <soap>
[GRAB] <soap>
[WASH] <hands_both>
[RINSE] <hands_both>
[TURNTO] <faucet>
[FIND] <towel>
[GRAB] <towel>
[WIPE] <hands_both>


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

Here is an example plan to achieve a goal for reference:
Scene_Objects:['filing_cabinet', 'microwave', 'chair', 'drawing', 'clothes_underwear', 'hanger', 'bathroom_counter', 'bedroom', 'keyboard', 'clothes_jacket', 'ceilinglamp', 'tvstand', 'faucet', 'picture', 'mat', 'mousepad', 'couch', 'pillow', 'dining_room', 'food_food', 'check', 'coffe_maker', 'mirror', 'ice', 'wooden_spoon', 'rag', 'cupboard', 'door', 'sink', 'table']
Task:Clean mirror
response:
{
    "thoughts": Spray glass cleaner on mirror. Wipe with a clean cloth.,
    "actions": ['[WALK] <bathroom>', '[WALK] <cleaning_solution>', '[FIND] <cleaning_solution>', '[GRAB] <cleaning_solution>', '[WALK] <mirror>', '[PUTOBJBACK] <cleaning_solution>', '[FIND] <rag>', '[GRAB] <rag>', '[WALK] <mirror>', '[WIPE] <mirror>', '[WIPE] <mirror>', '[WIPE] <mirror>', '[PUTOBJBACK] <rag>']
}

Input:
Scene_Objects:['food_salt', 'toilet', 'knifeblock', 'drawing', 'hanger', 'bathroom_counter', 'floor', 'ceiling', 'longboard', 'character', 'bookshelf', 'brush', 'ceilinglamp', 'mat', 'stereo', 'toaster', 'pillow', 'wall', 'bench', 'photoframe', 'bed', 'novel', 'wine', 'after_shave', 'vacuum_cleaner', 'dresser', 'pajamas', 'table', 'board_game', 'shoe_rack']
Task:Vacuum
response:

Plug in vacuum. Walk around with vacuum, covering all of the floor. Unplug vacuum.

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


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

Here is an example plan to achieve a goal for reference:
Scene_Objects:['measuring_cup', 'detergent', 'orchid', 'clothes_underwear', 'floor', 'character', 'button', 'stovefan', 'ceilinglamp', 'toaster', 'homework', 'mousepad', 'couch', 'dustpan', 'microphone', 'form', 'towel', 'powersocket', 'basket_for_clothes', 'bed', 'light_bulb', 'oven_mitts', 'tray', 'kitchen_counter', 'cupboard', 'laundry_detergent', 'sink', 'bathroom_cabinet', 'colander', 'washing_machine']
Task:Wash clothes
response:
{
    "thoughts": Walk to laundry room. Find laundry basket. Grab laundry basket. Find washing machine. Walk to washing machine. Open washing machine. Find detergent. Grab detergent. Put in detergent. Put in clothes. Close washing machine. Turn on machine.,
    "actions": ['[WALK] <bathroom>', '[WALK] <basket_for_clothes>', '[FIND] <basket_for_clothes>', '[GRAB] <basket_for_clothes>', '[FIND] <washing_machine>', '[WALK] <washing_machine>', '[OPEN] <washing_machine>', '[FIND] <laundry_detergent>', '[GRAB] <laundry_detergent>', '[POUR] <laundry_detergent> <washing_machine>', '[PUTOBJBACK] <laundry_detergent>', '[PUTBACK] <basket_for_clothes> <washing_machine>', '[CLOSE] <washing_machine>', '[SWITCHON] <washing_machine>']
}

Input:
Scene_Objects:['food_salt', 'chair', 'ceilingfan', 'drawing', 'floor', 'ceiling', 'phone', 'remote_control', 'food_bacon', 'table_cloth', 'ceilinglamp', 'tvstand', 'balanceball', 'window', 'couch', 'wall', 'powersocket', 'oven', 'cup', 'bed', 'coffe_maker', 'television', 'curtain', 'lighter', 'doorjamb', 'shaving_cream', 'headset', 'cupboard', 'table', 'clothes_shirt']
Task:Watch TV
response:

We recently got a 43 inch TV and have enjoyed watching some of our favorite movies and TV shows. We use a remote to do so.

[WALK] <home_office>
[WALK] <couch>
[SIT] <couch>
[FIND] <remote_control>
[GRAB] <remote_control>
[TOUCH] <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:['chair', 'detergent', 'food_butter', 'clothes_underwear', 'hanger', 'floor', 'stamp', 'bookshelf', 'computer', 'clothes_jacket', 'table_cloth', 'mat', 'shoe-shine_kit', 'clothes_socks', 'closetdrawer', 'couch', 'clothes_pants', 'basket_for_clothes', 'check', 'mouthwash', 'food_rice', 'vacuum_cleaner', 'laundry_detergent', 'clothes_dress', 'bathroom_cabinet', 'light', 'dishwasher', 'clothes_shirt', 'washing_machine', 'creditcard']
Task:Wash clothes
response:
{
    "thoughts": I grab the basket for clothes from the bedroom. I carry it and walk to the washing machine. I open the washing machine. I grab the dirty clothes. I put the clothes in the washing machine. I grab the laundry detergent and put it in the washing machine. I close the washing machine. I switch on the washing machine.,
    "actions": ['[WALK] <bedroom>', '[WALK] <basket_for_clothes>', '[FIND] <basket_for_clothes>', '[GRAB] <basket_for_clothes>', '[WALK] <washing_machine>', '[DROP] <basket_for_clothes>', '[OPEN] <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_underwear>', '[GRAB] <clothes_underwear>', '[PUTBACK] <clothes_underwear> <washing_machine>', '[FIND] <clothes_socks>', '[GRAB] <clothes_socks>', '[PUTBACK] <clothes_socks> <washing_machine>', '[FIND] <laundry_detergent>', '[GRAB] <laundry_detergent>', '[PUTBACK] <laundry_detergent> <washing_machine>', '[GRAB] <laundry_detergent>', '[PUTOBJBACK] <laundry_detergent>', '[CLOSE] <washing_machine>', '[SWITCHON] <washing_machine>']
}

Input:
Scene_Objects:['dry_pasta', 'sponge', 'scissors', 'food_salt', 'trashcan', 'drawing', 'needle', 'hanger', 'longboard', 'floor', 'character', 'stamp', 'keyboard', 'stovefan', 'ceilinglamp', 'deck_of_cards', 'window', 'couch', 'dining_room', 'wall', 'photoframe', 'television', 'curtain', 'rag', 'pencil', 'shoes', 'clothes_dress', 'conditioner', 'sink', 'table']
Task:Text friends while sitting on couch
response:

[WALK] <home_office>
[WALK] <phone>
[FIND] <phone>
[GRAB] <phone>
[WALK] <couch>
[SIT] <couch>
[TURNTO] <phone>
[LOOKAT] <phone>
[TOUCH] <phone>


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

Here is an example plan to achieve a goal for reference:
Scene_Objects:['tablelamp', 'blender', 'mop', 'bathroom', 'cat', 'trashcan', 'knifeblock', 'stamp', 'button', 'piano_bench', 'faucet', 'mousepad', 'bowl', 'nightstand', 'wall_clock', 'oven', 'wall', 'bench', 'photoframe', 'novel', 'food_food', 'coffe_maker', 'curtain', 'pencil', 'shoes', 'hairbrush', 'hair', 'instrument_guitar', 'dishwasher', 'tooth_paste']
Task:Read book
response:
{
    "thoughts": pick up  the book open the book and read,
    "actions": ['[WALK] <bedroom>', '[WALK] <novel>', '[GRAB] <novel>', '[READ] <novel>']
}

Input:
Scene_Objects:['dry_pasta', 'walllamp', 'ceilingfan', 'drawing', 'floor', 'ceiling', 'bookshelf', 'stovefan', 'ceilinglamp', 'tvstand', 'balanceball', 'mat', 'window', 'foundation', 'couch', 'wall', 'pasta', 'toy', 'box', 'television', 'curtain', 'diary', 'towel_rack', 'kitchen_counter', 'cupboard', 'clothes_scarf', 'home_office', 'table', 'vase', 'coffee']
Task:Change TV channels
response:

Take remote. Change to desired channel by you.

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


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

Here is an example plan to achieve a goal for reference:
Scene_Objects:['microwave', 'walllamp', 'ground_coffee', 'drawing', 'orchid', 'wallshelf', 'floor', 'ceiling', 'phone', 'bookshelf', 'remote_control', 'mat', 'tvstand', 'ceilinglamp', 'shower', 'window', 'couch', 'pillow', 'wall', 'powersocket', 'oven', 'photoframe', 'television', 'curtain', 'doorjamb', 'towel_rack', 'pencil', 'door', 'table', 'light']
Task:Watch TV
response:
{
    "thoughts": walk to living room, find couch, sit on couch, find remote control , turn on tv by pressing button,
    "actions": ['[WALK] <home_office>', '[WALK] <couch>', '[FIND] <couch>', '[SIT] <couch>', '[FIND] <remote_control>', '[FIND] <television>', '[TURNTO] <television>']
}

Input:
Scene_Objects:['sheets', 'filing_cabinet', 'tablelamp', 'crayon', 'microwave', 'toilet', 'detergent', 'milk', 'folder', 'bedroom', 'toaster', 'stovefan', 'balanceball', 'stereo', 'window', 'mousepad', 'food_noodles', 'dining_room', 'nightstand', 'box', 'newspaper', 'tray', 'lighter', 'headset', 'controller', 'door', 'maindoor', 'instrument_guitar', 'table', 'soap']
Task:Walk through
response:

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


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

Here is an example plan to achieve a goal for reference:
Scene_Objects:['fork', 'filing_cabinet', 'blow_dryer', 'trashcan', 'drawing', 'knife', 'hanger', 'bathroom_counter', 'floor', 'ceiling', 'character', 'desk', 'toaster', 'faucet', 'picture', 'towel', 'dining_room', 'wall', 'nightstand', 'powersocket', 'photoframe', 'novel', 'food_food', 'controller', 'door', 'sink', 'bathroom_cabinet', 'clothes_skirt', 'soap', 'board_game']
Task:Wash hands
response:
{
    "thoughts": I walk into the bathroom. Walk to the sink. Turn on tap. Get soap. Wash and rinse hands. Turn off tap. Dry hands.,
    "actions": ['[WALK] <bathroom>', '[WALK] <sink>', '[FIND] <sink>', '[TURNTO] <sink>', '[LOOKAT] <sink>', '[WALK] <sink>', '[FIND] <faucet>', '[SWITCHON] <faucet>', '[FIND] <soap>', '[GRAB] <soap>', '[RINSE] <soap>', '[SWITCHOFF] <faucet>', '[FIND] <towel>', '[GRAB] <towel>']
}

Input:
Scene_Objects:['measuring_cup', 'toilet', 'freezer', 'bathroom', 'trashcan', 'ceilingfan', 'drawing', 'orchid', 'floor', 'ceiling', 'bedroom', 'keyboard', 'remote_control', 'computer', 'table_cloth', 'ceilinglamp', 'tvstand', 'balanceball', 'window', 'mousepad', 'couch', 'food_jam', 'pillow', 'wall', 'television', 'curtain', 'towel_rack', 'chessboard', 'table', 'light']
Task:Watch  TV
response:

Sit on my couch  directly opposite  my tv , switch  on my tv with the  remote control  and watch

[WALK] <home_office>
[WALK] <couch>
[FIND] <couch>
[SIT] <couch>
[FIND] <remote_control>
[GRAB] <remote_control>
[FIND] <television>
[SWITCHON] <television>
[PUTOBJBACK] <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:['blender', 'detergent', 'orchid', 'hanger', 'floor', 'ceiling', 'dvd_player', 'character', 'purse', 'envelope', 'mat', 'window', 'foundation', 'broom', 'wall', 'nightstand', 'keys', 'novel', 'check', 'toothbrush_holder', 'oven_mitts', 'curtain', 'doorjamb', 'mouse', 'dresser', 'hairdryer', 'home_office', 'clothes_shirt', 'coffee', 'creditcard']
Task:Put on coat
response:
{
    "thoughts": Open closet and grab coat.  Put on coat and fasten the front closed.  Close closet.,
    "actions": ['[WALK] <home_office>', '[WALK] <dresser>', '[FIND] <dresser>', '[OPEN] <dresser>', '[FIND] <clothes_shirt>', '[GRAB] <clothes_shirt>', '[PUTON] <clothes_shirt>']
}

Input:
Scene_Objects:['fork', 'pot', 'tablelamp', 'crayon', 'toilet', 'bathroom', 'cat', 'ceilingfan', 'drawing', 'cpuscreen', 'hanger', 'bathroom_counter', 'floor', 'ceiling', 'phone', 'desk', 'faucet', 'shower', 'oil', 'clothes_pants', 'pillow', 'wall', 'bench', 'photoframe', 'television', 'shaving_cream', 'shoes', 'sink', 'bathroom_cabinet', 'light']
Task:Clean sink
response:

Take a premoistened cleaning wipe and wipe down top of sink and faucet.  Next clean the sink bowl.  Let air dry.

[WALK] <bathroom>
[WALK] <rag>
[FIND] <rag>
[GRAB] <rag>
[WALK] <sink>
[FIND] <faucet>
[WIPE] <faucet>
[WIPE] <sink>
[PUTOBJBACK] <rag>


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

Here is an example plan to achieve a goal for reference:
Scene_Objects:['filing_cabinet', 'tea', 'ceilingfan', 'drawing', 'floor', 'bookshelf', 'ceilinglamp', 'shower', 'window', 'couch', 'food_orange', 'towel', 'dining_room', 'wall', 'powersocket', 'television', 'tray', 'wooden_spoon', 'rag', 'lighter', 'towel_rack', 'pencil', 'dresser', 'clothes_dress', 'hairdryer', 'sink', 'bathroom_cabinet', 'table', 'dishwasher', 'clothes_shirt']
Task:Relax on sofa
response:
{
    "thoughts": walk to living room, find sofa, sit in sofa,
    "actions": ['[WALK] <home_office>', '[WALK] <couch>', '[FIND] <couch>', '[WALK] <couch>', '[SIT] <couch>']
}

Input:
Scene_Objects:['filing_cabinet', 'measuring_cup', 'chair', 'ground_coffee', 'trashcan', 'orchid', 'drawing', 'cpuscreen', 'longboard', 'floor', 'ceiling', 'desk', 'tea_bag', 'keyboard', 'bookshelf', 'computer', 'ceilinglamp', 'mat', 'mousepad', 'wall', 'powersocket', 'cup', 'television', 'curtain', 'doorjamb', 'mouse', 'door', 'maindoor', 'light', 'table']
Task:Hang pictures
response:

My daughter was a week early which threw us for a loop. I'm still hanging pictures in her nursery.

[WALK] <bedroom>
[WALK] <drawing>
[FIND] <drawing>
[GRAB] <drawing>
[FIND] <wall>
[PUTBACK] <drawing> <wall>
[TURNTO] <drawing>
[LOOKAT] <drawing>
[FIND] <drawing>
[GRAB] <drawing>
[PUTBACK] <drawing> <wall>
[TURNTO] <drawing>
[LOOKAT] <drawing>


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

Here is an example plan to achieve a goal for reference:
Scene_Objects:['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:
{
    "thoughts": today morning i went to bathroom and took my toothbrush and paste from tooth brush holder and brushed and cleaned my teeth well,
    "actions": ['[WALK] <bathroom>', '[WALK] <toothbrush_holder>', '[FIND] <toothbrush_holder>', '[FIND] <tooth_paste>', '[GRAB] <tooth_paste>', '[FIND] <toothbrush>', '[GRAB] <toothbrush>', '[PUTBACK] <tooth_paste> <toothbrush_holder>', '[WALK] <water>', '[FIND] <water>', '[GRAB] <water>', '[POUR] <water> <toothbrush>']
}

Input:
Scene_Objects:['dry_pasta', 'pot', 'microwave', 'walllamp', 'food_butter', 'knifeblock', 'drawing', 'floor', 'ceiling', 'bookshelf', 'keyboard', 'toaster', 'tvstand', 'balanceball', 'picture', 'shower', 'oil', 'food_peanut_butter', 'pillow', 'wall', 'oven', 'television', 'coin', 'diary', 'mouse', 'cupboard', 'bag', 'bathroom_cabinet', 'vase', 'shoe_rack']
Task:Make popcorn
response:

Lay popcorn bag flat inside microwave and press popcorn button to start.

[WALK] <dining_room>
[WALK] <food_food>
[FIND] <food_food>
[GRAB] <food_food>
[WALK] <microwave>
[TURNTO] <microwave>
[OPEN] <microwave>
[PUTIN] <food_food> <microwave>
[CLOSE] <microwave>
[SWITCHON] <microwave>


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', 'band-aids', 'toothbrush', 'orchid', 'phone', 'desk', 'keyboard', 'bookshelf', 'computer', 'toaster', 'faucet', 'picture', 'shower', 'mousepad', 'candle', 'food_orange', 'oven', 'basket_for_clothes', 'bed', 'check', 'food_food', 'television', 'tray', 'after_shave', 'headset', 'comb', 'dresser', 'laundry_detergent', 'napkin', 'bathroom_cabinet']
Task:Sit in chair
response:
{
    "thoughts": I sit in a chair to rest and eat.,
    "actions": ['[WALK] <dining_room>', '[WALK] <chair>', '[FIND] <chair>', '[PULL] <chair>', '[SIT] <chair>']
}

Input:
Scene_Objects:['pot', 'chair', 'drawing', 'bathroom_counter', 'floor', 'ceiling', 'mail', 'toaster', 'mat', 'faucet', 'stereo', 'window', 'wall', 'oven', 'powersocket', 'cup', 'photoframe', 'television', 'tray', 'food_onion', 'centerpiece', 'hairbrush', 'cupboard', 'sink', 'spoon', 'bathroom_cabinet', 'vase', 'soap', 'tooth_paste', 'hands_both']
Task:Wash hands
response:

[WALK] <bathroom>
[WALK] <sink>
[FIND] <sink>
[TURNTO] <sink>
[FIND] <faucet>
[SWITCHON] <faucet>
[FIND] <soap>
[GRAB] <soap>
[FIND] <hands_both>
[SCRUB] <hands_both>
[PUTOBJBACK] <soap>
[RINSE] <hands_both>
[SWITCHOFF] <faucet>


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

Here is an example plan to achieve a goal for reference:
Scene_Objects:['fork', 'tablelamp', 'microwave', 'toilet', 'freezer', 'trashcan', 'food_carrot', 'drawing', 'floor', 'ceiling', 'mat', 'ceilinglamp', 'shower', 'couch', 'wall', 'novel', 'food_food', 'coffe_maker', 'doorjamb', 'mouse', 'kitchen_counter', 'dresser', 'cupboard', 'door', 'sink', 'home_office', 'instrument_guitar', 'bathroom_cabinet', 'table', 'dirt']
Task:Added meat to freezer
response:
{
    "thoughts": After shopping for groceries, i returned home, i walked to the dining room and placed meat items in freezer located in the dining room. I opened up the bags from the grocery store, removed all the meat items, and after opening the freezer door, i placed the meat items into the freezer, and closed the door.,
    "actions": ['[WALK] <dining_room>', '[WALK] <freezer>', '[FIND] <freezer>', '[OPEN] <freezer>', '[FIND] <food_food>', '[GRAB] <food_food>', '[PUTBACK] <food_food> <freezer>', '[CLOSE] <freezer>']
}

Input:
Scene_Objects:['dry_pasta', 'tablelamp', 'nail_polish', 'food_carrot', 'dough', 'knife', 'drawing', 'floor', 'ceiling', 'character', 'desk', 'alcohol', 'table_cloth', 'mat', 'tvstand', 'window', 'couch', 'food_orange', 'wall', 'oven', 'photoframe', 'check', 'television', 'doorjamb', 'console', 'food_steak', 'sink', 'bathroom_cabinet', 'table', 'home_office']
Task:Put out flowers
response:

Place a flower centrepiece on the entrance hall table.

[WALK] <home_office>
[WALK] <centerpiece>
[FIND] <centerpiece>
[GRAB] <centerpiece>
[WALK] <table>
[PUTBACK] <centerpiece> <table>


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

Here is an example plan to achieve a goal for reference:
Scene_Objects:['microwave', 'chair', 'hanger', 'bathroom_counter', 'character', 'keyboard', 'bookshelf', 'computer', 'stovefan', 'plate', 'tvstand', 'faucet', 'shower', 'dish_soap', 'mousepad', 'wall', 'wall_clock', 'oven', 'photoframe', 'bed', 'television', 'tray', 'towel_rack', 'dresser', 'door', 'sink', 'bathroom_cabinet', 'table', 'dishwasher', 'dirt']
Task:Wash dishes with dishwasher
response:
{
    "thoughts": walk into kitchen, find dishwasher, put plates in dishwasher, put soap in dishwasher, turn on dishwasher,
    "actions": ['[WALK] <dining_room>', '[WALK] <dishwasher>', '[FIND] <dishwasher>', '[OPEN] <dishwasher>', '[FIND] <dish_soap>', '[GRAB] <dish_soap>', '[PUTBACK] <dish_soap> <dishwasher>', '[FIND] <plate>', '[GRAB] <plate>', '[PUTBACK] <plate> <dishwasher>', '[FIND] <plate>', '[GRAB] <plate>', '[PUTBACK] <plate> <dishwasher>', '[CLOSE] <dishwasher>', '[SWITCHON] <dishwasher>']
}

Input:
Scene_Objects:['chair', 'drawing', 'hanger', 'floor', 'phone', 'bedroom', 'purse', 'toaster', 'laptop', 'plate', 'ceilinglamp', 'tooth_paste', 'form', 'food_kiwi', 'wall', 'bench', 'powersocket', 'photoframe', 'food_food', 'television', 'centerpiece', 'doorjamb', 'diary', 'dresser', 'cupboard', 'door', 'maindoor', 'table', 'light', 'board_game']
Task:Eat
response:

[WALK] <dining_room>
[WALK] <table>
[FIND] <chair>
[PULL] <chair>
[SIT] <chair>
[FIND] <plate>
[FIND] <food_food>
[GRAB] <food_food>
[PUTBACK] <food_food> <plate>
[EAT] <plate>


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

Here is an example plan to achieve a goal for reference:
Scene_Objects:['sponge', 'pot', 'juice', 'cd_player', 'toilet', 'freezer', 'trashcan', 'bedroom', 'remote_control', 'button', 'clothes_jacket', 'toaster', 'laptop', 'ceilinglamp', 'plate', 'homework', 'dining_room', 'broom', 'bench', 'tape', 'keys', 'coffe_maker', 'television', 'towel_rack', 'hair', 'cupboard', 'maindoor', 'sink', 'clothes_skirt', 'vase']
Task:Listen to music
response:
{
    "thoughts": I walk to my living room. Find CD player. Plugin the CD player to Power. Also find the remote control. Push the Botton,
    "actions": ['[WALK] <home_office>', '[WALK] <cd_player>', '[FIND] <cd_player>', '[PLUGIN] <cd_player>', '[FIND] <remote_control>', '[GRAB] <remote_control>', '[FIND] <button>', '[PUSH] <button>']
}

Input:
Scene_Objects:['fork', 'drawing', 'cpuscreen', 'ceiling', 'character', 'bedroom', 'man', 'keyboard', 'table_cloth', 'brush', 'stovefan', 'balanceball', 'picture', 'mousepad', 'couch', 'bowl', 'nightstand', 'pasta', 'cup', 'food_cheese', 'photoframe', 'curtain', 'shaving_cream', 'cards', 'laundry_detergent', 'maindoor', 'sink', 'napkin', 'home_office', 'bathroom_cabinet']
Task:Answer door
response:

Wait until doorbell rings, look to see who it is outside and open the door if you feel so inclined.

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


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

Here is an example plan to achieve a goal for reference:
Scene_Objects:['sponge', 'dry_pasta', 'tablelamp', 'walllamp', 'detergent', 'milk', 'orchid', 'floor', 'ceiling', 'button', 'toaster', 'faucet', 'wall', 'box', 'basket_for_clothes', 'keys', 'coffe_maker', 'food_food', 'curtain', 'food_sugar', 'kitchen_counter', 'dresser', 'cupboard', 'controller', 'bathtub', 'sink', 'home_office', 'coffee_cup', 'dishwasher', 'clothes_skirt']
Task:Make coffee
response:
{
    "thoughts": walk to kitchen, look at the coffee maker, open the coffee maker, find milk, suger and water, mix that all, put into coffee maker, switch on the coffee maker, wait for few mins, push the coffee button in coffee maker, we get coffee in coffee cup, drink coffee,
    "actions": ['[WALK] <dining_room>', '[WALK] <coffe_maker>', '[FIND] <coffe_maker>', '[TURNTO] <coffe_maker>', '[LOOKAT] <coffe_maker>', '[OPEN] <coffe_maker>', '[FIND] <milk>', '[GRAB] <milk>', '[PUTBACK] <milk> <coffe_maker>', '[FIND] <food_sugar>', '[FIND] <coffee_cup>', '[GRAB] <coffee_cup>', '[PUTBACK] <coffee_cup> <coffe_maker>', '[SWITCHON] <coffe_maker>', '[FIND] <button>', '[PUSH] <button>', '[GRAB] <coffee_cup>', '[DRINK] <coffee_cup>']
}

Input:
Scene_Objects:['sheets', 'tablelamp', 'drawing', 'knifeblock', 'cpuscreen', 'floor', 'phone', 'mop_bucket', 'bookmark', 'toaster', 'ceilinglamp', 'shoe-shine_kit', 'mat', 'stovefan', 'window', 'iron', 'couch', 'wall', 'food_cheese', 'photoframe', 'coffee_table', 'novel', 'video_game_controller', 'television', 'mouse', 'maindoor', 'bag', 'home_office', 'table', 'clothes_shirt']
Task:Read book
response:

Sit down in recliner.  Pick up novel off of coffee table.  Open novel to last read page.  Begin reading

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


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

Here is an example plan to achieve a goal for reference:
Scene_Objects:['chair', 'walllamp', 'bills', 'cpuscreen', 'wallshelf', 'hanger', 'floor', 'ceiling', 'shampoo', 'desk', 'keyboard', 'computer', 'ceilinglamp', 'mat', 'mousepad', 'closetdrawer', 'wall', 'powersocket', 'television', 'toothbrush_holder', 'wine', 'doorjamb', 'mouse', 'dresser', 'hairbrush', 'controller', 'clothes_dress', 'home_office', 'light', 'table']
Task:Turn on computer
response:
{
    "thoughts": Press the power button on the computer to turn it on,
    "actions": ['[WALK] <home_office>', '[WALK] <computer>', '[SWITCHON] <computer>']
}

Input:
Scene_Objects:['spectacles', 'ceilingfan', 'food_carrot', 'toothbrush', 'drawing', 'knife', 'floor', 'ceiling', 'bookshelf', 'keyboard', 'computer', 'ceilinglamp', 'tvstand', 'balanceball', 'faucet', 'window', 'couch', 'wall', 'cup', 'photoframe', 'light_bulb', 'coffe_maker', 'television', 'tray', 'curtain', 'pencil', 'maindoor', 'table', 'light', 'coffee']
Task:Watch TV
response:

Turn TV on to TV channel and sit down on the couch and watch TV.

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


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

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

Input:
Scene_Objects:['filing_cabinet', 'tablelamp', 'dog', 'freezer', 'dough', 'knifeblock', 'knife', 'hanger', 'bathroom_counter', 'ceiling', 'toaster', 'tvstand', 'faucet', 'couch', 'pasta', 'powersocket', 'oven', 'photoframe', 'novel', 'television', 'wooden_spoon', 'curtain', 'coffee_pot', 'mouse', 'dresser', 'door', 'sink', 'home_office', 'light', 'bathroom_cabinet']
Task:Greet guests
response:

[WALK] <home_office>
[WALK] <child>
[FIND] <child>
[GREET] <child>


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

Here is an example plan to achieve a goal for reference:
Scene_Objects:['measuring_cup', 'microwave', 'chair', 'freezer', 'nail_polish', 'bathroom', 'food_butter', 'knifeblock', 'cpuscreen', 'hanger', 'ceiling', 'dvd_player', 'stamp', 'bookshelf', 'keyboard', 'computer', 'stovefan', 'mat', 'tvstand', 'iron', 'nightstand', 'oven', 'cutting_board', 'check', 'television', 'coin', 'tray', 'doorjamb', 'bathroom_cabinet', 'teeth']
Task:Answer door
response:
{
    "thoughts": Walk up to the door.  Open the door and greet whomever is out side,
    "actions": ['[WALK] <home_office>', '[WALK] <man>', '[FIND] <man>', '[GREET] <man>']
}

Input:
Scene_Objects:['pot', 'mop', 'toilet', 'chair', 'freezer', 'ceilingfan', 'drawing', 'knifeblock', 'cpuscreen', 'floor', 'ceiling', 'remote_control', 'computer', 'button', 'ceilinglamp', 'tvstand', 'balanceball', 'window', 'couch', 'wall', 'wall_clock', 'bench', 'television', 'wine', 'curtain', 'coffee_pot', 'door', 'sink', 'spoon', 'table']
Task:Watch TV
response:

I watch Netflix from about 8:30 to 10:30 every night. I usually watch TV shows.

[WALK] <home_office>
[WALK] <wall_clock>
[FIND] <wall_clock>
[TURNTO] <wall_clock>
[LOOKAT] <wall_clock>
[FIND] <couch>
[SIT] <couch>
[FIND] <remote_control>
[GRAB] <remote_control>
[FIND] <television>
[SWITCHON] <television>
[PUTOBJBACK] <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:['chair', 'band-aids', 'trashcan', 'dough', 'knifeblock', 'cpuscreen', 'hanger', 'floor', 'ceiling', 'shampoo', 'dvd_player', 'desk', 'bookshelf', 'keyboard', 'computer', 'stovefan', 'mat', 'tvstand', 'shower', 'mousepad', 'food_orange', 'wall', 'oven', 'keys', 'mouse', 'shoes', 'hair', 'dishwasher', 'vase', 'coffee']
Task:Read book
response:
{
    "thoughts": find a book to read. sit down. read the book.,
    "actions": ['[WALK] <home_office>', '[WALK] <novel>', '[FIND] <novel>', '[GRAB] <novel>', '[WALK] <chair>', '[SIT] <chair>', '[READ] <novel>']
}

Input:
Scene_Objects:['filing_cabinet', 'tea', 'bathroom', 'ceilingfan', 'milk', 'drawing', 'hanger', 'floor', 'ceiling', 'phone', 'desk', 'bookshelf', 'computer', 'ceilinglamp', 'tvstand', 'balanceball', 'mat', 'window', 'shoe-shine_kit', 'couch', 'food_jam', 'microphone', 'wall', 'nightstand', 'oven', 'cutting_board', 'television', 'curtain', 'pencil', 'table']
Task:Watch TV
response:

We sit all around the television and watch a program.

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


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

Here is an example plan to achieve a goal for reference:
Scene_Objects:['tablelamp', 'mop', 'freezer', 'food_carrot', 'drawing', 'hanger', 'floor', 'ceiling', 'character', 'desk', 'bookshelf', 'table_cloth', 'faucet', 'mousepad', 'closetdrawer', 'couch', 'pillow', 'wall', 'nightstand', 'powersocket', 'bed', 'keys', 'newspaper', 'food_rice', 'doorjamb', 'dresser', 'door', 'bathroom_cabinet', 'light', 'scrabble']
Task:Turn light off
response:
{
    "thoughts": Put the light switch into the down, or off, position.,
    "actions": ['[WALK] <bedroom>', '[WALK] <light>', '[SWITCHOFF] <light>']
}

Input:
Scene_Objects:['tablelamp', 'measuring_cup', 'toilet', 'chair', 'walllamp', 'trashcan', 'food_carrot', 'clothes_underwear', 'hanger', 'longboard', 'floor', 'ceiling', 'toaster', 'electric_shaver', 'couch', 'wall', 'nightstand', 'oven', 'cup', 'coffe_maker', 'food_food', 'television', 'cards', 'mouse', 'kitchen_counter', 'maindoor', 'home_office', 'light', 'dishwasher', 'coffee']
Task:Make coffee
response:

[WALK] <dining_room>
[WALK] <coffe_maker>
[FIND] <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:['fork', 'tablelamp', 'food_ice_cream', 'toothbrush', 'drawing', 'cpuscreen', 'hanger', 'bathroom_counter', 'purse', 'faucet', 'window', 'towel', 'wall', 'toy', 'bed', 'light_bulb', 'novel', 'coffe_maker', 'television', 'water', 'tray', 'curtain', 'towel_rack', 'kitchen_counter', 'dresser', 'maindoor', 'sink', 'tooth_paste', 'clothes_shirt', 'teeth']
Task:Wash teeth
response:
{
    "thoughts": Walk to bathroom. Find tooth paste, tooth brush and water. Squeeze tooth paste on tooth brush. Wash teeth.,
    "actions": ['[WALK] <bathroom>', '[WALK] <tooth_paste>', '[FIND] <tooth_paste>', '[FIND] <toothbrush>', '[FIND] <water>', '[SQUEEZE] <tooth_paste>', '[FIND] <teeth>', '[WASH] <teeth>']
}

Input:
Scene_Objects:['spectacles', 'chair', 'walllamp', 'ceilingfan', 'drawing', 'floor', 'ceiling', 'character', 'bookshelf', 'remote_control', 'toaster', 'ceilinglamp', 'tvstand', 'balanceball', 'mat', 'window', 'shower', 'stereo', 'couch', 'wall', 'cutting_board', 'cup', 'food_cheese', 'novel', 'food_food', 'television', 'wine', 'curtain', 'door', 'table']
Task:Watch movie
response:

Sit down on couch in front of TV.  Use remote to turn on the TV

[WALK] <home_office>
[WALK] <couch>
[FIND] <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:['food_pizza', 'toilet', 'freezer', 'drawing', 'cpuscreen', 'floor', 'ceiling', 'envelope', 'table_cloth', 'stovefan', 'ceilinglamp', 'mat', 'shower', 'stereo', 'mousepad', 'towel', 'wall', 'powersocket', 'photoframe', 'bed', 'toilet_paper', 'tray', 'curtain', 'doorjamb', 'dresser', 'controller', 'door', 'food_steak', 'light', 'tooth_paste']
Task:Take shower
response:
{
    "thoughts": walk to bathroom , find shower , take a shower,
    "actions": ['[WALK] <bathroom>', '[WALK] <shower>', '[FIND] <shower>']
}

Input:
Scene_Objects:['sponge', 'pot', 'crayon', 'tea', 'chair', 'walllamp', 'nail_polish', 'trashcan', 'knifeblock', 'bathroom_counter', 'floor', 'ceiling', 'bookshelf', 'mat', 'faucet', 'picture', 'wall', 'oven', 'food_food', 'check', 'television', 'ice', 'tray', 'rag', 'pencil', 'kitchen_counter', 'dresser', 'cupboard', 'sink', 'spoon']
Task:Clean
response:

Take out a rag. Turn on faucet and get water on the rag. Clean counter off.

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


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

Here is an example plan to achieve a goal for reference:
Scene_Objects:['filing_cabinet', 'microwave', 'toilet', 'bathroom', 'food_butter', 'milk', 'orchid', 'floor', 'ceiling', 'character', 'bedroom', 'desk', 'bookshelf', 'computer', 'ceilinglamp', 'shower', 'window', 'mousepad', 'closetdrawer', 'couch', 'clothes_hat', 'wall', 'coffe_maker', 'television', 'tray', 'curtain', 'dresser', 'bathtub', 'bathroom_cabinet', 'table']
Task:Pick up phone
response:
{
    "thoughts": Walk to the entrance hall. Find the telephone. Grab the telephone.,
    "actions": ['[WALK] <home_office>', '[WALK] <phone>', '[FIND] <phone>', '[WALK] <phone>', '[GRAB] <phone>']
}

Input:
Scene_Objects:['juice', 'measuring_cup', 'microwave', 'freezer', 'drawing', 'bathroom_counter', 'floor', 'ceiling', 'phone', 'desk', 'face', 'mop_bucket', 'tvstand', 'faucet', 'food_peanut_butter', 'towel', 'wall', 'oven', 'face_soap', 'tape', 'photoframe', 'bed', 'keys', 'rag', 'cards', 'comb', 'cupboard', 'sink', 'spoon', 'bathroom_cabinet']
Task:Wash face
response:

Turn on water faucet. Get rag wet. Get face soap out. Squirt face soap in hands and put it on face. Rub soap into face. Wash soap off of face. Dry face off on the hand towel. Hang out rag and hand towel.

[WALK] <bathroom>
[WALK] <sink>
[FIND] <rag>
[GRAB] <rag>
[FIND] <faucet>
[SWITCHON] <faucet>
[WASH] <rag>
[FIND] <face_soap>
[GRAB] <face_soap>
[POUR] <face_soap> <rag>
[PUTOBJBACK] <face_soap>
[FIND] <face>
[SCRUB] <face>
[PUTBACK] <rag> <sink>
[RINSE] <face>
[RINSE] <rag>
[SWITCHOFF] <faucet>
[GRAB] <rag>
[PUTOBJBACK] <rag>
[FIND] <towel>
[GRAB] <towel>
[WIPE] <face>
[PUTOBJBACK] <towel>