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

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

Input:
Scene_Objects:['filing_cabinet', 'chair', 'dog', 'blow_dryer', 'toothbrush', 'orchid', 'clothes_underwear', 'hanger', 'bathroom_counter', 'ceiling', 'purse', 'food_bacon', 'toaster', 'ceilinglamp', 'shower', 'clothes_socks', 'mousepad', 'oil', 'clothes_pants', 'microphone', 'pillow', 'pajamas', 'controller', 'laundry_detergent', 'sink', 'bathroom_cabinet', 'clothes_skirt', 'dishwasher', 'clothes_shirt', 'washing_machine']
Task:Wash clothes
response:

I grab the basket for clothes from the bedroom. I carry it and walk to the washing machine. I open the washing machine. I grab the dirty clothes. I put the clothes in the washing machine. I grab the laundry detergent and put it in the washing machine. I close the washing machine. I switch on the washing machine.


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

Here is an example plan to achieve a goal for reference:
Scene_Objects:['sponge', 'tablelamp', 'beer', 'chair', 'walllamp', 'bathroom', 'cat', 'drawing', 'wallshelf', 'cpuscreen', 'hanger', 'floor', 'ceiling', 'desk', 'keyboard', 'computer', 'mat', 'tvstand', 'ceilinglamp', 'tooth_paste', 'closetdrawer', 'couch', 'pillow', 'wall', 'photoframe', 'television', 'coin', 'doorjamb', 'dresser', 'board_game']
Task:Watch TV
response:
{
    "thoughts": Watch TV in the living room.,
    "actions": ['[WALK] <home_office>', '[WALK] <television>', '[FIND] <television>', '[SWITCHON] <television>', '[TURNTO] <television>', '[WATCH] <television>']
}

Input:
Scene_Objects:['food_pizza', 'microwave', 'walllamp', 'bathroom', 'trashcan', 'dough', 'ceiling', 'character', 'computer', 'stovefan', 'toaster', 'tvstand', 'oil', 'pillow', 'pasta', 'powersocket', 'cup', 'bed', 'novel', 'food_food', 'mouthwash', 'curtain', 'rag', 'towel_rack', 'cupboard', 'controller', 'door', 'spoon', 'home_office', 'table']
Task:Listen to music
response:

I walk into the living room. I find the stereo and turn it on, and I listen to the music.

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


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

Here is an example plan to achieve a goal for reference:
Scene_Objects:['sheets', 'filing_cabinet', 'chair', 'ground_coffee', 'bathroom', 'detergent', 'bathroom_counter', 'bedroom', 'bookshelf', 'button', 'toaster', 'mat', 'ceilinglamp', 'window', 'mousepad', 'couch', 'dining_room', 'photoframe', 'bed', 'novel', 'coffe_maker', 'food_food', 'mouse', 'pencil', 'kitchen_counter', 'dresser', 'sink', 'dishwasher', 'clothes_skirt', 'soap']
Task:Pick up phone
response:
{
    "thoughts": walk to living room , find phone ,pick up phone 3,
    "actions": ['[WALK] <home_office>', '[WALK] <phone>', '[FIND] <phone>']
}

Input:
Scene_Objects:['pot', 'freezer', 'ceilingfan', 'drawing', 'knifeblock', 'floor', 'ceiling', 'phone', 'tea_bag', 'computer', 'button', 'bookmark', 'ceilinglamp', 'tvstand', 'balanceball', 'window', 'foundation', 'couch', 'clothes_hat', 'wall', 'oven', 'bench', 'television', 'curtain', 'vacuum_cleaner', 'dresser', 'maindoor', 'spoon', 'home_office', 'table']
Task:Watch TV
response:

walk to living room, find the television, switch on the television, find the sofa, walk to sofa, sit in sofa, watch the television

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


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

Here is an example plan to achieve a goal for reference:
Scene_Objects:['juice', 'blow_dryer', 'cat', 'toothbrush', 'orchid', 'floor', 'keyboard', 'mat', 'ceilinglamp', 'shoe-shine_kit', 'picture', 'window', 'mousepad', 'couch', 'pillow', 'food_kiwi', 'wall', 'powersocket', 'shelf', 'photoframe', 'television', 'ice', 'curtain', 'after_shave', 'doorjamb', 'diary', 'vacuum_cleaner', 'conditioner', 'home_office', 'table']
Task:Pet cat
response:
{
    "thoughts": I would walk into the living room. Then sit on the couch and pet the cat.,
    "actions": ['[WALK] <home_office>', '[WALK] <couch>', '[SIT] <couch>', '[FIND] <cat>', '[TOUCH] <cat>']
}

Input:
Scene_Objects:['sheets', 'spectacles', 'filing_cabinet', 'walllamp', 'ceilingfan', 'food_carrot', 'toothbrush', 'drawing', 'desk', 'bookshelf', 'stovefan', 'balanceball', 'shower', 'window', 'candle', 'clothes_pants', 'food_orange', 'dining_room', 'bench', 'bed', 'keys', 'food_food', 'diary', 'mouse', 'shoes', 'sink', 'vase', 'tooth_paste', 'scrabble', 'teeth']
Task:Brush teeth
response:

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


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

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

Input:
Scene_Objects:['jelly', 'trashcan', 'food_carrot', 'drawing', 'food_egg', 'bathroom_counter', 'ceiling', 'keyboard', 'bookshelf', 'mop_bucket', 'tvstand', 'iron', 'oil', 'food_noodles', 'mousepad', 'dustpan', 'towel', 'nightstand', 'cup', 'light_bulb', 'razor', 'food_donut', 'rag', 'shaving_cream', 'towel_rack', 'pencil', 'kitchen_counter', 'bag', 'bathroom_cabinet', 'dishwasher']
Task:Listen to music
response:

I pull up my online classes on the computer to look at what the assigned reading is. I get my textbook, notebook, and mechanical pencil. As I'm reading, I take notes over important points. I then use those notes to complete the assignment for the week. Frequently that involves writing a post on an online discussion board that answers a question related to things from the reading.

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


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

Here is an example plan to achieve a goal for reference:
Scene_Objects:['tablelamp', 'freezer', 'bathroom', 'drawing', 'knifeblock', 'cpuscreen', 'bathroom_counter', 'floor', 'ceiling', 'phone', 'bedroom', 'desk', 'bookshelf', 'shower', 'homework', 'wall', 'powersocket', 'box', 'bed', 'coffe_maker', 'television', 'after_shave', 'doorjamb', 'towel_rack', 'mouse', 'cards', 'cupboard', 'home_office', 'light', 'dishwasher']
Task:Turn on light
response:
{
    "thoughts": Walk into living room. Find wall. Find light button. Switch on light button.,
    "actions": ['[WALK] <home_office>', '[WALK] <light>', '[FIND] <light>', '[SWITCHON] <light>']
}

Input:
Scene_Objects:['tablelamp', 'juice', 'measuring_cup', 'chair', 'trashcan', 'ceilingfan', 'drawing', 'cpuscreen', 'floor', 'ceiling', 'phone', 'desk', 'keyboard', 'bookshelf', 'computer', 'ceilinglamp', 'balanceball', 'mousepad', 'wall', 'nightstand', 'doorjamb', 'mouse', 'pencil', 'cupboard', 'door', 'maindoor', 'home_office', 'light', 'dishwasher', 'creditcard']
Task:Work
response:

turn computer on, open application to work with

