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:['tablelamp', 'walllamp', 'drawing', 'orchid', 'wallshelf', 'floor', 'ceiling', 'folder', 'bookshelf', 'remote_control', 'button', 'mat', 'tvstand', 'ceilinglamp', 'shower', 'window', 'couch', 'pillow', 'wall', 'powersocket', 'photoframe', 'television', 'curtain', 'doorjamb', 'towel_rack', 'mouse', 'door', 'sink', 'table', 'light']
Task:Change TV channel
response:

I go the living room, look for my tv remote control, take the control and then sit down on the couch and turn on the TV and push the buttons on the remote control to change the channel.

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


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

Here is an example plan to achieve a goal for reference:
Scene_Objects:['filing_cabinet', 'measuring_cup', 'walllamp', 'bathroom', 'drawing', 'wallshelf', 'floor', 'ceiling', 'bookshelf', 'bookmark', 'mat', 'tvstand', 'ceilinglamp', 'window', 'couch', 'pillow', 'wall', 'bench', 'cup', 'photoframe', 'novel', 'check', 'coffe_maker', 'television', 'tray', 'curtain', 'doorjamb', 'bathroom_cabinet', 'light', 'table']
Task:Read book
response:
{
    "thoughts": I go to the book case, I select a book, I go back and sit down, then I read.,
    "actions": ['[WALK] <filing_cabinet>', '[FIND] <novel>', '[GRAB] <novel>', '[WALK] <couch>', '[READ] <novel>']
}

Input:
Scene_Objects:['walllamp', 'bathroom', 'drawing', 'orchid', 'wallshelf', 'floor', 'ceiling', 'bookshelf', 'remote_control', 'toaster', 'mat', 'tvstand', 'ceilinglamp', 'shower', 'window', 'couch', 'pillow', 'wall', 'powersocket', 'photoframe', 'television', 'curtain', 'after_shave', 'doorjamb', 'mouse', 'dresser', 'door', 'table', 'light', 'dishwasher']
Task:Change TV channel
response:

I go in the living room. Then I find the remote, sit on the couch and turn on the television. Then I use the remote the change the TV channel.

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


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

Here is an example plan to achieve a goal for reference:
Scene_Objects:['pot', 'crayon', 'freezer', 'bathroom', 'trashcan', 'dough', 'knifeblock', 'orchid', 'floor', 'ceiling', 'clothes_jacket', 'brush', 'ceilinglamp', 'mat', 'balanceball', 'clothes_socks', 'couch', 'microphone', 'form', 'wall', 'food_food', 'check', 'oven_mitts', 'wine', 'mouse', 'cupboard', 'food_steak', 'spoon', 'table', 'tooth_paste']
Task:Cook some food
response:
{
    "thoughts": Go kitchen and make something for eat,
    "actions": ['[WALK] <dining_room>', '[WALK] <freezer>', '[OPEN] <freezer>', '[FIND] <food_food>']
}

Input:
Scene_Objects:['fork', 'filing_cabinet', 'juice', 'food_ice_cream', 'bathroom', 'orchid', 'floor', 'ceiling', 'phone', 'shampoo', 'bookshelf', 'tvstand', 'stereo', 'shower', 'couch', 'wall', 'wall_clock', 'powersocket', 'oven', 'photoframe', 'food_food', 'television', 'after_shave', 'doorjamb', 'mouse', 'dresser', 'controller', 'home_office', 'light', 'coffee']
Task:Pick up phone
response:

first i will go to home office and switch on the lights and answer the call after then i will put back it and switch off the lights and close the door

[RUN] <home_office>
[WALK] <light>
[FIND] <light>
[SWITCHON] <light>
[FIND] <phone>
[GRAB] <phone>
[PUTOBJBACK] <phone>
[SWITCHOFF] <light>


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

Here is an example plan to achieve a goal for reference:
Scene_Objects:['food_pizza', 'tea', 'microwave', 'walllamp', 'bathroom', 'trashcan', 'orchid', 'floor', 'phone', 'keyboard', 'food_cake', 'toaster', 'stovefan', 'plate', 'mat', 'dish_soap', 'oil', 'pillow', 'wall', 'cup', 'photoframe', 'coffe_maker', 'curtain', 'centerpiece', 'mouse', 'kitchen_counter', 'comb', 'cupboard', 'bathroom_cabinet', 'dishwasher']
Task:Wash dishes with dishwasher
response:
{
    "thoughts": I go to the kitchen and open the dishwasher. I fill it up with dirty dishes and glasses. Then I put dish soap in the dishwasher, close it and turn it on.,
    "actions": ['[WALK] <dining_room>', '[WALK] <dishwasher>', '[FIND] <dishwasher>', '[OPEN] <dishwasher>', '[FIND] <plate>', '[GRAB] <plate>', '[PUTBACK] <plate> <dishwasher>', '[FIND] <plate>', '[GRAB] <plate>', '[PUTBACK] <plate> <dishwasher>', '[FIND] <plate>', '[GRAB] <plate>', '[PUTBACK] <plate> <dishwasher>', '[FIND] <plate>', '[GRAB] <plate>', '[PUTBACK] <plate> <dishwasher>', '[FIND] <plate>', '[GRAB] <plate>', '[PUTBACK] <plate> <dishwasher>', '[FIND] <cup>', '[GRAB] <cup>', '[PUTBACK] <cup> <dishwasher>', '[FIND] <dish_soap>', '[GRAB] <dish_soap>', '[PUTBACK] <dish_soap> <dishwasher>', '[CLOSE] <dishwasher>', '[SWITCHON] <dishwasher>']
}

Input:
Scene_Objects:['sheets', 'sponge', 'tablelamp', 'measuring_cup', 'toilet', 'chair', 'jelly', 'freezer', 'ground_coffee', 'trashcan', 'toothbrush', 'drawing', 'clothes_underwear', 'phone', 'desk', 'keyboard', 'computer', 'mousepad', 'television', 'towel_rack', 'cd', 'hairbrush', 'pajamas', 'dresser', 'controller', 'door', 'bathtub', 'sink', 'bathroom_cabinet', 'tooth_paste']
Task:Wash teeth
response:

before going to bed or when wake up earily morning brush teeth

[WALK] <bathroom>
[WALK] <tooth_paste>
[FIND] <tooth_paste>
[GRAB] <tooth_paste>
[FIND] <toothbrush>
[GRAB] <toothbrush>


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

Here is an example plan to achieve a goal for reference:
Scene_Objects:['pot', 'tablelamp', 'chair', 'freezer', 'walllamp', 'milk', 'floor', 'keyboard', 'table_cloth', 'stovefan', 'mat', 'tvstand', 'faucet', 'window', 'couch', 'clothes_hat', 'pillow', 'dining_room', 'toy', 'basket_for_clothes', 'coffe_maker', 'video_game_controller', 'tray', 'doorjamb', 'kettle', 'dresser', 'cupboard', 'clothes_dress', 'sink', 'table']
Task:Pick up toys
response:
{
    "thoughts": Bend down and pick up the toys off of the floor.,
    "actions": ['[WALK] <bedroom>', '[WALK] <toy>', '[FIND] <toy>', '[GRAB] <toy>', '[WALK] <dresser>', '[OPEN] <dresser>', '[PUTIN] <toy> <dresser>', '[FIND] <toy>', '[GRAB] <toy>', '[WALK] <dresser>', '[PUTIN] <toy> <dresser>', '[FIND] <toy>', '[WALK] <dresser>', '[GRAB] <toy>', '[PUTIN] <toy> <dresser>', '[CLOSE] <dresser>']
}

Input:
Scene_Objects:['chair', 'freezer', 'trashcan', 'drawing', 'bathroom_counter', 'floor', 'ceiling', 'phone', 'bedroom', 'bookshelf', 'keyboard', 'stovefan', 'shoe-shine_kit', 'faucet', 'electric_shaver', 'towel', 'wall', 'powersocket', 'photoframe', 'coffee_filter', 'coin', 'tray', 'food_onion', 'doorjamb', 'towel_rack', 'dishrack', 'sink', 'bathroom_cabinet', 'soap', 'hands_both']
Task:Wash hands
response:

Go to the bathroom. Turn on the sink. Rinse hands. Apply soap and scrub your hands together. Rinse hands again. Turn off faucet. Dry hands on a towel.

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


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

Here is an example plan to achieve a goal for reference:
Scene_Objects:['tablelamp', 'chair', 'walllamp', 'drawing', 'orchid', 'cpuscreen', 'wallshelf', 'hanger', 'floor', 'ceiling', 'phone', 'desk', 'keyboard', 'computer', 'mail', 'mat', 'ceilinglamp', 'tvstand', 'mousepad', 'couch', 'pillow', 'wall', 'nightstand', 'oven', 'television', 'doorjamb', 'mouse', 'dresser', 'door', 'home_office']
Task:Check email
response:
{
    "thoughts": Turn on the computer.  Wait for it to load.  Get online.  Go to the email service.  Open the email.  Read the email.,
    "actions": ['[WALK] <home_office>', '[WALK] <chair>', '[FIND] <chair>', '[SIT] <chair>', '[FIND] <computer>', '[SWITCHON] <computer>', '[FIND] <keyboard>', '[TYPE] <keyboard>', '[FIND] <mail>', '[GRAB] <mail>', '[READ] <mail>']
}

Input:
Scene_Objects:['sheets', 'microwave', 'toilet', 'chair', 'dog', 'cpuscreen', 'keyboard', 'ceilinglamp', 'plate', 'laptop', 'faucet', 'window', 'stereo', 'oil', 'food_noodles', 'mousepad', 'dining_room', 'nightstand', 'food_food', 'check', 'wine', 'curtain', 'after_shave', 'comb', 'dresser', 'napkin', 'home_office', 'table', 'bathroom_cabinet', 'light']
Task:Listen to music
response:

I reach out arm. I put hand on radio. I turn on radio. I pick a station.

[WALK] <bedroom>
[WALK] <stereo>
[TOUCH] <stereo>
[TURNTO] <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:['sheets', 'tablelamp', 'dough', 'drawing', 'cpuscreen', 'hanger', 'floor', 'ceiling', 'desk', 'keyboard', 'computer', 'mat', 'window', 'mousepad', 'closetdrawer', 'pillow', 'wall', 'nightstand', 'powersocket', 'bed', 'novel', 'check', 'curtain', 'mouse', 'pencil', 'dresser', 'light', 'table', 'vase', 'shoe_rack']
Task:Read book
response:
{
    "thoughts": Put child in bed, sit down,read book.,
    "actions": ['[WALK] <bedroom>', '[WALK] <dresser>', '[OPEN] <dresser>', '[FIND] <novel>', '[GRAB] <novel>', '[FIND] <bed>', '[SIT] <bed>', '[READ] <novel>']
}

