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

Here is an example plan to achieve a goal for reference:
Scene_Objects:['tablelamp', 'microwave', 'toilet', 'chair', 'trashcan', 'ceilingfan', 'drawing', 'cpuscreen', 'floor', 'ceiling', 'phone', 'desk', 'keyboard', 'bookshelf', 'computer', 'button', 'mail', 'ceilinglamp', 'deck_of_cards', 'balanceball', 'window', 'mousepad', 'wall', 'nightstand', 'photoframe', 'novel', 'doorjamb', 'mouse', 'light', 'dishwasher']
Task:Write an email
response:
{
    "thoughts": Switch on computer, Use keybord and mouse to open e-mail provider, type requested e-mail, click send, close e-mail provider, turn off computer,
    "actions": ['[WALK] <home_office>', '[WALK] <computer>', '[FIND] <computer>', '[SWITCHON] <computer>', '[FIND] <mouse>', '[FIND] <keyboard>', '[FIND] <mail>', '[OPEN] <mail>', '[TYPE] <keyboard>', '[FIND] <button>', '[PUSH] <button>', '[CLOSE] <mail>', '[SWITCHOFF] <computer>']
}

Input:
Scene_Objects:['water_glass', 'filing_cabinet', 'food_salt', 'microwave', 'freezer', 'walllamp', 'ground_coffee', 'knifeblock', 'needle', 'floor', 'mail', 'plate', 'faucet', 'window', 'pillow', 'nightstand', 'basket_for_clothes', 'cup', 'photoframe', 'bed', 'coffe_maker', 'coffee_filter', 'coin', 'water', 'after_shave', 'dresser', 'hairbrush', 'maindoor', 'table', 'shoe_rack']
Task:Drink
response:

walk to kitchen, look at the water glass, grab that glass, find the water cane, open the water cane tap, drink water

[WALK] <dining_room>
[WALK] <water_glass>
[FIND] <water_glass>
[TURNTO] <water_glass>
[LOOKAT] <water_glass>
[GRAB] <water_glass>
[FIND] <water>


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

