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', 'chair', 'blow_dryer', 'nail_polish', 'ground_coffee', 'milk', 'knife', 'wallshelf', 'hanger', 'character', 'desk', 'keyboard', 'stovefan', 'mat', 'plate', 'food_jam', 'nightstand', 'wall', 'toy', 'bed', 'coffe_maker', 'wine', 'rag', 'centerpiece', 'pencil', 'dresser', 'door', 'bathroom_cabinet', 'table', 'dishwasher']
Task:Read book
response:
{
    "thoughts": Pick up the book, open to current page, read the words.,
    "actions": ['[WALK] <home_office>', '[WALK] <novel>', '[FIND] <novel>', '[GRAB] <novel>', '[READ] <novel>']
}

Input:
Scene_Objects:['pot', 'tablelamp', 'jelly', 'bathroom', 'detergent', 'dough', 'orchid', 'floor', 'bedroom', 'mat', 'dish_soap', 'mousepad', 'dining_room', 'wall', 'nightstand', 'oven', 'food_cheese', 'photoframe', 'coffe_maker', 'food_food', 'ice', 'tray', 'kitchen_counter', 'headset', 'dishrack', 'dresser', 'cupboard', 'door', 'home_office', '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:['food_salt', 'toilet', 'walllamp', 'drawing', 'orchid', 'floor', 'phone', 'character', 'computer', 'mat', 'tvstand', 'ceilinglamp', 'faucet', 'window', 'closetdrawer', 'couch', 'pillow', 'wall', 'nightstand', 'wall_clock', 'bed', 'television', 'curtain', 'doorjamb', 'towel_rack', 'kitchen_counter', 'hairdryer', 'sink', 'home_office', 'table']
Task:Relax on sofa
response:
{
    "thoughts": Walk into the living room. Walk up to the sofa. Sit down on the sofa.,
    "actions": ['[WALK] <home_office>', '[WALK] <couch>', '[SIT] <couch>']
}

Input:
Scene_Objects:['sheets', 'chair', 'nail_polish', 'knife', 'cpuscreen', 'floor', 'desk', 'bedroom', 'keyboard', 'computer', 'clothes_jacket', 'mat', 'mousepad', 'closetdrawer', 'couch', 'dining_room', 'wall', 'basket_for_clothes', 'cup', 'check', 'television', 'curtain', 'mouse', 'chessboard', 'shoes', 'comb', 'cupboard', 'hairdryer', 'door', 'home_office']
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:['toilet', 'chair', 'walllamp', 'ceilingfan', 'drawing', 'floor', 'ceiling', 'keyboard', 'remote_control', 'ceilinglamp', 'tvstand', 'balanceball', 'shoe-shine_kit', 'window', 'oil', 'couch', 'wall', 'cup', 'food_food', 'coffe_maker', 'television', 'curtain', 'doorjamb', 'console', 'hairbrush', 'cupboard', 'food_steak', 'maindoor', 'door', 'table']
Task:Watch TV
response:
{
    "thoughts": Watch favorite shows, netflix, hulu,
    "actions": ['[WALK] <home_office>', '[WALK] <remote_control>', '[FIND] <remote_control>', '[GRAB] <remote_control>', '[WALK] <couch>', '[SIT] <couch>', '[FIND] <television>', '[SWITCHON] <television>', '[PUTBACK] <remote_control> <couch>', '[TURNTO] <television>', '[WATCH] <television>']
}

Input:
Scene_Objects:['pot', 'filing_cabinet', 'microwave', 'walllamp', 'cpuscreen', 'wallshelf', 'floor', 'phone', 'bookshelf', 'food_cake', 'plate', 'iron', 'dish_soap', 'mousepad', 'dining_room', 'wall', 'cup', 'newspaper', 'novel', 'coffe_maker', 'food_food', 'check', 'coin', 'oven_mitts', 'food_rice', 'curtain', 'mouse', 'kitchen_counter', 'cupboard', 'dishwasher']
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:['dry_pasta', 'pot', 'microwave', 'walllamp', 'toothbrush', 'drawing', 'knifeblock', 'wallshelf', 'keyboard', 'food_cake', 'ceilinglamp', 'tvstand', 'shower', 'stereo', 'oil', 'tooth_paste', 'couch', 'closetdrawer', 'dining_room', 'toy', 'basket_for_clothes', 'light_bulb', 'check', 'centerpiece', 'kettle', 'mouse', 'kitchen_counter', 'shoes', 'light', 'board_game']
Task:Brush teeth
response:
{
    "thoughts": EARLY MORNING AND BEFORE GOING TO BED,
    "actions": ['[WALK] <bathroom>', '[WALK] <tooth_paste>', '[FIND] <tooth_paste>', '[GRAB] <tooth_paste>', '[FIND] <toothbrush>', '[GRAB] <toothbrush>']
}

Input:
Scene_Objects:['sheets', 'glue', 'sponge', 'microwave', 'toilet', 'freezer', 'walllamp', 'drawing', 'bathroom_counter', 'floor', 'bedroom', 'purse', 'mat', 'ceilinglamp', 'shower', 'picture', 'wall', 'powersocket', 'oven', 'toilet_paper', 'food_donut', 'tray', 'curtain', 'doorjamb', 'cupboard', 'door', 'hairdryer', 'spoon', 'light', 'dirt']
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:['filing_cabinet', 'tablelamp', 'toilet', 'chair', 'freezer', 'blow_dryer', 'bathroom', 'trashcan', 'drawing', 'wallshelf', 'cpuscreen', 'floor', 'ceiling', 'desk', 'tea_bag', 'bookshelf', 'ceilinglamp', 'dining_room', 'wall', 'oven', 'photoframe', 'bed', 'novel', 'check', 'tray', 'doorjamb', 'towel_rack', 'console', 'pencil', 'light']
Task:Read book
response:
{
    "thoughts": Walk to the Living Room. Look at the Cabinet. Find a Textbook. Grab the textbook. Open the Textbook. Read the textbook.,
    "actions": ['[WALK] <home_office>', '[WALK] <filing_cabinet>', '[FIND] <filing_cabinet>', '[TURNTO] <filing_cabinet>', '[LOOKAT] <filing_cabinet>', '[FIND] <novel>', '[GRAB] <novel>', '[READ] <novel>']
}

Input:
Scene_Objects:['fork', 'pot', 'tea', 'microwave', 'walllamp', 'detergent', 'knifeblock', 'bathroom_counter', 'floor', 'ceiling', 'stovefan', 'toaster', 'faucet', 'stereo', 'bowl', 'food_kiwi', 'wall', 'oven', 'bed', 'coffe_maker', 'food_food', 'drinking_glass', 'food_donut', 'tray', 'after_shave', 'kitchen_counter', 'cupboard', 'sink', 'dishwasher', 'clothes_skirt']
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', 'blender', 'crayon', 'microwave', 'nail_polish', 'ceilingfan', 'drawing', 'orchid', 'floor', 'ceiling', 'button', 'table_cloth', 'toaster', 'ceilinglamp', 'tvstand', 'balanceball', 'stereo', 'window', 'couch', 'dining_room', 'wall', 'nightstand', 'oven', 'novel', 'television', 'curtain', 'dresser', 'pajamas', 'table', 'instrument_violin']
Task:Turn off TV
response:
{
    "thoughts": Walk over to tv and press power button,
    "actions": ['[WALK] <home_office>', '[WALK] <television>', '[SWITCHOFF] <television>']
}

Input:
Scene_Objects:['filing_cabinet', 'chair', 'walllamp', 'blow_dryer', 'orchid', 'cpuscreen', 'floor', 'ceiling', 'character', 'desk', 'keyboard', 'computer', 'mat', 'ceilinglamp', 'tvstand', 'mousepad', 'closetdrawer', 'pillow', 'wall', 'television', 'ice', 'rag', 'doorjamb', 'mouse', 'controller', 'door', 'light', 'table', 'scrabble', 'dirt']
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:['microwave', 'toilet', 'dog', 'toothbrush', 'bills', 'drawing', 'knifeblock', 'hanger', 'bathroom_counter', 'floor', 'ceiling', 'character', 'purse', 'faucet', 'balanceball', 'food_noodles', 'wall', 'bench', 'cup', 'photoframe', 'mouthwash', 'console', 'kitchen_counter', 'cupboard', 'sink', 'bag', 'bathroom_cabinet', 'home_office', 'soap', 'hands_both']
Task:Wash hands
response:
{
    "thoughts": go to bathroom. walk to sink,turn on faucet, put hands in water. rub hands together. grab soap. rub soap in hands. put soap down. put hands under water. rubs hands together. turn off faucet,
    "actions": ['[WALK] <bathroom>', '[WALK] <sink>', '[FIND] <faucet>', '[SWITCHON] <faucet>', '[FIND] <soap>', '[GRAB] <soap>', '[FIND] <hands_both>', '[SCRUB] <hands_both>', '[PUTOBJBACK] <soap>', '[RINSE] <hands_both>', '[SWITCHOFF] <faucet>']
}

Input:
Scene_Objects:['spectacles', 'crayon', 'microwave', 'toilet', 'knife', 'bathroom_counter', 'floor', 'ceiling', 'phone', 'shampoo', 'computer', 'mat', 'tvstand', 'picture', 'oil', 'couch', 'pillow', 'wall', 'powersocket', 'cup', 'food_food', 'tray', 'doorjamb', 'mouse', 'kitchen_counter', 'shoes', 'cupboard', 'bathroom_cabinet', 'light', 'instrument_violin']
Task:Pick up phone
response:

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:['tablelamp', 'chair', 'dog', 'trashcan', 'drawing', 'cpuscreen', 'character', 'keyboard', 'bookshelf', 'toaster', 'mat', 'tvstand', 'faucet', 'window', 'mousepad', 'pillow', 'dining_room', 'wall', 'nightstand', 'powersocket', 'photoframe', 'food_food', 'wooden_spoon', 'kettle', 'shaving_cream', 'towel_rack', 'cupboard', 'conditioner', 'bathtub', 'dirt']
Task:Lock door
response:
{
    "thoughts": Turn the lock.,
    "actions": ['[WALK] <bedroom>']
}

Input:
Scene_Objects:['filing_cabinet', 'food_salt', 'freezer', 'orchid', 'wallshelf', 'clothes_underwear', 'cpuscreen', 'phone', 'character', 'bedroom', 'keyboard', 'toaster', 'mat', 'plate', 'picture', 'foundation', 'dish_soap', 'clothes_socks', 'pillow', 'powersocket', 'cutting_board', 'basket_for_clothes', 'bed', 'television', 'curtain', 'diary', 'cupboard', 'sink', 'spoon', 'home_office']
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:['sheets', 'filing_cabinet', 'tablelamp', 'bathroom', 'knifeblock', 'wallshelf', 'bathroom_counter', 'character', 'bedroom', 'tea_bag', 'keyboard', 'food_cake', 'toaster', 'ceilinglamp', 'shower', 'faucet', 'couch', 'food_jam', 'clothes_pants', 'bowl', 'dining_room', 'nightstand', 'oven', 'ice', 'lighter', 'mouse', 'conditioner', 'door', 'bathroom_cabinet', 'light']
Task:Pick up phone
response:
{
    "thoughts": Walk to the living room, Find Phone stand. Find Phone. Pickup the receiver to attend the call.,
    "actions": ['[WALK] <home_office>', '[WALK] <phone>', '[FIND] <phone>', '[GRAB] <phone>']
}

Input:
Scene_Objects:['tablelamp', 'measuring_cup', 'walllamp', 'orchid', 'floor', 'ceiling', 'phone', 'keyboard', 'remote_control', 'bookshelf', 'computer', 'tvstand', 'window', 'closetdrawer', 'couch', 'pillow', 'dining_room', 'broom', 'nightstand', 'wall', 'television', 'curtain', 'doorjamb', 'pencil', 'dresser', 'pajamas', 'laundry_detergent', 'clothes_dress', 'bag', 'table']
Task:Watch TV
response:

walk into the living room walk to the remote pick it up and turn in the tv and watch

[WALK] <home_office>
[WALK] <remote_control>
[GRAB] <remote_control>
[FIND] <television>
[TURNTO] <television>
[POINTAT] <television>
[SWITCHON] <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:['filing_cabinet', 'tablelamp', 'chair', 'walllamp', 'drawing', 'wallshelf', 'hanger', 'floor', 'ceiling', 'phone', 'desk', 'remote_control', 'computer', 'stovefan', 'mat', 'tvstand', 'ceilinglamp', 'closetdrawer', 'couch', 'pillow', 'wall', 'photoframe', 'television', 'curtain', 'doorjamb', 'kitchen_counter', 'dresser', 'door', 'table', 'light']
Task:Watch TV
response:
{
    "thoughts": I sit down on the couch, get the tv remote, click the on button, and change the channel to the show i want to watch,
    "actions": ['[WALK] <home_office>', '[WALK] <television>', '[FIND] <television>', '[SWITCHON] <television>', '[WALK] <couch>', '[SIT] <couch>', '[FIND] <remote_control>', '[GRAB] <remote_control>', '[TURNTO] <television>', '[POINTAT] <television>', '[PUTOBJBACK] <remote_control>', '[WATCH] <television>']
}

Input:
Scene_Objects:['sheets', 'filing_cabinet', 'tablelamp', 'food_salt', 'chair', 'cpuscreen', 'hanger', 'kitchen_cabinet', 'bathroom_counter', 'desk', 'bookshelf', 'thread', 'stovefan', 'laptop', 'faucet', 'window', 'clothes_socks', 'closetdrawer', 'powersocket', 'food_cheese', 'water', 'drinking_glass', 'tray', 'curtain', 'mouse', 'kitchen_counter', 'dishrack', 'sink', 'table', 'colander']
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:['food_bread', 'food_pizza', 'tablelamp', 'microwave', 'floor', 'ceiling', 'desk', 'bookshelf', 'stovefan', 'mat', 'ceilinglamp', 'laptop', 'window', 'homework', 'oil', 'closetdrawer', 'couch', 'nightstand', 'wall', 'cup', 'bed', 'food_food', 'mouthwash', 'toothbrush_holder', 'oven_mitts', 'razor', 'food_donut', 'check', 'clothes_scarf', 'bathroom_cabinet']
Task:Go to sleep
response:
{
    "thoughts": Walk to bedroom. Walk to bed, lie in bed.,
    "actions": ['[WALK] <bedroom>', '[WALK] <bed>', '[LIE] <bed>']
}

Input:
Scene_Objects:['tea', 'toilet', 'chair', 'freezer', 'ground_coffee', 'drawing', 'floor', 'phone', 'alcohol', 'mail', 'piano_bench', 'mat', 'shower', 'stereo', 'homework', 'food_peanut_butter', 'pillow', 'dining_room', 'food_kiwi', 'wall', 'bowl', 'powersocket', 'curtain', 'doorjamb', 'cd', 'laundry_detergent', 'door', 'sink', 'light', 'soap']
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:['sheets', 'walllamp', 'drawing', 'orchid', 'bills', 'floor', 'desk', 'mat', 'tvstand', 'stereo', 'clothes_socks', 'closetdrawer', 'dining_room', 'wall_clock', 'oven', 'powersocket', 'basket_for_clothes', 'photoframe', 'newspaper', 'clothes_gloves', 'standingmirror', 'mouthwash', 'television', 'razor', 'towel_rack', 'kitchen_counter', 'clothes_dress', 'sink', 'soap', 'washing_machine']
Task:Wash clothes
response:
{
    "thoughts": put clothes and soap in the washing machine, turn it on,
    "actions": ['[WALK] <dining_room>', '[WALK] <washing_machine>', '[FIND] <washing_machine>', '[FIND] <basket_for_clothes>', '[OPEN] <basket_for_clothes>', '[FIND] <soap>', '[GRAB] <soap>', '[OPEN] <washing_machine>', '[PUTBACK] <soap> <washing_machine>', '[CLOSE] <washing_machine>', '[SWITCHON] <washing_machine>']
}

Input:
Scene_Objects:['dry_pasta', 'tablelamp', 'mop', 'chair', 'walllamp', 'food_butter', 'food_egg', 'cpuscreen', 'floor', 'ceiling', 'stamp', 'mail', 'stovefan', 'ceilinglamp', 'stereo', 'window', 'couch', 'pillow', 'wall', 'nightstand', 'powersocket', 'television', 'curtain', 'after_shave', 'mouse', 'hair', 'food_steak', 'sink', 'light', 'table']
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:['sheets', 'tablelamp', 'food_salt', 'toilet', 'bathroom_counter', 'floor', 'phone', 'desk', 'stovefan', 'toaster', 'plate', 'tvstand', 'picture', 'mat', 'mousepad', 'dining_room', 'food_kiwi', 'basket_for_clothes', 'cup', 'photoframe', 'bed', 'novel', 'keys', 'coin', 'food_rice', 'tray', 'pencil', 'kitchen_counter', 'door', 'table']
Task:Pet cat
response:
{
    "thoughts": I walk to the living room. I find the cat. I pet the cat.,
    "actions": ['[WALK] <home_office>', '[WALK] <cat>', '[FIND] <cat>', '[TOUCH] <cat>']
}

Input:
Scene_Objects:['tablelamp', 'scissors', 'microwave', 'walllamp', 'bathroom', 'orchid', 'drawing', 'floor', 'ceiling', 'desk', 'bookshelf', 'computer', 'toaster', 'tvstand', 'faucet', 'window', 'closetdrawer', 'couch', 'pillow', 'nightstand', 'wall', 'bed', 'keys', 'food_food', 'television', 'tray', 'curtain', 'kettle', 'dresser', 'table']
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:['pot', 'tablelamp', 'crayon', 'toilet', 'drawing', 'wallshelf', 'bathroom_counter', 'floor', 'phone', 'ceiling', 'bedroom', 'mail', 'food_bacon', 'clothes_jacket', 'table_cloth', 'faucet', 'mousepad', 'closetdrawer', 'food_jam', 'nightstand', 'powersocket', 'novel', 'food_food', 'centerpiece', 'diary', 'console', 'cupboard', 'bathroom_cabinet', 'table', 'light']
Task:Pick up phone
response:
{
    "thoughts": Pick up the ringing phone,
    "actions": ['[WALK] <home_office>', '[WALK] <table>', '[FIND] <table>', '[TURNTO] <table>', '[POINTAT] <table>', '[FIND] <phone>', '[GRAB] <phone>', '[PUTOBJBACK] <phone>']
}

Input:
Scene_Objects:['chair', 'walllamp', 'nail_polish', 'orchid', 'bills', 'cpuscreen', 'floor', 'ceiling', 'desk', 'keyboard', 'computer', 'mat', 'ceilinglamp', 'tvstand', 'shower', 'mousepad', 'closetdrawer', 'clothes_pants', 'pillow', 'wall', 'powersocket', 'photoframe', 'bed', 'television', 'doorjamb', 'mouse', 'door', 'home_office', 'light', 'table']
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:['juice', 'bathroom', 'detergent', 'nail_polish', 'trashcan', 'food_butter', 'orchid', 'hanger', 'longboard', 'floor', 'bathroom_counter', 'remote_control', 'envelope', 'computer', 'window', 'electric_shaver', 'wall', 'cutting_board', 'bed', 'television', 'tray', 'curtain', 'after_shave', 'lighter', 'mouse', 'cupboard', 'clothes_dress', 'light', 'clothes_skirt', 'board_game']
Task:Watch TV
response:
{
    "thoughts": Watching tv with a remote is always fun; lay back, relax and enjoy;,
    "actions": ['[WALK] <bedroom>', '[WALK] <television>', '[FIND] <television>', '[SWITCHON] <television>', '[FIND] <remote_control>', '[GRAB] <remote_control>', '[FIND] <bed>', '[LIE] <bed>']
}

Input:
Scene_Objects:['pot', 'tea', 'microwave', 'band-aids', 'walllamp', 'detergent', 'knifeblock', 'floor', 'ceiling', 'shampoo', 'stovefan', 'toaster', 'faucet', 'dining_room', 'bowl', 'wall', 'oven', 'powersocket', 'cup', 'coffe_maker', 'check', 'oven_mitts', 'water', 'tray', 'wooden_spoon', 'kitchen_counter', 'cupboard', 'laundry_detergent', 'sink', 'dishwasher']
Task:Drink
response:

Go to the kitchen, grab a cup from the cupboard, go to the sink, put cup under faucet, turn on faucet til cup is full, turn off faucet, drink from cup

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


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

Here is an example plan to achieve a goal for reference:
Scene_Objects:['dry_pasta', 'tablelamp', 'crayon', 'band-aids', 'nail_polish', 'cat', 'food_carrot', 'drawing', 'knifeblock', 'bathroom_counter', 'floor', 'ceiling', 'food_bacon', 'ceilinglamp', 'shoe-shine_kit', 'window', 'couch', 'food_kiwi', 'wall', 'bed', 'keys', 'check', 'television', 'oven_mitts', 'curtain', 'conditioner', 'maindoor', 'instrument_guitar', 'table', 'bathroom_cabinet']
Task:Pet cat
response:
{
    "thoughts": The cat is laying on the couch in the living room. I want to pet it, so I am going to walk to the living room, sit on the couch, and pet the cat.,
    "actions": ['[WALK] <home_office>', '[WALK] <couch>', '[SIT] <couch>', '[FIND] <cat>', '[TURNTO] <cat>', '[LOOKAT] <cat>', '[TOUCH] <cat>']
}

Input:
Scene_Objects:['sheets', 'filing_cabinet', 'knifeblock', 'drawing', 'food_egg', 'desk', 'keyboard', 'food_cake', 'stovefan', 'ceilinglamp', 'tvstand', 'mat', 'brush', 'window', 'foundation', 'deck_of_cards', 'pillow', 'dining_room', 'wall', 'nightstand', 'photoframe', 'light_bulb', 'clothes_gloves', 'check', 'mouthwash', 'curtain', 'dresser', 'clothes_dress', 'sink', 'creditcard']
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:['toilet', 'detergent', 'drawing', 'orchid', 'cpuscreen', 'hanger', 'bathroom_counter', 'floor', 'character', 'desk', 'keyboard', 'thread', 'table_cloth', 'tvstand', 'balanceball', 'shower', 'mousepad', 'couch', 'wall', 'photoframe', 'bed', 'toilet_paper', 'food_onion', 'towel_rack', 'mouse', 'kitchen_counter', 'cd', 'hairbrush', 'bathroom_cabinet', 'light']
Task:Go to toilet
response:
{
    "thoughts": walk to bathroom , run to toilet,
    "actions": ['[WALK] <bathroom>', '[RUN] <toilet>']
}

Input:
Scene_Objects:['pot', 'toilet', 'freezer', 'food_carrot', 'drawing', 'hanger', 'floor', 'ceiling', 'shampoo', 'stovefan', 'mat', 'shower', 'window', 'nightstand', 'wall', 'powersocket', 'food_cheese', 'photoframe', 'bed', 'newspaper', 'food_food', 'drinking_glass', 'water', 'curtain', 'doorjamb', 'dresser', 'food_steak', 'door', 'home_office', 'light']
Task:Drink
response:

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', 'tea', 'jelly', 'dog', 'chair', 'ground_coffee', 'bathroom', 'phone', 'bedroom', 'stovefan', 'mat', 'plate', 'faucet', 'shoe-shine_kit', 'wall', 'nightstand', 'powersocket', 'cup', 'basket_for_clothes', 'newspaper', 'food_food', 'coffe_maker', 'tray', 'curtain', 'food_steak', 'door', 'bag', 'instrument_guitar', 'light', 'dishwasher']
Task:Set up table
response:
{
    "thoughts": Walk into kitchen, find plate, drop plate on table in living room, walk into kitchen, find cup, bring cup to table in living room, walk into kitchen find fork, bring fork to table in living room,
    "actions": ['[WALK] <dining_room>', '[WALK] <plate>', '[FIND] <plate>', '[GRAB] <plate>', '[WALK] <home_office>', '[DROP] <plate>', '[WALK] <dining_room>', '[WALK] <cup>', '[FIND] <cup>', '[GRAB] <cup>', '[WALK] <home_office>', '[DROP] <cup>', '[WALK] <dining_room>', '[WALK] <fork>', '[FIND] <fork>', '[GRAB] <fork>', '[WALK] <home_office>', '[DROP] <fork>']
}

Input:
Scene_Objects:['pot', 'chair', 'walllamp', 'orchid', 'needle', 'cpuscreen', 'floor', 'ceiling', 'desk', 'keyboard', 'computer', 'clothes_jacket', 'mat', 'ceilinglamp', 'tvstand', 'mousepad', 'closetdrawer', 'pillow', 'wall', 'photoframe', 'coffe_maker', 'television', 'doorjamb', 'mouse', 'kitchen_counter', 'cupboard', 'door', 'sink', 'light', 'table']
Task:Browse internet
response:

I go to my desk. I turn on the computer. I open a web page and look at it.

[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:['pot', 'filing_cabinet', 'beer', 'microwave', 'walllamp', 'drawing', 'orchid', 'wallshelf', 'floor', 'ceiling', 'keyboard', 'food_cake', 'ceilinglamp', 'faucet', 'window', 'mousepad', 'couch', 'pillow', 'wall', 'photoframe', 'tray', 'curtain', 'doorjamb', 'towel_rack', 'door', 'bathtub', 'bathroom_cabinet', 'table', 'light', 'dishwasher']
Task:Relax on sofa
response:
{
    "thoughts": Walk to living room. Sit on sofa. Lie down on sofa.,
    "actions": ['[WALK] <home_office>', '[WALK] <couch>', '[FIND] <couch>', '[SIT] <couch>', '[LIE] <couch>']
}

Input:
Scene_Objects:['sheets', 'bathroom', 'food_carrot', 'wallshelf', 'ceiling', 'dvd_player', 'character', 'bedroom', 'desk', 'keyboard', 'thread', 'stovefan', 'shower', 'faucet', 'mousepad', 'closetdrawer', 'couch', 'pillow', 'cup', 'bed', 'food_food', 'razor', 'toothbrush_holder', 'curtain', 'kitchen_counter', 'vacuum_cleaner', 'dresser', 'napkin', 'table', 'clothes_skirt']
Task:Pick up phone
response:

Go to the living room.  Find the telephone.  Lift up the receiver.

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


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

Here is an example plan to achieve a goal for reference:
Scene_Objects:['sheets', 'filing_cabinet', 'juice', 'microwave', 'chair', 'walllamp', 'orchid', 'cpuscreen', 'floor', 'ceiling', 'desk', 'bedroom', 'keyboard', 'computer', 'ceilinglamp', 'mat', 'shower', 'faucet', 'window', 'mousepad', 'food_orange', 'wall', 'television', 'curtain', 'after_shave', 'mouse', 'dresser', 'door', 'napkin', 'table']
Task:Clean screen
response:
{
    "thoughts": Use a soft rag to wipe the screen until there are no marks on it.,
    "actions": ['[WALK] <home_office>', '[WALK] <rag>', '[FIND] <rag>', '[GRAB] <rag>', '[WALK] <computer>', '[WIPE] <computer>', '[PUTOBJBACK] <rag>']
}

Input:
Scene_Objects:['tablelamp', 'chair', 'walllamp', 'orchid', 'clothes_underwear', 'floor', 'ceiling', 'character', 'bedroom', 'remote_control', 'computer', 'ceilinglamp', 'tvstand', 'window', 'closetdrawer', 'couch', 'pillow', 'wall', 'nightstand', 'powersocket', 'food_food', 'television', 'wooden_spoon', 'curtain', 'diary', 'dresser', 'cupboard', 'clothes_dress', 'table', 'light']
Task:Watch TV
response:

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

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


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

Here is an example plan to achieve a goal for reference:
Scene_Objects:['food_bread', 'microwave', 'toilet', 'walllamp', 'knifeblock', 'wallshelf', 'floor', 'shampoo', 'character', 'computer', 'bookmark', 'toaster', 'plate', 'faucet', 'shoe-shine_kit', 'dish_soap', 'wall', 'toy', 'light_bulb', 'coffe_maker', 'rag', 'kitchen_counter', 'hairbrush', 'cupboard', 'dresser', 'controller', 'sink', 'home_office', 'table', 'dishwasher']
Task:Wash dishes by hand
response:
{
    "thoughts": Make some dish water, grab a dish rag, put dishes in dish water and wash.,
    "actions": ['[RUN] <sink>', '[FIND] <dish_soap>', '[GRAB] <dish_soap>', '[FIND] <plate>', '[PUTBACK] <dish_soap> <plate>', '[RINSE] <dish_soap>', '[FIND] <plate>', '[WASH] <plate>']
}

Input:
Scene_Objects:['pot', 'microwave', 'walllamp', 'knifeblock', 'orchid', 'floor', 'phone', 'ceiling', 'bedroom', 'keyboard', 'food_bacon', 'stovefan', 'toaster', 'plate', 'faucet', 'window', 'homework', 'closetdrawer', 'wall', 'oven', 'ice', 'tray', 'rag', 'doorjamb', 'kitchen_counter', 'cupboard', 'hairdryer', 'sink', 'bathroom_cabinet', 'coffee']
Task:Wash dishes by hand
response:

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

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


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

Here is an example plan to achieve a goal for reference:
Scene_Objects:['pot', 'crayon', 'chair', 'bathroom', 'food_butter', 'phone', 'ceiling', 'bedroom', 'tea_bag', 'laptop', 'ceilinglamp', 'shower', 'iron', 'clothes_socks', 'closetdrawer', 'clothes_pants', 'pillow', 'wall', 'powersocket', 'standingmirror', 'photoframe', 'toothbrush_holder', 'food_donut', 'curtain', 'doorjamb', 'towel_rack', 'pencil', 'controller', 'door', 'table']
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:['pot', 'chair', 'walllamp', 'orchid', 'bills', 'cpuscreen', 'floor', 'ceiling', 'character', 'desk', 'keyboard', 'computer', 'mat', 'ceilinglamp', 'tvstand', 'shoe-shine_kit', 'mousepad', 'closetdrawer', 'pillow', 'wall', 'bed', 'television', 'doorjamb', 'mouse', 'vacuum_cleaner', 'comb', 'door', 'home_office', 'light', 'table']
Task:Browse internet
response:

I go to the living room, where my computer is. I locate it, switch it on and type desired URL adress in the web browser.

[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:['tablelamp', 'walllamp', 'detergent', 'orchid', 'knife', 'bathroom_counter', 'floor', 'ceiling', 'keyboard', 'remote_control', 'computer', 'tvstand', 'faucet', 'plate', 'window', 'oil', 'closetdrawer', 'couch', 'pillow', 'nightstand', 'wall', 'bed', 'television', 'tray', 'curtain', 'doorjamb', 'mouse', 'dresser', 'door', 'table']
Task:Watch TV
response:
{
    "thoughts": turn on the tv,
    "actions": ['[WALK] <home_office>', '[WALK] <television>', '[FIND] <television>', '[SWITCHON] <television>', '[FIND] <remote_control>', '[TOUCH] <remote_control>']
}

Input:
Scene_Objects:['sheets', 'juice', 'tea', 'toilet', 'freezer', 'walllamp', 'dough', 'drawing', 'food_egg', 'floor', 'dvd_player', 'character', 'alcohol', 'stovefan', 'mat', 'shower', 'closetdrawer', 'clothes_hat', 'food_jam', 'wall', 'powersocket', 'curtain', 'doorjamb', 'mouse', 'kitchen_counter', 'laundry_detergent', 'door', 'light', 'dishwasher', 'table']
Task:Go to toilet
response:

I walk to the entrance of the bathroom. I turn to the door. I open the door to the bathroom. I walk inside of the bathroom. I find the toilet inside of the bathroom and walk over to it. I turn and look at the toilet.

[WALK] <bathroom>
[WALK] <toilet>
[FIND] <toilet>
[TURNTO] <toilet>
[LOOKAT] <toilet>
[WALK] <toilet>
[TURNTO] <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', 'chair', 'ceilingfan', 'trashcan', 'drawing', 'clothes_underwear', 'floor', 'ceiling', 'character', 'bookshelf', 'table_cloth', 'mop_bucket', 'ceilinglamp', 'tvstand', 'balanceball', 'mat', 'window', 'food_noodles', 'couch', 'wall', 'nightstand', 'food_food', 'television', 'curtain', 'cupboard', 'table', 'light', 'vase', 'dishwasher', 'dirt']
Task:Watch TV
response:
{
    "thoughts": Sit on the couch or the chair or the floor and watch cable, movies, or netflix.,
    "actions": ['[WALK] <home_office>', '[WALK] <television>', '[FIND] <television>', '[SWITCHON] <television>', '[FIND] <couch>', '[SIT] <couch>', '[TURNTO] <television>', '[WATCH] <television>']
}

Input:
Scene_Objects:['glue', 'pot', 'filing_cabinet', 'food_bread', 'toilet', 'jelly', 'freezer', 'food_butter', 'drawing', 'cpuscreen', 'floor', 'ceiling', 'bedroom', 'brush', 'mat', 'shower', 'mousepad', 'nightstand', 'wall', 'powersocket', 'photoframe', 'food_food', 'television', 'ice', 'doorjamb', 'hair', 'door', 'napkin', 'light', 'table']
Task:Put groceries in Fridge
response:

Go to kitchen and put groceries in fridge

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


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

Here is an example plan to achieve a goal for reference:
Scene_Objects:['food_pizza', 'walllamp', 'cat', 'drawing', 'orchid', 'wallshelf', 'floor', 'ceiling', 'desk', 'bookshelf', 'computer', 'mat', 'tvstand', 'couch', 'pillow', 'wall', 'powersocket', 'photoframe', 'bed', 'food_food', 'check', 'television', 'curtain', 'doorjamb', 'kitchen_counter', 'clothes_dress', 'door', 'conditioner', 'sink', 'light']
Task:Pet cat
response:
{
    "thoughts": My cat looks like it wants attention, so I will go pet it on the couch.,
    "actions": ['[WALK] <home_office>', '[WALK] <light>', '[FIND] <light>', '[SWITCHON] <light>', '[FIND] <cat>', '[WALK] <couch>', '[SIT] <couch>', '[TURNTO] <cat>', '[TOUCH] <cat>']
}

Input:
Scene_Objects:['pot', 'food_bread', 'microwave', 'detergent', 'knifeblock', 'floor', 'ceiling', 'character', 'computer', 'toaster', 'ceilinglamp', 'faucet', 'shower', 'wall', 'cup', 'check', 'mouthwash', 'water', 'wine', 'after_shave', 'curtain', 'food_onion', 'mouse', 'kitchen_counter', 'vacuum_cleaner', 'cupboard', 'conditioner', 'sink', 'napkin', 'bathroom_cabinet']
Task:Drink
response:

I go in the kitchen and get the glass near the sink. I open the faucet, then I pour water in it, turn off the faucet and drink it.

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


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

Here is an example plan to achieve a goal for reference:
Scene_Objects:['food_bread', 'scissors', 'chair', 'bathroom', 'detergent', 'cat', 'ceilingfan', 'dough', 'knifeblock', 'hanger', 'floor', 'ceiling', 'character', 'stovefan', 'ceilinglamp', 'tvstand', 'balanceball', 'shower', 'microphone', 'wall', 'oven', 'coffe_maker', 'tray', 'curtain', 'lighter', 'kitchen_counter', 'vacuum_cleaner', 'dresser', 'home_office', 'dishwasher']
Task:Pet cat
response:
{
    "thoughts": Find a cat in the kitchen and touch it,
    "actions": ['[WALK] <dining_room>', '[WALK] <cat>', '[FIND] <cat>', '[WALK] <cat>', '[TOUCH] <cat>']
}

Input:
Scene_Objects:['spectacles', 'chair', 'walllamp', 'orchid', 'knifeblock', 'cpuscreen', 'bathroom_counter', 'floor', 'ceiling', 'shampoo', 'desk', 'bedroom', 'keyboard', 'computer', 'mat', 'ceilinglamp', 'tvstand', 'iron', 'mousepad', 'closetdrawer', 'pillow', 'wall', 'bed', 'television', 'doorjamb', 'mouse', 'door', 'home_office', 'light', 'table']
Task:Write an email
response:

enter office, find computer, turn it on,

[WALK] <home_office>
[WALK] <computer>
[FIND] <computer>
[SWITCHON] <computer>
[FIND] <keyboard>
[TOUCH] <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:['walllamp', 'drawing', 'orchid', 'wallshelf', 'cpuscreen', 'floor', 'ceiling', 'character', 'tea_bag', 'computer', 'mat', 'tvstand', 'mousepad', 'couch', 'candle', 'pillow', 'bowl', 'wall', 'oven', 'toy', 'cup', 'photoframe', 'television', 'wooden_spoon', 'curtain', 'doorjamb', 'dresser', 'laundry_detergent', 'sink', 'tooth_paste']
Task:Relax on sofa
response:
{
    "thoughts": Walk to the living room, find the sofa and sit in the sofa and find pillow. lie down in sofa.,
    "actions": ['[WALK] <home_office>', '[WALK] <couch>', '[FIND] <couch>', '[SIT] <couch>', '[FIND] <pillow>', '[LIE] <couch>']
}

Input:
Scene_Objects:['filing_cabinet', 'detergent', 'bills', 'orchid', 'floor', 'ceiling', 'phone', 'bedroom', 'mat', 'laptop', 'shower', 'faucet', 'ceilinglamp', 'mousepad', 'microphone', 'form', 'pillow', 'broom', 'wall', 'newspaper', 'after_shave', 'doorjamb', 'cd', 'comb', 'controller', 'door', 'bathroom_cabinet', 'light', 'table', 'creditcard']
Task:Turn on light
response:

I walk to wall. I put my hand on the switch. I push the button. I turn on the lights.

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


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

Here is an example plan to achieve a goal for reference:
Scene_Objects:['beer', 'walllamp', 'ceilingfan', 'orchid', 'hanger', 'longboard', 'floor', 'ceiling', 'character', 'bedroom', 'folder', 'bookshelf', 'toaster', 'ceilinglamp', 'plate', 'dish_soap', 'candle', 'wall', 'oven', 'bench', 'box', 'cup', 'clothes_gloves', 'coffe_maker', 'tray', 'console', 'maindoor', 'door', 'napkin', 'dishwasher']
Task:Wash dishes with dishwasher
response:
{
    "thoughts": I go to the kitchen and open the dishwasher. I fill it up with dirty dishes and glasses. Then I put dish soap in the dishwasher, close it and turn it on.,
    "actions": ['[WALK] <dining_room>', '[WALK] <dishwasher>', '[FIND] <dishwasher>', '[OPEN] <dishwasher>', '[FIND] <plate>', '[GRAB] <plate>', '[PUTBACK] <plate> <dishwasher>', '[FIND] <plate>', '[GRAB] <plate>', '[PUTBACK] <plate> <dishwasher>', '[FIND] <plate>', '[GRAB] <plate>', '[PUTBACK] <plate> <dishwasher>', '[FIND] <plate>', '[GRAB] <plate>', '[PUTBACK] <plate> <dishwasher>', '[FIND] <plate>', '[GRAB] <plate>', '[PUTBACK] <plate> <dishwasher>', '[FIND] <cup>', '[GRAB] <cup>', '[PUTBACK] <cup> <dishwasher>', '[FIND] <dish_soap>', '[GRAB] <dish_soap>', '[PUTBACK] <dish_soap> <dishwasher>', '[CLOSE] <dishwasher>', '[SWITCHON] <dishwasher>']
}

Input:
Scene_Objects:['scissors', 'dog', 'walllamp', 'clothes_underwear', 'bathroom_counter', 'phone', 'character', 'desk', 'tea_bag', 'envelope', 'toaster', 'ceilinglamp', 'window', 'mousepad', 'food_kiwi', 'nightstand', 'cutting_board', 'photoframe', 'coffe_maker', 'television', 'tray', 'rag', 'doorjamb', 'diary', 'cupboard', 'hairdryer', 'home_office', 'light', 'table', 'creditcard']
Task:Receive credit card
response:

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

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


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

Here is an example plan to achieve a goal for reference:
Scene_Objects:['fork', 'sheets', 'microwave', 'toilet', 'freezer', 'trashcan', 'food_carrot', 'drawing', 'bills', 'hanger', 'floor', 'ceiling', 'bookshelf', 'mat', 'ceilinglamp', 'shower', 'oil', 'pillow', 'wall', 'novel', 'food_food', 'doorjamb', 'kitchen_counter', 'dresser', 'cupboard', 'door', 'bathtub', 'sink', 'home_office', 'light']
Task:Put away groceries
response:
{
    "thoughts": Place groceries in refrigerator from shopping at the grocery store.,
    "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:['filing_cabinet', 'tablelamp', 'crayon', 'microwave', 'freezer', 'detergent', 'drawing', 'knife', 'cpuscreen', 'purse', 'stovefan', 'brush', 'mat', 'faucet', 'food_noodles', 'couch', 'dustpan', 'nightstand', 'wall', 'powersocket', 'newspaper', 'novel', 'ice', 'kitchen_counter', 'hairbrush', 'cupboard', 'sink', 'table', 'clothes_skirt', 'board_game']
Task:Turn on light
response:

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

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


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

Here is an example plan to achieve a goal for reference:
Scene_Objects:['pot', 'food_salt', 'microwave', 'ceilingfan', 'orchid', 'bathroom_counter', 'bookshelf', 'purse', 'stovefan', 'mat', 'iron', 'electric_shaver', 'food_noodles', 'mousepad', 'couch', 'clothes_pants', 'pillow', 'powersocket', 'keys', 'coffe_maker', 'oven_mitts', 'wine', 'shaving_cream', 'pencil', 'kitchen_counter', 'vacuum_cleaner', 'dresser', 'home_office', 'light', 'tooth_paste']
Task:Hang up car keys
response:
{
    "thoughts": Open the front door. Enter the entrance hall. Take out car keys from purse. Hang car keys up on hook on the wall.,
    "actions": ['[WALK] <home_office>', '[WALK] <purse>', '[FIND] <purse>', '[OPEN] <purse>', '[FIND] <keys>', '[GRAB] <keys>', '[CLOSE] <purse>']
}

Input:
Scene_Objects:['sheets', 'pot', 'filing_cabinet', 'scissors', 'bathroom', 'drawing', 'floor', 'ceiling', 'desk', 'bookshelf', 'computer', 'mat', 'laptop', 'ceilinglamp', 'window', 'closetdrawer', 'couch', 'wall', 'powersocket', 'photoframe', 'television', 'doorjamb', 'lighter', 'mouse', 'comb', 'door', 'sink', 'light', 'dishwasher', 'soap']
Task:Turn on light
response:

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


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

Here is an example plan to achieve a goal for reference:
Scene_Objects:['water_glass', 'food_bread', 'bathroom', 'trashcan', 'food_carrot', 'drawing', 'cpuscreen', 'hanger', 'bathroom_counter', 'floor', 'phone', 'folder', 'bedroom', 'desk', 'keyboard', 'toaster', 'bench', 'tray', 'doorjamb', 'diary', 'console', 'mouse', 'towel_rack', 'cd', 'dresser', 'cupboard', 'controller', 'conditioner', 'table', 'vase']
Task:Drink
response:
{
    "thoughts": walk to kitchen, walk to table, grab water glass and drink water,
    "actions": ['[WALK] <dining_room>', '[WALK] <table>', '[FIND] <water_glass>', '[GRAB] <water_glass>', '[DRINK] <water_glass>', '[PUTBACK] <water_glass> <table>']
}

Input:
Scene_Objects:['beer', 'microwave', 'dog', 'chair', 'cat', 'knifeblock', 'hanger', 'bathroom_counter', 'floor', 'phone', 'character', 'keyboard', 'clothes_jacket', 'ceilinglamp', 'shoe-shine_kit', 'tvstand', 'closetdrawer', 'oven', 'food_cheese', 'novel', 'toothbrush_holder', 'television', 'food_donut', 'console', 'controller', 'clothes_scarf', 'light', 'colander', 'board_game', 'creditcard']
Task:Pet cat
response:


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

Here is an example plan to achieve a goal for reference:
Scene_Objects:['glue', 'filing_cabinet', 'tablelamp', 'microwave', 'toilet', 'dog', 'walllamp', 'bathroom', 'knifeblock', 'food_egg', 'food_bacon', 'brush', 'mat', 'deck_of_cards', 'balanceball', 'tvstand', 'ceilinglamp', 'picture', 'couch', 'wall', 'tape', 'cup', 'toilet_paper', 'food_food', 'video_game_controller', 'water', 'cupboard', 'bathroom_cabinet', 'table', 'vase']
Task:Drink
response:
{
    "thoughts": I go to the kitchen. I get a glass. I fill it with water. I take a drink from the glass.,
    "actions": ['[WALK] <dining_room>', '[WALK] <cup>', '[FIND] <cup>', '[GRAB] <cup>', '[WALK] <water>', '[FIND] <water>', '[GRAB] <water>', '[POUR] <water> <cup>', '[DRINK] <cup>']
}

Input:
Scene_Objects:['dry_pasta', 'spectacles', 'sheets', 'tablelamp', 'microwave', 'chair', 'jelly', 'walllamp', 'drawing', 'bathroom_counter', 'floor', 'ceiling', 'stovefan', 'ceilinglamp', 'picture', 'window', 'couch', 'pillow', 'wall', 'nightstand', 'wall_clock', 'photoframe', 'food_food', 'coffe_maker', 'television', 'centerpiece', 'coffee_pot', 'pencil', 'shoes', 'bathroom_cabinet']
Task:Relax on sofa
response:

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


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

Here is an example plan to achieve a goal for reference:
Scene_Objects:['sheets', 'pot', 'food_pizza', 'dry_pasta', 'walllamp', 'trashcan', 'food_carrot', 'dough', 'knifeblock', 'orchid', 'bathroom_counter', 'floor', 'ceiling', 'table_cloth', 'stovefan', 'toaster', 'wall', 'wall_clock', 'oven', 'food_cheese', 'food_food', 'coffe_maker', 'tray', 'doorjamb', 'coffee_pot', 'kitchen_counter', 'cupboard', 'home_office', 'table', 'dishwasher']
Task:Keep an eye on stove as something is cooking
response:
{
    "thoughts": Watch whatever is cooking on the stove so it doesn't burn or pour. Turn off heat when done,
    "actions": ['[WALK] <dining_room>', '[WALK] <oven>', '[FIND] <pot>', '[TURNTO] <pot>', '[LOOKAT] <pot>', '[FIND] <wall_clock>', '[TURNTO] <wall_clock>', '[LOOKAT] <wall_clock>', '[SWITCHOFF] <oven>']
}

Input:
Scene_Objects:['pot', 'food_salt', 'toilet', 'chair', 'walllamp', 'orchid', 'cpuscreen', 'floor', 'ceiling', 'phone', 'desk', 'keyboard', 'computer', 'stovefan', 'mat', 'ceilinglamp', 'tvstand', 'mousepad', 'closetdrawer', 'pillow', 'bowl', 'wall', 'television', 'doorjamb', 'mouse', 'door', 'bathroom_cabinet', 'light', 'table', 'board_game']
Task:Write an email
response:

Turn on PC and log onto email account. Type email and send it. Switch off computer.

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


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

Here is an example plan to achieve a goal for reference:
Scene_Objects:['fork', 'tablelamp', 'chair', 'freezer', 'drawing', 'knifeblock', 'cpuscreen', 'needle', 'floor', 'ceiling', 'desk', 'stamp', 'keyboard', 'computer', 'brush', 'mousepad', 'wall', 'nightstand', 'bed', 'photoframe', 'check', 'food_food', 'doorjamb', 'mouse', 'kitchen_counter', 'headset', 'door', 'table', 'light', 'shoe_rack']
Task:Listen to music
response:
{
    "thoughts": I'll walk to my bedroom, where I have my computer. I'll walk to my computer and sit down in front of it. I'll put on my headphones and unlock my computer. I'll then navigate to music stored locally or streamed through the web.,
    "actions": ['[WALK] <bedroom>', '[WALK] <computer>', '[FIND] <computer>', '[TURNTO] <computer>', '[LOOKAT] <computer>', '[WALK] <computer>', '[FIND] <chair>', '[PULL] <chair>', '[SIT] <chair>', '[FIND] <headset>', '[GRAB] <headset>', '[PUTON] <headset>', '[SWITCHON] <computer>', '[FIND] <keyboard>', '[TYPE] <keyboard>']
}

Input:
Scene_Objects:['pot', 'microwave', 'freezer', 'detergent', 'orchid', 'knifeblock', 'knife', 'hanger', 'floor', 'character', 'bedroom', 'mop_bucket', 'toaster', 'stovefan', 'faucet', 'electric_shaver', 'couch', 'bowl', 'wall', 'box', 'food_cheese', 'coffe_maker', 'food_food', 'razor', 'shaving_cream', 'kitchen_counter', 'cupboard', 'sink', 'table', 'dishwasher']
Task:Wash dishes with dishwasher
response:

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

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


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

Here is an example plan to achieve a goal for reference:
Scene_Objects:['filing_cabinet', 'walllamp', 'orchid', 'drawing', 'wallshelf', 'floor', 'ceiling', 'desk', 'bookshelf', 'remote_control', 'computer', 'mat', 'tvstand', 'ceilinglamp', 'shower', 'window', 'laptop', 'mousepad', 'couch', 'pillow', 'wall', 'powersocket', 'photoframe', 'video_game_controller', 'television', 'curtain', 'doorjamb', 'door', 'light', 'table']
Task:Watch TV
response:
{
    "thoughts": Watching TV,
    "actions": ['[WALK] <home_office>', '[WALK] <remote_control>', '[FIND] <remote_control>', '[GRAB] <remote_control>', '[FIND] <television>', '[SWITCHON] <television>', '[FIND] <couch>', '[SIT] <couch>', '[FIND] <television>', '[TURNTO] <television>', '[WATCH] <television>']
}

Input:
Scene_Objects:['measuring_cup', 'detergent', 'orchid', 'clothes_underwear', 'floor', 'character', 'button', 'stovefan', 'ceilinglamp', 'toaster', 'homework', 'mousepad', 'couch', 'dustpan', 'microphone', 'form', 'towel', 'powersocket', 'basket_for_clothes', 'bed', 'light_bulb', 'oven_mitts', 'tray', 'kitchen_counter', 'cupboard', 'laundry_detergent', 'sink', 'bathroom_cabinet', 'colander', 'washing_machine']
Task:Wash clothes
response:

Walk to laundry room. Find laundry basket. Grab laundry basket. Find washing machine. Walk to washing machine. Open washing machine. Find detergent. Grab detergent. Put in detergent. Put in clothes. Close washing machine. Turn on machine.


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', 'beer', 'microwave', 'chair', 'drawing', 'hanger', 'ceiling', 'desk', 'bedroom', 'keyboard', 'computer', 'clothes_jacket', 'bookmark', 'laptop', 'ceilinglamp', 'faucet', 'shower', 'mousepad', 'couch', 'food_peanut_butter', 'photoframe', 'newspaper', 'razor', 'tray', 'kitchen_counter', 'vacuum_cleaner', 'clothes_dress', 'door', 'bathroom_cabinet', 'tooth_paste']
Task:Write an email
response:
{
    "thoughts": I go to my bed room and sit on the chair and in front of me is my desktop computer and start writing an email.,
    "actions": ['[WALK] <bathroom>', '[WALK] <chair>', '[FIND] <chair>', '[SIT] <chair>', '[FIND] <computer>', '[SWITCHON] <computer>', '[TURNTO] <computer>', '[LOOKAT] <computer>', '[FIND] <keyboard>', '[TYPE] <keyboard>']
}

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

put away groceries in fridge. open the door, put on shelf, close the door.

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


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

Here is an example plan to achieve a goal for reference:
Scene_Objects:['sheets', 'ground_coffee', 'bathroom', 'shampoo', 'character', 'bedroom', 'bookshelf', 'keyboard', 'envelope', 'bookmark', 'shower', 'iron', 'foundation', 'mousepad', 'closetdrawer', 'couch', 'wall', 'oven', 'basket_for_clothes', 'cup', 'bed', 'food_food', 'curtain', 'towel_rack', 'cupboard', 'door', 'food_steak', 'bathroom_cabinet', 'dishwasher', 'dirt']
Task:Brush teeth
response:
{
    "thoughts": go to the bathroom and brush your teeth,
    "actions": ['[WALK] <bathroom>', '[WALK] <toothbrush>', '[FIND] <toothbrush>', '[GRAB] <toothbrush>', '[WALK] <tooth_paste>', '[FIND] <tooth_paste>', '[GRAB] <tooth_paste>', '[POUR] <tooth_paste> <toothbrush>']
}

Input:
Scene_Objects:['food_bread', 'tablelamp', 'chair', 'walllamp', 'floor', 'ceiling', 'bookshelf', 'mail', 'food_bacon', 'ceilinglamp', 'shower', 'couch', 'pillow', 'food_kiwi', 'wall', 'nightstand', 'newspaper', 'coffe_maker', 'check', 'television', 'doorjamb', 'coffee_pot', 'vacuum_cleaner', 'shoes', 'dresser', 'pajamas', 'napkin', 'home_office', 'bathroom_cabinet', 'board_game']
Task:Relax on sofa
response:

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


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

Here is an example plan to achieve a goal for reference:
Scene_Objects:['tablelamp', 'chair', 'walllamp', 'drawing', 'wallshelf', 'cpuscreen', 'bathroom_counter', 'floor', 'ceiling', 'phone', 'desk', 'keyboard', 'computer', 'laptop', 'mat', 'tvstand', 'mousepad', 'closetdrawer', 'couch', 'pillow', 'dining_room', 'wall', 'oven', 'cup', 'photoframe', 'television', 'doorjamb', 'mouse', 'door', 'creditcard']
Task:Play on laptop
response:
{
    "thoughts": Sit down on the couch. Place laptop on lap. Open laptop. Turn on laptop. Choose selected program. Play selected program. Close game. Close laptop.,
    "actions": ['[WALK] <home_office>', '[WALK] <laptop>', '[FIND] <laptop>', '[GRAB] <laptop>', '[FIND] <couch>', '[SIT] <couch>', '[SWITCHON] <laptop>', '[FIND] <keyboard>', '[TYPE] <keyboard>', '[SWITCHOFF] <laptop>', '[PUTOBJBACK] <laptop>']
}

Input:
Scene_Objects:['glue', 'sponge', 'pot', 'filing_cabinet', 'dog', 'knife', 'wallshelf', 'hanger', 'ceiling', 'character', 'desk', 'bookshelf', 'keyboard', 'computer', 'stovefan', 'mat', 'shower', 'closetdrawer', 'pillow', 'box', 'novel', 'food_onion', 'shaving_cream', 'pencil', 'chessboard', 'comb', 'dresser', 'clothes_scarf', 'dishwasher', 'board_game']
Task:Pick up phone
response:

Walk into the home office. Pick up the phone.

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


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

Here is an example plan to achieve a goal for reference:
Scene_Objects:['chair', 'walllamp', 'orchid', 'cpuscreen', 'clothes_underwear', 'floor', 'ceiling', 'phone', 'desk', 'keyboard', 'computer', 'mat', 'ceilinglamp', 'stereo', 'tvstand', 'mousepad', 'couch', 'broom', 'wall', 'bed', 'check', 'toilet_paper', 'television', 'ice', 'kettle', 'mouse', 'door', 'sink', 'home_office', 'table']
Task:Browse internet
response:
{
    "thoughts": I go in my office, sit at my desk turn on the computer, then type on my keyboard and open my web browser.,
    "actions": ['[WALK] <home_office>', '[WALK] <desk>', '[FIND] <chair>', '[SIT] <chair>', '[FIND] <computer>', '[SWITCHON] <computer>', '[FIND] <keyboard>', '[TYPE] <keyboard>']
}

Input:
Scene_Objects:['pot', 'toilet', 'walllamp', 'nail_polish', 'bathroom', 'drawing', 'cpuscreen', 'bathroom_counter', 'floor', 'bedroom', 'keyboard', 'remote_control', 'button', 'bookmark', 'toaster', 'mat', 'faucet', 'food_jam', 'nightstand', 'tape', 'coffee_table', 'novel', 'check', 'mouse', 'pencil', 'chessboard', 'dresser', 'door', 'food_steak', 'laser_pointer']
Task:Change TV channel
response:

walk next to the coffee table. pick up the remote control from the top of the coffee table. Point the remote to the TV. Press the blue arrow on the remote.

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


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

Here is an example plan to achieve a goal for reference:
Scene_Objects:['filing_cabinet', 'chair', 'walllamp', 'bathroom', 'cpuscreen', 'bathroom_counter', 'floor', 'ceiling', 'desk', 'bedroom', 'keyboard', 'bookshelf', 'computer', 'alcohol', 'stovefan', 'ceilinglamp', 'tvstand', 'mousepad', 'couch', 'wall', 'powersocket', 'food_food', 'television', 'curtain', 'doorjamb', 'mouse', 'cupboard', 'door', 'bathroom_cabinet', 'table']
Task:Browse internet
response:
{
    "thoughts": Turn on computer, pull up browser, browse the internet,
    "actions": ['[WALK] <home_office>', '[WALK] <computer>', '[FIND] <computer>', '[SWITCHON] <computer>', '[TURNTO] <computer>', '[LOOKAT] <computer>']
}

Input:
Scene_Objects:['sheets', 'microwave', 'detergent', 'orchid', 'knifeblock', 'floor', 'ceiling', 'bookshelf', 'mail', 'toaster', 'stovefan', 'faucet', 'closetdrawer', 'pillow', 'food_kiwi', 'wall', 'nightstand', 'oven', 'photoframe', 'television', 'coin', 'drinking_glass', 'water', 'curtain', 'kitchen_counter', 'vacuum_cleaner', 'cupboard', 'sink', 'dishwasher', 'coffee']
Task:Drink
response:

I walk to the kitchen and approach the sink. I take a drinking glass and set it under the faucet. I turn the faucet until the water fills the glass, then turn it back. Finally I lift the glass out of the sink and drink the water.

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


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

Here is an example plan to achieve a goal for reference:
Scene_Objects:['sheets', 'food_pizza', 'filing_cabinet', 'beer', 'measuring_cup', 'chair', 'ground_coffee', 'knifeblock', 'longboard', 'floor', 'ceiling', 'bedroom', 'keyboard', 'computer', 'mail', 'toaster', 'picture', 'dustpan', 'wall', 'bench', 'cutting_board', 'tape', 'cup', 'coffe_maker', 'coffee_filter', 'water', 'after_shave', 'dresser', 'maindoor', 'dishwasher']
Task:Make coffee
response:
{
    "thoughts": Open coffee maker. Put filter in main basket, put ground coffee in filter, fill reservoir with water, turn on coffee maker.,
    "actions": ['[WALK] <dining_room>', '[WALK] <coffe_maker>', '[FIND] <coffe_maker>', '[OPEN] <coffe_maker>', '[FIND] <coffee_filter>', '[GRAB] <coffee_filter>', '[PUTBACK] <coffee_filter> <coffe_maker>', '[FIND] <ground_coffee>', '[GRAB] <ground_coffee>', '[PUTBACK] <ground_coffee> <coffe_maker>', '[GRAB] <ground_coffee>', '[PUTOBJBACK] <ground_coffee>', '[WALK] <water>', '[FIND] <water>', '[GRAB] <water>', '[POUR] <water> <coffe_maker>', '[CLOSE] <coffe_maker>', '[SWITCHON] <coffe_maker>']
}

Input:
Scene_Objects:['sponge', 'scissors', 'microwave', 'bathroom', 'drawing', 'knifeblock', 'floor', 'bedroom', 'desk', 'toaster', 'mat', 'plate', 'faucet', 'shower', 'closetdrawer', 'wall', 'powersocket', 'newspaper', 'photoframe', 'bed', 'check', 'food_rice', 'ice', 'curtain', 'mouse', 'kitchen_counter', 'cupboard', 'sink', 'instrument_guitar', 'board_game']
Task:Wash dishes by hand
response:

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

[WALK] <dining_room>
[WALK] <sink>
[FIND] <plate>
[RINSE] <plate>
[FIND] <sponge>
[GRAB] <sponge>
[WASH] <plate>


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

Here is an example plan to achieve a goal for reference:
Scene_Objects:['freezer', 'walllamp', 'bathroom', 'drawing', 'floor', 'desk', 'bookshelf', 'keyboard', 'mat', 'tvstand', 'ceilinglamp', 'faucet', 'window', 'shower', 'electric_shaver', 'couch', 'pillow', 'wall', 'wall_clock', 'oven', 'bed', 'television', 'oven_mitts', 'curtain', 'cupboard', 'bathtub', 'home_office', 'table', 'bathroom_cabinet', 'light']
Task:Read magazine
response:
{
    "thoughts": Please sit on the couch and read a magazine,
    "actions": ['[WALK] <home_office>', '[WALK] <newspaper>', '[FIND] <newspaper>', '[GRAB] <newspaper>', '[WALK] <couch>', '[SIT] <couch>', '[TURNTO] <newspaper>', '[LOOKAT] <newspaper>', '[READ] <newspaper>', '[READ] <newspaper>', '[READ] <newspaper>']
}

Input:
Scene_Objects:['fork', 'pot', 'blender', 'crayon', 'microwave', 'cat', 'drawing', 'orchid', 'needle', 'phone', 'stovefan', 'ceilinglamp', 'tvstand', 'shower', 'food_jam', 'dining_room', 'powersocket', 'bed', 'photoframe', 'coffe_maker', 'television', 'diary', 'shoes', 'comb', 'controller', 'food_steak', 'instrument_violin', 'sink', 'dishwasher', 'board_game']
Task:Pet cat
response:

I walk to the living room. I find the cat. I pet the cat.

[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:['spectacles', 'food_salt', 'chair', 'walllamp', 'orchid', 'cpuscreen', 'hanger', 'floor', 'ceiling', 'desk', 'keyboard', 'computer', 'ceilinglamp', 'mousepad', 'closetdrawer', 'oil', 'wall', 'nightstand', 'powersocket', 'toy', 'bed', 'coffe_maker', 'television', 'doorjamb', 'centerpiece', 'mouse', 'dresser', 'hair', 'light', 'table']
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:['chair', 'walllamp', 'blow_dryer', 'orchid', 'cpuscreen', 'floor', 'ceiling', 'desk', 'keyboard', 'thread', 'computer', 'mat', 'ceilinglamp', 'tvstand', 'mousepad', 'closetdrawer', 'couch', 'pillow', 'dining_room', 'wall', 'photoframe', 'television', 'doorjamb', 'mouse', 'dresser', 'door', 'sink', 'light', 'table', 'creditcard']
Task:Browse internet
response:

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

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


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

Here is an example plan to achieve a goal for reference:
Scene_Objects:['pot', 'microwave', 'toilet', 'freezer', 'walllamp', 'trashcan', 'knifeblock', 'kitchen_cabinet', 'floor', 'ceiling', 'bathroom_counter', 'bookshelf', 'deck_of_cards', 'faucet', 'mousepad', 'pillow', 'wall', 'oven', 'box', 'cup', 'toilet_paper', 'rag', 'kitchen_counter', 'cupboard', 'sink', 'bag', 'bathroom_cabinet', 'bathtub', 'table', 'home_office']
Task:Drink
response:
{
    "thoughts": I walk the kitchen and walk up to the kitchen cabinet. I open the cabinet and take out a cup. I walk to sink and I turn the faucet on using the cold water handle. I put my cup under the running water until it is full. I turn off the cold water handle and bring the cup to my mouth and take a drink.,
    "actions": ['[WALK] <dining_room>', '[WALK] <kitchen_cabinet>', '[FIND] <kitchen_cabinet>', '[OPEN] <kitchen_cabinet>', '[FIND] <cup>', '[GRAB] <cup>', '[FIND] <faucet>', '[SWITCHON] <faucet>', '[WALK] <sink>', '[FIND] <faucet>', '[PUSH] <faucet>', '[PUTBACK] <cup> <sink>', '[GRAB] <cup>', '[SWITCHOFF] <faucet>', '[DRINK] <cup>']
}

Input:
Scene_Objects:['pot', 'tablelamp', 'beer', 'toilet', 'freezer', 'walllamp', 'drawing', 'knifeblock', 'kitchen_cabinet', 'floor', 'ceiling', 'food_chicken', 'stovefan', 'mat', 'toaster', 'shower', 'nightstand', 'wall', 'powersocket', 'oven', 'photoframe', 'food_food', 'food_donut', 'tray', 'doorjamb', 'kitchen_counter', 'cupboard', 'door', 'light', 'dishwasher']
Task:Cook some food
response:

Walk into the kitchen. Open the fridge. Take out the chicken. Open the kitchen cabinet. Take out the frying pan. Put the chicken in the frying pan. Put the frying pan on the stove. Turn on the stove. Cook the chicken.

[WALK] <dining_room>
[WALK] <freezer>
[OPEN] <freezer>
[FIND] <food_chicken>
[GRAB] <food_chicken>
[CLOSE] <freezer>
[FIND] <kitchen_cabinet>
[OPEN] <kitchen_cabinet>
[FIND] <pot>
[GRAB] <pot>
[CLOSE] <kitchen_cabinet>
[WALK] <oven>
[PUTBACK] <pot> <oven>
[PUTBACK] <food_chicken> <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:['glue', 'food_bread', 'chair', 'freezer', 'band-aids', 'walllamp', 'food_butter', 'drawing', 'orchid', 'knifeblock', 'floor', 'ceiling', 'button', 'clothes_jacket', 'toaster', 'ceilinglamp', 'microphone', 'wall', 'oven', 'powersocket', 'bed', 'food_food', 'coffe_maker', 'oven_mitts', 'ice', 'tray', 'curtain', 'pencil', 'clothes_dress', 'dishwasher']
Task:Make toast
response:
{
    "thoughts": Place slices of bread in a toaster ,wait for the bread to pop up .Set aside.,
    "actions": ['[WALK] <dining_room>', '[WALK] <freezer>', '[FIND] <freezer>', '[OPEN] <freezer>', '[FIND] <food_bread>', '[GRAB] <food_bread>', '[CLOSE] <freezer>', '[FIND] <toaster>', '[PLUGIN] <toaster>', '[PUTBACK] <food_bread> <toaster>', '[SWITCHON] <toaster>']
}

Input:
Scene_Objects:['glue', 'juice', 'toilet', 'freezer', 'knifeblock', 'drawing', 'hanger', 'floor', 'ceiling', 'bedroom', 'keyboard', 'computer', 'mat', 'shower', 'dining_room', 'nightstand', 'wall', 'powersocket', 'oven', 'photoframe', 'newspaper', 'food_food', 'curtain', 'doorjamb', 'cupboard', 'door', 'napkin', 'home_office', 'light', 'instrument_guitar']
Task:Put groceries in Fridge
response:

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

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


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

Here is an example plan to achieve a goal for reference:
Scene_Objects:['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:
{
    "thoughts": walk to home office ,find computer ,switch on computer and work,
    "actions": ['[WALK] <home_office>', '[WALK] <computer>', '[FIND] <computer>', '[SWITCHON] <computer>']
}

Input:
Scene_Objects:['sheets', 'pot', 'mop', 'toilet', 'chair', 'freezer', 'cpuscreen', 'food_egg', 'floor', 'table_cloth', 'toaster', 'mat', 'plate', 'ceilinglamp', 'dish_soap', 'couch', 'food_peanut_butter', 'dustpan', 'bowl', 'wall', 'photoframe', 'coffe_maker', 'food_food', 'television', 'tray', 'kitchen_counter', 'cupboard', 'light', 'dishwasher', 'table']
Task:Wash dishes with dishwasher
response:

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


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

Here is an example plan to achieve a goal for reference:
Scene_Objects:['pot', 'scissors', 'tablelamp', 'chair', 'drawing', 'cpuscreen', 'floor', 'phone', 'character', 'desk', 'keyboard', 'computer', 'mat', 'deck_of_cards', 'tvstand', 'mousepad', 'form', 'pillow', 'wall', 'oven', 'powersocket', 'check', 'television', 'tray', 'doorjamb', 'towel_rack', 'mouse', 'cards', 'door', 'light']
Task:Pick up phone
response:
{
    "thoughts": Enter office. Go to desk. Pick up phone.,
    "actions": ['[WALK] <home_office>', '[WALK] <desk>', '[FIND] <phone>', '[GRAB] <phone>']
}

Input:
Scene_Objects:['food_bread', 'food_pizza', 'tablelamp', 'microwave', 'floor', 'ceiling', 'desk', 'bookshelf', 'stovefan', 'mat', 'ceilinglamp', 'laptop', 'window', 'homework', 'oil', 'closetdrawer', 'couch', 'nightstand', 'wall', 'cup', 'bed', 'food_food', 'mouthwash', 'toothbrush_holder', 'oven_mitts', 'razor', 'food_donut', 'check', 'clothes_scarf', 'bathroom_cabinet']
Task:Go to sleep
response:

Walk to bedroom. Walk to bed, lie in bed.

[WALK] <bedroom>
[WALK] <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:['sheets', 'tablelamp', 'bathroom', 'drawing', 'floor', 'character', 'bedroom', 'stamp', 'computer', 'mat', 'ceilinglamp', 'faucet', 'window', 'mousepad', 'closetdrawer', 'clothes_hat', 'pillow', 'dining_room', 'broom', 'wall', 'bed', 'doorjamb', 'dresser', 'cupboard', 'sink', 'bathroom_cabinet', 'light', 'home_office', 'board_game', 'dirt']
Task:Turn on light
response:
{
    "thoughts": walk to living room ,find electrical outlet , switch on eletrical outlet,
    "actions": ['[WALK] <home_office>', '[WALK] <electrical_outlet>', '[FIND] <electrical_outlet>', '[SWITCHON] <electrical_outlet>']
}

Input:
Scene_Objects:['pot', 'cpuscreen', 'wallshelf', 'bathroom_counter', 'floor', 'stovefan', 'plate', 'shower', 'picture', 'faucet', 'dish_soap', 'pillow', 'wall', 'powersocket', 'cutting_board', 'tape', 'cup', 'coffe_maker', 'food_food', 'television', 'lighter', 'centerpiece', 'mouse', 'kitchen_counter', 'chessboard', 'dresser', 'cupboard', 'bathroom_cabinet', 'table', 'dishwasher']
Task:Wash dishes with dishwasher
response:

I go to the kitchen and open the dishwasher. I fill it up with dirty dishes and glasses. Then I put dish soap in the dishwasher, close it and turn it on.

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


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

Here is an example plan to achieve a goal for reference:
Scene_Objects:['pot', 'food_pizza', 'tablelamp', 'chair', 'detergent', 'bathroom_counter', 'floor', 'ceiling', 'phone', 'desk', 'bookshelf', 'stovefan', 'ceilinglamp', 'mat', 'faucet', 'shower', 'mousepad', 'dustpan', 'dining_room', 'wall', 'powersocket', 'oven', 'check', 'television', 'doorjamb', 'hairbrush', 'controller', 'sink', 'home_office', 'light']
Task:Turn on light
response:
{
    "thoughts": Walk to living room.  Find light switch.  Switch on light switch.,
    "actions": ['[WALK] <home_office>', '[WALK] <light>', '[FIND] <light>', '[SWITCHON] <light>']
}

Input:
Scene_Objects:['tea', 'chair', 'walllamp', 'orchid', 'cpuscreen', 'bathroom_counter', 'floor', 'ceiling', 'desk', 'keyboard', 'computer', 'mat', 'ceilinglamp', 'tvstand', 'shoe-shine_kit', 'mousepad', 'closetdrawer', 'pillow', 'wall', 'cutting_board', 'cup', 'coffe_maker', 'television', 'doorjamb', 'mouse', 'vacuum_cleaner', 'controller', 'door', 'light', 'table']
Task:Work
response:

Go to office, find computer, switch on computer, type on keyboard, use mouse, switch off computer

[WALK] <home_office>
[WALK] <computer>
[FIND] <computer>
[SWITCHON] <computer>
[FIND] <keyboard>
[TYPE] <keyboard>
[FIND] <mouse>
[PUSH] <mouse>
[SWITCHOFF] <computer>


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

Here is an example plan to achieve a goal for reference:
Scene_Objects:['pot', 'filing_cabinet', 'tablelamp', 'walllamp', 'drawing', 'bathroom_counter', 'floor', 'phone', 'piano_bench', 'toaster', 'mat', 'faucet', 'shower', 'window', 'dining_room', 'wall', 'bench', 'hands_both', 'bed', 'television', 'oven_mitts', 'water', 'curtain', 'paper_towel', 'hairdryer', 'sink', 'bathroom_cabinet', 'home_office', 'soap', 'teeth']
Task:Wash hands
response:
{
    "thoughts": 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.,
    "actions": ['[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>']
}

Input:
Scene_Objects:['pot', 'measuring_cup', 'toilet', 'ground_coffee', 'knife', 'hanger', 'bathroom_counter', 'floor', 'ceiling', 'phone', 'computer', 'button', 'ceilinglamp', 'stereo', 'faucet', 'oil', 'pillow', 'wall', 'pasta', 'photoframe', 'coffe_maker', 'coffee_filter', 'coin', 'kitchen_counter', 'cupboard', 'bathroom_cabinet', 'light', 'dishwasher', 'table', 'home_office']
Task:Make coffee
response:

Open the coffee maker and put a filer, grab ground coffee and put it in the coffee maker, then close the coffee maker and switch it on

[WALK] <dining_room>
[WALK] <coffe_maker>
[FIND] <coffe_maker>
[OPEN] <coffe_maker>
[FIND] <coffee_filter>
[GRAB] <coffee_filter>
[PUTBACK] <coffee_filter> <coffe_maker>
[FIND] <ground_coffee>
[GRAB] <ground_coffee>
[FIND] <ground_coffee>
[PUTBACK] <ground_coffee> <coffe_maker>
[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:['tablelamp', 'beer', 'crayon', 'chair', 'freezer', 'walllamp', 'orchid', 'drawing', 'hanger', 'floor', 'ceiling', 'bedroom', 'bookshelf', 'food_cake', 'ceilinglamp', 'tvstand', 'mat', 'couch', 'food_peanut_butter', 'pillow', 'wall', 'nightstand', 'powersocket', 'cup', 'food_food', 'television', 'curtain', 'pencil', 'kitchen_counter', 'door']
Task:Relax on sofa
response:
{
    "thoughts": I walk to the sofa, and lie down on the sofa.,
    "actions": ['[WALK] <couch>', '[LIE] <couch>']
}

Input:
Scene_Objects:['dry_pasta', 'microwave', 'ground_coffee', 'knifeblock', 'knife', 'kitchen_cabinet', 'floor', 'ceiling', 'tea_bag', 'table_cloth', 'toaster', 'shoe-shine_kit', 'faucet', 'shower', 'window', 'homework', 'wall', 'basket_for_clothes', 'coffe_maker', 'water', 'drinking_glass', 'curtain', 'mouse', 'kitchen_counter', 'vacuum_cleaner', 'comb', 'cupboard', 'sink', 'light', 'clothes_skirt']
Task:Drink
response:

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

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


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

Here is an example plan to achieve a goal for reference:
Scene_Objects:['pot', 'food_pizza', 'mop', 'walllamp', 'knifeblock', 'floor', 'ceiling', 'bedroom', 'bookshelf', 'clothes_jacket', 'stovefan', 'faucet', 'window', 'pillow', 'bowl', 'wall', 'wall_clock', 'oven', 'cup', 'photoframe', 'food_food', 'toilet_paper', 'tray', 'after_shave', 'towel_rack', 'kitchen_counter', 'cupboard', 'sink', 'table', 'tooth_paste']
Task:Cook some food
response:
{
    "thoughts": I switch on the stove and cook my groceries there.,
    "actions": ['[WALK] <dining_room>', '[WALK] <oven>', '[FIND] <oven>', '[SWITCHON] <oven>', '[FIND] <bowl>', '[GRAB] <bowl>', '[PUTBACK] <bowl> <oven>', '[FIND] <food_food>', '[SWITCHOFF] <oven>']
}

Input:
Scene_Objects:['tea', 'microwave', 'band-aids', 'bathroom', 'detergent', 'drawing', 'orchid', 'wallshelf', 'cpuscreen', 'hanger', 'floor', 'ceiling', 'table_cloth', 'toaster', 'mat', 'tvstand', 'stereo', 'food_noodles', 'mousepad', 'food_jam', 'bowl', 'nightstand', 'wall', 'cup', 'bed', 'clothes_gloves', 'newspaper', 'coffe_maker', 'doorjamb', 'table']
Task:Listen to music
response:

I go into my bedroom and see my stereo. I decide to play music. I walk over to the stereo and turn it on. I sit down on the bed to listen to the music.

[WALK] <bedroom>
[WALK] <stereo>
[FIND] <stereo>
[TURNTO] <stereo>
[LOOKAT] <stereo>
[SWITCHON] <stereo>
[FIND] <bed>
[SIT] <bed>