Input:
Scene_Objects:['pot', 'microwave', 'toilet', 'chair', 'freezer', 'walllamp', 'trashcan', 'wallshelf', 'hanger', 'bathroom_counter', 'floor', 'bookshelf', 'stovefan', 'ceilinglamp', 'tvstand', 'faucet', 'homework', 'pillow', 'wall', 'pasta', 'powersocket', 'photoframe', 'oven_mitts', 'doorjamb', 'kitchen_counter', 'comb', 'door', 'bathtub', 'light', 'dishwasher']
Task:Go to toilet
response:

I walk to bathroom, I open the door of the bathroom, and sit on the toilet.

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


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

Here is an example plan to achieve a goal for reference:
Scene_Objects:['measuring_cup', 'walllamp', 'bathroom', 'drawing', 'orchid', 'hanger', 'floor', 'phone', 'character', 'stamp', 'tea_bag', 'toaster', 'ceilinglamp', 'shoe-shine_kit', 'iron', 'brush', 'window', 'couch', 'food_orange', 'pillow', 'wall', 'bench', 'tray', 'curtain', 'after_shave', 'sink', 'bathroom_cabinet', 'table', 'home_office', 'soap']
Task:Relax on sofa
response:
{
    "thoughts": Sitting down and relaxing on the sofa,
    "actions": ['[WALK] <home_office>', '[WALK] <couch>', '[FIND] <couch>', '[SIT] <couch>']
}

Input:
Scene_Objects:['chair', 'walllamp', 'orchid', 'drawing', 'wallshelf', 'floor', 'ceiling', 'bedroom', 'tea_bag', 'bookshelf', 'keyboard', 'brush', 'mat', 'tvstand', 'ceilinglamp', 'shower', 'window', 'stovefan', 'shoe-shine_kit', 'pillow', 'wall', 'powersocket', 'photoframe', 'novel', 'television', 'wooden_spoon', 'curtain', 'doorjamb', 'bathroom_cabinet', 'light']
Task:Watch TV
response:

Walk into the living room. Sit on the couch. Turn on TV.

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


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

Here is an example plan to achieve a goal for reference:
Scene_Objects:['tablelamp', 'food_ice_cream', 'mop', 'nail_polish', 'detergent', 'trashcan', 'food_carrot', 'drawing', 'hanger', 'longboard', 'floor', 'keyboard', 'ceilinglamp', 'plate', 'faucet', 'window', 'couch', 'wall', 'nightstand', 'powersocket', 'bench', 'novel', 'food_food', 'television', 'wine', 'doorjamb', 'conditioner', 'bathroom_cabinet', 'table', 'clothes_skirt']
Task:Relax on sofa
response:
{
    "thoughts": Walk into the living room. Walk up to the sofa. Sit down on the sofa.,
    "actions": ['[WALK] <home_office>', '[WALK] <couch>', '[SIT] <couch>']
}

Input:
Scene_Objects:['sheets', 'pot', 'food_pizza', 'tablelamp', 'mop', 'chair', 'freezer', 'walllamp', 'dough', 'drawing', 'knifeblock', 'wallshelf', 'orchid', 'floor', 'ceiling', 'mop_bucket', 'toaster', 'stovefan', 'faucet', 'bowl', 'wall', 'oven', 'bench', 'toy', 'tray', 'kitchen_counter', 'dresser', 'cupboard', 'door', 'sink']
Task:Cook some food
response:

go to the kitchen and cook some thing to eat

[WALK] <dining_room>
[WALK] <freezer>
[FIND] <freezer>
[OPEN] <freezer>
[FIND] <oven>
[OPEN] <oven>
[FIND] <food_pizza>
[GRAB] <food_pizza>
[PUTIN] <food_pizza> <oven>
[SWITCHON] <oven>


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

Here is an example plan to achieve a goal for reference:
Scene_Objects:['pot', 'food_bread', 'beer', 'toilet', 'freezer', 'walllamp', 'drawing', 'knifeblock', 'floor', 'ceiling', 'desk', 'toaster', 'mat', 'stovefan', 'shower', 'faucet', 'food_orange', 'nightstand', 'wall', 'powersocket', 'oven', 'photoframe', 'coffe_maker', 'tray', 'doorjamb', 'kitchen_counter', 'cupboard', 'door', 'sink', 'light']
Task:Make toast
response:
{
    "thoughts": Place slices of bread in a toaster ,wait for the bread to pop up .Set aside.,
    "actions": ['[WALK] <dining_room>', '[WALK] <freezer>', '[FIND] <freezer>', '[OPEN] <freezer>', '[FIND] <food_bread>', '[GRAB] <food_bread>', '[CLOSE] <freezer>', '[FIND] <toaster>', '[PLUGIN] <toaster>', '[PUTBACK] <food_bread> <toaster>', '[SWITCHON] <toaster>']
}

Input:
Scene_Objects:['walllamp', 'trashcan', 'drawing', 'orchid', 'wallshelf', 'floor', 'ceiling', 'bookshelf', 'remote_control', 'stovefan', 'mat', 'tvstand', 'ceilinglamp', 'shower', 'window', 'couch', 'pillow', 'dining_room', 'wall', 'powersocket', 'oven', 'photoframe', 'television', 'curtain', 'doorjamb', 'kitchen_counter', 'door', 'home_office', 'table', 'light']
Task:Watch TV
response:

I walk to the Living Room.  I find the remote.  I grab the remote and take a seat on the couch.  I switch on the TV with the remote and  watch the television.