Here is an example plan to achieve a goal for reference:
Scene_Objects:['sheets', 'filing_cabinet', '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:
{
    "thoughts": i go find the phone. i pick up the phone,
    "actions": ['[WALK] <home_office>', '[WALK] <phone>', '[FIND] <phone>', '[GRAB] <phone>']
}

Input:
Scene_Objects:['tablelamp', 'toilet', 'chair', 'walllamp', 'trashcan', 'ceilingfan', 'drawing', 'cpuscreen', 'hanger', 'floor', 'ceiling', 'phone', 'desk', 'keyboard', 'bookshelf', 'computer', 'ceilinglamp', 'balanceball', 'mousepad', 'oil', 'wall', 'nightstand', 'photoframe', 'doorjamb', 'mouse', 'dresser', 'cupboard', 'clothes_dress', 'door', 'light']
Task:Browse internet
response:

I want to surf the internet and look around at funny pictures.

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


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:['bathroom', 'detergent', 'cat', 'knife', 'food_egg', 'character', 'stamp', 'bedroom', 'desk', 'mat', 'ceilinglamp', 'shower', 'faucet', 'stereo', 'window', 'oil', 'mousepad', 'clothes_hat', 'towel', 'pillow', 'dining_room', 'powersocket', 'coin', 'console', 'towel_rack', 'dishrack', 'cupboard', 'maindoor', 'sink', 'bag']
Task:Keep cats out of room
response:
{
    "thoughts": Stand in the doorway and create a loud noise so the cats will stay out.,
    "actions": ['[WALK] <bedroom>', '[WALK] <cat>', '[FIND] <cat>', '[TURNTO] <cat>', '[LOOKAT] <cat>', '[FIND] <cat>', '[TURNTO] <cat>', '[LOOKAT] <cat>']
}

Input:
Scene_Objects:['tablelamp', 'toilet', 'chair', 'nail_polish', 'trashcan', 'ceilingfan', 'drawing', 'cpuscreen', 'clothes_underwear', 'floor', 'ceiling', 'phone', 'desk', 'keyboard', 'bookshelf', 'computer', 'mail', 'ceilinglamp', 'balanceball', 'mousepad', 'dustpan', 'towel', 'food_kiwi', 'wall', 'nightstand', 'novel', 'doorjamb', 'mouse', 'home_office', 'light']
Task:Write an email
response:

go to the office and use the computer to write and email

[WALK] <home_office>
[WALK] <computer>
[FIND] <computer>
[SWITCHON] <computer>
[FIND] <mail>
[OPEN] <mail>
[FIND] <keyboard>
[TYPE] <keyboard>


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

Here is an example plan to achieve a goal for reference:
Scene_Objects:['scissors', 'walllamp', 'bathroom', 'knifeblock', 'wallshelf', 'floor', 'ceiling', 'bookshelf', 'keyboard', 'stovefan', 'ceilinglamp', 'tvstand', 'shower', 'plate', 'window', 'toaster', 'clothes_pants', 'broom', 'powersocket', 'bench', 'bed', 'check', 'food_food', 'coffe_maker', 'after_shave', 'dresser', 'hair', 'door', 'sink', 'clothes_shirt']
Task:Get dressed
response:
{
    "thoughts": Get some clothes together that make an appropriate outfit.  Put them on,
    "actions": ['[WALK] <bedroom>', '[WALK] <dresser>', '[FIND] <dresser>', '[OPEN] <dresser>', '[FIND] <clothes_pants>', '[GRAB] <clothes_pants>', '[PUTON] <clothes_pants>', '[FIND] <clothes_shirt>', '[GRAB] <clothes_shirt>', '[PUTON] <clothes_shirt>', '[CLOSE] <dresser>']
}

Input:
Scene_Objects:['spectacles', 'tea', 'ground_coffee', 'walllamp', 'hanger', 'longboard', 'floor', 'ceiling', 'button', 'toaster', 'faucet', 'mousepad', 'candle', 'wall', 'nightstand', 'powersocket', 'keys', 'novel', 'coffe_maker', 'clothes_gloves', 'coffee_filter', 'water', 'ice', 'tray', 'food_onion', 'cupboard', 'door', 'light', 'dishwasher', 'soap']
Task:Make coffee
response:

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

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


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

Here is an example plan to achieve a goal for reference:
Scene_Objects:['fork', 'tablelamp', 'crayon', 'microwave', 'drawing', 'bills', 'cpuscreen', 'longboard', 'floor', 'bookshelf', 'computer', 'button', 'table_cloth', 'toaster', 'ceilinglamp', 'faucet', 'window', 'oil', 'couch', 'food_jam', 'food_orange', 'wall', 'bench', 'mouthwash', 'television', 'cupboard', 'table', 'clothes_skirt', 'light', 'tooth_paste']
Task:Relax on sofa
response:
{
    "thoughts": walk into living room, look at the sofa which one is available, sit on the sofa, now take relax on the sofa,
    "actions": ['[WALK] <home_office>', '[WALK] <couch>', '[FIND] <couch>', '[TURNTO] <couch>', '[LOOKAT] <couch>', '[SIT] <couch>']
}

Input:
Scene_Objects:['toilet', 'ceilingfan', 'drawing', 'floor', 'ceiling', 'keyboard', 'ceilinglamp', 'laptop', 'faucet', 'tvstand', 'window', 'couch', 'microphone', 'towel', 'pillow', 'wall', 'oven', 'powersocket', 'photoframe', 'novel', 'food_food', 'television', 'tray', 'mouse', 'dresser', 'sink', 'clothes_scarf', 'home_office', 'table', 'clothes_skirt']
Task:Relax on sofa
response:

I walk to the living room. I see the couch.  I sit down on the couch, then lie down and put my feet up.

[WALK] <home_office>
[WALK] <couch>
[FIND] <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', 'tablelamp', 'food_salt', 'microwave', 'toilet', 'walllamp', 'drawing', 'needle', 'hanger', 'bathroom_counter', 'ceiling', 'bedroom', 'desk', 'computer', 'bookmark', 'stovefan', 'plate', 'tvstand', 'dish_soap', 'closetdrawer', 'dining_room', 'wall', 'wall_clock', 'oven', 'powersocket', 'curtain', 'kitchen_counter', 'sink', 'bathroom_cabinet', 'dishwasher']
Task:Wash dishes with dishwasher
response:
{
    "thoughts": 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.,
    "actions": ['[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>']
}

Input:
Scene_Objects:['tablelamp', 'toilet', 'chair', 'trashcan', 'ceilingfan', 'drawing', 'cpuscreen', 'floor', 'ceiling', 'phone', 'desk', 'bedroom', 'keyboard', 'bookshelf', 'computer', 'alcohol', 'ceilinglamp', 'balanceball', 'mousepad', 'wall', 'nightstand', 'food_cheese', 'toothbrush_holder', 'doorjamb', 'towel_rack', 'mouse', 'cupboard', 'bathroom_cabinet', 'light', 'home_office']
Task:Work
response:

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


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

Here is an example plan to achieve a goal for reference:
Scene_Objects:['sheets', 'food_ice_cream', 'measuring_cup', 'knife', 'orchid', 'cpuscreen', 'bathroom_counter', 'ceiling', 'phone', 'alcohol', 'computer', 'table_cloth', 'mat', 'deck_of_cards', 'stereo', 'window', 'pillow', 'powersocket', 'cup', 'newspaper', 'check', 'ice', 'after_shave', 'lighter', 'diary', 'cd', 'cupboard', 'maindoor', 'colander', 'board_game']
Task:Listen to music
response:
{
    "thoughts": Find radio, turn it on,
    "actions": ['[WALK] <home_office>', '[WALK] <stereo>', '[FIND] <stereo>', '[SWITCHON] <stereo>']
}

Input:
Scene_Objects:['pot', 'scissors', 'freezer', 'bathroom', 'orchid', 'cpuscreen', 'hanger', 'floor', 'ceiling', 'bookshelf', 'piano_bench', 'ceilinglamp', 'tvstand', 'faucet', 'clothes_socks', 'pillow', 'wall', 'nightstand', 'bed', 'newspaper', 'food_onion', 'doorjamb', 'towel_rack', 'shoes', 'dresser', 'hair', 'hairdryer', 'maindoor', 'spoon', 'table']
Task:Put groceries in Fridge
response:

In the kitchen where I left the bags of groceries, I grab cheese from the grocery bag, I walk over to the refrigerator, open it up, neatly put cheese in the fridge, Close the 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:['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:['water_glass', 'microwave', 'needle', 'kitchen_cabinet', 'desk', 'alcohol', 'mat', 'ceilinglamp', 'balanceball', 'window', 'couch', 'clothes_pants', 'dining_room', 'nightstand', 'wall', 'wall_clock', 'oven', 'toilet_paper', 'mouthwash', 'water', 'ice', 'tray', 'rag', 'doorjamb', 'towel_rack', 'coffee_pot', 'pencil', 'door', 'dishwasher', 'vase']
Task:Drink
response:

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


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

Here is an example plan to achieve a goal for reference:
Scene_Objects:['microwave', 'chair', 'walllamp', 'food_carrot', 'orchid', 'knife', 'cpuscreen', 'floor', 'ceiling', 'phone', 'desk', 'keyboard', 'bookshelf', 'computer', 'food_bacon', 'ceilinglamp', 'mat', 'tvstand', 'stereo', 'mousepad', 'couch', 'wall', 'powersocket', 'toy', 'photoframe', 'mouse', 'controller', 'door', 'table', 'light']
Task:Browse internet
response:
{
    "thoughts": turn on the computer and browse the internet,
    "actions": ['[WALK] <home_office>', '[WALK] <computer>', '[FIND] <computer>', '[SWITCHON] <computer>']
}

Input:
Scene_Objects:['pot', 'filing_cabinet', 'food_pizza', 'food_salt', 'jelly', 'band-aids', 'drawing', 'orchid', 'cpuscreen', 'floor', 'ceiling', 'phone', 'desk', 'bookshelf', 'keyboard', 'computer', 'mat', 'ceilinglamp', 'broom', 'wall', 'powersocket', 'doorjamb', 'lighter', 'door', 'sink', 'light', 'table', 'laser_pointer', 'clothes_shirt', 'creditcard']
Task:Turn on light
response:

I go into my room, find the light,  then turn on the lights.

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


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

Here is an example plan to achieve a goal for reference:
Scene_Objects:['blender', 'toilet', 'chair', 'walllamp', 'detergent', 'food_carrot', 'orchid', 'cpuscreen', 'hanger', 'bathroom_counter', 'floor', 'ceiling', 'phone', 'desk', 'keyboard', 'computer', 'bookmark', 'mat', 'window', 'mousepad', 'broom', 'wall', 'wall_clock', 'nightstand', 'novel', 'coin', 'lighter', 'centerpiece', 'mouse', 'dresser']
Task:Read book
response:
{
    "thoughts": find a book to read. sit down. read the book.,
    "actions": ['[WALK] <home_office>', '[WALK] <novel>', '[FIND] <novel>', '[GRAB] <novel>', '[WALK] <chair>', '[SIT] <chair>', '[READ] <novel>']
}

Input:
Scene_Objects:['water_glass', 'pot', 'food_salt', 'mop', 'freezer', 'walllamp', 'detergent', 'knifeblock', 'floor', 'ceiling', 'purse', 'button', 'piano_bench', 'food_bacon', 'stovefan', 'ceilinglamp', 'tvstand', 'faucet', 'form', 'wall', 'bench', 'food_food', 'television', 'water', 'kitchen_counter', 'cupboard', 'food_steak', 'sink', 'maindoor', 'table']
Task:Drink
response:

I need to go to Kitchen.  Get a cup.  Fill cup.  Drink

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


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

Here is an example plan to achieve a goal for reference:
Scene_Objects:['fork', 'filing_cabinet', 'chair', 'drawing', 'bills', 'knife', 'floor', 'ceilinglamp', 'stereo', 'window', 'couch', 'food_jam', 'form', 'towel', 'dining_room', 'wall', 'basket_for_clothes', 'photoframe', 'novel', 'food_food', 'check', 'television', 'oven_mitts', 'razor', 'tray', 'pencil', 'dresser', 'pajamas', 'table', 'soap']
Task:Read book
response:
{
    "thoughts": Sit and read,
    "actions": ['[WALK] <home_office>', '[WALK] <filing_cabinet>', '[OPEN] <filing_cabinet>', '[FIND] <novel>', '[GRAB] <novel>', '[CLOSE] <filing_cabinet>', '[WALK] <couch>', '[SIT] <couch>', '[READ] <novel>']
}

Input:
Scene_Objects:['tablelamp', 'microwave', 'board_game', 'walllamp', 'bathroom', 'ceilingfan', 'drawing', 'longboard', 'phone', 'ceiling', 'dvd_player', 'bedroom', 'tea_bag', 'stamp', 'keyboard', 'stovefan', 'plate', 'picture', 'form', 'pillow', 'oven', 'television', 'centerpiece', 'shoes', 'cd', 'bag', 'dishwasher', 'soap', 'tooth_paste', 'creditcard']
Task:Pet cat
response:

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


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

Here is an example plan to achieve a goal for reference:
Scene_Objects:['fork', 'chair', 'walllamp', 'drawing', 'wallshelf', 'hanger', 'floor', 'ceiling', 'desk', 'remote_control', 'computer', 'mat', 'tvstand', 'ceilinglamp', 'closetdrawer', 'couch', 'form', 'pillow', 'wall', 'pasta', 'powersocket', 'photoframe', 'television', 'food_donut', 'curtain', 'doorjamb', 'chessboard', 'dresser', 'laundry_detergent', 'table']
Task:Watch TV
response:
{
    "thoughts": walk to living room, find couch, sit on couch, find remote control , turn on tv by pressing button,
    "actions": ['[WALK] <home_office>', '[WALK] <couch>', '[FIND] <couch>', '[SIT] <couch>', '[FIND] <remote_control>', '[FIND] <television>', '[TURNTO] <television>']
}

Input:
Scene_Objects:['filing_cabinet', 'microwave', 'ceilingfan', 'drawing', 'knifeblock', 'knife', 'floor', 'ceiling', 'remote_control', 'ceilinglamp', 'tvstand', 'balanceball', 'mat', 'window', 'stereo', 'food_noodles', 'couch', 'dustpan', 'form', 'dining_room', 'wall', 'powersocket', 'oven', 'check', 'television', 'curtain', 'kitchen_counter', 'cd', 'table', 'vase']
Task:Watch TV
response:

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


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

Here is an example plan to achieve a goal for reference:
Scene_Objects:['pot', 'chair', 'walllamp', 'bathroom', 'cpuscreen', 'hanger', 'floor', 'ceiling', 'character', 'desk', 'keyboard', 'computer', 'ceilinglamp', 'tvstand', 'window', 'mousepad', 'wall', 'wall_clock', 'powersocket', 'oven', 'check', 'television', 'oven_mitts', 'doorjamb', 'mouse', 'kitchen_counter', 'sink', 'napkin', 'table', 'shoe_rack']
Task:Browse internet
response:
{
    "thoughts": I will walk to the computer at the desk in my home office, sit in the chair, turn on the computer, open a web browser, type in the address, and view the computer.,
    "actions": ['[WALK] <home_office>', '[WALK] <desk>', '[FIND] <chair>', '[SIT] <chair>', '[FIND] <computer>', '[SWITCHON] <computer>', '[FIND] <mouse>', '[GRAB] <mouse>', '[TOUCH] <mouse>', '[FIND] <keyboard>', '[GRAB] <keyboard>', '[TYPE] <keyboard>', '[TURNTO] <computer>', '[LOOKAT] <computer>']
}

Input:
Scene_Objects:['pot', 'filing_cabinet', 'freezer', 'bathroom', 'drawing', 'cpuscreen', 'floor', 'ceiling', 'phone', 'character', 'desk', 'bookshelf', 'keyboard', 'computer', 'clothes_jacket', 'table_cloth', 'mat', 'food_kiwi', 'wall', 'powersocket', 'clothes_gloves', 'food_food', 'coffe_maker', 'doorjamb', 'coffee_pot', 'headset', 'door', 'hairdryer', 'light', 'tooth_paste']
Task:Turn on light
response:

I walk towards to the bedroom, and I open the door of the bedroom, and I switch on the lights inside the bedroom, the switch is beside the door.

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


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

Here is an example plan to achieve a goal for reference:
Scene_Objects:['tablelamp', 'toilet', 'bathroom', 'orchid', 'cpuscreen', 'wallshelf', 'floor', 'phone', 'character', 'bedroom', 'toaster', 'ceilinglamp', 'stovefan', 'wall_clock', 'powersocket', 'bed', 'food_food', 'television', 'wooden_spoon', 'kitchen_counter', 'dresser', 'cupboard', 'door', 'sink', 'hairdryer', 'home_office', 'light', 'clothes_skirt', 'bathtub', 'bathroom_cabinet']
Task:Read book
response:
{
    "thoughts": pick up your book and read it,
    "actions": ['[WALK] <bedroom>', '[WALK] <novel>', '[GRAB] <novel>', '[READ] <novel>']
}

Input:
Scene_Objects:['toilet', 'walllamp', 'drawing', 'orchid', 'knifeblock', 'bathroom_counter', 'floor', 'ceiling', 'table_cloth', 'mat', 'ceilinglamp', 'shower', 'plate', 'wall', 'nightstand', 'powersocket', 'food_cheese', 'bed', 'coffe_maker', 'tray', 'curtain', 'towel_rack', 'dresser', 'controller', 'clothes_scarf', 'home_office', 'bathroom_cabinet', 'board_game', 'scrabble', 'teeth']
Task:Take shower
response:

walk to bathroom , find shower , take a shower

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


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

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

Input:
Scene_Objects:['pot', 'measuring_cup', 'walllamp', 'bathroom', 'trashcan', 'ceilingfan', 'orchid', 'cpuscreen', 'hanger', 'floor', 'ceiling', 'shampoo', 'character', 'toaster', 'mat', 'dish_soap', 'couch', 'wall', 'nightstand', 'oven', 'powersocket', 'bench', 'photoframe', 'coffe_maker', 'tray', 'doorjamb', 'shaving_cream', 'cupboard', 'food_steak', 'dishwasher']
Task:Wash dishes with dishwasher
response:

I go to the dishwasher and put dish soap. I close the dishwasher and turn it on.

[WALK] <dining_room>
[WALK] <dishwasher>
[FIND] <dishwasher>
[OPEN] <dishwasher>
[FIND] <dish_soap>
[GRAB] <dish_soap>
[PUTBACK] <dish_soap> <dishwasher>
[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', 'filing_cabinet', 'scissors', 'mop', 'microwave', 'toilet', 'walllamp', 'drawing', 'orchid', 'cpuscreen', 'floor', 'desk', 'bookshelf', 'tvstand', 'shower', 'stereo', 'mousepad', 'wall', 'powersocket', 'photoframe', 'bed', 'food_food', 'television', 'curtain', 'doorjamb', 'coffee_pot', 'chessboard', 'laundry_detergent', 'door', 'board_game']
Task:Go to toilet
response:
{
    "thoughts": walk to bathroom , run to toilet,
    "actions": ['[WALK] <bathroom>', '[RUN] <toilet>']
}

Input:
Scene_Objects:['chair', 'band-aids', 'trashcan', 'dough', 'knifeblock', 'cpuscreen', 'hanger', 'floor', 'ceiling', 'shampoo', 'dvd_player', 'desk', 'bookshelf', 'keyboard', 'computer', 'stovefan', 'mat', 'tvstand', 'shower', 'mousepad', 'food_orange', 'wall', 'oven', 'keys', 'mouse', 'shoes', 'hair', 'dishwasher', 'vase', 'coffee']
Task:Read book
response:

find a book to read. sit down. read the book.

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


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

Here is an example plan to achieve a goal for reference:
Scene_Objects:['mop', 'toilet', 'freezer', 'food_carrot', 'cpuscreen', 'bathroom_counter', 'floor', 'ceiling', 'piano_bench', 'stovefan', 'mat', 'faucet', 'wall', 'wall_clock', 'oven', 'cutting_board', 'toilet_paper', 'video_game_controller', 'television', 'tray', 'doorjamb', 'towel_rack', 'coffee_pot', 'kitchen_counter', 'dresser', 'conditioner', 'sink', 'bathroom_cabinet', 'light', 'teeth']
Task:Wash teeth
response:
{
    "thoughts": Walk to bathroom.  Find mouthwash or turn on water.  Put mouthwash or water in mouth.  Swish around for 30 seconds.  Spit mouthwash out.,
    "actions": ['[WALK] <bathroom>', '[WALK] <faucet>', '[FIND] <faucet>', '[SWITCHON] <faucet>', '[FIND] <teeth>', '[RINSE] <teeth>']
}

Input:
Scene_Objects:['glue', 'pot', 'scissors', 'walllamp', 'detergent', 'drawing', 'clothes_underwear', 'floor', 'phone', 'character', 'button', 'toaster', 'plate', 'tvstand', 'dish_soap', 'oil', 'candle', 'wall', 'oven', 'tape', 'box', 'coffe_maker', 'food_food', 'check', 'tray', 'centerpiece', 'controller', 'light', 'dishwasher', 'soap']
Task:Wash dishes with dishwasher
response:

walk into kitchen, find dishwasher, put plates in dishwasher, put soap in dishwasher, turn on dishwasher

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


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', 'chair', 'walllamp', 'ground_coffee', 'detergent', 'trashcan', 'orchid', 'drawing', 'bedroom', 'tea_bag', 'bookshelf', 'envelope', 'alcohol', 'computer', 'ceilinglamp', 'mat', 'shower', 'deck_of_cards', 'food_noodles', 'microphone', 'bowl', 'wall', 'bench', 'powersocket', 'photoframe', 'television', 'dresser', 'napkin', 'table', 'clothes_shirt']
Task:Pet cat
response:
{
    "thoughts": First I need to find the cat in the living room. Then I walk over to the cat and pet it gently.,
    "actions": ['[WALK] <home_office>', '[WALK] <cat>', '[FIND] <cat>', '[WALK] <cat>', '[TOUCH] <cat>']
}

Input:
Scene_Objects:['toilet', 'chair', 'freezer', 'hanger', 'floor', 'ceiling', 'phone', 'dvd_player', 'character', 'desk', 'bedroom', 'bookshelf', 'envelope', 'computer', 'ceilinglamp', 'stereo', 'wall', 'pasta', 'cup', 'tray', 'doorjamb', 'dresser', 'cupboard', 'hair', 'clothes_dress', 'door', 'clothes_scarf', 'maindoor', 'light', 'dishwasher']
Task:Turn on light
response:

Walk to the Living Room. Switch on 1 light. Walk to dining room. Switch on 1 light. Walk to Entrance hall. Switch on 1 light.

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


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

Here is an example plan to achieve a goal for reference:
Scene_Objects:['food_pizza', 'freezer', 'trashcan', 'drawing', 'bathroom_counter', 'ceiling', 'phone', 'thread', 'computer', 'stovefan', 'faucet', 'shower', 'food_jam', 'dining_room', 'wall', 'powersocket', 'tape', 'coffe_maker', 'food_food', 'mirror', 'doorjamb', 'mouse', 'paper_towel', 'dresser', 'cupboard', 'sink', 'clothes_scarf', 'bathroom_cabinet', 'home_office', 'dirt']
Task:Clean  mirror
response:
{
    "thoughts": Spray Windex or glass and mirror cleaner onto mirror. Use paper towel to wipe off cleaner until mirror is dry and has no streaks.,
    "actions": ['[WALK] <bathroom>', '[WALK] <bathroom_cabinet>', '[FIND] <bathroom_cabinet>', '[OPEN] <bathroom_cabinet>', '[FIND] <paper_towel>', '[GRAB] <paper_towel>', '[CLOSE] <bathroom_cabinet>', '[WALK] <mirror>', '[WIPE] <mirror>', '[FIND] <trashcan>', '[PUTBACK] <paper_towel> <trashcan>']
}

Input:
Scene_Objects:['pot', 'toilet', 'jelly', 'band-aids', 'chair', 'drawing', 'cpuscreen', 'bathroom_counter', 'floor', 'shampoo', 'ceiling', 'desk', 'keyboard', 'purse', 'brush', 'toaster', 'shoe-shine_kit', 'plate', 'faucet', 'mousepad', 'towel', 'dining_room', 'wall', 'photoframe', 'newspaper', 'coffe_maker', 'toothbrush_holder', 'mouse', 'door', 'home_office']
Task:Go to toilet
response:

I walk into the bathroom. I walk over to the toilet. I sit on the toilet.

[WALK] <bathroom>
[WALK] <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:['pot', 'freezer', 'ceilingfan', 'drawing', 'knifeblock', 'floor', 'ceiling', 'phone', 'tea_bag', 'computer', 'button', 'bookmark', 'ceilinglamp', 'tvstand', 'balanceball', 'window', 'foundation', 'couch', 'clothes_hat', 'wall', 'oven', 'bench', 'television', 'curtain', 'vacuum_cleaner', 'dresser', 'maindoor', 'spoon', 'home_office', 'table']
Task:Watch TV
response:
{
    "thoughts": walk to living room, find the television, switch on the television, find the sofa, walk to sofa, sit in sofa, watch the television,
    "actions": ['[WALK] <home_office>', '[WALK] <television>', '[FIND] <television>', '[SWITCHON] <television>', '[FIND] <couch>', '[WALK] <couch>', '[SIT] <couch>', '[TURNTO] <television>', '[WATCH] <television>']
}

Input:
Scene_Objects:['pot', 'tablelamp', 'chair', 'bathroom', 'trashcan', 'ceilingfan', 'drawing', 'cpuscreen', 'bathroom_counter', 'floor', 'ceiling', 'phone', 'desk', 'keyboard', 'bookshelf', 'computer', 'ceilinglamp', 'deck_of_cards', 'balanceball', 'mousepad', 'dustpan', 'wall', 'nightstand', 'photoframe', 'wine', 'doorjamb', 'mouse', 'dresser', 'light', 'colander']
Task:Browse internet
response:

Go find a computer, turn it on, click google, and browse the internet.

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


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

Here is an example plan to achieve a goal for reference:
Scene_Objects:['filing_cabinet', 'tablelamp', 'chair', 'freezer', 'drawing', 'orchid', 'floor', 'ceiling', 'desk', 'bedroom', 'bookshelf', 'computer', 'mat', 'shoe-shine_kit', 'oil', 'pillow', 'wall', 'pasta', 'powersocket', 'cup', 'food_food', 'video_game_controller', 'toothbrush_holder', 'television', 'doorjamb', 'kettle', 'door', 'light', 'clothes_skirt', 'coffee']
Task:Turn on light
response:
{
    "thoughts": switching on light in an area,
    "actions": ['[WALK] <home_office>', '[WALK] <light>', '[FIND] <light>', '[SWITCHON] <light>']
}

Input:
Scene_Objects:['tablelamp', 'bathroom', 'ceilingfan', 'drawing', 'cpuscreen', 'floor', 'ceiling', 'remote_control', 'purse', 'button', 'ceilinglamp', 'tvstand', 'balanceball', 'window', 'homework', 'couch', 'dining_room', 'wall', 'bench', 'food_food', 'coffe_maker', 'television', 'toilet_paper', 'wooden_spoon', 'curtain', 'pencil', 'shoes', 'table', 'light', 'vase']
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:['food_pizza', 'drawing', 'orchid', 'floor', 'ceiling', 'phone', 'computer', 'tvstand', 'plate', 'faucet', 'shower', 'couch', 'pillow', 'dining_room', 'wall', 'pasta', 'newspaper', 'novel', 'check', 'toilet_paper', 'food_food', 'doorjamb', 'towel_rack', 'kitchen_counter', 'cupboard', 'controller', 'door', 'table', 'light', 'dishwasher']
Task:Relax on sofa
response:
{
    "thoughts": I walk into the living room. I cross the room to the couch. I sit down and relax.,
    "actions": ['[WALK] <home_office>', '[WALK] <couch>', '[SIT] <couch>']
}

Input:
Scene_Objects:['pot', 'walllamp', 'knifeblock', 'orchid', 'cpuscreen', 'drawing', 'bathroom_counter', 'floor', 'ceiling', 'shampoo', 'food_bacon', 'table_cloth', 'stovefan', 'faucet', 'dining_room', 'wall', 'oven', 'photoframe', 'novel', 'coffe_maker', 'drinking_glass', 'wine', 'shaving_cream', 'kitchen_counter', 'cupboard', 'maindoor', 'sink', 'bathroom_cabinet', 'dishwasher', 'scrabble']
Task:Drink
response:

First I go into the kitchen, open the cupboard and find a glass.Then I close the cupboard. Then I go to the sink, turn the faucet on fill the glass under the faucet. I turn off the faucet and then I drink.

[WALK] <dining_room>
[WALK] <cupboard>
[FIND] <cupboard>
[OPEN] <cupboard>
[FIND] <drinking_glass>
[GRAB] <drinking_glass>
[WALK] <sink>
[FIND] <faucet>
[SWITCHON] <faucet>
[PUTBACK] <drinking_glass> <sink>
[GRAB] <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:['tablelamp', 'juice', 'toilet', 'chair', 'trashcan', 'ceilingfan', 'drawing', 'cpuscreen', 'hanger', 'floor', 'ceiling', 'phone', 'desk', 'keyboard', 'bookshelf', 'computer', 'toaster', 'ceilinglamp', 'stovefan', 'balanceball', 'mat', 'mousepad', 'oil', 'wall', 'nightstand', 'photoframe', 'doorjamb', 'mouse', 'light', 'dishwasher']
Task:Work
response:
{
    "thoughts": Go to office, sit at desk, turn on computer, enter password, open application and begin work,
    "actions": ['[WALK] <home_office>', '[WALK] <computer>', '[FIND] <computer>', '[SWITCHON] <computer>', '[FIND] <keyboard>', '[TYPE] <keyboard>', '[FIND] <mouse>', '[PUSH] <mouse>', '[TURNTO] <computer>', '[LOOKAT] <computer>']
}

Input:
Scene_Objects:['spectacles', 'food_bread', 'filing_cabinet', 'tablelamp', 'chair', 'trashcan', 'ceilingfan', 'drawing', 'cpuscreen', 'floor', 'ceiling', 'phone', 'desk', 'keyboard', 'bookshelf', 'computer', 'ceilinglamp', 'deck_of_cards', 'balanceball', 'mousepad', 'food_noodles', 'pillow', 'wall', 'nightstand', 'oven', 'basket_for_clothes', 'doorjamb', 'towel_rack', 'mouse', 'light']
Task:Work
response:

walk to home office ,find computer ,switch on computer and work

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


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

Here is an example plan to achieve a goal for reference:
Scene_Objects:['food_salt', 'microwave', 'trashcan', 'drawing', 'floor', 'dvd_player', 'desk', 'envelope', 'ceilinglamp', 'tvstand', 'mat', 'window', 'mousepad', 'couch', 'pillow', 'dining_room', 'broom', 'wall', 'nightstand', 'cup', 'check', 'television', 'coin', 'colander', 'after_shave', 'cd', 'cupboard', 'table', 'vase', 'soap']
Task:Relax on sofa
response:
{
    "thoughts": Go to the living room. Find the sofa. Sit on the sofa. Close your eyes. Breath calmly. Relax,
    "actions": ['[WALK] <home_office>', '[WALK] <couch>', '[FIND] <couch>', '[SIT] <couch>']
}

Input:
Scene_Objects:['filing_cabinet', 'juice', 'cat', 'food_butter', 'orchid', 'hanger', 'floor', 'shampoo', 'phone', 'mat', 'shower', 'electric_shaver', 'dustpan', 'microphone', 'towel', 'pillow', 'dining_room', 'wall', 'bench', 'tape', 'food_cheese', 'check', 'wine', 'curtain', 'vacuum_cleaner', 'dresser', 'sink', 'napkin', 'bathroom_cabinet', 'vase']
Task:Read book
response:

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

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


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

Here is an example plan to achieve a goal for reference:
Scene_Objects:['drawing', 'bills', 'bathroom_counter', 'floor', 'ceiling', 'character', 'computer', 'toaster', 'ceilinglamp', 'window', 'food_noodles', 'couch', 'microphone', 'pillow', 'wall', 'newspaper', 'novel', 'coffe_maker', 'television', 'coin', 'toothbrush_holder', 'shoes', 'dresser', 'cupboard', 'laundry_detergent', 'bathroom_cabinet', 'table', 'vase', 'laser_pointer', 'creditcard']
Task:Read book
response:
{
    "thoughts": Sit on couch. Grab book. Open book. Read book.,
    "actions": ['[WALK] <couch>', '[SIT] <couch>', '[FIND] <novel>', '[GRAB] <novel>', '[READ] <novel>']
}

Input:
Scene_Objects:['sheets', 'filing_cabinet', 'chair', 'freezer', 'ground_coffee', 'ceilingfan', 'drawing', 'needle', 'floor', 'ceiling', 'bookshelf', 'remote_control', 'computer', 'food_bacon', 'ceilinglamp', 'tvstand', 'balanceball', 'window', 'couch', 'clothes_pants', 'wall', 'toy', 'food_food', 'television', 'oven_mitts', 'curtain', 'diary', 'headset', 'home_office', 'table']
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:['glue', 'pot', 'filing_cabinet', 'microwave', 'chair', 'cpuscreen', 'hanger', 'bathroom_counter', 'floor', 'ceiling', 'face', 'toaster', 'stovefan', 'faucet', 'oil', 'towel', 'wall', 'facial_cleanser', 'check', 'coffe_maker', 'tray', 'rag', 'mouse', 'kitchen_counter', 'dresser', 'door', 'sink', 'bathroom_cabinet', 'table', 'soap']
Task:Wash face
response:
{
    "thoughts": Turn the faucet on. Wet the face. Take facial cleanser out of packaging. Lather on face. Rinse face with water. Turn off the faucet. Dry face with towel.,
    "actions": ['[WALK] <bathroom>', '[WALK] <sink>', '[FIND] <faucet>', '[SWITCHON] <faucet>', '[FIND] <face>', '[WASH] <face>', '[FIND] <rag>', '[GRAB] <rag>', '[RINSE] <rag>', '[FIND] <facial_cleanser>', '[GRAB] <facial_cleanser>', '[POUR] <facial_cleanser> <rag>', '[PUTOBJBACK] <facial_cleanser>', '[SCRUB] <face>', '[RINSE] <rag>', '[PUTOBJBACK] <rag>', '[RINSE] <face>', '[SWITCHOFF] <faucet>', '[FIND] <towel>', '[GRAB] <towel>', '[WIPE] <face>', '[PUTOBJBACK] <towel>']
}

Input:
Scene_Objects:['chair', 'freezer', 'detergent', 'food_butter', 'trashcan', 'hanger', 'floor', 'phone', 'ceiling', 'bedroom', 'computer', 'button', 'mat', 'laptop', 'plate', 'window', 'wall', 'nightstand', 'bed', 'check', 'curtain', 'doorjamb', 'dresser', 'cupboard', 'controller', 'door', 'light', 'dishwasher', 'laser_pointer', 'shoe_rack']
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:['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:
{
    "thoughts": 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,
    "actions": ['[WALK] <home_office>', '[WALK] <couch>', '[FIND] <couch>', '[TURNTO] <couch>', '[LOOKAT] <couch>', '[SIT] <couch>', '[FIND] <cat>', '[TURNTO] <cat>', '[LOOKAT] <cat>', '[TOUCH] <cat>']
}

Input:
Scene_Objects:['food_bread', 'scissors', 'mop', 'chair', 'ceilingfan', 'milk', 'toothbrush', 'knifeblock', 'phone', 'bookshelf', 'stovefan', 'toaster', 'tvstand', 'shower', 'couch', 'food_peanut_butter', 'dustpan', 'oven', 'photoframe', 'clothes_gloves', 'bed', 'video_game_controller', 'tray', 'towel_rack', 'clothes_scarf', 'table', 'light', 'soap', 'tooth_paste', 'scrabble']
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:['filing_cabinet', 'freezer', 'bathroom', 'food_carrot', 'drawing', 'orchid', 'wallshelf', 'food_egg', 'bathroom_counter', 'shampoo', 'phone', 'mat', 'ceilinglamp', 'shower', 'electric_shaver', 'clothes_socks', 'couch', 'microphone', 'dining_room', 'food_kiwi', 'nightstand', 'wall', 'check', 'food_food', 'after_shave', 'mouse', 'kitchen_counter', 'cupboard', 'home_office', 'laser_pointer']
Task:Turn on light
response:
{
    "thoughts": I go home and it's dark so I can not see anything,
    "actions": ['[WALK] <home_office>', '[WALK] <floor_lamp>', '[FIND] <floor_lamp>', '[SWITCHON] <floor_lamp>']
}

Input:
Scene_Objects:['tablelamp', 'measuring_cup', 'toilet', 'drawing', 'bathroom_counter', 'floor', 'ceiling', 'longboard', 'button', 'ceilinglamp', 'faucet', 'oil', 'teeth', 'clothes_hat', 'towel', 'wall', 'photoframe', 'bed', 'doorjamb', 'diary', 'kitchen_counter', 'dishrack', 'coffee', 'hairbrush', 'maindoor', 'sink', 'bathroom_cabinet', 'vase', '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:['fork', 'filing_cabinet', 'blender', 'chair', 'freezer', 'walllamp', 'nail_polish', 'detergent', 'drawing', 'knife', 'wallshelf', 'bathroom_counter', 'floor', 'desk', 'computer', 'mat', 'ceilinglamp', 'plate', 'faucet', 'mousepad', 'candle', 'microphone', 'bowl', 'wall', 'nightstand', 'bench', 'bed', 'keys', 'food_food', 'table']
Task:Eat
response:
{
    "thoughts": I get my prepared dinner set on the dining table, sit down on chair, pick up utensils, eat food,
    "actions": ['[WALK] <dining_room>', '[WALK] <food_food>', '[FIND] <food_food>', '[GRAB] <food_food>', '[WALK] <dining_room>', '[WALK] <table>', '[FIND] <table>', '[PUTBACK] <food_food> <table>', '[FIND] <chair>', '[SIT] <chair>', '[FIND] <fork>', '[GRAB] <fork>', '[FIND] <knife>', '[GRAB] <knife>', '[FIND] <plate>', '[EAT] <plate>']
}

Input:
Scene_Objects:['blender', 'dog', 'band-aids', 'drawing', 'bathroom_counter', 'floor', 'longboard', 'bedroom', 'food_cake', 'computer', 'table_cloth', 'ceilinglamp', 'tvstand', 'faucet', 'mat', 'window', 'couch', 'dustpan', 'clothes_pants', 'bowl', 'wall', 'television', 'oven_mitts', 'after_shave', 'doorjamb', 'towel_rack', 'cards', 'shoes', 'home_office', 'table']
Task:Relax on sofa
response:

I walk into the living room. I bend down. I sit on the sofa.

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


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

Here is an example plan to achieve a goal for reference:
Scene_Objects:['tablelamp', 'chair', 'walllamp', 'bathroom', 'orchid', 'cpuscreen', 'wallshelf', 'hanger', 'clothes_underwear', 'floor', 'ceiling', 'phone', 'desk', 'keyboard', 'computer', 'ceilinglamp', 'tvstand', 'mat', 'mousepad', 'couch', 'pillow', 'wall', 'nightstand', 'check', 'television', 'doorjamb', 'mouse', 'dresser', 'door', 'light']
Task:Research
response:
{
    "thoughts": I read different articles online to gain a better understanding of a particular business, industry, method, terminology, etc.,
    "actions": ['[WALK] <home_office>', '[WALK] <computer>', '[FIND] <computer>', '[SWITCHON] <computer>', '[TURNTO] <computer>', '[LOOKAT] <computer>', '[FIND] <check>', '[GRAB] <check>', '[READ] <check>']
}

Input:
Scene_Objects:['tablelamp', 'chair', 'freezer', 'nail_polish', 'trashcan', 'bills', 'drawing', 'hanger', 'bathroom_counter', 'character', 'bedroom', 'keyboard', 'computer', 'stereo', 'shower', 'form', 'dining_room', 'powersocket', 'oven', 'bench', 'cup', 'coffe_maker', 'mouthwash', 'television', 'coin', 'wooden_spoon', 'tray', 'doorjamb', 'mouse', 'bathroom_cabinet']
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:['tablelamp', 'freezer', 'bathroom', 'drawing', 'knifeblock', 'cpuscreen', 'bathroom_counter', 'floor', 'ceiling', 'phone', 'bedroom', 'desk', 'bookshelf', 'shower', 'homework', 'wall', 'powersocket', 'box', 'bed', 'coffe_maker', 'television', 'after_shave', 'doorjamb', 'towel_rack', 'mouse', 'cards', 'cupboard', 'home_office', 'light', 'dishwasher']
Task:Turn on light
response:
{
    "thoughts": Walk into living room. Find wall. Find light button. Switch on light button.,
    "actions": ['[WALK] <home_office>', '[WALK] <light>', '[FIND] <light>', '[SWITCHON] <light>']
}

Input:
Scene_Objects:['pot', 'food_bread', 'food_ice_cream', 'toilet', 'chair', 'freezer', 'ceilingfan', 'drawing', 'longboard', 'floor', 'ceiling', 'remote_control', 'ceilinglamp', 'tvstand', 'balanceball', 'mat', 'window', 'oil', 'couch', 'wall', 'bench', 'mouthwash', 'television', 'curtain', 'shaving_cream', 'mouse', 'headset', 'bathroom_cabinet', 'table', 'light']
Task:Watch TV
response:

go to the living room. find the remote. sit on the couch. turn on the tv.

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


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

Here is an example plan to achieve a goal for reference:
Scene_Objects:['sheets', 'juice', 'microwave', 'freezer', 'bills', 'floor', 'ceiling', 'desk', 'tea_bag', 'computer', 'ceilinglamp', 'plate', 'window', 'mousepad', 'couch', 'dining_room', 'broom', 'wall', 'powersocket', 'novel', 'food_food', 'mouthwash', 'television', 'curtain', 'rag', 'towel_rack', 'kitchen_counter', 'comb', 'door', 'laser_pointer']
Task:Put groceries in Fridge
response:
{
    "thoughts": Walk to the kitchen. Open the fridge, take the groceries and put in it. Closed the fridge,,
    "actions": ['[WALK] <dining_room>', '[WALK] <freezer>', '[FIND] <freezer>', '[OPEN] <freezer>', '[FIND] <food_food>', '[GRAB] <food_food>', '[PUTIN] <food_food> <freezer>', '[CLOSE] <freezer>']
}

Input:
Scene_Objects:['food_pizza', 'filing_cabinet', 'tablelamp', 'chair', 'freezer', 'detergent', 'hanger', 'floor', 'ceiling', 'phone', 'purse', 'computer', 'mail', 'toaster', 'tvstand', 'mousepad', 'wall', 'check', 'ice', 'tray', 'doorjamb', 'towel_rack', 'coffee_pot', 'cards', 'dresser', 'cupboard', 'door', 'napkin', 'light', 'scrabble']
Task:Pick up phone
response:

I walk over to the phone. .I reach my arm out. I open my hand. I place my hand on the phone. I close my fingers around the phone. I pick up the phone.

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


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

Here is an example plan to achieve a goal for reference:
Scene_Objects:['filing_cabinet', 'tablelamp', 'chair', 'ground_coffee', 'wallshelf', 'hanger', 'floor', 'stamp', 'desk', 'bookshelf', 'tea_bag', 'envelope', 'computer', 'mop_bucket', 'mat', 'shower', 'foundation', 'form', 'wall', 'powersocket', 'cutting_board', 'photoframe', 'novel', 'check', 'television', 'wooden_spoon', 'after_shave', 'doorjamb', 'door', 'light']
Task:Read to child
response:
{
    "thoughts": Read a book out loud to a child,
    "actions": ['[WALK] <bedroom>', '[WALK] <child>', '[FIND] <child>', '[GREET] <child>', '[WALK] <filing_cabinet>', '[OPEN] <filing_cabinet>', '[FIND] <novel>', '[GRAB] <novel>', '[WALK] <chair>', '[PULL] <chair>', '[SIT] <chair>', '[TURNTO] <novel>', '[LOOKAT] <novel>', '[TURNTO] <novel>', '[POINTAT] <novel>', '[TURNTO] <novel>', '[POINTAT] <novel>', '[READ] <novel>', '[READ] <novel>', '[READ] <novel>']
}

Input:
Scene_Objects:['pot', 'food_bread', 'freezer', 'food_butter', 'toothbrush', 'knifeblock', 'food_egg', 'cpuscreen', 'longboard', 'bathroom_counter', 'phone', 'ceiling', 'tea_bag', 'plate', 'shower', 'deck_of_cards', 'window', 'electric_shaver', 'dish_soap', 'broom', 'bench', 'powersocket', 'tape', 'mouthwash', 'centerpiece', 'shaving_cream', 'mouse', 'bathroom_cabinet', 'dishwasher', 'coffee']
Task:Wash dishes by hand
response:

Pick up dish.  Put in soapy water.  Wash dish.

[WALK] <dining_room>
[WALK] <dish_soap>
[FIND] <dish_soap>
[GRAB] <dish_soap>
[FIND] <plate>
[GRAB] <plate>
[PUTBACK] <dish_soap> <plate>
[SCRUB] <plate>
[RINSE] <plate>
[WIPE] <plate>


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

Here is an example plan to achieve a goal for reference:
Scene_Objects:['sponge', 'pot', 'blender', 'beer', 'microwave', 'knifeblock', 'cpuscreen', 'hanger', 'floor', 'ceiling', 'table_cloth', 'toaster', 'plate', 'faucet', 'tvstand', 'window', 'dish_soap', 'food_orange', 'wall', 'cup', 'bed', 'food_food', 'tray', 'wooden_spoon', 'mouse', 'pencil', 'kitchen_counter', 'dishrack', 'cupboard', 'sink']
Task:Wash dirty dishes
response:
{
    "thoughts": Wet the sponge, apply soap to sponge, scrub dishes, rinse dishes, place on dish rack.,
    "actions": ['[WALK] <dining_room>', '[WALK] <sink>', '[FIND] <sponge>', '[GRAB] <sponge>', '[FIND] <faucet>', '[SWITCHON] <faucet>', '[PUTBACK] <sponge> <sink>', '[GRAB] <sponge>', '[FIND] <dish_soap>', '[GRAB] <dish_soap>', '[POUR] <dish_soap> <sponge>', '[PUTOBJBACK] <dish_soap>', '[FIND] <plate>', '[GRAB] <plate>', '[SCRUB] <plate>', '[RINSE] <plate>', '[FIND] <dishrack>', '[PUTBACK] <plate> <dishrack>', '[FIND] <plate>', '[GRAB] <plate>', '[SCRUB] <plate>', '[RINSE] <plate>', '[PUTBACK] <plate> <dishrack>', '[RINSE] <sponge>', '[PUTOBJBACK] <sponge>', '[SWITCHOFF] <faucet>']
}

Input:
Scene_Objects:['tea', 'freezer', 'walllamp', 'knifeblock', 'kitchen_cabinet', 'floor', 'ceiling', 'dvd_player', 'desk', 'table_cloth', 'ceilinglamp', 'plate', 'mousepad', 'couch', 'candle', 'tape', 'light_bulb', 'novel', 'coin', 'water', 'drinking_glass', 'wine', 'tray', 'coffee_pot', 'mouse', 'cd', 'conditioner', 'maindoor', 'napkin', 'home_office']
Task:Drink
response:

You walk to the kitchen and open the kitchen cabinet and grab a drinking glass. You find the water and pour the water into the drinking glass. You drink the water from the glass.

[WALK] <dining_room>
[WALK] <kitchen_cabinet>
[FIND] <kitchen_cabinet>
[OPEN] <kitchen_cabinet>
[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:['filing_cabinet', 'tablelamp', 'dog', 'freezer', 'dough', 'knifeblock', 'knife', 'hanger', 'bathroom_counter', 'ceiling', 'toaster', 'tvstand', 'faucet', 'couch', 'pasta', 'powersocket', 'oven', 'photoframe', 'novel', 'television', 'wooden_spoon', 'curtain', 'coffee_pot', 'mouse', 'dresser', 'door', 'sink', 'home_office', 'light', 'bathroom_cabinet']
Task:Greet guests
response:
{
    "thoughts": Say hi,
    "actions": ['[WALK] <home_office>', '[WALK] <child>', '[FIND] <child>', '[GREET] <child>']
}

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

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:['tablelamp', 'crayon', 'tea', 'mop', 'microwave', 'toilet', 'toothbrush', 'drawing', 'knifeblock', 'orchid', 'phone', 'ceiling', 'computer', 'stovefan', 'toaster', 'tvstand', 'window', 'floor_lamp', 'couch', 'clothes_hat', 'photoframe', 'after_shave', 'food_onion', 'headset', 'chessboard', 'cupboard', 'controller', 'door', 'bathroom_cabinet', 'clothes_skirt']
Task:Switch on lamp
response:
{
    "thoughts": Press the button so the light comes on.,
    "actions": ['[WALK] <bedroom>', '[WALK] <floor_lamp>', '[FIND] <floor_lamp>', '[SWITCHON] <floor_lamp>']
}

Input:
Scene_Objects:['sheets', 'pot', 'chair', 'freezer', 'food_carrot', 'cpuscreen', 'bathroom_counter', 'floor', 'ceiling', 'thread', 'mail', 'ceilinglamp', 'mat', 'iron', 'balanceball', 'faucet', 'food_orange', 'pillow', 'wall', 'pasta', 'box', 'cup', 'newspaper', 'food_food', 'check', 'toilet_paper', 'chessboard', 'maindoor', 'napkin', 'creditcard']
Task:Put groceries in Fridge
response:

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


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

Here is an example plan to achieve a goal for reference:
Scene_Objects:['food_pizza', 'toilet', 'freezer', 'drawing', 'cpuscreen', 'floor', 'ceiling', 'envelope', 'table_cloth', 'stovefan', 'ceilinglamp', 'mat', 'shower', 'stereo', 'mousepad', 'towel', 'wall', 'powersocket', 'photoframe', 'bed', 'toilet_paper', 'tray', 'curtain', 'doorjamb', 'dresser', 'controller', 'door', 'food_steak', 'light', 'tooth_paste']
Task:Take shower
response:
{
    "thoughts": walk to bathroom , find shower , take a shower,
    "actions": ['[WALK] <bathroom>', '[WALK] <shower>', '[FIND] <shower>']
}

Input:
Scene_Objects:['filing_cabinet', 'food_salt', 'chair', 'blow_dryer', 'bathroom', 'drawing', 'knifeblock', 'bathroom_counter', 'floor', 'shampoo', 'bookshelf', 'purse', 'keyboard', 'ceilinglamp', 'deck_of_cards', 'shower', 'window', 'couch', 'wall', 'powersocket', 'tape', 'photoframe', 'television', 'food_rice', 'after_shave', 'controller', 'conditioner', 'door', 'table', 'scrabble']
Task:Relax on sofa
response:

I walk into the living room and I lie down on the sofa.

[WALK] <home_office>
[WALK] <couch>
[FIND] <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', 'food_pizza', 'tablelamp', 'food_ice_cream', 'crayon', 'shampoo', 'keyboard', 'mail', 'bookmark', 'stovefan', 'faucet', 'pillow', 'dining_room', 'broom', 'wall', 'love_seat', 'photoframe', 'novel', 'food_food', 'wine', 'tray', 'after_shave', 'shaving_cream', 'kettle', 'headset', 'pajamas', 'laundry_detergent', 'door', 'bathroom_cabinet', 'shoe_rack']
Task:Read book
response:
{
    "thoughts": Obtain a book from the book shelf. Sit in the easy chair.  Read the book.  Mark the stopping point with a bookmark.  Put the book back on the book shelf.,
    "actions": ['[WALK] <home_office>', '[WALK] <novel>', '[FIND] <novel>', '[GRAB] <novel>', '[FIND] <love_seat>', '[SIT] <love_seat>', '[READ] <novel>', '[FIND] <bookmark>', '[GRAB] <bookmark>', '[PUTBACK] <bookmark> <novel>', '[PUTOBJBACK] <novel>']
}

Input:
Scene_Objects:['sheets', 'filing_cabinet', 'beer', 'jelly', 'bathroom', 'ceilingfan', 'drawing', 'floor', 'ceiling', 'keyboard', 'clothes_jacket', 'table_cloth', 'toaster', 'ceilinglamp', 'tvstand', 'balanceball', 'window', 'homework', 'food_noodles', 'couch', 'wall', 'oven', 'basket_for_clothes', 'cup', 'television', 'curtain', 'conditioner', 'maindoor', 'table', 'vase']
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:['food_ice_cream', 'measuring_cup', 'toilet', 'chair', 'drawing', 'food_egg', 'clothes_underwear', 'hanger', 'bathroom_counter', 'floor', 'ceiling', 'stamp', 'bookshelf', 'button', 'shoe-shine_kit', 'shower', 'window', 'broom', 'wall', 'wall_clock', 'powersocket', 'bench', 'standingmirror', 'novel', 'coin', 'doorjamb', 'door', 'light', 'table', 'creditcard']
Task:Read
response:
{
    "thoughts": We pick out a book from the bookshelf and read it.,
    "actions": ['[WALK] <novel>', '[WALK] <bookshelf>', '[FIND] <novel>', '[GRAB] <novel>', '[FIND] <chair>', '[SIT] <chair>', '[READ] <novel>']
}

Input:
Scene_Objects:['pot', 'food_pizza', 'tablelamp', 'food_salt', 'freezer', 'walllamp', 'trashcan', 'food_carrot', 'knifeblock', 'floor', 'ceiling', 'food_bacon', 'stovefan', 'ceilinglamp', 'toaster', 'mousepad', 'wall', 'nightstand', 'oven', 'toy', 'box', 'photoframe', 'keys', 'toothbrush_holder', 'tray', 'kitchen_counter', 'hair', 'door', 'sink', 'dishwasher']
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:['band-aids', 'trashcan', 'wallshelf', 'clothes_underwear', 'desk', 'keyboard', 'mail', 'computer', 'tvstand', 'shower', 'window', 'clothes_socks', 'couch', 'food_peanut_butter', 'pillow', 'basket_for_clothes', 'keys', 'coffe_maker', 'television', 'food_donut', 'tray', 'rag', 'headset', 'clothes_scarf', 'bathtub', 'sink', 'light', 'dishwasher', 'soap', 'washing_machine']
Task:Wash clothes
response:
{
    "thoughts": Get dirty clothes out of basket for clothes in bedroom, carry dirty clothes to laundry room, place dirty clothes in washing machine, add laundry detergent to washing machine, turn washing machine on, set type of wash, start washing machine,
    "actions": ['[WALK] <bedroom>', '[WALK] <basket_for_clothes>', '[FIND] <basket_for_clothes>', '[OPEN] <basket_for_clothes>', '[GRAB] <basket_for_clothes>', '[WALK] <bathroom>', '[WALK] <washing_machine>', '[FIND] <washing_machine>', '[OPEN] <washing_machine>', '[PUTBACK] <basket_for_clothes> <washing_machine>', '[FIND] <soap>', '[GRAB] <soap>', '[PUTBACK] <soap> <washing_machine>', '[FIND] <washing_machine>', '[CLOSE] <washing_machine>', '[SWITCHON] <washing_machine>']
}

Input:
Scene_Objects:['tablelamp', 'microwave', 'freezer', 'bathroom', 'cpuscreen', 'desk', 'tea_bag', 'alcohol', 'tvstand', 'oven', 'tape', 'cutting_board', 'cup', 'clothes_gloves', 'novel', 'toilet_paper', 'television', 'coffee_filter', 'wooden_spoon', 'mouse', 'cd', 'controller', 'maindoor', 'sink', 'home_office', 'light', 'dishwasher', 'soap', 'dirt', 'shoe_rack']
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:['fork', 'pot', 'toilet', 'chair', 'freezer', 'food_butter', 'food_carrot', 'drawing', 'floor', 'ceiling', 'keyboard', 'mat', 'ceilinglamp', 'shower', 'oil', 'food_peanut_butter', 'food_orange', 'nightstand', 'wall', 'powersocket', 'photoframe', 'food_food', 'food_onion', 'doorjamb', 'pencil', 'dresser', 'door', 'napkin', 'light', 'shoe_rack']
Task:Put groceries in Fridge
response:
{
    "thoughts": put away groceries in fridge. open the door, put on shelf, close the door.,
    "actions": ['[WALK] <dining_room>', '[WALK] <freezer>', '[FIND] <freezer>', '[OPEN] <freezer>', '[FIND] <food_food>', '[GRAB] <food_food>', '[PUTIN] <food_food> <freezer>', '[CLOSE] <freezer>']
}

Input:
Scene_Objects:['tablelamp', 'toilet', 'chair', 'trashcan', 'ceilingfan', 'drawing', 'cpuscreen', 'bathroom_counter', 'floor', 'ceiling', 'phone', 'desk', 'keyboard', 'bookshelf', 'computer', 'ceilinglamp', 'balanceball', 'mousepad', 'couch', 'wall', 'nightstand', 'toy', 'photoframe', 'curtain', 'rag', 'doorjamb', 'mouse', 'dresser', 'door', 'light']
Task:Browse internet
response:

walk into Living room, look for computer, walk to computer, turn on computer, grab mouse, click mouse

[WALK] <home_office>
[WALK] <computer>
[FIND] <computer>
[TURNTO] <computer>
[LOOKAT] <computer>
[WALK] <computer>
[TURNTO] <computer>
[FIND] <mouse>
[GRAB] <mouse>


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', 'detergent', 'food_carrot', 'clothes_underwear', 'hanger', 'floor', 'ceiling', 'phone', 'computer', 'bookmark', 'toaster', 'balanceball', 'wall', 'powersocket', 'photoframe', 'coffee_filter', 'tray', 'doorjamb', 'cards', 'mouse', 'shaving_cream', 'shoes', 'dresser', 'cupboard', 'door', 'napkin', 'home_office', 'light', 'vase']
Task:Turn on light
response:
{
    "thoughts": switching on light in an area,
    "actions": ['[WALK] <home_office>', '[WALK] <light>', '[FIND] <light>', '[SWITCHON] <light>']
}

Input:
Scene_Objects:['glue', 'scissors', 'tablelamp', 'freezer', 'trashcan', 'drawing', 'floor', 'shampoo', 'folder', 'bookshelf', 'purse', 'computer', 'window', 'wall', 'powersocket', 'cutting_board', 'cup', 'bed', 'photoframe', 'television', 'curtain', 'food_onion', 'shaving_cream', 'mouse', 'pencil', 'hair', 'maindoor', 'clothes_scarf', 'home_office', 'colander']
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:['dry_pasta', 'walllamp', 'cat', 'drawing', 'orchid', 'cpuscreen', 'hanger', 'bathroom_counter', 'floor', 'character', 'envelope', 'computer', 'toaster', 'mat', 'tvstand', 'ceilinglamp', 'shower', 'window', 'mousepad', 'couch', 'pillow', 'wall', 'wall_clock', 'oven', 'coffe_maker', 'television', 'curtain', 'hair', 'bathroom_cabinet', 'table']
Task:Pet cat
response:
{
    "thoughts": I would walk into the living room. Then sit on the couch and pet the cat.,
    "actions": ['[WALK] <home_office>', '[WALK] <couch>', '[SIT] <couch>', '[FIND] <cat>', '[TOUCH] <cat>']
}

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

go to living room and lie down on the sofa.

[WALK] <home_office>
[WALK] <couch>
[FIND] <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', 'microwave', 'toilet', 'chair', 'freezer', 'bathroom', 'orchid', 'floor', 'bedroom', 'bookshelf', 'toaster', 'tvstand', 'faucet', 'shower', 'stereo', 'closetdrawer', 'couch', 'broom', 'wall', 'wall_clock', 'photoframe', 'bed', 'television', 'mouse', 'kitchen_counter', 'comb', 'dresser', 'sink', 'spoon', 'clothes_skirt']
Task:Go to toilet
response:
{
    "thoughts": I walk into the bath room and go to the toilet,
    "actions": ['[WALK] <bathroom>', '[WALK] <toilet>', '[FIND] <toilet>', '[SIT] <toilet>']
}

Input:
Scene_Objects:['pot', 'chair', 'ground_coffee', 'food_butter', 'toothbrush', 'knifeblock', 'drawing', 'phone', 'keyboard', 'bookshelf', 'table_cloth', 'mat', 'plate', 'electric_shaver', 'window', 'pillow', 'nightstand', 'oven', 'newspaper', 'clothes_gloves', 'photoframe', 'toilet_paper', 'water', 'centerpiece', 'towel_rack', 'kettle', 'pencil', 'clothes_scarf', 'tooth_paste', 'teeth']
Task:Wash teeth
response:

Walk to bathroom. Find tooth paste, tooth brush and water. Squeeze tooth paste on tooth brush. Wash teeth.

[WALK] <bathroom>
[WALK] <tooth_paste>
[FIND] <tooth_paste>
[FIND] <toothbrush>
[FIND] <water>
[SQUEEZE] <tooth_paste>
[FIND] <teeth>
[WASH] <teeth>


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

Here is an example plan to achieve a goal for reference:
Scene_Objects:['sponge', 'pot', 'blender', 'beer', 'microwave', 'knifeblock', 'cpuscreen', 'hanger', 'floor', 'ceiling', 'table_cloth', 'toaster', 'plate', 'faucet', 'tvstand', 'window', 'dish_soap', 'food_orange', 'wall', 'cup', 'bed', 'food_food', 'tray', 'wooden_spoon', 'mouse', 'pencil', 'kitchen_counter', 'dishrack', 'cupboard', 'sink']
Task:Wash dirty dishes
response:
{
    "thoughts": Wet the sponge, apply soap to sponge, scrub dishes, rinse dishes, place on dish rack.,
    "actions": ['[WALK] <dining_room>', '[WALK] <sink>', '[FIND] <sponge>', '[GRAB] <sponge>', '[FIND] <faucet>', '[SWITCHON] <faucet>', '[PUTBACK] <sponge> <sink>', '[GRAB] <sponge>', '[FIND] <dish_soap>', '[GRAB] <dish_soap>', '[POUR] <dish_soap> <sponge>', '[PUTOBJBACK] <dish_soap>', '[FIND] <plate>', '[GRAB] <plate>', '[SCRUB] <plate>', '[RINSE] <plate>', '[FIND] <dishrack>', '[PUTBACK] <plate> <dishrack>', '[FIND] <plate>', '[GRAB] <plate>', '[SCRUB] <plate>', '[RINSE] <plate>', '[PUTBACK] <plate> <dishrack>', '[RINSE] <sponge>', '[PUTOBJBACK] <sponge>', '[SWITCHOFF] <faucet>']
}

Input:
Scene_Objects:['food_bread', 'tablelamp', 'walllamp', 'ground_coffee', 'ceilingfan', 'drawing', 'bathroom_counter', 'floor', 'ceiling', 'phone', 'desk', 'mat', 'faucet', 'couch', 'pillow', 'wall', 'pasta', 'wall_clock', 'cup', 'photoframe', 'bed', 'television', 'water', 'wine', 'curtain', 'paper_towel', 'sink', 'bathroom_cabinet', 'soap', 'hands_both']
Task:Wash hands
response:

I walk into the bathroom. I turn on the water. I put soap on my hands. I rinse my hands. I turn off the water. I dry my hands.

[WALK] <bathroom>
[WALK] <sink>
[FIND] <water>
[TURNTO] <water>
[FIND] <soap>
[GRAB] <soap>
[FIND] <hands_both>
[SCRUB] <hands_both>
[RINSE] <hands_both>
[TURNTO] <water>
[FIND] <paper_towel>
[GRAB] <paper_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:['scissors', 'tablelamp', 'chair', 'freezer', 'walllamp', 'drawing', 'wallshelf', 'hanger', 'floor', 'ceiling', 'desk', 'keyboard', 'computer', 'mat', 'tvstand', 'ceilinglamp', 'faucet', 'shower', 'closetdrawer', 'couch', 'pillow', 'wall', 'nightstand', 'photoframe', 'newspaper', 'television', 'doorjamb', 'dresser', 'soap', 'instrument_violin']
Task:Watch TV
response:
{
    "thoughts": I sit on my couch and watch TV in my living room,
    "actions": ['[WALK] <home_office>', '[WALK] <television>', '[SWITCHON] <television>', '[TURNTO] <television>', '[LOOKAT] <television>', '[TOUCH] <television>', '[TURNTO] <television>', '[LOOKAT] <television>', '[TOUCH] <television>', '[TURNTO] <television>', '[LOOKAT] <television>', '[WALK] <couch>', '[SIT] <couch>', '[TURNTO] <television>', '[LOOKAT] <television>', '[WATCH] <television>', '[WATCH] <television>', '[WATCH] <television>']
}

Input:
Scene_Objects:['spectacles', 'pot', 'tablelamp', 'chair', 'dog', 'walllamp', 'ceilingfan', 'knifeblock', 'needle', 'bathroom_counter', 'floor', 'computer', 'shoe-shine_kit', 'dustpan', 'box', 'cup', 'bed', 'keys', 'television', 'food_donut', 'tray', 'curtain', 'doorjamb', 'kettle', 'kitchen_counter', 'shoes', 'comb', 'sink', 'bathroom_cabinet', 'board_game']
Task:Brush teeth
response:

[WALK] <bathroom>
[WALK] <toothbrush>
[FIND] <toothbrush>
[GRAB] <toothbrush>
[WALK] <tooth_paste>
[FIND] <tooth_paste>
[GRAB] <tooth_paste>
[POUR] <tooth_paste> <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', 'walllamp', 'knifeblock', 'cpuscreen', 'wallshelf', 'bathroom_counter', 'floor', 'ceiling', 'ceilinglamp', 'faucet', 'couch', 'dustpan', 'pillow', 'towel', 'wall', 'nightstand', 'oven', 'box', 'bed', 'keys', 'check', 'toilet_paper', 'television', 'kitchen_counter', 'dresser', 'instrument_guitar', 'soap', 'tooth_paste']
Task:Relax on sofa
response:
{
    "thoughts": Go to living room.  Find sofa.  Sit on sofa.,
    "actions": ['[WALK] <home_office>', '[WALK] <couch>', '[FIND] <couch>', '[SIT] <couch>']
}

Input:
Scene_Objects:['food_pizza', 'tablelamp', 'jelly', 'ceilingfan', 'knifeblock', 'cpuscreen', 'bathroom_counter', 'floor', 'bookshelf', 'computer', 'clothes_jacket', 'piano_bench', 'stovefan', 'toaster', 'tvstand', 'ceilinglamp', 'balanceball', 'stereo', 'brush', 'food_jam', 'clothes_hat', 'nightstand', 'pasta', 'powersocket', 'bench', 'bed', 'oven_mitts', 'tray', 'towel_rack', 'home_office']
Task:Listen to music
response:

I walk to the radio.  I switch on the radio and listen

[WALK] <home_office>
[WALK] <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:['walllamp', 'orchid', 'drawing', 'wallshelf', 'bathroom_counter', 'floor', 'ceiling', 'phone', 'bookshelf', 'remote_control', 'envelope', 'clothes_jacket', 'mat', 'tvstand', 'ceilinglamp', 'shower', 'window', 'couch', 'pillow', 'wall', 'powersocket', 'bench', 'photoframe', 'bed', 'television', 'curtain', 'doorjamb', 'door', 'light', 'table']
Task:Watch TV
response:
{
    "thoughts": Enter the living room, find TV remote, grab TV remote, switch on TV, find sofa, sit down on the sofa, watch TV,
    "actions": ['[WALK] <home_office>', '[WALK] <remote_control>', '[FIND] <remote_control>', '[GRAB] <remote_control>', '[FIND] <television>', '[SWITCHON] <television>', '[FIND] <couch>', '[WALK] <couch>', '[SIT] <couch>', '[TURNTO] <television>', '[WATCH] <television>']
}

Input:
Scene_Objects:['sponge', 'chair', 'ceilingfan', 'drawing', 'cpuscreen', 'floor', 'ceiling', 'desk', 'keyboard', 'remote_control', 'food_cake', 'envelope', 'computer', 'ceilinglamp', 'tvstand', 'balanceball', 'faucet', 'window', 'couch', 'wall', 'wall_clock', 'light_bulb', 'television', 'curtain', 'hair', 'food_steak', 'sink', 'bathroom_cabinet', 'table', 'dishwasher']
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', 'toilet', 'chair', 'walllamp', 'trashcan', 'ceilingfan', 'drawing', 'cpuscreen', 'hanger', 'floor', 'ceiling', 'phone', 'desk', 'bookshelf', 'keyboard', 'envelope', 'computer', 'bookmark', 'ceilinglamp', 'balanceball', 'mousepad', 'wall', 'nightstand', 'photoframe', 'check', 'doorjamb', 'mouse', 'dresser', 'cupboard', 'door', 'light']
Task:Work
response:
{
    "thoughts": I go to the home office to work on my project. I turn on the light and walk to my desk. I turn on the computer. Then I look through the documents. After I'm done, I turn off the computer.,
    "actions": ['[WALK] <home_office>', '[WALK] <light>', '[FIND] <light>', '[SWITCHON] <light>', '[WALK] <desk>', '[FIND] <computer>', '[SWITCHON] <computer>', '[FIND] <check>', '[TURNTO] <check>', '[LOOKAT] <check>', '[SWITCHOFF] <computer>']
}

Input:
Scene_Objects:['freezer', 'trashcan', 'food_carrot', 'orchid', 'bathroom_counter', 'floor', 'ceiling', 'desk', 'alcohol', 'button', 'ceilinglamp', 'plate', 'clothes_socks', 'couch', 'food_orange', 'wall', 'bench', 'powersocket', 'photoframe', 'light_bulb', 'food_food', 'coffee_filter', 'drinking_glass', 'water', 'towel_rack', 'dishrack', 'cupboard', 'clothes_dress', 'light', 'colander']
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:['fork', 'filing_cabinet', 'food_bread', 'microwave', 'trashcan', 'drawing', 'knifeblock', 'cpuscreen', 'hanger', 'bathroom_counter', 'bedroom', 'tea_bag', 'tvstand', 'window', 'form', 'pillow', 'broom', 'bench', 'basket_for_clothes', 'newspaper', 'bed', 'check', 'coffe_maker', 'tray', 'door', 'home_office', 'light', 'bathroom_cabinet', 'tooth_paste', 'coffee']
Task:Get dressed
response:
{
    "thoughts": I get dressed in my bedroom in the mornings.,
    "actions": ['[WALK] <bedroom>', '[WALK] <shoes>', '[FIND] <shoes>', '[GRAB] <shoes>', '[PUTON] <shoes>']
}

Input:
Scene_Objects:['pot', 'food_bread', 'microwave', 'bathroom', 'ceilingfan', 'drawing', 'bathroom_counter', 'floor', 'ceiling', 'phone', 'toaster', 'mat', 'faucet', 'towel', 'wall', 'bench', 'photoframe', 'light_bulb', 'lighter', 'pencil', 'chessboard', 'dresser', 'hair', 'cupboard', 'sink', 'bathroom_cabinet', 'vase', 'soap', 'hands_both', 'shoe_rack']
Task:Wash hands
response:

I go to the sink, turn on the water,  put soap on my hands, rub them together, then rinse them off and turn off the water. I then towel off my hands.

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


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

Here is an example plan to achieve a goal for reference:
Scene_Objects:['jelly', 'trashcan', 'cpuscreen', 'clothes_underwear', 'ceiling', 'folder', 'desk', 'computer', 'stovefan', 'shower', 'mousepad', 'candle', 'clothes_hat', 'dining_room', 'newspaper', 'photoframe', 'food_food', 'video_game_controller', 'oven_mitts', 'curtain', 'pencil', 'kitchen_counter', 'dishrack', 'laundry_detergent', 'door', 'light', 'dishwasher', 'soap', 'tooth_paste', 'washing_machine']
Task:Wash clothes
response:
{
    "thoughts": Walk to bathroom. Open washer. Put clothes in washer. Put soap in washer. Close washer. Turn washer on.,
    "actions": ['[WALK] <home_office>', '[WALK] <washing_machine>', '[FIND] <washing_machine>', '[OPEN] <washing_machine>', '[FIND] <clothes_underwear>', '[GRAB] <clothes_underwear>', '[PUTBACK] <clothes_underwear> <washing_machine>', '[FIND] <soap>', '[GRAB] <soap>', '[PUTBACK] <soap> <washing_machine>', '[CLOSE] <washing_machine>', '[SWITCHON] <washing_machine>']
}

Input:
Scene_Objects:['filing_cabinet', 'chair', 'bathroom', 'milk', 'knifeblock', 'cpuscreen', 'floor', 'ceiling', 'phone', 'character', 'desk', 'bookshelf', 'keyboard', 'purse', 'computer', 'shower', 'window', 'electric_shaver', 'mousepad', 'oil', 'couch', 'form', 'wall', 'food_food', 'television', 'rag', 'lighter', 'mouse', 'controller', 'sink']
Task:Pick up phone
response:

first when i hear the ringing sound i will run to my living room and picks up and i will say hello

[RUN] <home_office>
[WALK] <chair>
[FIND] <chair>
[SIT] <chair>
[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', 'food_ice_cream', 'toilet', 'freezer', 'drawing', 'floor', 'ceiling', 'phone', 'stovefan', 'mat', 'ceilinglamp', 'shower', 'bowl', 'nightstand', 'wall', 'powersocket', 'oven', 'photoframe', 'bed', 'food_food', 'coffe_maker', 'wooden_spoon', 'doorjamb', 'pencil', 'comb', 'door', 'light', 'soap', 'scrabble', 'creditcard']
Task:Put groceries in Fridge
response:
{
    "thoughts": In the kitchen where I left the bags of groceries, I grab cheese from the grocery bag, I walk over to the refrigerator, open it up, neatly put cheese in the fridge, Close the fridge,
    "actions": ['[WALK] <dining_room>', '[WALK] <food_food>', '[FIND] <food_food>', '[GRAB] <food_food>', '[WALK] <freezer>', '[OPEN] <freezer>', '[PUTIN] <food_food> <freezer>', '[CLOSE] <freezer>']
}

Input:
Scene_Objects:['water_glass', 'chair', 'cat', 'hanger', 'bathroom_counter', 'floor', 'bookshelf', 'keyboard', 'ceilinglamp', 'shower', 'foundation', 'couch', 'food_orange', 'powersocket', 'bench', 'clothes_gloves', 'toilet_paper', 'razor', 'food_donut', 'mouse', 'kitchen_counter', 'shoes', 'dishrack', 'dresser', 'pajamas', 'laundry_detergent', 'clothes_scarf', 'home_office', 'laser_pointer', 'creditcard']
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>