[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:['pot', 'microwave', 'toilet', 'freezer', 'trashcan', 'drawing', 'wallshelf', 'cpuscreen', 'floor', 'desk', 'bookshelf', 'toaster', 'mat', 'ceilinglamp', 'plate', 'window', 'couch', 'pillow', 'wall', 'nightstand', 'bench', 'photoframe', 'coffe_maker', 'food_rice', 'dresser', 'cupboard', 'bathroom_cabinet', 'table', 'dishwasher', 'home_office']
Task:Set up table
response:
{
    "thoughts": Get dishes. Place dishes neatly around table. Get food. Place food on middle of table.,
    "actions": ['[WALK] <dining_room>', '[WALK] <plate>', '[FIND] <plate>', '[GRAB] <plate>', '[WALK] <dining_room>', '[WALK] <table>', '[PUTBACK] <plate> <table>', '[WALK] <dining_room>', '[WALK] <plate>', '[FIND] <plate>', '[GRAB] <plate>', '[WALK] <dining_room>', '[WALK] <table>', '[PUTBACK] <plate> <table>', '[WALK] <dining_room>', '[WALK] <plate>', '[FIND] <plate>', '[GRAB] <plate>', '[WALK] <dining_room>', '[WALK] <table>', '[PUTBACK] <plate> <table>', '[WALK] <dining_room>', '[WALK] <food_food>', '[FIND] <food_food>', '[GRAB] <food_food>', '[WALK] <dining_room>', '[WALK] <table>', '[PUTBACK] <food_food> <table>', '[WALK] <dining_room>', '[WALK] <food_food>', '[FIND] <food_food>', '[GRAB] <food_food>', '[WALK] <dining_room>', '[WALK] <table>', '[PUTBACK] <food_food> <table>']
}

Input:
Scene_Objects:['sheets', 'juice', 'band-aids', 'walllamp', 'detergent', 'ceilingfan', 'drawing', 'bathroom_counter', 'floor', 'ceiling', 'computer', 'stovefan', 'mat', 'ceilinglamp', 'faucet', 'shower', 'tvstand', 'balanceball', 'dustpan', 'towel', 'wall', 'photoframe', 'television', 'curtain', 'doorjamb', 'dishrack', 'door', 'sink', 'bathroom_cabinet', 'shoe_rack']
Task:Take shower
response:

Walk to Bathroom. Open the Bathroom Cabinet. Grab a Towel. Close the Bathroom Cabinet. Rinse the Shower.

[WALK] <bathroom>
[WALK] <bathroom_cabinet>
[FIND] <bathroom_cabinet>
[OPEN] <bathroom_cabinet>
[FIND] <towel>
[GRAB] <towel>
[CLOSE] <bathroom_cabinet>
[FIND] <shower>
[RINSE] <shower>


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

Here is an example plan to achieve a goal for reference:
Scene_Objects:['sponge', 'pot', 'microwave', 'freezer', 'drawing', 'floor', 'ceiling', 'dvd_player', 'keyboard', 'stovefan', 'mat', 'laptop', 'stereo', 'oil', 'mousepad', 'couch', 'pillow', 'wall', 'food_food', 'television', 'drinking_glass', 'water', 'curtain', 'diary', 'pencil', 'kitchen_counter', 'cupboard', 'sink', 'light', 'instrument_violin']
Task:Drink
response:
{
    "thoughts": go to the kitchen,
    "actions": ['[WALK] <dining_room>', '[WALK] <freezer>', '[FIND] <freezer>', '[OPEN] <freezer>', '[FIND] <drinking_glass>', '[GRAB] <drinking_glass>', '[FIND] <water>', '[DRINK] <drinking_glass>']
}

Input:
Scene_Objects:['band-aids', 'walllamp', 'floor', 'keyboard', 'toaster', 'mat', 'plate', 'tvstand', 'stereo', 'window', 'dish_soap', 'couch', 'food_kiwi', 'wall', 'oven', 'bench', 'cup', 'coffe_maker', 'wine', 'tray', 'cards', 'dishrack', 'dresser', 'clothes_dress', 'maindoor', 'spoon', 'napkin', 'dishwasher', 'vase', 'colander']
Task:Wash dishes with dishwasher
response:

Walk to the kitchen. Find the dishwasher. Walk to the dishwasher. Open the dishwasher. Find plate no.1. Grab plate no.1. Put plate no.1 into the dishwasher. Find plate no.2. Grab plate no.2. Put plate no.2 into the dishwasher. Find the spoon. Grab the spoon. Put the spoon into the dishwasher. Find the dish soap. Put the dish soap into the dishwasher. Close the dishwasher. Switch on the dishwasher.

[WALK] <dining_room>
[WALK] <dishwasher>
[FIND] <dishwasher>
[WALK] <dishwasher>
[OPEN] <dishwasher>
[FIND] <plate>
[GRAB] <plate>
[PUTBACK] <plate> <dishwasher>
[FIND] <plate>
[GRAB] <plate>
[PUTBACK] <plate> <dishwasher>
[FIND] <spoon>
[GRAB] <spoon>
[PUTBACK] <spoon> <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:['dry_pasta', 'blender', 'beer', 'mop', 'chair', 'freezer', 'bathroom', 'drawing', 'cpuscreen', 'ceiling', 'keyboard', 'alcohol', 'ceilinglamp', 'faucet', 'window', 'powersocket', 'toy', 'food_cheese', 'check', 'tray', 'console', 'mouse', 'pencil', 'kitchen_counter', 'hairbrush', 'hair', 'food_steak', 'bathtub', 'bathroom_cabinet', 'vase']
Task:Answer door
response:
{
    "thoughts": Wait until doorbell rings, look to see who it is outside and open the door if you feel so inclined.,
    "actions": ['[WALK] <home_office>', '[WALK] <man>', '[FIND] <man>', '[GREET] <man>']
}

Input:
Scene_Objects:['sheets', 'pot', 'filing_cabinet', 'dog', 'freezer', 'walllamp', 'dough', 'bathroom_counter', 'floor', 'ceiling', 'phone', 'keyboard', 'toaster', 'ceilinglamp', 'tvstand', 'balanceball', 'mousepad', 'food_peanut_butter', 'clothes_pants', 'dining_room', 'wall', 'novel', 'coffe_maker', 'coffee_filter', 'water', 'shoes', 'controller', 'dishwasher', 'clothes_shirt', 'coffee']
Task:Make coffee
response:

[RUN] <dining_room>
[WALK] <coffe_maker>
[FIND] <coffee_filter>
[GRAB] <coffee_filter>
[OPEN] <coffe_maker>
[PUTBACK] <coffee_filter> <coffe_maker>
[FIND] <coffee>
[GRAB] <coffee>
[POUR] <coffee> <coffe_maker>
[PUTOBJBACK] <coffee>
[WALK] <water>
[FIND] <water>
[GRAB] <water>
[POUR] <water> <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:['sheets', 'spectacles', 'filing_cabinet', 'food_salt', 'walllamp', 'drawing', 'bathroom_counter', 'floor', 'character', 'shower', 'stereo', 'microphone', 'wall', 'toy', 'cutting_board', 'cup', 'novel', 'food_food', 'check', 'food_onion', 'coffee_pot', 'console', 'shaving_cream', 'towel_rack', 'shoes', 'cd', 'hairbrush', 'maindoor', 'soap', 'coffee']
Task:Read
response:
{
    "thoughts": Read a book in the living room,
    "actions": ['[WALK] <home_office>', '[WALK] <filing_cabinet>', '[OPEN] <filing_cabinet>', '[FIND] <novel>', '[GRAB] <novel>', '[CLOSE] <filing_cabinet>', '[READ] <novel>']
}

Input:
Scene_Objects:['measuring_cup', 'chair', 'freezer', 'ceilingfan', 'orchid', 'hanger', 'floor', 'ceiling', 'desk', 'keyboard', 'bookmark', 'ceilinglamp', 'stereo', 'balanceball', 'microphone', 'wall', 'powersocket', 'box', 'cup', 'food_cheese', 'mouthwash', 'television', 'coffee_filter', 'tray', 'doorjamb', 'kitchen_counter', 'hairdryer', 'home_office', 'table', 'vase']
Task:Put groceries in Fridge
response:

Walk to kitchen. Grab groceries and walk to the fridge. Open fridge and put groceries in the fridge. Close the fridge.

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


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

Here is an example plan to achieve a goal for reference:
Scene_Objects:['filing_cabinet', 'tea', 'toilet', 'jelly', 'band-aids', 'dog', 'walllamp', 'bathroom_counter', 'floor', 'bedroom', 'keyboard', 'mop_bucket', 'mat', 'ceilinglamp', 'shower', 'mousepad', 'couch', 'food_peanut_butter', 'dining_room', 'wall', 'pasta', 'powersocket', 'nightstand', 'razor', 'food_donut', 'tray', 'chessboard', 'controller', 'laundry_detergent', 'light']
Task:Go to toilet
response:
{
    "thoughts": I walk into the bathroom. I walk over to the toilet. I sit on the toilet.,
    "actions": ['[WALK] <bathroom>', '[WALK] <toilet>', '[SIT] <toilet>']
}

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

you go into your office, switch on the light, find chair at desk, sit in the chair, switch on the computer and work.

[WALK] <home_office>
[WALK] <light>
[FIND] <light>
[SWITCHON] <light>
[FIND] <desk>
[FIND] <chair>
[SIT] <chair>
[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:['sheets', 'crayon', 'chair', 'walllamp', 'bathroom', 'ceiling', 'bedroom', 'keyboard', 'bookshelf', 'clothes_jacket', 'toaster', 'deck_of_cards', 'faucet', 'mousepad', 'microphone', 'wall', 'tape', 'novel', 'food_food', 'check', 'food_donut', 'tray', 'towel_rack', 'dresser', 'pajamas', 'clothes_dress', 'hairdryer', 'bathroom_cabinet', 'home_office', 'table']
Task:Grab things
response:
{
    "thoughts": The robot will need some kind of hands or grabbing device to transport objects.,
    "actions": ['[WALK] <novel>', '[TURNTO] <novel>', '[GRAB] <novel>']
}

Input:
Scene_Objects:['sheets', 'food_pizza', 'chair', 'cat', 'drawing', 'floor', 'tea_bag', 'bookshelf', 'thread', 'toaster', 'ceilinglamp', 'stovefan', 'window', 'couch', 'food_orange', 'wall', 'food_food', 'television', 'oven_mitts', 'food_onion', 'curtain', 'after_shave', 'comb', 'napkin', 'home_office', 'table', 'dishwasher', 'bathroom_cabinet', 'laser_pointer', 'scrabble']
Task:Relax on sofa
response:

go to the living room,find the sofa,sat down in the sofa,take some relaxation.

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


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

Here is an example plan to achieve a goal for reference:
Scene_Objects:['filing_cabinet', 'toilet', 'chair', 'trashcan', 'food_carrot', 'drawing', 'knifeblock', 'hanger', 'floor', 'tea_bag', 'ceilinglamp', 'tvstand', 'shower', 'window', 'homework', 'couch', 'dustpan', 'food_orange', 'dining_room', 'wall', 'nightstand', 'photoframe', 'clothes_gloves', 'coffe_maker', 'check', 'television', 'mouse', 'pencil', 'table', 'laser_pointer']
Task:Relax on sofa
response:
{
    "thoughts": Walk to the living room, turn to the sofa. Sit on the sofa and relax.,
    "actions": ['[WALK] <home_office>', '[WALK] <couch>', '[FIND] <couch>', '[TURNTO] <couch>', '[SIT] <couch>']
}

Input:
Scene_Objects:['measuring_cup', 'freezer', 'orchid', 'phone', 'clothes_jacket', 'table_cloth', 'mat', 'plate', 'shower', 'clothes_socks', 'food_jam', 'bowl', 'broom', 'nightstand', 'oven', 'cup', 'food_food', 'television', 'after_shave', 'curtain', 'doorjamb', 'mouse', 'dresser', 'clothes_dress', 'maindoor', 'door', 'napkin', 'instrument_guitar', 'home_office', 'light']
Task:Pet cat
response:

Walk into the living room, sit down by the cat, put out hand, stroke the cat from head to tail

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


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

Here is an example plan to achieve a goal for reference:
Scene_Objects:['fork', 'filing_cabinet', 'chair', 'dog', 'toothbrush', 'drawing', 'bills', 'ceiling', 'folder', 'desk', 'bedroom', 'remote_control', 'button', 'clothes_jacket', 'stovefan', 'mat', 'faucet', 'dining_room', 'broom', 'nightstand', 'wall', 'cutting_board', 'novel', 'mouse', 'kitchen_counter', 'cd', 'pajamas', 'sink', 'bathroom_cabinet', 'home_office']
Task:Change TV channel
response:
{
    "thoughts": I pick up the remote. I press button on remote.,
    "actions": ['[WALK] <bedroom>', '[WALK] <remote_control>', '[FIND] <remote_control>', '[GRAB] <remote_control>', '[FIND] <button>', '[PUSH] <button>']
}

Input:
Scene_Objects:['freezer', 'walllamp', 'ground_coffee', 'knifeblock', 'cpuscreen', 'longboard', 'floor', 'phone', 'bedroom', 'toaster', 'faucet', 'pillow', 'wall', 'bed', 'novel', 'water', 'tray', 'centerpiece', 'cards', 'kitchen_counter', 'shoes', 'dresser', 'cupboard', 'conditioner', 'sink', 'bag', 'napkin', 'table', 'dishwasher', 'board_game']
Task:Drink
response:

Walk to kitchen, grab a glass, walk to sink, turn on tap and pour water into glass, drink from glass.

[WALK] <dining_room>
[WALK] <cup>
[FIND] <cup>
[GRAB] <cup>
[WALK] <sink>
[WALK] <water>
[FIND] <water>
[GRAB] <water>
[POUR] <water> <cup>
[DRINK] <cup>


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

Here is an example plan to achieve a goal for reference:
Scene_Objects:['tablelamp', 'microwave', 'chair', 'walllamp', 'orchid', 'knifeblock', 'cpuscreen', 'wallshelf', 'bathroom_counter', 'floor', 'ceiling', 'remote_control', 'computer', 'ceilinglamp', 'tvstand', 'window', 'closetdrawer', 'couch', 'pillow', 'dining_room', 'wall', 'nightstand', 'television', 'curtain', 'shaving_cream', 'dresser', 'home_office', 'table', 'bathroom_cabinet', 'shoe_rack']
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:['filing_cabinet', 'food_salt', 'jelly', 'walllamp', 'trashcan', 'hanger', 'longboard', 'floor', 'desk', 'mail', 'toaster', 'plate', 'shower', 'balanceball', 'couch', 'wall', 'oven', 'box', 'cup', 'bed', 'coffe_maker', 'tray', 'rag', 'doorjamb', 'kitchen_counter', 'cupboard', 'sink', 'dishwasher', 'vase', 'laser_pointer']
Task:Wash dishes with dishwasher
response:

Walk to Kitchen, find dishwasher. Find vessels to be washed. Open dishwasher, put vessels in dish washer, close dish washer and switch it on.

[WALK] <dining_room>
[WALK] <dishwasher>
[FIND] <dishwasher>
[OPEN] <dishwasher>
[FIND] <cup>
[GRAB] <cup>
[PUTBACK] <cup> <dishwasher>
[FIND] <plate>
[GRAB] <plate>
[GRAB] <cup>
[PUTBACK] <cup> <plate>
[GRAB] <cup>
[PUTBACK] <cup> <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:['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:
{
    "thoughts": I walk to my cat, and I pet him,
    "actions": ['[WALK] <cat>', '[TOUCH] <cat>']
}

Input:
Scene_Objects:['microwave', 'toilet', 'chair', 'ceiling', 'toaster', 'ceilinglamp', 'mat', 'shower', 'faucet', 'tvstand', 'deck_of_cards', 'picture', 'clothes_pants', 'food_orange', 'food_kiwi', 'oven', 'bench', 'bed', 'food_food', 'television', 'wine', 'pencil', 'dresser', 'clothes_dress', 'bathroom_cabinet', 'light', 'dishwasher', 'vase', 'table', 'coffee']
Task:Listen to music
response:

I find a radio. I turn on the radio. I listen to music.

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


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

Here is an example plan to achieve a goal for reference:
Scene_Objects:['sheets', 'pot', 'toilet', 'blow_dryer', 'bathroom', 'trashcan', 'orchid', 'dvd_player', 'keyboard', 'mail', 'computer', 'food_bacon', 'stovefan', 'ceilinglamp', 'picture', 'window', 'couch', 'clothes_pants', 'oven', 'photoframe', 'coffe_maker', 'food_food', 'television', 'food_onion', 'coffee_pot', 'sink', 'bathroom_cabinet', 'light', 'dishwasher', 'vase']
Task:Wash dishes with dishwasher
response:
{
    "thoughts": grab the vesseles and wash,
    "actions": ['[WALK] <dining_room>', '[WALK] <bowl>', '[FIND] <bowl>', '[GRAB] <bowl>', '[WALK] <dining_room>', '[WASH] <bowl>', '[WALK] <detergent>', '[FIND] <detergent>', '[RINSE] <detergent>']
}

Input:
Scene_Objects:['dry_pasta', 'food_pizza', 'filing_cabinet', 'scissors', 'chair', 'ceilingfan', 'dough', 'drawing', 'orchid', 'floor', 'ceiling', 'phone', 'bookshelf', 'remote_control', 'stovefan', 'ceilinglamp', 'tvstand', 'balanceball', 'window', 'couch', 'food_orange', 'wall', 'powersocket', 'coffee_table', 'television', 'coin', 'wooden_spoon', 'curtain', 'maindoor', 'table']
Task:Watch TV
response:

I walk into the living room and sit on the couch. I pick up the remote to turn on the television. I put down the remote on the coffee table and look at the 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', 'food_ice_cream', 'mop', 'tea', 'freezer', 'walllamp', 'floor', 'character', 'stovefan', 'toaster', 'mat', 'tvstand', 'stereo', 'window', 'electric_shaver', 'food_noodles', 'couch', 'soap', 'pillow', 'wall', 'bench', 'toilet_paper', 'food_food', 'doorjamb', 'diary', 'dresser', 'hairbrush', 'napkin', 'bathroom_cabinet', 'colander']
Task:Go to toilet
response:
{
    "thoughts": I walk to bathroom. find closet. Uset It. Clean it. Use Toilet paper,
    "actions": ['[WALK] <bathroom>', '[WALK] <dresser>', '[FIND] <dresser>', '[OPEN] <dresser>', '[CLOSE] <dresser>', '[FIND] <toilet_paper>', '[WASH] <dresser>', '[FIND] <toilet_paper>', '[TOUCH] <toilet_paper>']
}

Input:
Scene_Objects:['microwave', 'walllamp', 'drawing', 'knifeblock', 'bathroom_counter', 'floor', 'ceiling', 'character', 'toaster', 'mat', 'laptop', 'faucet', 'tvstand', 'couch', 'dining_room', 'wall', 'powersocket', 'tape', 'cup', 'photoframe', 'coffe_maker', 'shaving_cream', 'towel_rack', 'cupboard', 'maindoor', 'sink', 'bag', 'bathroom_cabinet', 'light', 'hands_both']
Task:Wash hands
response:

[WALK] <bathroom>
[WALK] <sink>
[FIND] <sink>
[FIND] <hands_both>
[RINSE] <hands_both>
[SCRUB] <hands_both>
[RINSE] <hands_both>


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

Here is an example plan to achieve a goal for reference:
Scene_Objects:['sheets', 'pot', 'chair', 'freezer', 'detergent', 'trashcan', 'dough', 'clothes_underwear', 'folder', 'stamp', 'bookshelf', 'clothes_jacket', 'table_cloth', 'mousepad', 'couch', 'food_jam', 'clothes_hat', 'pillow', 'nightstand', 'bench', 'oven', 'cutting_board', 'bed', 'food_food', 'check', 'doorjamb', 'console', 'cupboard', 'home_office', 'table']
Task:Pick up phone
response:
{
    "thoughts": i go find the phone. i pick up the phone,
    "actions": ['[WALK] <home_office>', '[WALK] <phone>', '[FIND] <phone>', '[GRAB] <phone>']
}

Input:
Scene_Objects:['filing_cabinet', 'juice', 'jelly', 'detergent', 'cat', 'bathroom_counter', 'keyboard', 'food_bacon', 'piano_bench', 'faucet', 'window', 'couch', 'candle', 'pillow', 'nightstand', 'tape', 'food_food', 'coffe_maker', 'video_game_controller', 'ice', 'doorjamb', 'towel_rack', 'kitchen_counter', 'cd', 'cupboard', 'hair', 'door', 'bathroom_cabinet', 'table', 'creditcard']
Task:Pet cat
response:

Walk into the living room. Walk up to the cat. Pet the cat with your hand.

[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:['sponge', 'food_pizza', 'juice', 'crayon', 'blow_dryer', 'bathroom', 'trashcan', 'drawing', 'cpuscreen', 'bathroom_counter', 'floor', 'ceiling', 'bedroom', 'mat', 'tvstand', 'faucet', 'wall', 'powersocket', 'bench', 'tape', 'photoframe', 'clothes_gloves', 'food_donut', 'after_shave', 'doorjamb', 'dishrack', 'door', 'sink', 'bathroom_cabinet', 'soap']
Task:Clean sink
response:
{
    "thoughts": Take a premoistened cleaning wipe and wipe down top of sink and faucet.  Next clean the sink bowl.  Let air dry.,
    "actions": ['[WALK] <bathroom>', '[WALK] <rag>', '[FIND] <rag>', '[GRAB] <rag>', '[WALK] <sink>', '[FIND] <faucet>', '[WIPE] <faucet>', '[WIPE] <sink>', '[PUTOBJBACK] <rag>']
}

Input:
Scene_Objects:['trashcan', 'ceilingfan', 'drawing', 'bathroom_counter', 'floor', 'ceiling', 'character', 'folder', 'keyboard', 'remote_control', 'alcohol', 'button', 'stovefan', 'ceilinglamp', 'tvstand', 'balanceball', 'window', 'foundation', 'couch', 'pillow', 'wall', 'nightstand', 'cup', 'television', 'curtain', 'food_steak', 'napkin', 'table', 'clothes_shirt', 'creditcard']
Task:Change TV channel
response:

Take TV remote to change TV Channel. Press channel/program +/- button on TV remote.

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


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

Here is an example plan to achieve a goal for reference:
Scene_Objects:['tablelamp', 'chair', 'freezer', 'dough', 'drawing', 'cpuscreen', 'floor', 'ceiling', 'phone', 'desk', 'keyboard', 'bookshelf', 'computer', 'bookmark', 'stovefan', 'mat', 'window', 'pillow', 'wall', 'nightstand', 'powersocket', 'bed', 'novel', 'coffe_maker', 'curtain', 'doorjamb', 'door', 'sink', 'light', 'laser_pointer']
Task:Read book
response:
{
    "thoughts": I go to the bedroom and turn on the light. I lie in bed. I grab my book from the nightstand, and look for the bookmark to check where I last left off. I read for a while. When I'm done, I put the bookmark on the page I stop at and place the book back on the nightstand.,
    "actions": ['[WALK] <bedroom>', '[WALK] <light>', '[FIND] <light>', '[SWITCHON] <light>', '[FIND] <bed>', '[LIE] <bed>', '[FIND] <novel>', '[GRAB] <novel>', '[FIND] <bookmark>', '[GRAB] <bookmark>', '[READ] <novel>', '[PUTBACK] <bookmark> <novel>', '[FIND] <nightstand>', '[PUTBACK] <novel> <nightstand>']
}

Input:
Scene_Objects:['food_bread', 'freezer', 'walllamp', 'trashcan', 'food_carrot', 'cpuscreen', 'floor', 'ceiling', 'folder', 'bedroom', 'character', 'ceilinglamp', 'tvstand', 'faucet', 'dustpan', 'dining_room', 'wall', 'nightstand', 'oven', 'bench', 'photoframe', 'bed', 'food_food', 'television', 'food_donut', 'food_rice', 'doorjamb', 'shaving_cream', 'table', 'vase']
Task:Put groceries in Fridge
response:

walk to kitchen and seprate the groceries and arrange in fridge.

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


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

Here is an example plan to achieve a goal for reference:
Scene_Objects:['pot', 'microwave', 'chair', 'drawing', 'floor', 'ceiling', 'bedroom', 'alcohol', 'toaster', 'stovefan', 'mat', 'shower', 'faucet', 'deck_of_cards', 'shoe-shine_kit', 'pillow', 'wall', 'oven', 'cup', 'coffe_maker', 'tray', 'doorjamb', 'towel_rack', 'mouse', 'kitchen_counter', 'cupboard', 'sink', 'home_office', 'table', 'dishwasher']
Task:Drink
response:
{
    "thoughts": Turn on the faucet.  Place glass under tap and fill with water.  Turn off faucet.  Drink water.,
    "actions": ['[WALK] <dining_room>', '[WALK] <cupboard>', '[FIND] <cupboard>', '[OPEN] <cupboard>', '[FIND] <cup>', '[GRAB] <cup>', '[CLOSE] <cupboard>', '[WALK] <sink>', '[FIND] <faucet>', '[SWITCHON] <faucet>', '[PUTBACK] <cup> <sink>', '[GRAB] <cup>', '[SWITCHOFF] <faucet>', '[DRINK] <cup>']
}

Input:
Scene_Objects:['sponge', 'water_glass', 'pot', 'glue', 'walllamp', 'trashcan', 'knifeblock', 'ceiling', 'clothes_jacket', 'stovefan', 'toaster', 'mat', 'faucet', 'microphone', 'wall', 'cup', 'bed', 'food_food', 'check', 'water', 'food_donut', 'curtain', 'kitchen_counter', 'chessboard', 'cupboard', 'laundry_detergent', 'sink', 'spoon', 'bathroom_cabinet', 'dirt']
Task:Drink
response:

I walk to the kitchen. open the cupboard. Find the water glass, grab it. Fill the glass with water and drink water.

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


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

Here is an example plan to achieve a goal for reference:
Scene_Objects:['filing_cabinet', 'juice', 'toilet', 'chair', 'bathroom', 'drawing', 'orchid', 'bathroom_counter', 'phone', 'character', 'bedroom', 'toaster', 'mat', 'stereo', 'faucet', 'floor_lamp', 'shower', 'couch', 'dining_room', 'pasta', 'oven', 'powersocket', 'love_seat', 'newspaper', 'photoframe', 'coffe_maker', 'tray', 'dresser', 'bathtub', 'soap']
Task:Read
response:
{
    "thoughts": Sit on an easy chair.  Turn on music.  Take a book and read.  Turn on lamp at night.,
    "actions": ['[WALK] <home_office>', '[WALK] <stereo>', '[FIND] <stereo>', '[SWITCHON] <stereo>', '[FIND] <newspaper>', '[GRAB] <newspaper>', '[FIND] <love_seat>', '[SIT] <love_seat>', '[FIND] <floor_lamp>', '[SWITCHON] <floor_lamp>', '[READ] <newspaper>']
}

Input:
Scene_Objects:['filing_cabinet', 'tablelamp', 'juice', 'ceilingfan', 'drawing', 'needle', 'bills', 'floor', 'ceiling', 'phone', 'remote_control', 'computer', 'ceilinglamp', 'tvstand', 'balanceball', 'window', 'couch', 'candle', 'wall', 'nightstand', 'photoframe', 'mouthwash', 'razor', 'television', 'food_rice', 'curtain', 'towel_rack', 'headset', 'table', 'vase']
Task:Relax on sofa
response:

Go into the living room. Walk over to the sofa. Lie down on the sofa. Turn on and watch TV.

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


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

Here is an example plan to achieve a goal for reference:
Scene_Objects:['sheets', 'toilet', 'dog', 'band-aids', 'walllamp', 'ground_coffee', 'food_carrot', 'drawing', 'bathroom_counter', 'floor', 'phone', 'food_cake', 'computer', 'toaster', 'mat', 'faucet', 'window', 'couch', 'candle', 'pillow', 'wall', 'television', 'curtain', 'doorjamb', 'towel_rack', 'dresser', 'bathroom_cabinet', 'table', 'light', 'scrabble']
Task:Relax on sofa
response:
{
    "thoughts": I walk to the living room and stand in front of the sofa. Then I turn and sit on the sofa and lean my back against the pillow and my feet on the floor.,
    "actions": ['[WALK] <home_office>', '[WALK] <couch>', '[FIND] <couch>', '[TURNTO] <couch>', '[SIT] <couch>']
}

Input:
Scene_Objects:['spectacles', 'pot', 'beer', 'microwave', 'orchid', 'cpuscreen', 'bathroom_counter', 'floor', 'ceiling', 'bookshelf', 'button', 'toaster', 'dustpan', 'dining_room', 'bowl', 'wall', 'coffe_maker', 'toothbrush_holder', 'doorjamb', 'towel_rack', 'kitchen_counter', 'chessboard', 'vacuum_cleaner', 'headset', 'controller', 'clothes_scarf', 'coffee_cup', 'dishwasher', 'vase', 'coffee']
Task:Make coffee
response:

Walk to the kitchen at the coffee maker, grab coffee, pour coffee into coffee maker, put coffee into coffee maker, push coffee maker's button, wait to complete, grab coffee cup

[WALK] <dining_room>
[WALK] <coffe_maker>
[FIND] <coffee>
[GRAB] <coffee>
[OPEN] <coffe_maker>
[POUR] <coffee> <coffe_maker>
[FIND] <coffee_cup>
[GRAB] <coffee_cup>
[PUTBACK] <coffee_cup> <coffe_maker>
[FIND] <button>
[PUSH] <button>
[GRAB] <coffee_cup>


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

Here is an example plan to achieve a goal for reference:
Scene_Objects:['microwave', 'drawing', 'orchid', 'cpuscreen', 'floor', 'ceiling', 'mat', 'window', 'clothes_socks', 'couch', 'pillow', 'towel', 'broom', 'wall', 'bench', 'oven', 'toy', 'bed', 'coffe_maker', 'television', 'wooden_spoon', 'curtain', 'rag', 'doorjamb', 'food_onion', 'towel_rack', 'mouse', 'bathroom_cabinet', 'table', 'scrabble']
Task:Relax on sofa
response:
{
    "thoughts": Walk to living room. Find couch. Sit on couch,
    "actions": ['[WALK] <home_office>', '[WALK] <couch>', '[FIND] <couch>', '[SIT] <couch>']
}

Input:
Scene_Objects:['pot', 'filing_cabinet', 'toilet', 'freezer', 'bathroom', 'detergent', 'food_butter', 'longboard', 'bookshelf', 'stovefan', 'shower', 'pillow', 'towel', 'dining_room', 'nightstand', 'powersocket', 'toy', 'basket_for_clothes', 'newspaper', 'light_bulb', 'photoframe', 'food_food', 'coin', 'doorjamb', 'headset', 'shoes', 'hairbrush', 'cupboard', 'napkin', 'home_office']
Task:Listen to music
response:

I walk into my room and turn the radio on so that I can listen to music.

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


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

Here is an example plan to achieve a goal for reference:
Scene_Objects:['tablelamp', 'chair', 'walllamp', 'orchid', 'drawing', 'knifeblock', 'floor', 'ceiling', 'remote_control', 'computer', 'ceilinglamp', 'tvstand', 'window', 'foundation', 'homework', 'closetdrawer', 'couch', 'pillow', 'broom', 'nightstand', 'wall', 'oven', 'light_bulb', 'television', 'curtain', 'dresser', 'bathroom_cabinet', 'table', 'dishwasher', 'creditcard']
Task:Watch TV
response:
{
    "thoughts": I get home from work and decide to watch tv. I go to the living room and turn on the tv. I sit on the couch and use the remote to switch the channels to find what I want to watch.,
    "actions": ['[WALK] <home_office>', '[WALK] <home_office>', '[WALK] <television>', '[FIND] <television>', '[SWITCHON] <television>', '[WALK] <couch>', '[SIT] <couch>', '[TURNTO] <television>', '[LOOKAT] <television>', '[FIND] <remote_control>', '[GRAB] <remote_control>']
}

Input:
Scene_Objects:['toilet', 'chair', 'freezer', 'cat', 'knifeblock', 'cpuscreen', 'floor', 'ceiling', 'desk', 'bookshelf', 'keyboard', 'computer', 'iron', 'balanceball', 'mousepad', 'dustpan', 'pillow', 'broom', 'wall', 'oven', 'coffee_table', 'novel', 'food_food', 'coffe_maker', 'curtain', 'doorjamb', 'mouse', 'pencil', 'light', 'board_game']
Task:Read book
response:

I walk to the living room and pick up a book from the coffee table. I find my favorite chair.  I sit in the armchair and open the book.  I read.

[WALK] <home_office>
[WALK] <novel>
[FIND] <novel>
[WALK] <coffee_table>
[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:['sponge', 'food_pizza', 'filing_cabinet', 'microwave', 'chair', 'walllamp', 'orchid', 'knifeblock', 'bathroom_counter', 'ceiling', 'phone', 'stamp', 'keyboard', 'thread', 'computer', 'stovefan', 'toaster', 'plate', 'shower', 'mousepad', 'form', 'wall', 'food_cheese', 'bed', 'console', 'headset', 'dresser', 'spoon', 'bathroom_cabinet', 'bag']
Task:Walk to room
response:
{
    "thoughts": Leave the living room and enter the hall,
    "actions": ['[WALK] <home_office>', '[WALK] <home_office>']
}

Input:
Scene_Objects:['tablelamp', 'microwave', 'toilet', 'chair', 'trashcan', 'knifeblock', 'cpuscreen', 'floor', 'desk', 'tea_bag', 'keyboard', 'bookshelf', 'computer', 'alcohol', 'laptop', 'window', 'mousepad', 'couch', 'wall', 'nightstand', 'tape', 'cup', 'photoframe', 'food_food', 'mouse', 'vacuum_cleaner', 'chessboard', 'napkin', 'table', 'soap']
Task:Work
response:

first ill go to my home office adn ill switch on my laptop and with the use of mouse and keyboard il run my computer

[WALK] <home_office>
[WALK] <laptop>
[FIND] <laptop>
[SWITCHON] <laptop>
[FIND] <keyboard>
[GRAB] <keyboard>
[FIND] <mouse>
[TOUCH] <mouse>
[RUN] <laptop>


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

Here is an example plan to achieve a goal for reference:
Scene_Objects:['filing_cabinet', 'microwave', 'toilet', 'chair', 'freezer', 'walllamp', 'orchid', 'drawing', 'bathroom_counter', 'floor', 'bookmark', 'toaster', 'mat', 'tvstand', 'faucet', 'shower', 'laptop', 'mousepad', 'wall', 'oven', 'powersocket', 'towel_rack', 'kitchen_counter', 'headset', 'door', 'sink', 'bathtub', 'home_office', 'bathroom_cabinet', 'light']
Task:Go to toilet
response:
{
    "thoughts": I go to the bathroom. I locate the toilet. I walk to the toilet.,
    "actions": ['[WALK] <bathroom>', '[WALK] <toilet>', '[FIND] <toilet>', '[WALK] <toilet>']
}

Input:
Scene_Objects:['pot', 'food_salt', 'freezer', 'walllamp', 'trashcan', 'ceilingfan', 'cpuscreen', 'clothes_underwear', 'food_egg', 'phone', 'character', 'bedroom', 'envelope', 'clothes_jacket', 'mat', 'tvstand', 'couch', 'clothes_pants', 'newspaper', 'television', 'console', 'dishrack', 'cupboard', 'laundry_detergent', 'door', 'maindoor', 'bathroom_cabinet', 'instrument_guitar', 'soap', 'washing_machine']
Task:Wash clothes
response:

Walk into laundry room. Open washing machine door. Put dirty clothes into washing machine. Measure laundry detergent and place into washing machine. Turn dial to appropriate wash setting. Power on.


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

Here is an example plan to achieve a goal for reference:
Scene_Objects:['spectacles', 'tablelamp', 'beer', 'toilet', 'band-aids', 'nail_polish', 'ceilingfan', 'food_carrot', 'toothbrush', 'knife', 'shampoo', 'ceiling', 'bedroom', 'stamp', 'tea_bag', 'mop_bucket', 'ceilinglamp', 'deck_of_cards', 'balanceball', 'homework', 'food_noodles', 'dining_room', 'bed', 'ice', 'mouse', 'spoon', 'home_office', 'bathroom_cabinet', 'vase', 'colander']
Task:Shut front door
response:
{
    "thoughts": Close the storm door. Lock the storm door.,
    "actions": ['[WALK] <home_office>']
}

Input:
Scene_Objects:['food_salt', 'drawing', 'hanger', 'bathroom_counter', 'floor', 'ceiling', 'phone', 'folder', 'faucet', 'couch', 'food_peanut_butter', 'wall', 'cup', 'photoframe', 'bed', 'check', 'oven_mitts', 'after_shave', 'coffee_pot', 'mouse', 'kitchen_counter', 'cd', 'conditioner', 'sink', 'clothes_scarf', 'bathroom_cabinet', 'light', 'soap', 'tooth_paste', 'hands_both']
Task:Wash hands
response:

You walk to the bathroom and turn to the sink. Grab the soap and wash your hands, put the soap back.

[WALK] <bathroom>
[WALK] <sink>
[FIND] <sink>
[TURNTO] <sink>
[FIND] <soap>
[GRAB] <soap>
[FIND] <hands_both>
[WASH] <hands_both>
[PUTOBJBACK] <soap>


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_ice_cream', 'freezer', 'walllamp', 'milk', 'knifeblock', 'cpuscreen', 'floor', 'ceiling', 'desk', 'keyboard', 'alcohol', 'computer', 'stovefan', 'ceilinglamp', 'faucet', 'mousepad', 'wall', 'oven', 'powersocket', 'cup', 'ice', 'tray', 'doorjamb', 'mouse', 'kitchen_counter', 'cupboard', 'door', 'sink', 'light']
Task:Get something to drink
response:
{
    "thoughts": Walk into the kitchen and to the cupboard to get a cup, walk to the fridge to look for a beverage to enjoy, open the freezer and get ice, pour beverage and enjoy,
    "actions": ['[WALK] <dining_room>', '[WALK] <cupboard>', '[FIND] <cupboard>', '[OPEN] <cupboard>', '[FIND] <cup>', '[GRAB] <cup>', '[CLOSE] <cupboard>', '[WALK] <freezer>', '[OPEN] <freezer>', '[FIND] <milk>', '[GRAB] <milk>', '[CLOSE] <freezer>', '[POUR] <milk> <cup>', '[DRINK] <cup>']
}

Input:
Scene_Objects:['sponge', 'juice', 'chair', 'jelly', 'nail_polish', 'cat', 'trashcan', 'drawing', 'bathroom_counter', 'floor', 'ceiling', 'character', 'bedroom', 'toaster', 'ceilinglamp', 'faucet', 'shower', 'iron', 'clothes_pants', 'food_kiwi', 'wall', 'photoframe', 'food_food', 'water', 'wooden_spoon', 'curtain', 'doorjamb', 'sink', 'bathroom_cabinet', 'teeth']
Task:Wash teeth
response:

[WALK] <bathroom>
[WALK] <faucet>
[FIND] <faucet>
[SWITCHON] <faucet>
[FIND] <water>
[TURNTO] <water>
[POINTAT] <water>
[FIND] <teeth>
[WASH] <teeth>
[SWITCHOFF] <faucet>


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

Here is an example plan to achieve a goal for reference:
Scene_Objects:['sheets', 'food_salt', 'chair', 'wallshelf', 'character', 'keyboard', 'food_cake', 'mop_bucket', 'stovefan', 'toaster', 'iron', 'shower', 'window', 'clothes_socks', 'closetdrawer', 'dining_room', 'broom', 'box', 'coffe_maker', 'television', 'tray', 'centerpiece', 'doorjamb', 'kettle', 'mouse', 'headset', 'cupboard', 'bag', 'table', 'light']
Task:Shut front door
response:
{
    "thoughts": Close the storm door. Lock the storm door.,
    "actions": ['[WALK] <home_office>']
}

Input:
Scene_Objects:['tablelamp', 'toilet', 'ground_coffee', 'walllamp', 'food_butter', 'knifeblock', 'cpuscreen', 'floor', 'ceiling', 'thread', 'stovefan', 'toaster', 'tvstand', 'faucet', 'pillow', 'wall', 'nightstand', 'oven', 'powersocket', 'coffe_maker', 'food_food', 'oven_mitts', 'coffee_filter', 'water', 'wine', 'wooden_spoon', 'controller', 'bathroom_cabinet', 'home_office', 'dishwasher']
Task:Make coffee
response:

Walk to kitchen, open coffee maker, find coffee filter, grab coffee filter, put coffee filter in coffee maker, find ground coffee, put ground coffee in coffee maker, pour water in coffee maker, close coffee maker and switch on coffee maker.

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


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

Here is an example plan to achieve a goal for reference:
Scene_Objects:['pot', 'water_glass', 'toilet', 'jelly', 'freezer', 'walllamp', 'drawing', 'floor', 'ceiling', 'stovefan', 'mat', 'shower', 'food_kiwi', 'wall', 'nightstand', 'oven', 'powersocket', 'photoframe', 'food_food', 'coffe_maker', 'water', 'tray', 'doorjamb', 'coffee_pot', 'kitchen_counter', 'cupboard', 'door', 'food_steak', 'spoon', 'light', 'dishwasher']
Task:Drink
response:
{
    "thoughts": I need to go to Kitchen.  Get a cup.  Fill cup.  Drink,
    "actions": ['[WALK] <dining_room>', '[WALK] <cupboard>', '[FIND] <cupboard>', '[OPEN] <cupboard>', '[FIND] <water_glass>', '[GRAB] <water_glass>', '[WALK] <freezer>', '[WALK] <water>', '[FIND] <water>', '[GRAB] <water>', '[POUR] <water> <water_glass>', '[DRINK] <water_glass>']
}

Input:
Scene_Objects:['spectacles', 'food_pizza', 'mop', 'bathroom', 'toothbrush', 'drawing', 'knifeblock', 'knife', 'bathroom_counter', 'floor', 'ceiling', 'bedroom', 'mop_bucket', 'brush', 'toaster', 'faucet', 'stereo', 'couch', 'towel', 'wall', 'powersocket', 'cup', 'photoframe', 'bed', 'mouse', 'dresser', 'sink', 'bathroom_cabinet', 'soap', 'tooth_paste']
Task:Wash teeth
response:

Upon entering the restroom, walk to the sink. Take a toothbrush and apply enough toothpaste so that 1/4 of the brush is covered (this is the appropriate amount). Proceed to "brush" your teeth using an up and down motion with the brush in your mouth. Brush for 2 minutes covering all areas of the teeth. Rinse with water and clean toothbrush with water too.

[WALK] <bathroom>
[WALK] <tooth_paste>
[FIND] <tooth_paste>
[SCRUB] <tooth_paste>
[FIND] <toothbrush>
[WASH] <toothbrush>
[FIND] <sink>
[RINSE] <sink>


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', 'freezer', 'trashcan', 'drawing', 'cpuscreen', 'floor', 'stamp', 'bedroom', 'stovefan', 'toaster', 'plate', 'faucet', 'shower', 'dish_soap', 'food_jam', 'towel', 'wall', 'nightstand', 'oven', 'coffe_maker', 'food_food', 'ice', 'tray', 'curtain', 'kitchen_counter', 'cupboard', 'sink', 'bathtub', 'dishwasher']
Task:Wash dishes with dishwasher
response:
{
    "thoughts": I walk into the kitchen and go to the dishwasher. I open the dishwasher and grab the dishes. Iplace the dishes into the dishwasher then close it. I add soap then turn the dishwasher on.,
    "actions": ['[WALK] <dining_room>', '[WALK] <dishwasher>', '[OPEN] <dishwasher>', '[WALK] <kitchen_counter>', '[FIND] <plate>', '[GRAB] <plate>', '[PUTBACK] <plate> <dishwasher>', '[FIND] <dish_soap>', '[GRAB] <dish_soap>', '[PUTBACK] <dish_soap> <dishwasher>', '[CLOSE] <dishwasher>', '[SWITCHON] <dishwasher>']
}

Input:
Scene_Objects:['jelly', 'drawing', 'hanger', 'bathroom_counter', 'floor', 'ceiling', 'brush', 'stovefan', 'faucet', 'iron', 'couch', 'towel', 'wall', 'powersocket', 'cutting_board', 'photoframe', 'bed', 'television', 'lighter', 'console', 'dresser', 'pajamas', 'door', 'sink', 'bathroom_cabinet', 'table', 'clothes_skirt', 'vase', 'soap', 'hands_both']
Task:Wash hands
response:

I go into the bathroom, get my hands wet, add soap, suds up my hands, rinse the soap off, turn the faucet off, dry my hands.

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


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

Here is an example plan to achieve a goal for reference:
Scene_Objects:['pot', 'scissors', 'chair', 'freezer', 'trashcan', 'knife', 'longboard', 'floor', 'shampoo', 'computer', 'button', 'tvstand', 'stereo', 'window', 'clothes_pants', 'pillow', 'dining_room', 'wall', 'nightstand', 'bed', 'novel', 'check', 'wine', 'curtain', 'cupboard', 'hair', 'sink', 'bathroom_cabinet', 'soap', 'creditcard']
Task:Read book
response:
{
    "thoughts": I would go lie down in my bed and open the book and start reading.,
    "actions": ['[WALK] <bedroom>', '[WALK] <bed>', '[FIND] <bed>', '[LIE] <bed>', '[FIND] <novel>', '[GRAB] <novel>', '[READ] <novel>']
}

Input:
Scene_Objects:['pot', 'tablelamp', 'toilet', 'chair', 'walllamp', 'ceilingfan', 'toothbrush', 'drawing', 'cpuscreen', 'floor', 'desk', 'bookshelf', 'keyboard', 'computer', 'bookmark', 'ceilinglamp', 'shower', 'faucet', 'window', 'mousepad', 'oil', 'couch', 'wall', 'nightstand', 'photoframe', 'novel', 'video_game_controller', 'television', 'mouse', 'table']
Task:Read book
response:

Find book, grab book, fin bookmark, sit down somewhere comfortable, open book, read book, close book after reading.

[WALK] <desk>
[FIND] <novel>
[FIND] <bookmark>
[GRAB] <bookmark>
[FIND] <couch>
[SIT] <couch>
[GRAB] <novel>
[READ] <novel>
[PUTBACK] <bookmark> <novel>


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

Here is an example plan to achieve a goal for reference:
Scene_Objects:['pot', 'filing_cabinet', 'bathroom', 'detergent', 'food_butter', 'drawing', 'wallshelf', 'floor', 'desk', 'bookshelf', 'plate', 'faucet', 'picture', 'iron', 'window', 'dish_soap', 'food_jam', 'wall', 'nightstand', 'toy', 'cutting_board', 'food_food', 'television', 'curtain', 'pajamas', 'conditioner', 'light', 'dishwasher', 'tooth_paste', 'shoe_rack']
Task:Wash dishes with dishwasher
response:
{
    "thoughts": Go to the kitchen.  Find the dishwasher.  Open the dishwasher.  Find the plates.  Load the plates into the dishwasher.  Find the soap.  Load the soap into the dishwasher.  Close the dishwasher.  Turn on the dishwasher.,
    "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] <dish_soap>', '[GRAB] <dish_soap>', '[PUTBACK] <dish_soap> <dishwasher>', '[CLOSE] <dishwasher>', '[SWITCHON] <dishwasher>']
}

Input:
Scene_Objects:['fork', 'filing_cabinet', 'mop', 'freezer', 'walllamp', 'ceilingfan', 'drawing', 'hanger', 'floor', 'ceiling', 'keyboard', 'remote_control', 'table_cloth', 'ceilinglamp', 'tvstand', 'balanceball', 'window', 'couch', 'dining_room', 'wall', 'wall_clock', 'photoframe', 'food_food', 'television', 'curtain', 'console', 'pencil', 'table', 'light', 'clothes_skirt']
Task:Change TV channel
response:

I walk into the living room. I sit on the couch and grab the remote. Then I turn on the TV and change the channel.

[WALK] <home_office>
[WALK] <couch>
[FIND] <couch>
[SIT] <couch>
[FIND] <remote_control>
[GRAB] <remote_control>
[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:['sheets', 'dry_pasta', 'food_ice_cream', 'toilet', 'freezer', 'knifeblock', 'wallshelf', 'folder', 'desk', 'stamp', 'bedroom', 'computer', 'toaster', 'mat', 'floor_lamp', 'dustpan', 'pillow', 'dining_room', 'broom', 'wall', 'nightstand', 'check', 'curtain', 'console', 'dresser', 'door', 'sink', 'bathroom_cabinet', 'light', 'dishwasher']
Task:Turn on light
response:
{
    "thoughts": I go home and it's dark so I can not see anything,
    "actions": ['[WALK] <home_office>', '[WALK] <floor_lamp>', '[FIND] <floor_lamp>', '[SWITCHON] <floor_lamp>']
}

Input:
Scene_Objects:['detergent', 'food_butter', 'ceilingfan', 'drawing', 'floor', 'ceiling', 'remote_control', 'thread', 'brush', 'ceilinglamp', 'tvstand', 'balanceball', 'iron', 'window', 'faucet', 'mousepad', 'couch', 'dining_room', 'wall', 'bed', 'food_food', 'television', 'food_donut', 'curtain', 'lighter', 'doorjamb', 'cards', 'sink', 'table', 'scrabble']
Task:Watch TV
response:

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


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

Here is an example plan to achieve a goal for reference:
Scene_Objects:['pot', 'tablelamp', 'microwave', 'ground_coffee', 'food_carrot', 'drawing', 'knifeblock', 'cpuscreen', 'hanger', 'floor', 'toaster', 'plate', 'faucet', 'foundation', 'mousepad', 'food_jam', 'food_kiwi', 'wall', 'pasta', 'powersocket', 'food_food', 'coffe_maker', 'rag', 'shaving_cream', 'kitchen_counter', 'dishrack', 'dresser', 'cupboard', 'sink', 'dishwasher']
Task:Wash dishes with dishwasher
response:
{
    "thoughts": Take a dish and put it in the dishwasher to be washed,
    "actions": ['[WALK] <dining_room>', '[WALK] <sink>', '[FIND] <plate>', '[GRAB] <plate>', '[FIND] <dishwasher>', '[OPEN] <dishwasher>', '[PUTBACK] <plate> <dishwasher>', '[FIND] <dishwasher>', '[CLOSE] <dishwasher>', '[SWITCHON] <dishwasher>']
}

Input:
Scene_Objects:['pot', 'scissors', 'chair', 'freezer', 'trashcan', 'knife', 'longboard', 'floor', 'shampoo', 'computer', 'button', 'tvstand', 'stereo', 'window', 'clothes_pants', 'pillow', 'dining_room', 'wall', 'nightstand', 'bed', 'novel', 'check', 'wine', 'curtain', 'cupboard', 'hair', 'sink', 'bathroom_cabinet', 'soap', 'creditcard']
Task:Read book
response:

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

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


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

Here is an example plan to achieve a goal for reference:
Scene_Objects:['sheets', 'crayon', 'chair', 'walllamp', 'bathroom', 'ceiling', 'bedroom', 'keyboard', 'bookshelf', 'clothes_jacket', 'toaster', 'deck_of_cards', 'faucet', 'mousepad', 'microphone', 'wall', 'tape', 'novel', 'food_food', 'check', 'food_donut', 'tray', 'towel_rack', 'dresser', 'pajamas', 'clothes_dress', 'hairdryer', 'bathroom_cabinet', 'home_office', 'table']
Task:Grab things
response:
{
    "thoughts": The robot will need some kind of hands or grabbing device to transport objects.,
    "actions": ['[WALK] <novel>', '[TURNTO] <novel>', '[GRAB] <novel>']
}

Input:
Scene_Objects:['tablelamp', 'walllamp', 'detergent', 'ceilingfan', 'drawing', 'knifeblock', 'bathroom_counter', 'floor', 'ceiling', 'longboard', 'remote_control', 'ceilinglamp', 'tvstand', 'balanceball', 'iron', 'window', 'couch', 'pillow', 'dining_room', 'wall', 'bed', 'television', 'curtain', 'pencil', 'dresser', 'clothes_dress', 'conditioner', 'table', 'board_game', 'coffee']
Task:Change TV channel
response:

Change the channel on the TV in the living room

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


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

Here is an example plan to achieve a goal for reference:
Scene_Objects:['tea', 'walllamp', 'drawing', 'orchid', 'food_egg', 'floor', 'ceiling', 'phone', 'character', 'remote_control', 'button', 'stovefan', 'ceilinglamp', 'tvstand', 'mat', 'faucet', 'shower', 'couch', 'clothes_hat', 'wall', 'powersocket', 'basket_for_clothes', 'check', 'mouthwash', 'television', 'food_onion', 'doorjamb', 'controller', 'door', 'table']
Task:Change TV channel
response:
{
    "thoughts": Walk to TV, grab remote control, press change channel button, repeat pressing change channel button util find the channel wanted, put back remote control,
    "actions": ['[WALK] <television>', '[FIND] <remote_control>', '[GRAB] <remote_control>', '[FIND] <button>', '[TOUCH] <button>', '[TURNTO] <television>', '[WATCH] <television>', '[TOUCH] <button>', '[TURNTO] <television>', '[WATCH] <television>', '[PUTOBJBACK] <remote_control>']
}

Input:
Scene_Objects:['scissors', 'toilet', 'chair', 'walllamp', 'ceilingfan', 'bathroom_counter', 'floor', 'phone', 'character', 'mail', 'computer', 'toaster', 'foundation', 'clothes_socks', 'food_peanut_butter', 'dining_room', 'wall', 'oven', 'powersocket', 'tape', 'cup', 'coffe_maker', 'video_game_controller', 'television', 'tray', 'curtain', 'cd', 'maindoor', 'bathroom_cabinet', 'dishwasher']
Task:Wash dishes with dishwasher
response:

I walk to the kitchen. I take plate. I open the dishwasher. I put plate in the dishwasher. I switch on the dishwasher.

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


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

Here is an example plan to achieve a goal for reference:
Scene_Objects:['pot', 'toilet', 'freezer', 'walllamp', 'drawing', 'knifeblock', 'floor', 'ceiling', 'food_chicken', 'food_cake', 'stovefan', 'mat', 'toaster', 'shower', 'food_noodles', 'oil', 'nightstand', 'wall', 'powersocket', 'oven', 'cup', 'photoframe', 'food_food', 'tray', 'doorjamb', 'kitchen_counter', 'cupboard', 'door', 'light', 'dishwasher']
Task:Cook some food
response:
{
    "thoughts": I walk in the kitchen, I open the fridge and remove the Chicken. I grab frying fan and put it on stove. I put chicken in the frying pan and I cook food.,
    "actions": ['[WALK] <dining_room>', '[WALK] <freezer>', '[FIND] <freezer>', '[OPEN] <freezer>', '[FIND] <food_chicken>', '[GRAB] <food_chicken>', '[FIND] <pot>', '[GRAB] <pot>', '[FIND] <oven>', '[PUTBACK] <pot> <oven>', '[PUTBACK] <food_chicken> <oven>']
}

Input:
Scene_Objects:['dry_pasta', 'tablelamp', 'scissors', 'food_salt', 'toilet', 'chair', 'detergent', 'drawing', 'cpuscreen', 'bathroom_counter', 'floor', 'desk', 'keyboard', 'mail', 'toaster', 'homework', 'mousepad', 'clothes_pants', 'wall', 'powersocket', 'photoframe', 'coffe_maker', 'food_food', 'coffee_pot', 'mouse', 'home_office', 'table', 'dishwasher', 'vase', 'tooth_paste']
Task:Go to toilet
response:

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

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


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

Here is an example plan to achieve a goal for reference:
Scene_Objects:['chair', 'freezer', 'food_carrot', 'drawing', 'orchid', 'cpuscreen', 'kitchen_cabinet', 'floor', 'ceiling', 'computer', 'mat', 'plate', 'ceilinglamp', 'stereo', 'couch', 'candle', 'food_orange', 'pillow', 'wall', 'oven', 'food_vegetable', 'novel', 'food_food', 'razor', 'television', 'console', 'kitchen_counter', 'cupboard', 'controller', 'table']
Task:Fix snack
response:
{
    "thoughts": Open fridge. Take out carrots and other vegetables. Put vegetables on a plate. Put away carrots and celery. Close fridge.,
    "actions": ['[WALK] <dining_room>', '[WALK] <kitchen_cabinet>', '[FIND] <kitchen_cabinet>', '[OPEN] <kitchen_cabinet>', '[FIND] <plate>', '[GRAB] <plate>', '[CLOSE] <kitchen_cabinet>', '[WALK] <freezer>', '[OPEN] <freezer>', '[FIND] <food_carrot>', '[GRAB] <food_carrot>', '[PUTBACK] <food_carrot> <plate>', '[FIND] <food_vegetable>', '[GRAB] <food_vegetable>', '[PUTBACK] <food_vegetable> <plate>', '[CLOSE] <freezer>', '[WALK] <table>', '[PUTBACK] <plate> <table>']
}

Input:
Scene_Objects:['scissors', 'mop', 'dog', 'cat', 'knifeblock', 'longboard', 'folder', 'keyboard', 'food_cake', 'alcohol', 'table_cloth', 'mat', 'window', 'pillow', 'bench', 'toy', 'clothes_gloves', 'novel', 'coffe_maker', 'coin', 'towel_rack', 'vacuum_cleaner', 'dresser', 'cupboard', 'maindoor', 'door', 'table', 'dishwasher', 'laser_pointer', 'creditcard']
Task:Browse internet
response:

I pick up my phone. I touch it to navigate to the web browser. I can swipe and tap the screen to visit different websites. Then I read or watch the content within those websites.

[WALK] <home_office>
[WALK] <phone>
[FIND] <phone>
[GRAB] <phone>
[TOUCH] <phone>
[TURNTO] <phone>
[LOOKAT] <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', 'freezer', 'trashcan', 'cpuscreen', 'floor', 'ceiling', 'desk', 'keyboard', 'computer', 'ceilinglamp', 'tvstand', 'shower', 'stereo', 'mousepad', 'wall', 'powersocket', 'food_food', 'food_donut', 'tray', 'after_shave', 'doorjamb', 'cards', 'mouse', 'shoes', 'dresser', 'food_steak', 'door', 'bathroom_cabinet', 'light', 'clothes_skirt']
Task:Cook some food
response:
{
    "thoughts": Go kitchen and make something for eat,
    "actions": ['[WALK] <dining_room>', '[WALK] <freezer>', '[OPEN] <freezer>', '[FIND] <food_food>']
}

Input:
Scene_Objects:['sheets', 'food_ice_cream', 'measuring_cup', 'knife', 'orchid', 'cpuscreen', 'bathroom_counter', 'ceiling', 'phone', 'alcohol', 'computer', 'table_cloth', 'mat', 'deck_of_cards', 'stereo', 'window', 'pillow', 'powersocket', 'cup', 'newspaper', 'check', 'ice', 'after_shave', 'lighter', 'diary', 'cd', 'cupboard', 'maindoor', 'colander', 'board_game']
Task:Listen to music
response:

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


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

Here is an example plan to achieve a goal for reference:
Scene_Objects:['sheets', 'toilet', 'walllamp', 'bathroom', 'detergent', 'knifeblock', 'bathroom_counter', 'purse', 'alcohol', 'bookmark', 'stovefan', 'toaster', 'stereo', 'food_jam', 'dining_room', 'powersocket', 'food_food', 'mouthwash', 'tray', 'after_shave', 'doorjamb', 'shaving_cream', 'mouse', 'kitchen_counter', 'cupboard', 'controller', 'hairdryer', 'sink', 'home_office', 'laser_pointer']
Task:Walk through
response:
{
    "thoughts": Walk through the hallway.,
    "actions": ['[WALK] <home_office>', '[WALK] <dining_room>', '[WALK] <home_office>']
}

Input:
Scene_Objects:['tablelamp', 'beer', 'cat', 'trashcan', 'milk', 'food_egg', 'bathroom_counter', 'floor', 'ceiling', 'dvd_player', 'character', 'desk', 'bookshelf', 'food_cake', 'computer', 'brush', 'ceilinglamp', 'plate', 'deck_of_cards', 'wall', 'powersocket', 'toy', 'newspaper', 'bed', 'coffe_maker', 'curtain', 'pencil', 'hair', 'door', 'light']
Task:Give milk to cat
response:

Grab milk and pour it into the plate so that the cat can drink

[WALK] <home_office>
[WALK] <cat>
[FIND] <cat>
[TURNTO] <cat>
[POINTAT] <cat>
[PULL] <cat>
[FIND] <milk>
[GRAB] <milk>
[FIND] <plate>
[POUR] <milk> <plate>
[TOUCH] <cat>
[SCRUB] <cat>


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

Here is an example plan to achieve a goal for reference:
Scene_Objects:['sheets', 'filing_cabinet', 'blender', 'beer', 'freezer', 'band-aids', 'walllamp', 'orchid', 'food_egg', 'cpuscreen', 'clothes_underwear', 'floor', 'ceiling', 'desk', 'keyboard', 'computer', 'food_bacon', 'button', 'ceilinglamp', 'mousepad', 'food_peanut_butter', 'wall', 'powersocket', 'food_food', 'doorjamb', 'mouse', 'door', 'sink', 'napkin', 'light']
Task:Put groceries in Fridge
response:
{
    "thoughts": I walk in to the kitchen. I open the fridge. I place the groceries in the fridge. I close the fridge.,
    "actions": ['[WALK] <dining_room>', '[WALK] <freezer>', '[FIND] <freezer>', '[OPEN] <freezer>', '[FIND] <food_food>', '[GRAB] <food_food>', '[PUTIN] <food_food> <freezer>', '[CLOSE] <freezer>']
}

Input:
Scene_Objects:['sheets', 'pot', 'food_pizza', 'tablelamp', 'microwave', 'ceilingfan', 'drawing', 'hanger', 'floor', 'ceiling', 'desk', 'remote_control', 'envelope', 'button', 'ceilinglamp', 'tvstand', 'balanceball', 'deck_of_cards', 'window', 'couch', 'wall', 'nightstand', 'novel', 'television', 'curtain', 'hairdryer', 'sink', 'home_office', 'table', 'bathroom_cabinet']
Task:Change TV channel
response:

Walk to the living room. Find the television. Switch on the television. Find the remote control. Grab the remote control. Point at television. Find the button. Push button.

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


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

Here is an example plan to achieve a goal for reference:
Scene_Objects:['pot', 'filing_cabinet', 'toilet', 'chair', 'cat', 'cpuscreen', 'hanger', 'bathroom_counter', 'floor', 'ceiling', 'phone', 'keyboard', 'food_bacon', 'stovefan', 'ceilinglamp', 'iron', 'dustpan', 'pillow', 'wall', 'toy', 'box', 'centerpiece', 'mouse', 'kitchen_counter', 'vacuum_cleaner', 'cd', 'dresser', 'cupboard', 'light', 'table']
Task:Vacuum
response:
{
    "thoughts": Plug in the vacuum. Turn it on. Push it back and forth across the floor until all the debris is gone.,
    "actions": ['[WALK] <home_office>', '[WALK] <dresser>', '[OPEN] <dresser>', '[FIND] <vacuum_cleaner>', '[GRAB] <vacuum_cleaner>', '[PULL] <vacuum_cleaner>', '[PLUGIN] <vacuum_cleaner>', '[SWITCHON] <vacuum_cleaner>', '[PULL] <vacuum_cleaner>', '[PUSH] <vacuum_cleaner>', '[PULL] <vacuum_cleaner>', '[PUSH] <vacuum_cleaner>', '[PULL] <vacuum_cleaner>', '[PUSH] <vacuum_cleaner>', '[SWITCHOFF] <vacuum_cleaner>', '[PLUGOUT] <vacuum_cleaner>', '[WALK] <dresser>', '[PUTIN] <vacuum_cleaner> <dresser>', '[CLOSE] <dresser>']
}

Input:
Scene_Objects:['sheets', 'microwave', 'dog', 'chair', 'bathroom', 'drawing', 'floor', 'ceiling', 'bedroom', 'bookshelf', 'purse', 'mat', 'ceilinglamp', 'shower', 'candle', 'wall', 'bed', 'clothes_gloves', 'food_food', 'water', 'food_rice', 'wooden_spoon', 'curtain', 'console', 'dishrack', 'pajamas', 'light', 'clothes_skirt', 'soap', 'dirt']
Task:Take shower
response:

go to a bathroom, open the shower, let water wash your body

[WALK] <bathroom>
[WALK] <shower>
[FIND] <soap>
[SCRUB] <soap>
[FIND] <water>
[RINSE] <water>


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

Here is an example plan to achieve a goal for reference:
Scene_Objects:['dry_pasta', 'scissors', 'chair', 'hanger', 'phone', 'keyboard', 'bookshelf', 'plate', 'faucet', 'window', 'mousepad', 'food_noodles', 'oil', 'food_peanut_butter', 'clothes_pants', 'dining_room', 'bench', 'oven', 'cutting_board', 'toy', 'basket_for_clothes', 'cup', 'photoframe', 'keys', 'food_food', 'laundry_detergent', 'bathroom_cabinet', 'instrument_violin', 'clothes_shirt', 'washing_machine']
Task:Wash clothes
response:
{
    "thoughts": Walk to bathroom, open wash-machine, lift laundry basket, grab cloth and put into wash-machine one by one, put down laundry basket, pour detergent, close wash-machine, turn on wash-machine.,
    "actions": ['[WALK] <bathroom>', '[WALK] <washing_machine>', '[FIND] <washing_machine>', '[OPEN] <washing_machine>', '[FIND] <basket_for_clothes>', '[GRAB] <basket_for_clothes>', '[FIND] <clothes_pants>', '[GRAB] <clothes_pants>', '[PUTBACK] <clothes_pants> <washing_machine>', '[FIND] <clothes_shirt>', '[GRAB] <clothes_shirt>', '[PUTBACK] <clothes_shirt> <washing_machine>', '[PUTOBJBACK] <basket_for_clothes>', '[WALK] <laundry_detergent>', '[FIND] <laundry_detergent>', '[GRAB] <laundry_detergent>', '[POUR] <laundry_detergent> <washing_machine>', '[CLOSE] <washing_machine>', '[SWITCHON] <washing_machine>']
}

Input:
Scene_Objects:['sheets', 'beer', 'measuring_cup', 'toilet', 'drawing', 'knife', 'hanger', 'floor', 'desk', 'tea_bag', 'keyboard', 'piano_bench', 'toaster', 'ceilinglamp', 'tvstand', 'balanceball', 'laptop', 'foundation', 'clothes_pants', 'towel', 'wall', 'nightstand', 'novel', 'television', 'tray', 'curtain', 'bag', 'table', 'vase', 'soap']
Task:Wash hands
response:

[WALK] <bathroom>
[WALK] <soap>
[FIND] <soap>
[GRAB] <soap>
[FIND] <towel>
[WIPE] <towel>


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

Here is an example plan to achieve a goal for reference:
Scene_Objects:['beer', 'crayon', 'ceilingfan', 'drawing', 'needle', 'floor', 'ceiling', 'shampoo', 'keyboard', 'remote_control', 'thread', 'food_bacon', 'button', 'stovefan', 'ceilinglamp', 'tvstand', 'balanceball', 'shower', 'window', 'couch', 'wall', 'photoframe', 'bed', 'television', 'coffee_filter', 'curtain', 'mouse', 'table', 'light', 'laser_pointer']
Task:Watch TV
response:
{
    "thoughts": I go into the living room. I find the remote. I turn on the tv. I sit on the couch and watch tv.,
    "actions": ['[WALK] <home_office>', '[WALK] <remote_control>', '[FIND] <remote_control>', '[FIND] <television>', '[TURNTO] <television>', '[POINTAT] <television>', '[SWITCHON] <television>', '[FIND] <couch>', '[SIT] <couch>', '[TURNTO] <television>', '[WATCH] <television>']
}

Input:
Scene_Objects:['sheets', 'tablelamp', 'crayon', 'mop', 'toilet', 'toothbrush', 'drawing', 'bathroom_counter', 'floor', 'desk', 'computer', 'ceilinglamp', 'deck_of_cards', 'faucet', 'mousepad', 'microphone', 'towel', 'wall', 'oven', 'tape', 'photoframe', 'novel', 'toothbrush_holder', 'towel_rack', 'cupboard', 'sink', 'bathroom_cabinet', 'home_office', 'table', 'tooth_paste']
Task:Brush teeth
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:['fork', 'food_bread', 'tablelamp', 'crayon', 'tea', 'toilet', 'walllamp', 'knife', 'floor', 'ceiling', 'toaster', 'mat', 'plate', 'faucet', 'dish_soap', 'couch', 'wall', 'oven', 'novel', 'coffe_maker', 'drinking_glass', 'tray', 'doorjamb', 'kettle', 'kitchen_counter', 'dresser', 'cupboard', 'door', 'dishwasher', 'clothes_shirt']
Task:Wash dishes with dishwasher
response:
{
    "thoughts": Walk to the kitchen and turn to the dishwasher, put the knife, glass, fork and plate into the dishwasher. Turn on the dishwasher.,
    "actions": ['[WALK] <dining_room>', '[WALK] <dishwasher>', '[FIND] <dishwasher>', '[TURNTO] <dishwasher>', '[FIND] <dish_soap>', '[GRAB] <dish_soap>', '[OPEN] <dishwasher>', '[PUTBACK] <dish_soap> <dishwasher>', '[FIND] <drinking_glass>', '[GRAB] <drinking_glass>', '[PUTBACK] <drinking_glass> <dishwasher>', '[FIND] <fork>', '[GRAB] <fork>', '[PUTBACK] <fork> <dishwasher>', '[FIND] <knife>', '[GRAB] <knife>', '[PUTBACK] <knife> <dishwasher>', '[FIND] <plate>', '[GRAB] <plate>', '[PUTBACK] <plate> <dishwasher>', '[CLOSE] <dishwasher>', '[SWITCHON] <dishwasher>']
}

Input:
Scene_Objects:['food_bread', 'tablelamp', 'chair', 'nail_polish', 'detergent', 'ceilingfan', 'knifeblock', 'orchid', 'cpuscreen', 'hanger', 'character', 'keyboard', 'computer', 'homework', 'window', 'towel', 'cutting_board', 'bed', 'photoframe', 'curtain', 'rag', 'towel_rack', 'mouse', 'kitchen_counter', 'headset', 'dresser', 'controller', 'maindoor', 'light', 'dishwasher']
Task:Turn on light
response:

walk to living room, find lamp, switch on.

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


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

Here is an example plan to achieve a goal for reference:
Scene_Objects:['sheets', 'filing_cabinet', 'food_salt', 'measuring_cup', 'toilet', 'jelly', 'drawing', 'floor', 'phone', 'ceiling', 'character', 'bookshelf', 'alcohol', 'mat', 'shower', 'foundation', 'electric_shaver', 'mousepad', 'wall', 'toy', 'basket_for_clothes', 'photoframe', 'wine', 'dresser', 'laundry_detergent', 'food_steak', 'door', 'napkin', 'bathroom_cabinet', 'dishwasher']
Task:Pick up toys
response:
{
    "thoughts": Pickup toys from around the room. Organize toys back into their appropriate spaces on the shelves and into the toy boxes.,
    "actions": ['[WALK] <bedroom>', '[WALK] <toy>', '[FIND] <toy>', '[GRAB] <toy>', '[WALK] <filing_cabinet>', '[OPEN] <filing_cabinet>', '[PUTBACK] <toy> <filing_cabinet>', '[CLOSE] <filing_cabinet>', '[FIND] <toy>', '[GRAB] <toy>', '[WALK] <dresser>', '[OPEN] <dresser>', '[PUTBACK] <toy> <dresser>', '[CLOSE] <dresser>', '[FIND] <toy>', '[GRAB] <toy>', '[WALK] <filing_cabinet>', '[OPEN] <filing_cabinet>', '[PUTBACK] <toy> <filing_cabinet>', '[CLOSE] <filing_cabinet>']
}

Input:
Scene_Objects:['fork', 'chair', 'walllamp', 'knife', 'food_egg', 'floor', 'food_cake', 'toaster', 'plate', 'tvstand', 'window', 'dish_soap', 'wall', 'nightstand', 'oven', 'cutting_board', 'coffe_maker', 'check', 'razor', 'television', 'food_donut', 'tray', 'centerpiece', 'doorjamb', 'dishrack', 'food_steak', 'spoon', 'light', 'dishwasher', 'colander']
Task:Wash dishes with dishwasher
response:

put forks, spoons, plates, knife in dishwasher, add dish soap, turn diswaser on

[WALK] <dining_room>
[WALK] <dishwasher>
[FIND] <dishwasher>
[OPEN] <dishwasher>
[FIND] <dish_soap>
[GRAB] <dish_soap>
[PUTBACK] <dish_soap> <dishwasher>
[FIND] <fork>
[GRAB] <fork>
[FIND] <dishrack>
[PUTBACK] <fork> <dishrack>
[FIND] <plate>
[GRAB] <plate>
[PUTBACK] <plate> <dishrack>
[FIND] <spoon>
[GRAB] <spoon>
[PUTBACK] <spoon> <dishrack>
[FIND] <knife>
[GRAB] <knife>
[PUTBACK] <knife> <dishrack>
[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', 'tablelamp', 'microwave', 'toothbrush', 'drawing', 'orchid', 'wallshelf', 'kitchen_cabinet', 'floor', 'ceiling', 'desk', 'bedroom', 'stovefan', 'toaster', 'ceilinglamp', 'faucet', 'shower', 'mousepad', 'pillow', 'wall', 'pasta', 'oven', 'coffe_maker', 'water', 'tray', 'towel_rack', 'kitchen_counter', 'headset', 'sauce_pan', 'cupboard']
Task:Cook some food
response:
{
    "thoughts": Cook some pasta on the stove,
    "actions": ['[WALK] <dining_room>', '[WALK] <kitchen_cabinet>', '[FIND] <kitchen_cabinet>', '[OPEN] <kitchen_cabinet>', '[FIND] <pasta>', '[GRAB] <pasta>', '[FIND] <water>', '[GRAB] <water>', '[FIND] <sauce_pan>', '[POUR] <water> <sauce_pan>', '[FIND] <oven>', '[SWITCHON] <oven>', '[PUTBACK] <pasta> <sauce_pan>', '[FIND] <sauce_pan>', '[GRAB] <sauce_pan>', '[PUTBACK] <sauce_pan> <oven>']
}

Input:
Scene_Objects:['tea', 'chair', 'freezer', 'cpuscreen', 'food_egg', 'hanger', 'floor', 'ceiling', 'phone', 'desk', 'bookshelf', 'keyboard', 'computer', 'clothes_jacket', 'stovefan', 'mousepad', 'wall', 'keys', 'check', 'oven_mitts', 'doorjamb', 'mouse', 'pencil', 'dresser', 'cupboard', 'door', 'clothes_scarf', 'napkin', 'home_office', 'light']
Task:Turn on light
response:

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


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

Here is an example plan to achieve a goal for reference:
Scene_Objects:['sheets', 'pot', 'chair', 'freezer', 'walllamp', 'bathroom', 'drawing', 'ceiling', 'dvd_player', 'character', 'bookshelf', 'keyboard', 'brush', 'ceilinglamp', 'toaster', 'mat', 'window', 'nightstand', 'bench', 'photoframe', 'food_food', 'after_shave', 'diary', 'kettle', 'shoes', 'chessboard', 'dresser', 'door', 'bathroom_cabinet', 'colander']
Task:Dust
response:
{
    "thoughts": Using soft brush, carefully dust both Indonesian wedding doll statues.,
    "actions": ['[WALK] <home_office>', '[WALK] <dresser>', '[OPEN] <dresser>', '[FIND] <brush>', '[GRAB] <brush>', '[CLOSE] <dresser>']
}

Input:
Scene_Objects:['food_salt', 'bathroom', 'detergent', 'ceilingfan', 'drawing', 'orchid', 'floor', 'ceiling', 'character', 'keyboard', 'remote_control', 'ceilinglamp', 'tvstand', 'balanceball', 'window', 'couch', 'food_peanut_butter', 'pillow', 'towel', 'dining_room', 'wall', 'powersocket', 'toilet_paper', 'television', 'curtain', 'pencil', 'headset', 'cd', 'table', 'dishwasher']
Task:Change TV channel
response:

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