[WALK] <home_office>
[WALK] <remote_control>
[FIND] <remote_control>
[GRAB] <remote_control>
[FIND] <couch>
[SIT] <couch>
[FIND] <television>
[SWITCHON] <television>
[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:['tablelamp', 'blender', 'bathroom', 'detergent', 'food_carrot', 'cpuscreen', 'wallshelf', 'phone', 'bedroom', 'desk', 'remote_control', 'envelope', 'computer', 'mail', 'tvstand', 'shower', 'iron', 'mousepad', 'closetdrawer', 'oven', 'powersocket', 'newspaper', 'novel', 'food_food', 'curtain', 'dresser', 'food_steak', 'sink', 'table', 'shoe_rack']
Task:Watch TV
response:
{
    "thoughts": I walk to the living room and sit on the couch.  I grab the TV remote.  I press the power button on the TV remote and the TV turns on.  I grab the surround sound remote.  I press the power button on the surround sound remote and the system turns on.,
    "actions": ['[WALK] <home_office>', '[WALK] <remote_control>', '[FIND] <remote_control>', '[GRAB] <remote_control>', '[PUSH] <remote_control>', '[FIND] <remote_control>', '[PUSH] <remote_control>']
}

Input:
Scene_Objects:['pot', 'microwave', 'jelly', 'bathroom', 'detergent', 'food_butter', 'drawing', 'needle', 'cpuscreen', 'bathroom_counter', 'character', 'stovefan', 'plate', 'window', 'bowl', 'wall', 'bench', 'cup', 'bed', 'coffe_maker', 'check', 'tray', 'towel_rack', 'kitchen_counter', 'vacuum_cleaner', 'pajamas', 'sink', 'light', 'dishwasher', 'teeth']
Task:Listen to music
response:

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


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

Here is an example plan to achieve a goal for reference:
Scene_Objects:['filing_cabinet', 'juice', 'chair', 'blow_dryer', 'bathroom_counter', 'floor', 'ceiling', 'bedroom', 'toaster', 'laptop', 'deck_of_cards', 'faucet', 'food_noodles', 'closetdrawer', 'food_orange', 'wall', 'nightstand', 'clothes_gloves', 'coffe_maker', 'toilet_paper', 'food_food', 'curtain', 'towel_rack', 'console', 'kitchen_counter', 'shoes', 'cupboard', 'sink', 'spoon', 'dishwasher']
Task:Make coffee
response:
{
    "thoughts": Making coffee,
    "actions": ['[WALK] <dining_room>', '[WALK] <coffe_maker>', '[FIND] <coffe_maker>', '[SWITCHON] <coffe_maker>']
}

Input:
Scene_Objects:['pot', 'tablelamp', 'microwave', 'toilet', 'walllamp', 'detergent', 'food_carrot', 'drawing', 'wallshelf', 'bathroom_counter', 'floor', 'bedroom', 'keyboard', 'bookshelf', 'mat', 'mousepad', 'dining_room', 'wall', 'nightstand', 'bench', 'basket_for_clothes', 'bed', 'photoframe', 'coffe_maker', 'food_food', 'wooden_spoon', 'mouse', 'dresser', 'sink', 'dishwasher']
Task:Go to sleep
response:

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


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

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

Input:
Scene_Objects:['pot', 'walllamp', 'drawing', 'orchid', 'wallshelf', 'floor', 'ceiling', 'bookshelf', 'remote_control', 'computer', 'mat', 'tvstand', 'ceilinglamp', 'shower', 'window', 'mousepad', 'couch', 'pillow', 'wall', 'powersocket', 'bench', 'photoframe', 'check', 'television', 'curtain', 'doorjamb', 'door', 'home_office', 'table', 'light']
Task:Watch TV
response:

Go to the living room. Find the remote. Pick up the remote. Find the sofa. Sit on the sofa. Look at the television. Aim the remote at the television. Press the power button. Flip the channels.

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


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

Here is an example plan to achieve a goal for reference:
Scene_Objects:['fork', 'pot', 'walllamp', 'knife', 'knifeblock', 'cpuscreen', 'hanger', 'kitchen_cabinet', 'floor', 'ceiling', 'tea_bag', 'toaster', 'stovefan', 'plate', 'faucet', 'deck_of_cards', 'tvstand', 'bowl', 'wall', 'oven', 'cup', 'coffe_maker', 'drinking_glass', 'food_donut', 'tray', 'kitchen_counter', 'cupboard', 'sink', 'spoon', 'dishwasher']
Task:Unload dishwasher
response:
{
    "thoughts": Open the dishwasher door. Take out all of the dishes and silverware. Put the dishes and silverware in their drawers and cabinets. Close the dishwasher door.,
    "actions": ['[WALK] <dining_room>', '[WALK] <dishwasher>', '[FIND] <dishwasher>', '[OPEN] <dishwasher>', '[FIND] <drinking_glass>', '[GRAB] <drinking_glass>', '[FIND] <cupboard>', '[OPEN] <cupboard>', '[PUTBACK] <drinking_glass> <cupboard>', '[FIND] <fork>', '[GRAB] <fork>', '[FIND] <kitchen_cabinet>', '[OPEN] <kitchen_cabinet>', '[PUTIN] <fork> <kitchen_cabinet>', '[FIND] <knife>', '[GRAB] <knife>', '[PUTIN] <knife> <kitchen_cabinet>', '[FIND] <spoon>', '[GRAB] <spoon>', '[PUTIN] <spoon> <kitchen_cabinet>', '[FIND] <plate>', '[GRAB] <plate>', '[PUTIN] <plate> <kitchen_cabinet>', '[CLOSE] <kitchen_cabinet>', '[CLOSE] <dishwasher>']
}

Input:
Scene_Objects:['walllamp', 'drawing', 'orchid', 'wallshelf', 'floor', 'ceiling', 'bookshelf', 'remote_control', 'toaster', 'mat', 'tvstand', 'ceilinglamp', 'shower', 'window', 'couch', 'pillow', 'bowl', 'wall', 'powersocket', 'photoframe', 'food_food', 'television', 'curtain', 'doorjamb', 'coffee_pot', 'shaving_cream', 'towel_rack', 'door', 'table', 'light']
Task:Watch TV
response:

I enter the living room and sit on the couch. I grab the remote and 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:['tablelamp', 'mop', 'microwave', 'chair', 'freezer', 'walllamp', 'orchid', 'cpuscreen', 'wallshelf', 'hanger', 'floor', 'ceiling', 'phone', 'desk', 'keyboard', 'computer', 'ceilinglamp', 'tvstand', 'mat', 'mousepad', 'couch', 'pillow', 'wall', 'nightstand', 'newspaper', 'television', 'doorjamb', 'mouse', 'dresser', 'door']
Task:Browse internet
response:
{
    "thoughts": Walk to the Home Office.  Find the computer.  Turn on the computer.,
    "actions": ['[WALK] <home_office>', '[WALK] <computer>', '[FIND] <computer>', '[SWITCHON] <computer>']
}

Input:
Scene_Objects:['chair', 'freezer', 'food_carrot', 'drawing', 'wallshelf', 'bathroom_counter', 'floor', 'ceiling', 'phone', 'keyboard', 'bookshelf', 'toaster', 'window', 'foundation', 'wall', 'bed', 'food_food', 'coffe_maker', 'toothbrush_holder', 'water', 'drinking_glass', 'food_onion', 'mouse', 'kitchen_counter', 'dresser', 'cupboard', 'hair', 'door', 'bathroom_cabinet', 'light']
Task:Drink
response:

im feeling thirsty im going to kitchen and open the freezer where i can find some cold water and im going to drink it to end up my thirst

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


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', 'freezer', 'woman', 'drawing', 'wallshelf', 'bathroom_counter', 'floor', 'man', 'bookshelf', 'keyboard', 'piano_bench', 'stovefan', 'tvstand', 'shower', 'faucet', 'oil', 'dining_room', 'food_kiwi', 'nightstand', 'bench', 'oven', 'powersocket', 'coffe_maker', 'tray', 'curtain', 'towel_rack', 'cupboard', 'door', 'sink', 'light']
Task:Greet guests
response:
{
    "thoughts": Stand next to the door. When the door opens from the outside, greet the guests.,
    "actions": ['[RUN] <home_office>', '[WALK] <woman>', '[FIND] <woman>', '[TURNTO] <woman>', '[LOOKAT] <woman>', '[GREET] <woman>', '[FIND] <man>', '[TURNTO] <man>', '[LOOKAT] <man>', '[GREET] <man>']
}

Input:
Scene_Objects:['water_glass', 'food_bread', 'chair', 'freezer', 'walllamp', 'detergent', 'trashcan', 'drawing', 'desk', 'keyboard', 'bookshelf', 'bookmark', 'stovefan', 'ceilinglamp', 'tvstand', 'shower', 'faucet', 'pillow', 'bowl', 'wall', 'box', 'coffe_maker', 'razor', 'television', 'curtain', 'doorjamb', 'towel_rack', 'door', 'sink', 'bathroom_cabinet']
Task:Drink
response:

Pour water into a glass and drink from the glass.

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


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', 'beer', 'microwave', 'chair', 'freezer', 'ground_coffee', 'floor', 'ceiling', 'mail', 'food_bacon', 'toaster', 'deck_of_cards', 'faucet', 'window', 'wall', 'wall_clock', 'bench', 'cutting_board', 'toy', 'light_bulb', 'coffe_maker', 'coffee_filter', 'water', 'curtain', 'after_shave', 'pencil', 'kitchen_counter', 'pajamas', 'sink', 'light']
Task:Make coffee
response:
{
    "thoughts": Open coffee maker. Put filter in main basket, put ground coffee in filter, fill reservoir with water, turn on coffee maker.,
    "actions": ['[WALK] <dining_room>', '[WALK] <coffe_maker>', '[FIND] <coffe_maker>', '[OPEN] <coffe_maker>', '[FIND] <coffee_filter>', '[GRAB] <coffee_filter>', '[PUTBACK] <coffee_filter> <coffe_maker>', '[FIND] <ground_coffee>', '[GRAB] <ground_coffee>', '[FIND] <ground_coffee>', '[PUTBACK] <ground_coffee> <coffe_maker>', '[WALK] <water>', '[FIND] <water>', '[GRAB] <water>', '[POUR] <water> <coffe_maker>', '[CLOSE] <coffe_maker>', '[SWITCHON] <coffe_maker>']
}

Input:
Scene_Objects:['sheets', 'filing_cabinet', 'microwave', 'ground_coffee', 'knifeblock', 'wallshelf', 'ceiling', 'phone', 'character', 'desk', 'piano_bench', 'stovefan', 'toaster', 'couch', 'clothes_hat', 'pillow', 'bench', 'oven', 'tape', 'cutting_board', 'doorjamb', 'cards', 'mouse', 'dishrack', 'cupboard', 'hairdryer', 'sink', 'clothes_scarf', 'table', 'dishwasher']
Task:Pick up phone
response:

i go find the phone. i pick up the phone

[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:['toilet', 'band-aids', 'drawing', 'orchid', 'kitchen_cabinet', 'floor', 'bathroom_counter', 'phone', 'bookshelf', 'computer', 'stovefan', 'mat', 'plate', 'ceilinglamp', 'tvstand', 'window', 'couch', 'food_peanut_butter', 'pillow', 'wall', 'nightstand', 'bench', 'powersocket', 'oven', 'cutting_board', 'curtain', 'mouse', 'table', 'dishwasher', 'light']
Task:Set up table
response:
{
    "thoughts": Walk to the kitchen. Open the kitchen cabinet. Grab the plate and put it on the table.,
    "actions": ['[WALK] <dining_room>', '[WALK] <kitchen_cabinet>', '[FIND] <kitchen_cabinet>', '[OPEN] <kitchen_cabinet>', '[FIND] <plate>', '[GRAB] <plate>', '[FIND] <table>', '[PUTBACK] <plate> <table>']
}

Input:
Scene_Objects:['fork', 'microwave', 'drawing', 'orchid', 'knifeblock', 'wallshelf', 'floor', 'ceiling', 'phone', 'stamp', 'bedroom', 'remote_control', 'button', 'mat', 'faucet', 'homework', 'couch', 'pillow', 'wall', 'basket_for_clothes', 'coffe_maker', 'television', 'tray', 'curtain', 'doorjamb', 'kitchen_counter', 'door', 'table', 'light', 'laser_pointer']
Task:Change TV channel
response:

go to living room. grab remote control. sit on couch. point remote at tv. push buttons.

[WALK] <home_office>
[WALK] <remote_control>
[FIND] <remote_control>
[GRAB] <remote_control>
[FIND] <couch>
[SIT] <couch>
[TURNTO] <remote_control>
[POINTAT] <remote_control>
[FIND] <button>
[PUSH] <button>


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

Here is an example plan to achieve a goal for reference:
Scene_Objects:['filing_cabinet', 'tablelamp', 'bathroom', 'trashcan', 'drawing', 'orchid', 'floor', 'phone', 'ceiling', 'desk', 'bedroom', 'keyboard', 'computer', 'faucet', 'picture', 'window', 'closetdrawer', 'couch', 'dining_room', 'bed', 'light_bulb', 'keys', 'check', 'video_game_controller', 'tray', 'doorjamb', 'mouse', 'kitchen_counter', 'bathtub', 'home_office']
Task:Pet cat
response:
{
    "thoughts": Petting the cat,
    "actions": ['[WALK] <home_office>', '[WALK] <cat>', '[FIND] <cat>', '[TOUCH] <cat>']
}

Input:
Scene_Objects:['pot', 'walllamp', 'drawing', 'orchid', 'wallshelf', 'cpuscreen', 'floor', 'ceiling', 'bookshelf', 'remote_control', 'keyboard', 'mat', 'tvstand', 'ceilinglamp', 'shower', 'window', 'couch', 'pillow', 'wall', 'powersocket', 'cup', 'photoframe', 'television', 'curtain', 'doorjamb', 'mouse', 'door', 'bathroom_cabinet', 'table', 'light']
Task:Watch TV
response:

You walk to the living room and sit on the sofa. You grab the remote control, look at it and point at the television, you watch television.

[WALK] <home_office>
[WALK] <couch>
[FIND] <couch>
[SIT] <couch>
[FIND] <remote_control>
[GRAB] <remote_control>
[TURNTO] <remote_control>
[LOOKAT] <remote_control>
[FIND] <television>
[TURNTO] <television>
[POINTAT] <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', 'freezer', 'walllamp', 'drawing', 'wallshelf', 'floor', 'character', 'keyboard', 'bookshelf', 'toaster', 'mat', 'tvstand', 'ceilinglamp', 'window', 'closetdrawer', 'couch', 'pillow', 'wall', 'nightstand', 'powersocket', 'wall_clock', 'toilet_paper', 'mouthwash', 'television', 'food_food', 'coffe_maker', 'curtain', 'doorjamb', 'bathroom_cabinet', 'table']
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:['tablelamp', 'microwave', 'wallshelf', 'bathroom_counter', 'floor', 'ceiling', 'bookshelf', 'mat', 'plate', 'faucet', 'tvstand', 'clothes_hat', 'pillow', 'wall', 'oven', 'powersocket', 'newspaper', 'photoframe', 'check', 'coffe_maker', 'doorjamb', 'kitchen_counter', 'dishrack', 'cupboard', 'door', 'sink', 'clothes_scarf', 'table', 'clothes_skirt', 'dishwasher']
Task:Wash dishes by hand
response:

Walking towards sink and look at the leftover plates. Scrape dishes to remove leftover food - use a rubber spatula or paper towel. Fill sink or dishpan with clean, hot water. Then wash and rinse to removing residues. Finally leave it to dry.

[WALK] <dining_room>
[WALK] <kitchen_counter>
[FIND] <plate>
[TURNTO] <plate>
[LOOKAT] <plate>
[GRAB] <plate>
[SCRUB] <plate>
[RINSE] <plate>
[WASH] <plate>
[PUTBACK] <plate> <kitchen_counter>


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

Here is an example plan to achieve a goal for reference:
Scene_Objects:['sponge', 'glue', 'toilet', 'chair', 'detergent', 'dough', 'drawing', 'orchid', 'hanger', 'floor', 'ceiling', 'keyboard', 'alcohol', 'stovefan', 'ceilinglamp', 'couch', 'microphone', 'wall', 'nightstand', 'photoframe', 'coffe_maker', 'coffee_filter', 'doorjamb', 'kitchen_counter', 'hairbrush', 'cupboard', 'home_office', 'dishwasher', 'coffee', 'shoe_rack']
Task:Make coffee
response:
{
    "thoughts": Open coffee maker. Put filter in main basket, put ground coffee in filter, fill reservoir with water, turn on coffee maker.,
    "actions": ['[WALK] <dining_room>', '[WALK] <coffe_maker>', '[FIND] <coffe_maker>', '[OPEN] <coffe_maker>', '[FIND] <coffee_filter>', '[GRAB] <coffee_filter>', '[PUTBACK] <coffee_filter> <coffe_maker>', '[FIND] <coffee>', '[GRAB] <coffee>', '[PUTBACK] <coffee> <coffe_maker>']
}

Input:
Scene_Objects:['juice', 'blender', 'tea', 'toilet', 'chair', 'freezer', 'walllamp', 'trashcan', 'knifeblock', 'cpuscreen', 'floor', 'ceiling', 'keyboard', 'bookshelf', 'toaster', 'ceilinglamp', 'shower', 'mousepad', 'food_jam', 'pillow', 'wall', 'powersocket', 'bed', 'tray', 'kitchen_counter', 'dresser', 'cupboard', 'home_office', 'table', 'bathroom_cabinet']
Task:Put groceries in Fridge
response:

Go to kitchen and put groceries in fridge

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


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

Here is an example plan to achieve a goal for reference:
Scene_Objects:['blender', 'freezer', 'walllamp', 'bathroom', 'drawing', 'clothes_underwear', 'hanger', 'floor', 'ceiling', 'character', 'keyboard', 'brush', 'tvstand', 'stereo', 'window', 'closetdrawer', 'towel', 'wall', 'powersocket', 'tape', 'food_food', 'television', 'curtain', 'doorjamb', 'vacuum_cleaner', 'dresser', 'door', 'clothes_scarf', 'dishwasher', 'board_game']
Task:vacuum carpet
response:
{
    "thoughts": I bring my vacuum cleaner into the living room.  I plug it into the wall.  I press the on switch on the vacuum cleaner.  I push the vacuum cleaner back and forth over the length and width of the carpet until I have vacuumed the entire carpet.  I turn the vacuum cleaner off.  I take the vacuum cleaner back to the hall closet.,
    "actions": ['[WALK] <home_office>', '[WALK] <dresser>', '[OPEN] <dresser>', '[FIND] <vacuum_cleaner>', '[GRAB] <vacuum_cleaner>', '[PULL] <vacuum_cleaner>', '[PLUGIN] <vacuum_cleaner>', '[SWITCHON] <vacuum_cleaner>', '[PULL] <vacuum_cleaner>', '[PUSH] <vacuum_cleaner>', '[PULL] <vacuum_cleaner>', '[PUSH] <vacuum_cleaner>', '[PULL] <vacuum_cleaner>', '[PUSH] <vacuum_cleaner>', '[SWITCHOFF] <vacuum_cleaner>', '[PLUGOUT] <vacuum_cleaner>', '[WALK] <dresser>', '[PUTIN] <vacuum_cleaner> <dresser>', '[CLOSE] <dresser>']
}

Input:
Scene_Objects:['dry_pasta', 'filing_cabinet', 'jelly', 'drawing', 'orchid', 'knifeblock', 'cpuscreen', 'bathroom_counter', 'floor', 'ceiling', 'character', 'computer', 'bookmark', 'faucet', 'clothes_socks', 'couch', 'pillow', 'broom', 'wall', 'wall_clock', 'tape', 'photoframe', 'novel', 'check', 'food_onion', 'doorjamb', 'door', 'bathtub', 'table', 'light']
Task:Relax on sofa
response:

Go to the living room and relax on the sofa with a book

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


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

Here is an example plan to achieve a goal for reference:
Scene_Objects:['pot', 'toilet', 'jelly', 'ceilingfan', 'drawing', 'hanger', 'floor', 'stamp', 'desk', 'ceilinglamp', 'balanceball', 'faucet', 'window', 'couch', 'clothes_pants', 'pillow', 'wall', 'nightstand', 'bed', 'photoframe', 'television', 'oven_mitts', 'food_rice', 'doorjamb', 'cards', 'shaving_cream', 'sink', 'table', 'light', 'shoe_rack']
Task:Relax on sofa
response:
{
    "thoughts": go to living room and lie down on the sofa.,
    "actions": ['[WALK] <home_office>', '[WALK] <couch>', '[FIND] <couch>', '[LIE] <couch>']
}

Input:
Scene_Objects:['scissors', 'chair', 'bathroom', 'drawing', 'wallshelf', 'cpuscreen', 'character', 'desk', 'envelope', 'computer', 'shower', 'faucet', 'electric_shaver', 'dustpan', 'dining_room', 'wall', 'bench', 'tape', 'photoframe', 'check', 'doorjamb', 'centerpiece', 'mouse', 'hairbrush', 'bathroom_cabinet', 'table', 'home_office', 'light', 'instrument_guitar', 'creditcard']
Task:Receive credit card
response:

hear the dooble, go to door, take de envelope, open it with a scissor, take the creditcard

[WALK] <home_office>
[WALK] <envelope>
[FIND] <envelope>
[GRAB] <envelope>
[WALK] <home_office>
[WALK] <scissors>
[FIND] <scissors>
[OPEN] <envelope>
[FIND] <creditcard>
[GRAB] <creditcard>


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

Here is an example plan to achieve a goal for reference:
Scene_Objects:['pot', 'tablelamp', 'microwave', 'walllamp', 'bathroom', 'drawing', 'wallshelf', 'floor', 'ceiling', 'bedroom', 'bookshelf', 'computer', 'brush', 'mat', 'tvstand', 'couch', 'clothes_hat', 'pillow', 'wall', 'nightstand', 'powersocket', 'cup', 'photoframe', 'food_food', 'television', 'doorjamb', 'bag', 'light', 'dishwasher', 'table']
Task:Relax on sofa
response:
{
    "thoughts": Open coffee maker. Put filter in main basket, put ground coffee in filter, fill reservoir with water, turn on coffee maker.,
    "actions": ['[WALK] <home_office>', '[WALK] <couch>', '[FIND] <couch>', '[SIT] <couch>']
}

Input:
Scene_Objects:['pot', 'filing_cabinet', 'tablelamp', 'blender', 'band-aids', 'trashcan', 'drawing', 'knifeblock', 'bathroom_counter', 'shampoo', 'phone', 'remote_control', 'mat', 'plate', 'window', 'oil', 'food_jam', 'bowl', 'wall', 'nightstand', 'newspaper', 'keys', 'check', 'coffe_maker', 'curtain', 'doorjamb', 'towel_rack', 'mouse', 'cupboard', 'table']
Task:Change TV channel
response:

take remote control, push "change channel" button

[WALK] <home_office>
[WALK] <remote_control>
[FIND] <remote_control>
[PUSH] <remote_control>


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

Here is an example plan to achieve a goal for reference:
Scene_Objects:['sheets', 'spectacles', 'filing_cabinet', 'walllamp', 'ceilingfan', 'food_carrot', 'toothbrush', 'drawing', 'desk', 'bookshelf', 'stovefan', 'balanceball', 'shower', 'window', 'candle', 'clothes_pants', 'food_orange', 'dining_room', 'bench', 'bed', 'keys', 'food_food', 'diary', 'mouse', 'shoes', 'sink', 'vase', 'tooth_paste', 'scrabble', 'teeth']
Task:Brush teeth
response:
{
    "thoughts": EARLY MORNING AND BEFORE GOING TO BED,
    "actions": ['[WALK] <bathroom>', '[WALK] <tooth_paste>', '[FIND] <tooth_paste>', '[GRAB] <tooth_paste>', '[FIND] <toothbrush>', '[GRAB] <toothbrush>']
}

Input:
Scene_Objects:['tablelamp', 'walllamp', 'trashcan', 'wallshelf', 'bathroom_counter', 'floor', 'ceiling', 'bedroom', 'stamp', 'desk', 'button', 'toaster', 'mat', 'plate', 'shower', 'dish_soap', 'pillow', 'wall', 'nightstand', 'food_cheese', 'coffe_maker', 'food_food', 'kitchen_counter', 'dishrack', 'cupboard', 'controller', 'hairdryer', 'home_office', 'dishwasher', 'instrument_violin']
Task:Wash dishes with dishwasher
response:

Walk to kitchen. Find dishwasher. Open dishwasher. Find dishrack. Find plate 1. Grab plate 1. Put plate 1 in dishrack. Repeat for dish 2. Find dish soap. Grab dish soap. Put dish soap to dishwasher. Close dishwasher. Switch on dishwasher.

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


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', 'blender', 'chair', 'freezer', 'walllamp', 'trashcan', 'knifeblock', 'orchid', 'food_egg', 'kitchen_cabinet', 'floor', 'ceiling', 'food_bacon', 'stovefan', 'ceilinglamp', 'toaster', 'faucet', 'wall', 'oven', 'food_cheese', 'food_food', 'food_donut', 'food_rice', 'wine', 'tray', 'kitchen_counter', 'dresser', 'cupboard', 'sink', 'dishwasher']
Task:Cook some food
response:
{
    "thoughts": Walk into kitchen. Open fridge. Take food from fridge. Close fridge. Put food on kitchen counter. Prepare food. Turn on stove. Open kitchen cabinet. Take pot. Close cabinet. Put food in pot. Put pot on stove. Cook food.,
    "actions": ['[WALK] <dining_room>', '[WALK] <freezer>', '[FIND] <freezer>', '[OPEN] <freezer>', '[FIND] <food_food>', '[GRAB] <food_food>', '[FIND] <kitchen_counter>', '[PUTBACK] <food_food> <kitchen_counter>', '[CLOSE] <freezer>', '[FIND] <kitchen_cabinet>', '[OPEN] <kitchen_cabinet>', '[FIND] <pot>', '[GRAB] <pot>', '[CLOSE] <kitchen_cabinet>', '[FIND] <oven>', '[PUTBACK] <pot> <oven>', '[GRAB] <food_food>', '[PUTBACK] <food_food> <oven>']
}

Input:
Scene_Objects:['sheets', 'spectacles', 'filing_cabinet', 'tablelamp', 'freezer', 'bathroom', 'bathroom_counter', 'phone', 'table_cloth', 'toaster', 'mat', 'tvstand', 'faucet', 'mousepad', 'towel', 'nightstand', 'oven', 'cup', 'bed', 'photoframe', 'newspaper', 'food_food', 'after_shave', 'doorjamb', 'towel_rack', 'mouse', 'dishrack', 'controller', 'dishwasher', 'tooth_paste']
Task:Turn on light
response:

I walk into my bedroom, go to the lamp and use the switch to turn it on.

[WALK] <bedroom>
[WALK] <floor_lamp>
[FIND] <floor_lamp>
[TURNTO] <floor_lamp>
[LOOKAT] <floor_lamp>
[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:['tablelamp', 'chair', 'dough', 'bills', 'drawing', 'clothes_underwear', 'floor', 'ceiling', 'shampoo', 'bookshelf', 'computer', 'mat', 'window', 'food_noodles', 'bowl', 'wall', 'nightstand', 'oven', 'basket_for_clothes', 'cup', 'bed', 'toilet_paper', 'mouthwash', 'ice', 'doorjamb', 'vacuum_cleaner', 'dishrack', 'door', 'napkin', 'home_office']
Task:Go to sleep
response:
{
    "thoughts": Walk to bedroom. Walk to bed, lie in bed.,
    "actions": ['[WALK] <bedroom>', '[WALK] <bed>', '[LIE] <bed>']
}

Input:
Scene_Objects:['filing_cabinet', 'walllamp', 'bathroom', 'detergent', 'orchid', 'knifeblock', 'drawing', 'hanger', 'floor', 'ceiling', 'phone', 'bookshelf', 'mat', 'shower', 'faucet', 'wall', 'powersocket', 'oven', 'light_bulb', 'novel', 'check', 'television', 'food_donut', 'curtain', 'doorjamb', 'kitchen_counter', 'spoon', 'home_office', 'light', 'dishwasher']
Task:Turn on light
response:

[WALK] <home_office>
[WALK] <light>
[FIND] <light>
[PLUGIN] <light>
[SWITCHON] <light>
[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:['spectacles', 'tablelamp', 'microwave', 'chair', 'wallshelf', 'hanger', 'floor', 'phone', 'food_bacon', 'piano_bench', 'stovefan', 'ceilinglamp', 'shower', 'mousepad', 'closetdrawer', 'powersocket', 'television', 'coin', 'food_donut', 'ice', 'rag', 'pencil', 'shoes', 'dresser', 'clothes_dress', 'clothes_scarf', 'sink', 'bathroom_cabinet', 'light', 'home_office']
Task:Hang up jacket
response:
{
    "thoughts": I put clothes on hangers and hang them in the closet,
    "actions": ['[WALK] <bedroom>', '[WALK] <clothes_dress>', '[FIND] <clothes_dress>', '[GRAB] <clothes_dress>', '[WALK] <dresser>', '[FIND] <hanger>', '[OPEN] <dresser>', '[PUTIN] <clothes_dress> <dresser>', '[FIND] <clothes_dress>', '[GRAB] <clothes_dress>', '[WALK] <dresser>', '[PUTIN] <clothes_dress> <dresser>', '[CLOSE] <dresser>']
}

Input:
Scene_Objects:['sponge', 'pot', 'microwave', 'walllamp', 'knifeblock', 'food_egg', 'floor', 'ceiling', 'desk', 'bedroom', 'ceilinglamp', 'plate', 'faucet', 'window', 'dish_soap', 'mousepad', 'bowl', 'wall', 'oven', 'powersocket', 'check', 'mouthwash', 'after_shave', 'kitchen_counter', 'dishrack', 'dresser', 'cupboard', 'sink', 'bathtub', 'dishwasher']
Task:Wash dishes by hand
response:

I go to the kitchen and turn on the faucet. I get dish soap and put it into the sink. I grab a sponge and a bowl and start cleaning it. I put the bowl into the dishrack. I find a plate and clean it as well. I put it into the dishrack, turn off the faucet and put the sponge back.

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


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

Here is an example plan to achieve a goal for reference:
Scene_Objects:['toilet', 'chair', 'cpuscreen', 'hanger', 'floor', 'ceiling', 'phone', 'desk', 'keyboard', 'bookshelf', 'computer', 'toaster', 'mat', 'stereo', 'faucet', 'mousepad', 'wall', 'wall_clock', 'cup', 'bed', 'photoframe', 'novel', 'coffe_maker', 'television', 'mouse', 'kitchen_counter', 'headset', 'cupboard', 'bathroom_cabinet', 'light']
Task:Listen to music
response:
{
    "thoughts": I walk to my bedroom.  I locate my stereo and turn it on.  I put on my headphones and sit to listen.,
    "actions": ['[WALK] <bedroom>', '[WALK] <stereo>', '[FIND] <stereo>', '[WALK] <stereo>', '[SWITCHON] <stereo>', '[FIND] <headset>', '[GRAB] <headset>', '[PUTON] <headset>', '[FIND] <chair>', '[SIT] <chair>']
}

Input:
Scene_Objects:['microwave', 'walllamp', 'cat', 'toothbrush', 'orchid', 'knife', 'bills', 'bathroom_counter', 'floor', 'desk', 'stovefan', 'laptop', 'shoe-shine_kit', 'shower', 'window', 'mousepad', 'couch', 'powersocket', 'photoframe', 'wooden_spoon', 'curtain', 'doorjamb', 'coffee_pot', 'mouse', 'door', 'bathtub', 'home_office', 'table', 'light', 'clothes_shirt']
Task:Pet cat
response:


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

Here is an example plan to achieve a goal for reference:
Scene_Objects:['food_oatmeal', 'microwave', 'freezer', 'bathroom', 'nail_polish', 'dough', 'food_carrot', 'orchid', 'drawing', 'knife', 'kitchen_cabinet', 'floor', 'ceiling', 'desk', 'brush', 'mat', 'couch', 'pillow', 'food_cereal', 'wall', 'food_vegetable', 'food_food', 'television', 'console', 'cards', 'kitchen_counter', 'cupboard', 'hair', 'door', 'light']
Task:Put groceries in Fridge
response:
{
    "thoughts": Walk to kitchen, find groceries in cabinet and move them to fridge and close fridge.,
    "actions": ['[WALK] <dining_room>', '[WALK] <kitchen_cabinet>', '[FIND] <kitchen_cabinet>', '[FIND] <food_vegetable>', '[GRAB] <food_vegetable>', '[FIND] <freezer>', '[OPEN] <freezer>', '[PUTIN] <food_vegetable> <freezer>', '[FIND] <food_carrot>', '[GRAB] <food_carrot>', '[PUTIN] <food_carrot> <freezer>', '[FIND] <food_cereal>', '[GRAB] <food_cereal>', '[PUTIN] <food_cereal> <freezer>', '[FIND] <food_oatmeal>', '[GRAB] <food_oatmeal>', '[PUTIN] <food_oatmeal> <freezer>', '[FIND] <food_food>', '[GRAB] <food_food>', '[PUTIN] <food_food> <freezer>', '[FIND] <freezer>', '[CLOSE] <freezer>']
}

Input:
Scene_Objects:['filing_cabinet', 'juice', 'walllamp', 'bathroom', 'drawing', 'orchid', 'wallshelf', 'floor', 'ceiling', 'bookshelf', 'remote_control', 'mat', 'tvstand', 'ceilinglamp', 'shower', 'window', 'couch', 'pillow', 'wall', 'powersocket', 'oven', 'cup', 'photoframe', 'coffee_table', 'television', 'curtain', 'doorjamb', 'door', 'table', 'light']
Task:Watch TV
response:

Sit down, turn on the TV with the remote control that is on the coffee table.

[WALK] <home_office>
[WALK] <couch>
[FIND] <couch>
[SIT] <couch>
[FIND] <coffee_table>
[TURNTO] <coffee_table>
[LOOKAT] <coffee_table>
[FIND] <remote_control>
[GRAB] <remote_control>
[FIND] <television>
[TURNTO] <television>
[LOOKAT] <television>
[TURNTO] <television>
[POINTAT] <television>
[SWITCHON] <television>


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

Here is an example plan to achieve a goal for reference:
Scene_Objects:['sponge', 'microwave', 'toilet', 'jelly', 'freezer', 'ground_coffee', 'food_carrot', 'drawing', 'wallshelf', 'floor', 'ceiling', 'phone', 'button', 'mat', 'shower', 'picture', 'dustpan', 'food_orange', 'form', 'nightstand', 'wall', 'powersocket', 'food_cheese', 'photoframe', 'light_bulb', 'food_food', 'doorjamb', 'cd', 'door', 'light']
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:['sheets', 'walllamp', 'trashcan', 'cpuscreen', 'bathroom_counter', 'floor', 'phone', 'ceiling', 'folder', 'bedroom', 'food_cake', 'computer', 'shower', 'iron', 'window', 'pillow', 'wall', 'nightstand', 'powersocket', 'tape', 'bed', 'television', 'wine', 'doorjamb', 'towel_rack', 'dresser', 'home_office', 'light', 'bathroom_cabinet', 'dishwasher']
Task:Pick up phone
response:

I walk to the kitchen and find the phone. I pick up the phone. I hold it to my ear.

[WALK] <dining_room>
[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:['dry_pasta', 'tablelamp', 'food_salt', 'chair', 'walllamp', 'detergent', 'drawing', 'clothes_underwear', 'floor', 'bedroom', 'toaster', 'ceilinglamp', 'tvstand', 'shower', 'food_noodles', 'garbage_can', 'mousepad', 'microphone', 'wall', 'nightstand', 'food_vegetable', 'bed', 'food_food', 'coffee_filter', 'mouse', 'sink', 'home_office', 'table', 'dishwasher', 'pantry']
Task:Organize pantry
response:
{
    "thoughts": Remove all perishable foods from the pantry, check dates and throw away any old food. Decide on an efficient ad neat arrangement for the food and replace it in the pantry accordingly.,
    "actions": ['[WALK] <dining_room>', '[WALK] <pantry>', '[FIND] <food_food>', '[GRAB] <food_food>', '[TURNTO] <food_food>', '[LOOKAT] <food_food>', '[FIND] <garbage_can>', '[PUTBACK] <food_food> <garbage_can>', '[FIND] <food_vegetable>', '[GRAB] <food_vegetable>', '[TURNTO] <food_vegetable>', '[LOOKAT] <food_vegetable>', '[PUTBACK] <food_vegetable> <garbage_can>', '[FIND] <dry_pasta>', '[GRAB] <dry_pasta>', '[TURNTO] <dry_pasta>', '[LOOKAT] <dry_pasta>', '[PUTOBJBACK] <dry_pasta>', '[FIND] <food_food>', '[TURNTO] <food_food>', '[LOOKAT] <food_food>', '[PUSH] <food_food>', '[FIND] <food_noodles>', '[GRAB] <food_noodles>', '[TURNTO] <food_noodles>', '[LOOKAT] <food_noodles>', '[PUTOBJBACK] <food_noodles>']
}

Input:
Scene_Objects:['pot', 'food_pizza', 'mop', 'walllamp', 'knifeblock', 'floor', 'ceiling', 'bedroom', 'bookshelf', 'clothes_jacket', 'stovefan', 'faucet', 'window', 'pillow', 'bowl', 'wall', 'wall_clock', 'oven', 'cup', 'photoframe', 'food_food', 'toilet_paper', 'tray', 'after_shave', 'towel_rack', 'kitchen_counter', 'cupboard', 'sink', 'table', 'tooth_paste']
Task:Cook some food
response:

I switch on the stove and cook my groceries there.

[WALK] <dining_room>
[WALK] <oven>
[FIND] <oven>
[SWITCHON] <oven>
[FIND] <bowl>
[GRAB] <bowl>
[PUTBACK] <bowl> <oven>
[FIND] <food_food>
[SWITCHOFF] <oven>


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

Here is an example plan to achieve a goal for reference:
Scene_Objects:['sheets', 'fork', 'filing_cabinet', 'tablelamp', 'blender', 'mop', 'bathroom', 'detergent', 'toothbrush', 'bills', 'hanger', 'floor', 'bedroom', 'envelope', 'toaster', 'stovefan', 'clothes_socks', 'mousepad', 'powersocket', 'basket_for_clothes', 'coffe_maker', 'toilet_paper', 'towel_rack', 'clothes_dress', 'bag', 'home_office', 'light', 'vase', 'soap', 'washing_machine']
Task:Wash clothes
response:
{
    "thoughts": Walk to Bathroom. Find basket for clothes. Lift clothes dress from basket. Find washing machine. Walk to washing machine. Put clothes in washing machine. Put soap in washing machine. Switch on washing machine.,
    "actions": ['[WALK] <bathroom>', '[WALK] <basket_for_clothes>', '[FIND] <basket_for_clothes>', '[FIND] <clothes_dress>', '[GRAB] <clothes_dress>', '[FIND] <washing_machine>', '[WALK] <washing_machine>', '[OPEN] <washing_machine>', '[PUTBACK] <clothes_dress> <washing_machine>', '[FIND] <soap>', '[GRAB] <soap>', '[PUTBACK] <soap> <washing_machine>', '[CLOSE] <washing_machine>', '[SWITCHON] <washing_machine>']
}

Input:
Scene_Objects:['spectacles', 'pot', 'food_ice_cream', 'microwave', 'toilet', 'walllamp', 'knifeblock', 'drawing', 'floor', 'ceiling', 'desk', 'computer', 'toaster', 'faucet', 'mousepad', 'oil', 'candle', 'bowl', 'wall', 'bed', 'photoframe', 'coffe_maker', 'lighter', 'cards', 'kitchen_counter', 'cupboard', 'door', 'sink', 'dishwasher', 'colander']
Task:Wash dishes with dishwasher
response:

Walk to Kitchen. Take the dishes from the sink. Apply dish washer, scrub and then wash with water.

[WALK] <sink>
[FIND] <bowl>
[GRAB] <bowl>
[FIND] <dishwasher>
[SCRUB] <dishwasher>
[RINSE] <bowl>
[OPEN] <dishwasher>
[WASH] <bowl>


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', '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:
{
    "thoughts": 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.,
    "actions": ['[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>']
}

Input:
Scene_Objects:['food_ice_cream', 'toilet', 'walllamp', 'nail_polish', 'dough', 'orchid', 'wallshelf', 'floor', 'ceiling', 'bookshelf', 'remote_control', 'keyboard', 'computer', 'stovefan', 'mat', 'tvstand', 'ceilinglamp', 'shower', 'window', 'wall', 'nightstand', 'powersocket', 'photoframe', 'television', 'curtain', 'doorjamb', 'cards', 'dishrack', 'door', 'light']
Task:Change TV channel
response:

first i will go to living room and then take the remote and swtitch on television after that il change the channel

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


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

Here is an example plan to achieve a goal for reference:
Scene_Objects:['spectacles', 'filing_cabinet', 'microwave', 'chair', 'bathroom', 'food_butter', 'drawing', 'orchid', 'cpuscreen', 'floor', 'ceiling', 'shower', 'foundation', 'couch', 'pillow', 'wall', 'nightstand', 'powersocket', 'box', 'newspaper', 'coffe_maker', 'food_onion', 'doorjamb', 'mouse', 'controller', 'door', 'bathtub', 'table', 'light', 'scrabble']
Task:Relax on sofa
response:
{
    "thoughts": Walk to the living room, find the sofa and sit in the sofa and find pillow. lie down in sofa.,
    "actions": ['[WALK] <home_office>', '[WALK] <couch>', '[FIND] <couch>', '[SIT] <couch>', '[FIND] <pillow>', '[LIE] <couch>']
}

Input:
Scene_Objects:['microwave', 'chair', 'food_butter', 'food_carrot', 'drawing', 'orchid', 'knifeblock', 'knife', 'cpuscreen', 'floor', 'ceiling', 'bookshelf', 'toaster', 'mat', 'food_noodles', 'couch', 'pillow', 'wall', 'bed', 'photoframe', 'food_food', 'curtain', 'doorjamb', 'towel_rack', 'cupboard', 'door', 'bathroom_cabinet', 'table', 'light', 'dirt']
Task:Relax on sofa
response:

[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:['tablelamp', 'blender', 'microwave', 'freezer', 'walllamp', 'bathroom', 'orchid', 'drawing', 'hanger', 'floor', 'ceiling', 'character', 'desk', 'computer', 'mat', 'tvstand', 'faucet', 'window', 'mousepad', 'closetdrawer', 'pillow', 'wall', 'nightstand', 'food_cheese', 'bed', 'novel', 'curtain', 'diary', 'dresser', 'bathroom_cabinet']
Task:Read book
response:
{
    "thoughts": Put child in bed, sit down,read book.,
    "actions": ['[WALK] <bedroom>', '[WALK] <dresser>', '[OPEN] <dresser>', '[FIND] <novel>', '[GRAB] <novel>', '[FIND] <bed>', '[SIT] <bed>', '[READ] <novel>']
}

Input:
Scene_Objects:['pot', 'filing_cabinet', 'chair', 'bathroom', 'trashcan', 'knifeblock', 'orchid', 'wallshelf', 'cpuscreen', 'bathroom_counter', 'phone', 'desk', 'food_cake', 'computer', 'table_cloth', 'tvstand', 'faucet', 'couch', 'oven', 'powersocket', 'cup', 'photoframe', 'check', 'tray', 'curtain', 'wooden_spoon', 'doorjamb', 'door', 'bathtub', 'soap']
Task:Pick up phone
response:

Walk into the home office. Pick up the phone.

[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:['pot', 'tablelamp', 'freezer', 'walllamp', 'food_carrot', 'desk', 'food_cake', 'remote_control', 'button', 'ceilinglamp', 'faucet', 'stereo', 'window', 'mousepad', 'couch', 'wall_clock', 'bench', 'box', 'cup', 'bed', 'keys', 'newspaper', 'food_food', 'ice', 'after_shave', 'maindoor', 'bathroom_cabinet', 'light', 'vase', 'soap']
Task:Watch TV
response:
{
    "thoughts": I walk to the living room and sit on the couch.  I grab the TV remote.  I press the power button on the TV remote and the TV turns on.  I grab the surround sound remote.  I press the power button on the surround sound remote and the system turns on.,
    "actions": ['[WALK] <home_office>', '[WALK] <remote_control>', '[FIND] <remote_control>', '[GRAB] <remote_control>', '[PUSH] <remote_control>', '[FIND] <remote_control>', '[PUSH] <remote_control>']
}

Input:
Scene_Objects:['tablelamp', 'food_salt', 'microwave', 'chair', 'walllamp', 'knifeblock', 'floor', 'phone', 'desk', 'tea_bag', 'keyboard', 'bookshelf', 'purse', 'toaster', 'mat', 'stereo', 'faucet', 'mousepad', 'pillow', 'mouthwash', 'curtain', 'cards', 'shoes', 'cd', 'dishrack', 'dresser', 'door', 'instrument_guitar', 'table', 'bathroom_cabinet']
Task:Read book
response:

[WALK] <home_office>
[WALK] <novel>
[FIND] <novel>
[GRAB] <novel>
[READ] <novel>
[PUTOBJBACK] <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:['filing_cabinet', 'food_salt', 'freezer', 'walllamp', 'drawing', 'orchid', 'floor', 'ceiling', 'bedroom', 'remote_control', 'ceilinglamp', 'tvstand', 'mat', 'homework', 'window', 'wall', 'powersocket', 'oven', 'toy', 'bed', 'toilet_paper', 'television', 'toothbrush_holder', 'food_donut', 'tray', 'doorjamb', 'door', 'sink', 'spoon', 'table']
Task:Change TV channel
response:
{
    "thoughts": Lift the remote and change the channel,
    "actions": ['[WALK] <home_office>', '[WALK] <television>', '[FIND] <television>', '[SWITCHON] <television>', '[FIND] <remote_control>', '[GRAB] <remote_control>', '[TURNTO] <television>', '[WATCH] <television>']
}

Input:
Scene_Objects:['sponge', 'pot', 'food_ice_cream', 'microwave', 'freezer', 'walllamp', 'knifeblock', 'floor', 'bookshelf', 'clothes_jacket', 'plate', 'faucet', 'tvstand', 'towel', 'wall', 'nightstand', 'bench', 'coffe_maker', 'television', 'wooden_spoon', 'after_shave', 'towel_rack', 'mouse', 'kitchen_counter', 'cupboard', 'pajamas', 'door', 'sink', 'home_office', 'tooth_paste']
Task:Wash dishes by hand
response:

go into the kitchen, walk to the sink. Turn on the water and rinse of a plate and clean them off fully with a sponge.

[WALK] <dining_room>
[WALK] <sink>
[FIND] <plate>
[RINSE] <plate>
[FIND] <sponge>
[GRAB] <sponge>
[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:['tablelamp', 'food_salt', 'measuring_cup', 'jelly', 'freezer', 'nail_polish', 'ceilingfan', 'drawing', 'orchid', 'longboard', 'floor', 'ceiling', 'bedroom', 'keyboard', 'ceilinglamp', 'tvstand', 'balanceball', 'stereo', 'window', 'deck_of_cards', 'mousepad', 'couch', 'clothes_pants', 'wall', 'television', 'curtain', 'kitchen_counter', 'chessboard', 'spoon', 'table']
Task:Change TV channel
response:
{
    "thoughts": I walk in living room. I find TV remote. I grab TV remote. I sit on sofa. I switch on TV. I switch channel.,
    "actions": ['[WALK] <home_office>', '[WALK] <remote_control>', '[FIND] <remote_control>', '[GRAB] <remote_control>', '[WALK] <couch>', '[SIT] <couch>', '[FIND] <television>', '[SWITCHON] <television>', '[TURNTO] <remote_control>', '[LOOKAT] <remote_control>', '[PUSH] <remote_control>']
}

Input:
Scene_Objects:['sheets', 'dry_pasta', 'food_ice_cream', 'toilet', 'freezer', 'knifeblock', 'wallshelf', 'folder', 'desk', 'stamp', 'bedroom', 'computer', 'toaster', 'mat', 'floor_lamp', 'dustpan', 'pillow', 'dining_room', 'broom', 'wall', 'nightstand', 'check', 'curtain', 'console', 'dresser', 'door', 'sink', 'bathroom_cabinet', 'light', 'dishwasher']
Task:Turn on light
response:

I go home and it's dark so I can not see anything

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


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

Here is an example plan to achieve a goal for reference:
Scene_Objects:['sheets', 'chair', 'walllamp', 'detergent', 'knifeblock', 'orchid', 'cpuscreen', 'drawing', 'bathroom_counter', 'phone', 'folder', 'man', 'keyboard', 'mop_bucket', 'tvstand', 'faucet', 'picture', 'plate', 'mousepad', 'bench', 'oven', 'powersocket', 'photoframe', 'food_food', 'check', 'food_onion', 'clothes_scarf', 'spoon', 'light', 'dishwasher']
Task:Greet guests
response:
{
    "thoughts": When someone knocks I n the door walk through the hallway and greet them.,
    "actions": ['[RUN] <home_office>', '[WALK] <man>', '[FIND] <man>', '[GREET] <man>', '[FIND] <man>', '[GREET] <man>']
}

Input:
Scene_Objects:['sponge', 'toilet', 'chair', 'freezer', 'band-aids', 'walllamp', 'cat', 'drawing', 'orchid', 'floor', 'ceiling', 'phone', 'bedroom', 'ceilinglamp', 'tvstand', 'clothes_socks', 'couch', 'pillow', 'dining_room', 'wall', 'bench', 'clothes_gloves', 'novel', 'tray', 'doorjamb', 'kitchen_counter', 'door', 'table', 'light', 'dishwasher']
Task:Pet cat
response:

walk to entrance hall, look at the sofa, sit on the sofa, look at the cat, allow cat to near with you, touch the cat smoothly on it head, now pet the cat smoothly

[WALK] <home_office>
[WALK] <couch>
[FIND] <couch>
[TURNTO] <couch>
[LOOKAT] <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:['sheets', 'chair', 'walllamp', 'detergent', 'knifeblock', 'orchid', 'cpuscreen', 'drawing', 'bathroom_counter', 'phone', 'folder', 'man', 'keyboard', 'mop_bucket', 'tvstand', 'faucet', 'picture', 'plate', 'mousepad', 'bench', 'oven', 'powersocket', 'photoframe', 'food_food', 'check', 'food_onion', 'clothes_scarf', 'spoon', 'light', 'dishwasher']
Task:Greet guests
response:
{
    "thoughts": When someone knocks I n the door walk through the hallway and greet them.,
    "actions": ['[RUN] <home_office>', '[WALK] <man>', '[FIND] <man>', '[GREET] <man>', '[FIND] <man>', '[GREET] <man>']
}

Input:
Scene_Objects:['freezer', 'toothbrush', 'cpuscreen', 'clothes_underwear', 'wallshelf', 'floor', 'phone', 'ceiling', 'character', 'bookshelf', 'computer', 'button', 'pillow', 'dining_room', 'bench', 'food_food', 'television', 'tray', 'curtain', 'doorjamb', 'towel_rack', 'mouse', 'cd', 'dresser', 'cupboard', 'pajamas', 'clothes_dress', 'sink', 'home_office', 'laser_pointer']
Task:Browse internet
response:

Walk to home office. Walk to computer. Switch on Computer.

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


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

Here is an example plan to achieve a goal for reference:
Scene_Objects:['chair', 'walllamp', 'bathroom', 'trashcan', 'orchid', 'drawing', 'cpuscreen', 'floor', 'ceiling', 'folder', 'bedroom', 'bookshelf', 'keyboard', 'ceilinglamp', 'faucet', 'window', 'couch', 'pillow', 'wall', 'powersocket', 'food_food', 'television', 'curtain', 'doorjamb', 'towel_rack', 'dresser', 'bathtub', 'light', 'table', 'instrument_violin']
Task:Straighten pictures on wall
response:
{
    "thoughts": Move the pictures/paintings until they are straight.,
    "actions": ['[WALK] <home_office>', '[WALK] <drawing>', '[FIND] <drawing>', '[TURNTO] <drawing>', '[LOOKAT] <drawing>', '[TOUCH] <drawing>', '[PUSH] <drawing>', '[FIND] <drawing>', '[TURNTO] <drawing>', '[LOOKAT] <drawing>', '[TOUCH] <drawing>', '[PUSH] <drawing>']
}

Input:
Scene_Objects:['pot', 'filing_cabinet', 'microwave', 'ground_coffee', 'walllamp', 'orchid', 'knifeblock', 'floor', 'ceiling', 'character', 'bookshelf', 'toaster', 'mat', 'faucet', 'wall', 'basket_for_clothes', 'photoframe', 'bed', 'coffe_maker', 'food_food', 'coffee_filter', 'kitchen_counter', 'cd', 'dresser', 'cupboard', 'door', 'napkin', 'bathroom_cabinet', 'light', 'dishwasher']
Task:Make coffee
response:

You walk into the kitchen and turn to the coffee maker. You grab the coffee filter and put into the coffee machine, you also grab the ground coffee and put it into the coffee machine. You turn on the coffee machine.

[WALK] <dining_room>
[WALK] <coffe_maker>
[FIND] <coffe_maker>
[TURNTO] <coffe_maker>
[FIND] <coffee_filter>
[GRAB] <coffee_filter>
[OPEN] <coffe_maker>
[PUTBACK] <coffee_filter> <coffe_maker>
[FIND] <ground_coffee>
[GRAB] <ground_coffee>
[PUTBACK] <ground_coffee> <coffe_maker>
[SWITCHON] <coffe_maker>


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

Here is an example plan to achieve a goal for reference:
Scene_Objects:['pot', 'tablelamp', 'toilet', 'freezer', 'walllamp', 'bathroom', 'trashcan', 'knifeblock', 'floor', 'ceiling', 'desk', 'bedroom', 'stovefan', 'ceilinglamp', 'plate', 'mat', 'couch', 'wall', 'oven', 'food_food', 'tray', 'food_onion', 'curtain', 'diary', 'kitchen_counter', 'dishrack', 'sauce_pan', 'cupboard', 'spoon', 'home_office']
Task:Cook some food
response:
{
    "thoughts": I pull a sauce pan from the cupboard. I turn the stove on. I take my ingredients from the pantry and fridge. I put the ingredients in the pan and I mix them with a spoon. I cook until the food is finished and transfer my food to a plate.,
    "actions": ['[WALK] <dining_room>', '[WALK] <food_food>', '[FIND] <food_food>', '[FIND] <pot>', '[GRAB] <pot>', '[FIND] <spoon>', '[GRAB] <spoon>', '[FIND] <sauce_pan>', '[PUTBACK] <spoon> <sauce_pan>', '[FIND] <freezer>', '[OPEN] <freezer>', '[FIND] <plate>', '[PUTBACK] <pot> <plate>']
}

Input:
Scene_Objects:['filing_cabinet', 'bathroom', 'drawing', 'orchid', 'floor', 'ceiling', 'phone', 'desk', 'bookshelf', 'keyboard', 'shower', 'oil', 'couch', 'pillow', 'bowl', 'wall', 'powersocket', 'bed', 'television', 'doorjamb', 'towel_rack', 'kitchen_counter', 'door', 'sink', 'bathtub', 'bathroom_cabinet', 'light', 'table', 'clothes_skirt', 'creditcard']
Task:Relax on sofa
response:

I want to relax on the sofa to some relaxing music in the living room.

[WALK] <home_office>
[WALK] <light>
[FIND] <light>
[SWITCHON] <light>
[WALK] <stereo>
[PLUGIN] <stereo>
[SWITCHON] <stereo>
[WALK] <couch>
[SIT] <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:['filing_cabinet', 'blender', 'crayon', 'toilet', 'chair', 'freezer', 'drawing', 'hanger', 'floor', 'ceiling', 'bookshelf', 'computer', 'clothes_jacket', 'ceilinglamp', 'window', 'pillow', 'wall', 'pasta', 'powersocket', 'toy', 'box', 'cup', 'check', 'coffe_maker', 'toothbrush_holder', 'doorjamb', 'dresser', 'door', 'light', 'scrabble']
Task:Pick up toys
response:
{
    "thoughts": Pickup toys from around the room. Organize toys back into their appropriate spaces on the shelves and into the toy boxes.,
    "actions": ['[WALK] <bedroom>', '[WALK] <toy>', '[FIND] <toy>', '[GRAB] <toy>', '[WALK] <filing_cabinet>', '[OPEN] <filing_cabinet>', '[PUTBACK] <toy> <filing_cabinet>', '[CLOSE] <filing_cabinet>', '[FIND] <toy>', '[GRAB] <toy>', '[WALK] <dresser>', '[OPEN] <dresser>', '[PUTBACK] <toy> <dresser>', '[CLOSE] <dresser>', '[FIND] <toy>', '[GRAB] <toy>', '[WALK] <filing_cabinet>', '[OPEN] <filing_cabinet>', '[PUTBACK] <toy> <filing_cabinet>', '[CLOSE] <filing_cabinet>']
}

Input:
Scene_Objects:['tablelamp', 'chair', 'freezer', 'bathroom', 'orchid', 'floor', 'ceiling', 'character', 'bedroom', 'computer', 'toaster', 'stovefan', 'ceilinglamp', 'picture', 'tooth_paste', 'couch', 'pillow', 'wall', 'nightstand', 'food_food', 'check', 'television', 'tray', 'doorjamb', 'mouse', 'kitchen_counter', 'cupboard', 'home_office', 'bathroom_cabinet', 'board_game']
Task:Put groceries in Fridge
response:

Walk to the kitchen. Open the fridge, take the groceries and put in it. Closed the fridge,

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


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

Here is an example plan to achieve a goal for reference:
Scene_Objects:['food_bread', 'chair', 'bathroom', 'detergent', 'orchid', 'knife', 'hanger', 'floor', 'character', 'computer', 'mail', 'table_cloth', 'toaster', 'foundation', 'window', 'mousepad', 'bench', 'shelf', 'photoframe', 'bed', 'coffe_maker', 'cards', 'chessboard', 'controller', 'door', 'maindoor', 'bathtub', 'light', 'vase', 'laser_pointer']
Task:Pick up phone
response:
{
    "thoughts": walk into living room, look at the phone when it ringing, grab the phone or pickup the phone,
    "actions": ['[WALK] <home_office>', '[WALK] <phone>', '[FIND] <phone>', '[TURNTO] <phone>', '[LOOKAT] <phone>']
}

Input:
Scene_Objects:['pot', 'tablelamp', 'walllamp', 'orchid', 'floor', 'ceiling', 'character', 'desk', 'table_cloth', 'toaster', 'ceilinglamp', 'plate', 'faucet', 'stovefan', 'dish_soap', 'mousepad', 'couch', 'wall', 'powersocket', 'bed', 'coffe_maker', 'food_food', 'kitchen_counter', 'cupboard', 'controller', 'sink', 'dishwasher', 'soap', 'clothes_shirt', 'teeth']
Task:Wash dishes with dishwasher
response:

Walk to the kitchen. Open the dishwasher. Grab plate and put it in the dishwasher. Grab dish soap and put it in the dishwasher. Switch on the dishwasher.

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


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

Here is an example plan to achieve a goal for reference:
Scene_Objects:['sponge', 'food_pizza', 'juice', 'toilet', 'freezer', 'blow_dryer', 'walllamp', 'ceilingfan', 'knifeblock', 'bathroom_counter', 'alcohol', 'button', 'stereo', 'form', 'towel', 'oven', 'basket_for_clothes', 'photoframe', 'light_bulb', 'toilet_paper', 'toothbrush_holder', 'kitchen_counter', 'shoes', 'chessboard', 'vacuum_cleaner', 'clothes_scarf', 'home_office', 'dishwasher', 'soap', 'shoe_rack']
Task:Wash hands
response:
{
    "thoughts": I walk to the kitchen and get the soap and wash my both hand using the soap and rinse my hands and use towel.,
    "actions": ['[WALK] <dining_room>', '[WALK] <soap>', '[FIND] <soap>', '[GRAB] <soap>', '[SCRUB] <soap>', '[FIND] <towel>', '[RINSE] <towel>']
}

Input:
Scene_Objects:['filing_cabinet', 'chair', 'freezer', 'orchid', 'bedroom', 'clothes_jacket', 'mop_bucket', 'stovefan', 'mousepad', 'pillow', 'dining_room', 'nightstand', 'wall', 'powersocket', 'oven', 'basket_for_clothes', 'bed', 'photoframe', 'mouthwash', 'television', 'wine', 'after_shave', 'doorjamb', 'sink', 'bathroom_cabinet', 'light', 'dishwasher', 'soap', 'washing_machine', 'coffee']
Task:Wash clothes
response:

Walk to the kitchen and find the basket of clothes. Put the soap and clothes into the washing machine. Turn on the washing machine.


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

Here is an example plan to achieve a goal for reference:
Scene_Objects:['filing_cabinet', 'chair', 'walllamp', 'orchid', 'cpuscreen', 'hanger', 'bathroom_counter', 'floor', 'ceiling', 'desk', 'keyboard', 'computer', 'food_bacon', 'brush', 'ceilinglamp', 'tvstand', 'mousepad', 'dining_room', 'wall', 'powersocket', 'bench', 'food_food', 'television', 'doorjamb', 'mouse', 'dresser', 'cupboard', 'bathroom_cabinet', 'table', 'light']
Task:Turn on computer
response:
{
    "thoughts": Find the power button. Press.,
    "actions": ['[WALK] <home_office>', '[WALK] <chair>', '[PULL] <chair>', '[SIT] <chair>', '[FIND] <computer>', '[SWITCHON] <computer>', '[TURNTO] <computer>', '[LOOKAT] <computer>']
}

Input:
Scene_Objects:['filing_cabinet', 'juice', 'food_ice_cream', 'knifeblock', 'needle', 'cpuscreen', 'floor', 'ceiling', 'phone', 'character', 'desk', 'bookshelf', 'mop_bucket', 'toaster', 'laptop', 'faucet', 'food_jam', 'wall', 'powersocket', 'box', 'television', 'curtain', 'doorjamb', 'mouse', 'kitchen_counter', 'chessboard', 'door', 'bag', 'light', 'table']
Task:Turn on light
response:

approach the light switch, raise hand to the switch, flip the switch

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


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

Here is an example plan to achieve a goal for reference:
Scene_Objects:['sheets', 'scissors', 'mop', 'toilet', 'blow_dryer', 'detergent', 'drawing', 'cpuscreen', 'bathroom_counter', 'floor', 'ceiling', 'desk', 'keyboard', 'toaster', 'tvstand', 'shower', 'mousepad', 'pillow', 'wall', 'powersocket', 'oven', 'cup', 'photoframe', 'bed', 'food_onion', 'doorjamb', 'shaving_cream', 'mouse', 'kitchen_counter', 'bathroom_cabinet']
Task:Go to toilet
response:
{
    "thoughts": I walk to bathroom, I open the door of the bathroom, and sit on the toilet.,
    "actions": ['[WALK] <bathroom>', '[WALK] <toilet>', '[FIND] <toilet>', '[SIT] <toilet>']
}

Input:
Scene_Objects:['pot', 'tablelamp', 'microwave', 'walllamp', 'knifeblock', 'kitchen_cabinet', 'floor', 'ceiling', 'folder', 'character', 'desk', 'faucet', 'stereo', 'mousepad', 'food_orange', 'wall', 'oven', 'photoframe', 'oven_mitts', 'water', 'drinking_glass', 'wooden_spoon', 'towel_rack', 'shaving_cream', 'kitchen_counter', 'cupboard', 'food_steak', 'sink', 'spoon', 'board_game']
Task:Drink
response:

Go to kitchen, open cabinet, get glass, close cabinet, put glass under faucet, turn on water, turn off water when glass has 85% water, lift glass to mouth, open mouth and put on glass, tilt glass up and swallow water.

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


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

Here is an example plan to achieve a goal for reference:
Scene_Objects:['filing_cabinet', 'tea', 'measuring_cup', 'band-aids', 'knifeblock', 'cpuscreen', 'dvd_player', 'folder', 'desk', 'bookmark', 'stereo', 'faucet', 'dustpan', 'microphone', 'oven', 'cup', 'bed', 'photoframe', 'check', 'coffe_maker', 'television', 'food_rice', 'pencil', 'shredder', 'controller', 'home_office', 'light', 'table', 'scrabble', 'electrical_outlet']
Task:Shred receipts
response:
{
    "thoughts": Take old receipts and put through the shredder,
    "actions": ['[WALK] <home_office>', '[WALK] <filing_cabinet>', '[FIND] <filing_cabinet>', '[OPEN] <filing_cabinet>', '[FIND] <check>', '[GRAB] <check>', '[CLOSE] <filing_cabinet>', '[FIND] <electrical_outlet>', '[FIND] <shredder>', '[PLUGIN] <shredder>', '[SWITCHON] <shredder>', '[PUTBACK] <check> <shredder>']
}

Input:
Scene_Objects:['pot', 'ground_coffee', 'walllamp', 'floor', 'ceiling', 'phone', 'bedroom', 'keyboard', 'food_cake', 'toaster', 'window', 'couch', 'wall', 'cup', 'coffe_maker', 'food_food', 'coffee_filter', 'water', 'after_shave', 'towel_rack', 'mouse', 'shaving_cream', 'kitchen_counter', 'cupboard', 'bathtub', 'napkin', 'home_office', 'instrument_guitar', 'dishwasher', 'instrument_violin']
Task:Make coffee
response:

Walk to kitchen. Find coffee maker. Find coffee filter. Put it in the coffee maker. Find ground coffee. Put it in the coffee maker. Find Water. Put it in the coffe maker. Switch on the coffee maker.

[WALK] <dining_room>
[WALK] <coffe_maker>
[FIND] <coffe_maker>
[FIND] <coffee_filter>
[GRAB] <coffee_filter>
[OPEN] <coffe_maker>
[PUTBACK] <coffee_filter> <coffe_maker>
[FIND] <ground_coffee>
[GRAB] <ground_coffee>
[PUTBACK] <ground_coffee> <coffe_maker>
[FIND] <water>
[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:['glue', 'food_bread', 'filing_cabinet', 'bathroom', 'ceiling', 'phone', 'keyboard', 'purse', 'bookshelf', 'laptop', 'ceilinglamp', 'faucet', 'nightstand', 'bench', 'photoframe', 'bed', 'clothes_gloves', 'food_food', 'coffe_maker', 'television', 'toothbrush_holder', 'curtain', 'shaving_cream', 'pencil', 'dresser', 'conditioner', 'door', 'spoon', 'bathroom_cabinet', 'table']
Task:Shut front door
response:
{
    "thoughts": Close the storm door. Lock the storm door.,
    "actions": ['[WALK] <home_office>']
}

Input:
Scene_Objects:['filing_cabinet', 'mop', 'chair', 'blow_dryer', 'orchid', 'cpuscreen', 'floor', 'phone', 'folder', 'desk', 'bookshelf', 'remote_control', 'computer', 'toaster', 'stovefan', 'mousepad', 'couch', 'pillow', 'wall', 'wall_clock', 'photoframe', 'novel', 'television', 'coin', 'coffee_filter', 'doorjamb', 'shoes', 'cupboard', 'sink', 'light']
Task:Watch TV
response:

I walk to the living room and sit on the couch.  I grab the TV remote.  I press the power button on the TV remote and the TV turns on.  I grab the surround sound remote.  I press the power button on the surround sound remote and the system turns on.

[WALK] <home_office>
[WALK] <remote_control>
[FIND] <remote_control>
[GRAB] <remote_control>
[PUSH] <remote_control>
[FIND] <remote_control>
[PUSH] <remote_control>