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', 'pot', 'filing_cabinet', 'tablelamp', 'microwave', 'walllamp', 'trashcan', 'floor', 'tea_bag', 'thread', 'toaster', 'ceilinglamp', 'plate', 'dish_soap', 'wall', 'bed', 'coffe_maker', 'food_food', 'check', 'oven_mitts', 'tray', 'doorjamb', 'pencil', 'kitchen_counter', 'hairbrush', 'cupboard', 'hair', 'controller', 'bathroom_cabinet', 'dishwasher']
Task:Wash dishes with dishwasher
response:

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

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


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

Here is an example plan to achieve a goal for reference:
Scene_Objects:['bathroom_counter', 'floor', 'ceiling', 'phone', 'stovefan', 'mat', 'faucet', 'shower', 'tooth_paste', 'towel', 'wall', 'wall_clock', 'oven', 'tape', 'photoframe', 'clothes_gloves', 'light_bulb', 'tray', 'doorjamb', 'towel_rack', 'mouse', 'sink', 'bathtub', 'bathroom_cabinet', 'table', 'light', 'vase', 'soap', 'home_office', 'hands_both']
Task:Wash hands
response:
{
    "thoughts": I go to the bathroom, open the faucet rinse the hands, wash the hands with soap and rinse again, then wipe with a towel.,
    "actions": ['[WALK] <bathroom>', '[WALK] <faucet>', '[FIND] <faucet>', '[TURNTO] <faucet>', '[FIND] <hands_both>', '[RINSE] <hands_both>', '[FIND] <soap>', '[GRAB] <soap>', '[WASH] <hands_both>', '[RINSE] <hands_both>', '[TURNTO] <faucet>', '[FIND] <towel>', '[GRAB] <towel>', '[WIPE] <hands_both>']
}

Input:
Scene_Objects:['tablelamp', 'chair', 'dough', 'bills', 'drawing', 'clothes_underwear', 'floor', 'ceiling', 'shampoo', 'bookshelf', 'computer', 'mat', 'window', 'food_noodles', 'bowl', 'wall', 'nightstand', 'oven', 'basket_for_clothes', 'cup', 'bed', 'toilet_paper', 'mouthwash', 'ice', 'doorjamb', 'vacuum_cleaner', 'dishrack', 'door', 'napkin', 'home_office']
Task:Go to sleep
response:

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

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


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

Here is an example plan to achieve a goal for reference:
Scene_Objects:['pot', 'filing_cabinet', 'band-aids', 'freezer', 'nail_polish', 'bathroom', 'cat', 'orchid', 'cpuscreen', 'phone', 'character', 'keyboard', 'mat', 'faucet', 'wall', 'oven', 'bed', 'keys', 'coffe_maker', 'mouthwash', 'food_onion', 'curtain', 'centerpiece', 'console', 'towel_rack', 'kitchen_counter', 'dresser', 'cupboard', 'door', 'home_office']
Task:Pet cat
response:
{
    "thoughts": First I need to find the cat in the living room. Then I walk over to the cat and pet it gently.,
    "actions": ['[WALK] <home_office>', '[WALK] <cat>', '[FIND] <cat>', '[WALK] <cat>', '[TOUCH] <cat>']
}

Input:
Scene_Objects:['food_pizza', 'tea', 'microwave', 'walllamp', 'bathroom', 'trashcan', 'orchid', 'floor', 'phone', 'keyboard', 'food_cake', 'toaster', 'stovefan', 'plate', 'mat', 'dish_soap', 'oil', 'pillow', 'wall', 'cup', 'photoframe', 'coffe_maker', 'curtain', 'centerpiece', 'mouse', 'kitchen_counter', 'comb', 'cupboard', 'bathroom_cabinet', 'dishwasher']
Task:Wash dishes with dishwasher
response:

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

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


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

Here is an example plan to achieve a goal for reference:
Scene_Objects:['sheets', 'pot', 'mop', 'dog', 'jelly', 'drawing', 'knife', 'bathroom_counter', 'floor', 'ceiling', 'longboard', 'character', 'computer', 'stovefan', 'faucet', 'oil', 'dining_room', 'wall', 'nightstand', 'oven', 'cutting_board', 'photoframe', 'check', 'tray', 'sink', 'napkin', 'bathroom_cabinet', 'soap', 'dirt', 'hands_both']
Task:Wash hands
response:
{
    "thoughts": go to the bathroom and wash your hands,
    "actions": ['[WALK] <bathroom>', '[WALK] <sink>', '[FIND] <faucet>', '[SWITCHON] <faucet>', '[FIND] <soap>', '[SQUEEZE] <soap>', '[FIND] <hands_both>', '[WASH] <hands_both>']
}

Input:
Scene_Objects:['sheets', 'sponge', 'tablelamp', 'food_ice_cream', 'crayon', 'measuring_cup', 'toilet', 'knifeblock', 'orchid', 'bathroom_counter', 'dvd_player', 'keyboard', 'computer', 'stovefan', 'mat', 'toaster', 'picture', 'window', 'microphone', 'pillow', 'bench', 'toy', 'novel', 'tray', 'curtain', 'chessboard', 'controller', 'conditioner', 'sink', 'dishwasher']
Task:Pet cat
response:

Walk to living room. Find cat. Walk to cat. Pull cat.

[WALK] <home_office>
[WALK] <cat>
[FIND] <cat>
[WALK] <cat>
[PULL] <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:['filing_cabinet', 'walllamp', 'orchid', 'drawing', 'wallshelf', 'floor', 'ceiling', 'desk', 'bookshelf', 'remote_control', 'computer', 'mat', 'tvstand', 'ceilinglamp', 'shower', 'window', 'laptop', 'mousepad', 'couch', 'pillow', 'wall', 'powersocket', 'photoframe', 'video_game_controller', 'television', 'curtain', 'doorjamb', 'door', 'light', 'table']
Task:Watch TV
response:
{
    "thoughts": Watching TV,
    "actions": ['[WALK] <home_office>', '[WALK] <remote_control>', '[FIND] <remote_control>', '[GRAB] <remote_control>', '[FIND] <television>', '[SWITCHON] <television>', '[FIND] <couch>', '[SIT] <couch>', '[FIND] <television>', '[TURNTO] <television>', '[WATCH] <television>']
}

Input:
Scene_Objects:['pot', 'band-aids', 'detergent', 'cat', 'knife', 'bathroom_counter', 'shampoo', 'floor', 'character', 'computer', 'bookmark', 'stovefan', 'mousepad', 'form', 'pillow', 'wall', 'pasta', 'oven', 'cup', 'keys', 'coffe_maker', 'television', 'food_onion', 'curtain', 'centerpiece', 'dishrack', 'sink', 'light', 'clothes_skirt', 'scrabble']
Task:Pick up phone
response:

walk into living room, look at the phone when it ringing, grab the phone or pickup the phone

[WALK] <home_office>
[WALK] <phone>
[FIND] <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:['tablelamp', 'measuring_cup', 'walllamp', 'trashcan', 'drawing', 'bathroom_counter', 'floor', 'ceiling', 'phone', 'face', 'computer', 'bookmark', 'mat', 'faucet', 'mousepad', 'clothes_hat', 'towel', 'dining_room', 'wall', 'wall_clock', 'nightstand', 'face_soap', 'basket_for_clothes', 'newspaper', 'tray', 'rag', 'mouse', 'dishrack', 'sink', 'bathroom_cabinet']
Task:Wash face
response:
{
    "thoughts": Turn on water faucet. Get rag wet. Get face soap out. Squirt face soap in hands and put it on face. Rub soap into face. Wash soap off of face. Dry face off on the hand towel. Hang out rag and hand towel.,
    "actions": ['[WALK] <bathroom>', '[WALK] <sink>', '[FIND] <rag>', '[GRAB] <rag>', '[FIND] <faucet>', '[SWITCHON] <faucet>', '[WASH] <rag>', '[FIND] <face_soap>', '[GRAB] <face_soap>', '[POUR] <face_soap> <rag>', '[PUTOBJBACK] <face_soap>', '[FIND] <face>', '[SCRUB] <face>', '[PUTBACK] <rag> <sink>', '[RINSE] <face>', '[RINSE] <rag>', '[SWITCHOFF] <faucet>', '[GRAB] <rag>', '[PUTOBJBACK] <rag>', '[FIND] <towel>', '[GRAB] <towel>', '[WIPE] <face>', '[PUTOBJBACK] <towel>']
}

Input:
Scene_Objects:['filing_cabinet', 'chair', 'walllamp', 'ground_coffee', 'nail_polish', 'orchid', 'drawing', 'cpuscreen', 'bathroom_counter', 'floor', 'ceiling', 'desk', 'keyboard', 'bookshelf', 'computer', 'alcohol', 'toaster', 'ceilinglamp', 'mat', 'faucet', 'stovefan', 'mousepad', 'oil', 'wall', 'bed', 'mouse', 'cupboard', 'door', 'hairdryer', 'table']
Task:Work
response:

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

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


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

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

Input:
Scene_Objects:['toilet', 'freezer', 'walllamp', 'cat', 'drawing', 'orchid', 'knifeblock', 'knife', 'floor', 'ceiling', 'bookshelf', 'stovefan', 'ceilinglamp', 'tvstand', 'window', 'couch', 'pillow', 'dining_room', 'wall', 'oven', 'photoframe', 'coffe_maker', 'check', 'curtain', 'lighter', 'dresser', 'napkin', 'home_office', 'table', 'coffee']
Task:Pet cat
response:

Walk into bedrrom and to the sofa. Sit on the sofa and touch cat.

[WALK] <home_office>
[WALK] <couch>
[SIT] <couch>
[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:['filing_cabinet', 'crayon', 'walllamp', 'woman', 'knifeblock', 'hanger', 'ceiling', 'folder', 'character', 'man', 'mop_bucket', 'bookmark', 'shower', 'window', 'electric_shaver', 'pillow', 'dining_room', 'wall_clock', 'cutting_board', 'bed', 'television', 'wine', 'curtain', 'mouse', 'pencil', 'sink', 'home_office', 'light', 'dirt', 'shoe_rack']
Task:Greet people
response:
{
    "thoughts": Say HI to those that come in.,
    "actions": ['[WALK] <home_office>', '[WALK] <woman>', '[FIND] <woman>', '[GREET] <woman>', '[FIND] <woman>', '[GREET] <woman>', '[FIND] <man>', '[GREET] <man>', '[FIND] <man>', '[GREET] <man>']
}

Input:
Scene_Objects:['pot', 'tablelamp', 'beer', 'chair', 'freezer', 'drawing', 'knifeblock', 'cpuscreen', 'floor', 'ceiling', 'desk', 'keyboard', 'computer', 'mousepad', 'food_jam', 'wall', 'nightstand', 'powersocket', 'bed', 'novel', 'food_onion', 'doorjamb', 'coffee_pot', 'mouse', 'kitchen_counter', 'dresser', 'door', 'table', 'light', 'dishwasher']
Task:Work
response:

I walk to the bedroom, then find the computer and sit in the chair ,next switch on the computer and finally type in the keyboard to start to work on it

[WALK] <bedroom>
[WALK] <computer>
[FIND] <computer>
[FIND] <chair>
[SIT] <chair>
[SWITCHON] <computer>
[FIND] <keyboard>
[TYPE] <keyboard>


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

Here is an example plan to achieve a goal for reference:
Scene_Objects:['sheets', 'chair', 'nail_polish', 'knife', 'cpuscreen', 'floor', 'desk', 'bedroom', 'keyboard', 'computer', 'clothes_jacket', 'mat', 'mousepad', 'closetdrawer', 'couch', 'dining_room', 'wall', 'basket_for_clothes', 'cup', 'check', 'television', 'curtain', 'mouse', 'chessboard', 'shoes', 'comb', 'cupboard', 'hairdryer', 'door', 'home_office']
Task:Read book
response:
{
    "thoughts": find a book to read. sit down. read the book.,
    "actions": ['[WALK] <home_office>', '[WALK] <novel>', '[FIND] <novel>', '[GRAB] <novel>', '[WALK] <chair>', '[SIT] <chair>', '[READ] <novel>']
}

Input:
Scene_Objects:['microwave', 'toilet', 'ground_coffee', 'walllamp', 'trashcan', 'orchid', 'bathroom_counter', 'floor', 'ceiling', 'phone', 'dvd_player', 'toaster', 'shoe-shine_kit', 'faucet', 'clothes_pants', 'dining_room', 'wall', 'photoframe', 'clothes_gloves', 'coffe_maker', 'coffee_filter', 'centerpiece', 'kitchen_counter', 'cd', 'cupboard', 'controller', 'clothes_scarf', 'home_office', 'table', 'dishwasher']
Task:Make coffee
response:

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

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


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

Here is an example plan to achieve a goal for reference:
Scene_Objects:['sponge', 'pot', 'fork', 'beer', 'walllamp', 'bathroom', 'orchid', 'kitchen_cabinet', 'floor', 'phone', 'toaster', 'mat', 'plate', 'tvstand', 'window', 'dish_soap', 'couch', 'bowl', 'wall', 'oven', 'bench', 'coffe_maker', 'tray', 'rag', 'console', 'kitchen_counter', 'dishrack', 'hair', 'maindoor', 'dishwasher']
Task:Wash dishes with dishwasher
response:
{
    "thoughts": I went to the kitchen and collected the dishes and put them into the dish washer and wiped them with towel and put back into cabinet..,
    "actions": ['[WALK] <dining_room>', '[WALK] <kitchen_cabinet>', '[FIND] <kitchen_cabinet>', '[OPEN] <kitchen_cabinet>', '[FIND] <plate>', '[GRAB] <plate>', '[FIND] <dishwasher>', '[OPEN] <dishwasher>', '[PUTBACK] <plate> <dishwasher>', '[FIND] <dish_soap>', '[GRAB] <dish_soap>', '[PUTBACK] <dish_soap> <dishwasher>', '[CLOSE] <dishwasher>', '[SWITCHON] <dishwasher>', '[GRAB] <plate>', '[WIPE] <plate>', '[FIND] <dishrack>', '[GRAB] <dishrack>', '[PUTOBJBACK] <dishrack>']
}

Input:
Scene_Objects:['tablelamp', 'measuring_cup', 'dog', 'freezer', 'walllamp', 'trashcan', 'drawing', 'bills', 'floor', 'ceiling', 'bookshelf', 'computer', 'button', 'tvstand', 'stereo', 'wall', 'nightstand', 'bench', 'bed', 'photoframe', 'television', 'razor', 'food_rice', 'wine', 'tray', 'comb', 'sink', 'bathroom_cabinet', 'light', 'dirt']
Task:Listen to music
response:

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

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


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

Here is an example plan to achieve a goal for reference:
Scene_Objects:['food_pizza', 'tablelamp', 'chair', 'freezer', 'detergent', 'bathroom_counter', 'desk', 'bedroom', 'keyboard', 'button', 'stovefan', 'ceilinglamp', 'stereo', 'shower', 'window', 'clothes_socks', 'dining_room', 'nightstand', 'wall', 'bench', 'oven', 'powersocket', 'bed', 'television', 'curtain', 'doorjamb', 'dresser', 'napkin', 'bathroom_cabinet', 'soap']
Task:Listen to music
response:
{
    "thoughts": Walk into living room, look for radio, grab on button,
    "actions": ['[WALK] <home_office>', '[WALK] <stereo>', '[FIND] <stereo>', '[TURNTO] <stereo>', '[LOOKAT] <stereo>', '[FIND] <button>', '[GRAB] <button>']
}

Input:
Scene_Objects:['filing_cabinet', 'tablelamp', 'juice', 'microwave', 'chair', 'ground_coffee', 'walllamp', 'detergent', 'trashcan', 'drawing', 'knife', 'floor', 'ceiling', 'thread', 'toaster', 'dustpan', 'wall', 'powersocket', 'box', 'coffe_maker', 'television', 'coffee_filter', 'water', 'tray', 'kitchen_counter', 'chessboard', 'cupboard', 'spoon', 'light', 'dishwasher']
Task:Make coffee
response:

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

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


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

Here is an example plan to achieve a goal for reference:
Scene_Objects:['pot', 'food_ice_cream', 'bathroom', 'detergent', 'cat', 'food_butter', 'toothbrush', 'orchid', 'cpuscreen', 'desk', 'bedroom', 'purse', 'envelope', 'mail', 'mop_bucket', 'toaster', 'shower', 'faucet', 'oil', 'food_orange', 'powersocket', 'cutting_board', 'shelf', 'curtain', 'after_shave', 'diary', 'kitchen_counter', 'door', 'napkin', 'tooth_paste']
Task:Wash teeth
response:
{
    "thoughts": before going to bed or when wake up earily morning brush teeth,
    "actions": ['[WALK] <bathroom>', '[WALK] <tooth_paste>', '[FIND] <tooth_paste>', '[GRAB] <tooth_paste>', '[FIND] <toothbrush>', '[GRAB] <toothbrush>']
}

Input:
Scene_Objects:['pot', 'scissors', 'toilet', 'chair', 'freezer', 'walllamp', 'knifeblock', 'orchid', 'cpuscreen', 'drawing', 'floor', 'ceiling', 'desk', 'keyboard', 'computer', 'button', 'ceilinglamp', 'mat', 'foundation', 'mousepad', 'clothes_pants', 'wall', 'photoframe', 'television', 'mouse', 'kitchen_counter', 'headset', 'door', 'home_office', 'table']
Task:Work
response:

[RUN] <home_office>
[WALK] <computer>
[FIND] <computer>
[SWITCHON] <computer>
[FIND] <chair>
[SIT] <chair>
[FIND] <mouse>
[GRAB] <mouse>
[TURNTO] <computer>
[LOOKAT] <computer>
[FIND] <keyboard>
[GRAB] <keyboard>
[TYPE] <keyboard>
[TURNTO] <computer>
[LOOKAT] <computer>
[TOUCH] <mouse>
[TYPE] <keyboard>
[TURNTO] <computer>
[LOOKAT] <computer>


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

Here is an example plan to achieve a goal for reference:
Scene_Objects:['scissors', 'microwave', 'toilet', 'walllamp', 'drawing', 'bills', 'wallshelf', 'floor', 'ceiling', 'character', 'computer', 'mat', 'ceilinglamp', 'tvstand', 'couch', 'pillow', 'dining_room', 'wall', 'nightstand', 'oven', 'bench', 'television', 'tray', 'curtain', 'towel_rack', 'pencil', 'kitchen_counter', 'bathtub', 'spoon', 'table']
Task:Watch TV
response:
{
    "thoughts": Walk to the room, in which the TV is located. Turn on TV pressing the power button for the TV. Watch TV.,
    "actions": ['[WALK] <home_office>', '[WALK] <television>', '[FIND] <television>', '[SWITCHON] <television>']
}

Input:
Scene_Objects:['filing_cabinet', 'microwave', 'toilet', 'walllamp', 'drawing', 'orchid', 'floor', 'ceiling', 'remote_control', 'stovefan', 'ceilinglamp', 'tvstand', 'mat', 'shower', 'window', 'homework', 'couch', 'candle', 'pillow', 'wall', 'nightstand', 'powersocket', 'check', 'television', 'curtain', 'doorjamb', 'kitchen_counter', 'door', 'table', 'light']
Task:Watch TV
response:

Walk into the living room. Sit down on the sofa. Pick up the remote control. Turn on the television with the remote control. Put down the remote control. Watch the television.

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


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

Here is an example plan to achieve a goal for reference:
Scene_Objects:['juice', 'walllamp', 'nail_polish', 'detergent', 'dough', 'drawing', 'food_egg', 'tea_bag', 'bookshelf', 'remote_control', 'alcohol', 'button', 'mop_bucket', 'table_cloth', 'stovefan', 'tvstand', 'shoe-shine_kit', 'shower', 'stereo', 'deck_of_cards', 'mousepad', 'powersocket', 'check', 'rag', 'towel_rack', 'pencil', 'conditioner', 'door', 'bathroom_cabinet', 'soap']
Task:Change TV channel
response:
{
    "thoughts": Take the Tv Remote Control  in the Living Room table And Press the Channel Change Button to change the channel,
    "actions": ['[WALK] <home_office>', '[WALK] <remote_control>', '[FIND] <remote_control>', '[GRAB] <remote_control>', '[FIND] <button>', '[PUSH] <button>', '[PUTOBJBACK] <remote_control>']
}

Input:
Scene_Objects:['filing_cabinet', 'beer', 'walllamp', 'drawing', 'orchid', 'hanger', 'bathroom_counter', 'floor', 'purse', 'food_bacon', 'piano_bench', 'toaster', 'ceilinglamp', 'shoe-shine_kit', 'shower', 'window', 'foundation', 'couch', 'pillow', 'wall', 'bench', 'check', 'wine', 'curtain', 'hairbrush', 'controller', 'door', 'bathroom_cabinet', 'table', 'creditcard']
Task:Relax on sofa
response:

Go to the living room. Find the sofa. Sit on the sofa. Close your eyes. Breath calmly. Relax

[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:['pot', 'toilet', 'chair', 'walllamp', 'ground_coffee', 'dough', 'cpuscreen', 'hanger', 'floor', 'ceiling', 'desk', 'keyboard', 'computer', 'ceilinglamp', 'mousepad', 'closetdrawer', 'oil', 'wall', 'powersocket', 'shelf', 'toilet_paper', 'television', 'doorjamb', 'mouse', 'kitchen_counter', 'vacuum_cleaner', 'dresser', 'light', 'table', 'vase']
Task:Vacuum
response:
{
    "thoughts": Keep my keyboard vacuumed and free of debris.,
    "actions": ['[WALK] <home_office>', '[WALK] <computer>', '[FIND] <vacuum_cleaner>', '[SWITCHON] <vacuum_cleaner>', '[SWITCHOFF] <vacuum_cleaner>']
}

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

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.


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', 'walllamp', 'nail_polish', 'detergent', 'food_carrot', 'drawing', 'wallshelf', 'floor', 'ceiling', 'computer', 'mat', 'tvstand', 'couch', 'microphone', 'pillow', 'wall', 'pasta', 'cup', 'photoframe', 'bed', 'novel', 'video_game_controller', 'television', 'curtain', 'doorjamb', 'towel_rack', 'pencil', 'kitchen_counter', 'home_office']
Task:Read book
response:
{
    "thoughts": Go to the living room and find the book you want to read. Take it and then go to the couch. Sit on it, open the book and start reading.,
    "actions": ['[WALK] <home_office>', '[WALK] <novel>', '[FIND] <novel>', '[GRAB] <novel>', '[FIND] <couch>', '[SIT] <couch>', '[READ] <novel>']
}

Input:
Scene_Objects:['fork', 'tablelamp', 'crayon', 'drawing', 'needle', 'bills', 'knifeblock', 'floor', 'phone', 'ceiling', 'character', 'mat', 'plate', 'homework', 'pillow', 'bowl', 'bench', 'newspaper', 'novel', 'food_food', 'video_game_controller', 'television', 'oven_mitts', 'food_rice', 'coffee_pot', 'shoes', 'cd', 'home_office', 'table', 'teeth']
Task:Set up table
response:

I walk to the table. I put down the dish. I put down the silverware. I put down the napkin.

[WALK]

[FIND] <fork>
[GRAB] <fork>
[PUTBACK] <fork>

[FIND] <fork>
[GRAB] <fork>
[PUTBACK] <fork>

[FIND] <fork>
[GRAB] <fork>
[PUTBACK] <fork>

[FIND] <fork>
[GRAB] <fork>
[PUTBACK] <fork>

[FIND] <fork>
[GRAB] <fork>
[PUTBACK] <fork>

[FIND] <plate>
[GRAB] <plate>
[PUTBACK] <plate>

[FIND] <plate>
[GRAB] <plate>
[PUTBACK] <plate>

[GRAB] <plate>
[PUTBACK] <plate>

[GRAB] <plate>
[PUTBACK] <plate>

[GRAB] <plate>
[PUTBACK] <plate>


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

Here is an example plan to achieve a goal for reference:
Scene_Objects:['pot', 'filing_cabinet', 'measuring_cup', 'microwave', 'walllamp', 'bathroom', 'trashcan', 'knifeblock', 'cpuscreen', 'floor', 'desk', 'toaster', 'stovefan', 'plate', 'faucet', 'iron', 'dish_soap', 'wall', 'oven', 'coffe_maker', 'food_food', 'wooden_spoon', 'tray', 'kitchen_counter', 'dishrack', 'cupboard', 'door', 'sink', 'bathroom_cabinet', '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:['dry_pasta', 'measuring_cup', 'microwave', 'walllamp', 'food_carrot', 'orchid', 'knifeblock', 'cpuscreen', 'drawing', 'floor', 'bedroom', 'cleaning_solution', 'computer', 'mop_bucket', 'table_cloth', 'stovefan', 'shower', 'iron', 'couch', 'bowl', 'dining_room', 'nightstand', 'cup', 'keys', 'curtain', 'doorjamb', 'comb', 'dresser', 'sink', 'hands_both']
Task:Wash hands
response:

walk to bathroom , find cleaning solution , squeeze cleaning solution , wash hands

[WALK] <bathroom>
[WALK] <cleaning_solution>
[FIND] <cleaning_solution>
[SQUEEZE] <cleaning_solution>
[FIND] <hands_both>
[WASH] <hands_both>


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

Here is an example plan to achieve a goal for reference:
Scene_Objects:['sponge', '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:
{
    "thoughts": Wash the teeth,
    "actions": ['[WALK] <bathroom>', '[WALK] <faucet>', '[FIND] <faucet>', '[SWITCHON] <faucet>', '[FIND] <water>', '[TURNTO] <water>', '[POINTAT] <water>', '[FIND] <teeth>', '[WASH] <teeth>', '[SWITCHOFF] <faucet>']
}

Input:
Scene_Objects:['food_pizza', 'walllamp', 'drawing', 'orchid', 'floor', 'ceiling', 'phone', 'remote_control', 'computer', 'toaster', 'ceilinglamp', 'tvstand', 'mat', 'window', 'mousepad', 'couch', 'pillow', 'towel', 'wall', 'powersocket', 'food_cheese', 'photoframe', 'television', 'curtain', 'doorjamb', 'shaving_cream', 'pencil', 'door', 'home_office', 'table']
Task:Watch TV
response:

Walk to living room. Sit on the sofa. Grab the remote control and plug in TV.

[WALK] <home_office>
[WALK] <couch>
[FIND] <couch>
[SIT] <couch>
[FIND] <remote_control>
[GRAB] <remote_control>
[FIND] <television>
[PLUGIN] <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', 'freezer', 'ground_coffee', 'bathroom', 'ceilingfan', 'drawing', 'clothes_underwear', 'floor', 'food_cake', 'toaster', 'mousepad', 'dining_room', 'oven', 'tape', 'box', 'photoframe', 'coin', 'curtain', 'shaving_cream', 'coffee_pot', 'headset', 'dishrack', 'cupboard', 'sink', 'clothes_scarf', 'home_office', 'dishwasher', 'soap', 'board_game', 'washing_machine']
Task:Wash clothes
response:
{
    "thoughts": Walk to bathroom. Open washer. Put clothes in washer. Put soap in washer. Close washer. Turn washer on.,
    "actions": ['[WALK] <home_office>', '[WALK] <washing_machine>', '[FIND] <washing_machine>', '[OPEN] <washing_machine>', '[FIND] <clothes_underwear>', '[GRAB] <clothes_underwear>', '[PUTBACK] <clothes_underwear> <washing_machine>', '[FIND] <soap>', '[GRAB] <soap>', '[PUTBACK] <soap> <washing_machine>', '[CLOSE] <washing_machine>', '[SWITCHON] <washing_machine>']
}

Input:
Scene_Objects:['pot', 'scissors', 'food_salt', 'freezer', 'walllamp', 'bathroom', 'detergent', 'knifeblock', 'desk', 'bedroom', 'bookshelf', 'keyboard', 'clothes_jacket', 'toaster', 'stereo', 'electric_shaver', 'food_noodles', 'dining_room', 'broom', 'wall', 'oven', 'box', 'cup', 'curtain', 'shoes', 'vacuum_cleaner', 'sink', 'bag', 'dishwasher', 'creditcard']
Task:Pick up phone
response:

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

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


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

Here is an example plan to achieve a goal for reference:
Scene_Objects:['chair', 'drawing', 'hanger', 'floor', 'ceiling', 'character', 'keyboard', 'tvstand', 'shower', 'closetdrawer', 'wall', 'wall_clock', 'oven', 'cup', 'standingmirror', 'check', 'television', 'centerpiece', 'console', 'mouse', 'vacuum_cleaner', 'shoes', 'comb', 'dresser', 'hairbrush', 'sink', 'bag', 'napkin', 'bathroom_cabinet', 'vase']
Task:vacuum carpet
response:
{
    "thoughts": I bring my vacuum cleaner into the living room.  I plug it into the wall.  I press the on switch on the vacuum cleaner.  I push the vacuum cleaner back and forth over the length and width of the carpet until I have vacuumed the entire carpet.  I turn the vacuum cleaner off.  I take the vacuum cleaner back to the hall closet.,
    "actions": ['[WALK] <home_office>', '[WALK] <dresser>', '[OPEN] <dresser>', '[FIND] <vacuum_cleaner>', '[GRAB] <vacuum_cleaner>', '[PULL] <vacuum_cleaner>', '[PLUGIN] <vacuum_cleaner>', '[SWITCHON] <vacuum_cleaner>', '[PULL] <vacuum_cleaner>', '[PUSH] <vacuum_cleaner>', '[PULL] <vacuum_cleaner>', '[PUSH] <vacuum_cleaner>', '[PULL] <vacuum_cleaner>', '[PUSH] <vacuum_cleaner>', '[SWITCHOFF] <vacuum_cleaner>', '[PLUGOUT] <vacuum_cleaner>', '[WALK] <dresser>', '[PUTIN] <vacuum_cleaner> <dresser>', '[CLOSE] <dresser>']
}

Input:
Scene_Objects:['food_pizza', 'scissors', 'tea', 'freezer', 'blow_dryer', 'drawing', 'knifeblock', 'cpuscreen', 'clothes_underwear', 'character', 'desk', 'toaster', 'shower', 'picture', 'mousepad', 'candle', 'dining_room', 'bench', 'oven', 'basket_for_clothes', 'bed', 'check', 'television', 'toothbrush_holder', 'curtain', 'mouse', 'sink', 'light', 'tooth_paste', 'laser_pointer']
Task:Turn on light
response:

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

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


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

Here is an example plan to achieve a goal for reference:
Scene_Objects:['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:
{
    "thoughts": 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.,
    "actions": ['[WALK] <home_office>', '[WALK] <couch>', '[FIND] <couch>', '[SIT] <couch>', '[FIND] <remote_control>', '[GRAB] <remote_control>', '[FIND] <television>', '[SWITCHON] <television>', '[FIND] <coffee_table>', '[PUTBACK] <remote_control> <coffee_table>', '[TURNTO] <television>', '[LOOKAT] <television>']
}

Input:
Scene_Objects:['band-aids', 'walllamp', 'knifeblock', 'cpuscreen', 'bathroom_counter', 'floor', 'ceiling', 'character', 'mail', 'bookmark', 'plate', 'faucet', 'picture', 'dish_soap', 'dustpan', 'wall', 'oven', 'bench', 'bed', 'food_food', 'curtain', 'doorjamb', 'kettle', 'kitchen_counter', 'vacuum_cleaner', 'dresser', 'cupboard', 'door', 'sink', 'dirt']
Task:Wash dishes by hand
response:

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

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


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

Here is an example plan to achieve a goal for reference:
Scene_Objects:['tablelamp', 'toilet', 'chair', 'walllamp', 'trashcan', 'ceilingfan', 'drawing', 'cpuscreen', 'hanger', 'floor', 'ceiling', 'phone', 'desk', 'bookshelf', 'keyboard', 'envelope', 'computer', 'bookmark', 'ceilinglamp', 'balanceball', 'mousepad', 'wall', 'nightstand', 'photoframe', 'check', 'doorjamb', 'mouse', 'dresser', 'cupboard', 'door', 'light']
Task:Work
response:
{
    "thoughts": I go to the home office to work on my project. I turn on the light and walk to my desk. I turn on the computer. Then I look through the documents. After I'm done, I turn off the computer.,
    "actions": ['[WALK] <home_office>', '[WALK] <light>', '[FIND] <light>', '[SWITCHON] <light>', '[WALK] <desk>', '[FIND] <computer>', '[SWITCHON] <computer>', '[FIND] <check>', '[TURNTO] <check>', '[LOOKAT] <check>', '[SWITCHOFF] <computer>']
}

Input:
Scene_Objects:['toilet', 'blow_dryer', 'bathroom', 'walllamp', 'orchid', 'cpuscreen', 'dvd_player', 'character', 'desk', 'stamp', 'envelope', 'stovefan', 'ceilinglamp', 'shoe-shine_kit', 'shower', 'homework', 'food_orange', 'dining_room', 'oven', 'bench', 'box', 'video_game_controller', 'television', 'food_donut', 'curtain', 'doorjamb', 'pajamas', 'napkin', 'light', 'clothes_shirt']
Task:Pet cat
response:

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

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


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

Here is an example plan to achieve a goal for reference:
Scene_Objects:['glue', 'chair', 'orchid', 'drawing', 'cpuscreen', 'wallshelf', 'floor', 'character', 'bedroom', 'toaster', 'ceilinglamp', 'mat', 'mousepad', 'couch', 'food_peanut_butter', 'wall', 'powersocket', 'cup', 'food_cheese', 'photoframe', 'food_food', 'coffe_maker', 'doorjamb', 'pencil', 'kitchen_counter', 'cd', 'shoes', 'hair', 'clothes_dress', 'table']
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:['sponge', 'microwave', 'toilet', 'walllamp', 'trashcan', 'bathroom_counter', 'floor', 'phone', 'character', 'piano_bench', 'bookmark', 'toaster', 'mat', 'shower', 'dish_soap', 'couch', 'wall', 'photoframe', 'novel', 'coffe_maker', 'check', 'cards', 'kitchen_counter', 'dresser', 'cupboard', 'controller', 'sink', 'home_office', 'bathroom_cabinet', 'dishwasher']
Task:Wash dishes with dishwasher
response:

walk to kitchen, find the dishwasher, apply dish soap into vessels or dishwasher, wash the dishes with a dishwasher

[WALK] <dining_room>
[WALK] <dishwasher>
[FIND] <dishwasher>
[FIND] <dish_soap>
[GRAB] <dish_soap>
[OPEN] <dishwasher>
[PUTBACK] <dish_soap> <dishwasher>
[WASH] <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:['filing_cabinet', 'microwave', 'freezer', 'drawing', 'bills', 'hanger', 'floor', 'ceiling', 'keyboard', 'computer', 'toaster', 'tvstand', 'floor_lamp', 'window', 'closetdrawer', 'couch', 'towel', 'wall', 'wall_clock', 'food_food', 'doorjamb', 'mouse', 'headset', 'shoes', 'dresser', 'controller', 'bathtub', 'sink', 'home_office', 'light']
Task:Turn night light on
response:
{
    "thoughts": I walk to the dresser and in the middle Io to small battery operated lamp and switch it on,
    "actions": ['[WALK] <bedroom>', '[WALK] <dresser>', '[FIND] <floor_lamp>', '[TURNTO] <floor_lamp>', '[SWITCHON] <floor_lamp>']
}

Input:
Scene_Objects:['sheets', 'tablelamp', 'microwave', 'chair', 'drawing', 'food_egg', 'bathroom_counter', 'floor', 'ceiling', 'tea_bag', 'bookshelf', 'mat', 'laptop', 'faucet', 'wall', 'box', 'photoframe', 'coffe_maker', 'colander', 'curtain', 'pencil', 'headset', 'dishrack', 'pajamas', 'sink', 'bathroom_cabinet', 'home_office', 'soap', 'clothes_shirt', 'hands_both']
Task:Wash hands
response:

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

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


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

Here is an example plan to achieve a goal for reference:
Scene_Objects:['food_pizza', 'filing_cabinet', 'crayon', 'walllamp', 'bathroom', 'toothbrush', 'floor', 'food_cake', 'toaster', 'plate', 'shower', 'faucet', 'electric_shaver', 'dish_soap', 'broom', 'wall', 'oven', 'bench', 'photoframe', 'light_bulb', 'novel', 'coffe_maker', 'television', 'tray', 'towel_rack', 'kettle', 'dishrack', 'table', 'dishwasher', 'tooth_paste']
Task:Wash dishes with dishwasher
response:
{
    "thoughts": Go to kitchen to put dirty dishs into dishwasher with soap to clean the dirty dishes,
    "actions": ['[WALK] <dining_room>', '[WALK] <dishwasher>', '[FIND] <dishwasher>', '[OPEN] <dishwasher>', '[FIND] <plate>', '[GRAB] <plate>', '[PUTBACK] <plate> <dishwasher>', '[FIND] <plate>', '[GRAB] <plate>', '[PUTBACK] <plate> <dishwasher>', '[FIND] <plate>', '[GRAB] <plate>', '[PUTBACK] <plate> <dishwasher>', '[FIND] <plate>', '[GRAB] <plate>', '[PUTBACK] <plate> <dishwasher>', '[FIND] <plate>', '[GRAB] <plate>', '[PUTBACK] <plate> <dishwasher>', '[FIND] <dish_soap>', '[GRAB] <dish_soap>', '[PUTBACK] <dish_soap> <dishwasher>', '[CLOSE] <dishwasher>', '[SWITCHON] <dishwasher>']
}

Input:
Scene_Objects:['blender', 'walllamp', 'drawing', 'orchid', 'bathroom_counter', 'floor', 'ceiling', 'keyboard', 'remote_control', 'thread', 'bookshelf', 'toaster', 'ceilinglamp', 'tvstand', 'mat', 'clothes_socks', 'wall', 'pasta', 'powersocket', 'cutting_board', 'cup', 'clothes_gloves', 'novel', 'television', 'rag', 'doorjamb', 'shoes', 'door', 'table', 'dishwasher']
Task:Watch TV
response:

[WALK] <home_office>
[WALK] <television>
[FIND] <television>
[SWITCHON] <television>
[FIND] <remote_control>
[TOUCH] <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:['filing_cabinet', 'chair', 'walllamp', 'ground_coffee', 'nail_polish', 'orchid', 'drawing', 'cpuscreen', 'bathroom_counter', 'floor', 'ceiling', 'desk', 'keyboard', 'bookshelf', 'computer', 'alcohol', 'toaster', 'ceilinglamp', 'mat', 'faucet', 'stovefan', 'mousepad', 'oil', 'wall', 'bed', 'mouse', 'cupboard', 'door', 'hairdryer', 'table']
Task:Work
response:
{
    "thoughts": Go to office, find computer, switch on computer, type on keyboard, use mouse, switch off computer,
    "actions": ['[WALK] <home_office>', '[WALK] <computer>', '[FIND] <computer>', '[SWITCHON] <computer>', '[FIND] <keyboard>', '[TYPE] <keyboard>', '[FIND] <mouse>', '[PUSH] <mouse>', '[SWITCHOFF] <computer>']
}

Input:
Scene_Objects:['crayon', 'toilet', 'chair', 'bathroom', 'detergent', 'dough', 'knife', 'drawing', 'floor', 'ceiling', 'tea_bag', 'ceilinglamp', 'tvstand', 'shower', 'plate', 'mousepad', 'clothes_socks', 'pillow', 'wall', 'cup', 'doorjamb', 'console', 'shoes', 'dresser', 'door', 'hairdryer', 'napkin', 'light', 'soap', 'laser_pointer']
Task:Turn on light
response:

Walk over to light switch. Turn on lights.


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

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

Input:
Scene_Objects:['spectacles', 'blender', 'freezer', 'cpuscreen', 'floor', 'ceiling', 'character', 'desk', 'bedroom', 'keyboard', 'computer', 'ceilinglamp', 'homework', 'mousepad', 'dining_room', 'food_kiwi', 'wall', 'powersocket', 'bench', 'oven', 'bed', 'food_food', 'doorjamb', 'mouse', 'controller', 'door', 'bathroom_cabinet', 'light', 'soap', 'clothes_shirt']
Task:Put groceries in Fridge
response:

Go to kitchen, open fridge, get groceries, put groceries in fridge, close fridge

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


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

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

Input:
Scene_Objects:['pot', 'crayon', 'chair', 'walllamp', 'detergent', 'orchid', 'drawing', 'cpuscreen', 'floor', 'ceiling', 'desk', 'keyboard', 'computer', 'table_cloth', 'mat', 'ceilinglamp', 'shower', 'mousepad', 'pillow', 'wall', 'powersocket', 'newspaper', 'television', 'tray', 'doorjamb', 'mouse', 'pencil', 'door', 'light', 'table']
Task:Write an email
response:

I walk into my office and go to the computer desk. I sit at my desk and turn the computer on. Then I write an email.

[WALK] <home_office>
[WALK] <light>
[FIND] <light>
[SWITCHON] <light>
[WALK] <desk>
[FIND] <chair>
[SIT] <chair>
[FIND] <computer>
[SWITCHON] <computer>
[FIND] <keyboard>
[TYPE] <keyboard>


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

Here is an example plan to achieve a goal for reference:
Scene_Objects:['filing_cabinet', 'walllamp', 'detergent', 'cat', 'milk', 'phone', 'ceiling', 'desk', 'mop_bucket', 'brush', 'ceilinglamp', 'tvstand', 'faucet', 'toaster', 'mat', 'closetdrawer', 'microphone', 'nightstand', 'wall_clock', 'toy', 'cup', 'food_food', 'after_shave', 'lighter', 'towel_rack', 'mouse', 'pajamas', 'controller', 'laundry_detergent', 'soap']
Task:Pet cat
response:
{
    "thoughts": Go to the living room where the cat sleeps. Find cat. Proceed to petting cat.,
    "actions": ['[WALK] <home_office>', '[WALK] <cat>', '[FIND] <cat>', '[TOUCH] <cat>']
}

Input:
Scene_Objects:['fork', 'water_glass', 'pot', 'measuring_cup', 'microwave', 'walllamp', 'blow_dryer', 'trashcan', 'knife', 'knifeblock', 'floor', 'ceiling', 'toaster', 'stovefan', 'plate', 'ceilinglamp', 'dish_soap', 'wall', 'oven', 'cup', 'bed', 'coffe_maker', 'tray', 'pencil', 'kitchen_counter', 'cupboard', 'sink', 'spoon', 'coffee_cup', 'dishwasher']
Task:Wash dishes with dishwasher
response:

I go to the kitchen and put plates, cutlery and glasses into the dishwasher, put the soap, close the machine and switch it on.

[WALK] <dining_room>
[WALK] <dishwasher>
[FIND] <dishwasher>
[OPEN] <dishwasher>
[FIND] <coffee_cup>
[GRAB] <coffee_cup>
[PUTBACK] <coffee_cup> <dishwasher>
[FIND] <coffee_cup>
[GRAB] <coffee_cup>
[PUTBACK] <coffee_cup> <dishwasher>
[FIND] <pot>
[GRAB] <pot>
[PUTBACK] <pot> <dishwasher>
[FIND] <pot>
[GRAB] <pot>
[PUTBACK] <pot> <dishwasher>
[FIND] <fork>
[GRAB] <fork>
[PUTBACK] <fork> <dishwasher>
[FIND] <fork>
[GRAB] <fork>
[PUTBACK] <fork> <dishwasher>
[FIND] <knife>
[GRAB] <knife>
[PUTBACK] <knife> <dishwasher>
[FIND] <knife>
[GRAB] <knife>
[PUTBACK] <knife> <dishwasher>
[FIND] <plate>
[GRAB] <plate>
[PUTBACK] <plate> <dishwasher>
[FIND] <plate>
[GRAB] <plate>
[PUTBACK] <plate> <dishwasher>
[FIND] <spoon>
[GRAB] <spoon>
[PUTBACK] <spoon> <dishwasher>
[FIND] <spoon>
[GRAB] <spoon>
[PUTBACK] <spoon> <dishwasher>
[FIND] <water_glass>
[GRAB] <water_glass>
[PUTBACK] <water_glass> <dishwasher>
[FIND] <water_glass>
[GRAB] <water_glass>
[PUTBACK] <water_glass> <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:['spectacles', 'filing_cabinet', 'tablelamp', 'juice', 'food_salt', 'microwave', 'chair', 'freezer', 'detergent', 'trashcan', 'toothbrush', 'floor', 'ceiling', 'bookshelf', 'toaster', 'shower', 'stereo', 'mousepad', 'clothes_pants', 'clothes_hat', 'pillow', 'dining_room', 'wall', 'food_food', 'check', 'food_donut', 'kitchen_counter', 'cupboard', 'door', 'home_office']
Task:Cook some food
response:
{
    "thoughts": Go kitchen and make something for eat,
    "actions": ['[WALK] <dining_room>', '[WALK] <freezer>', '[OPEN] <freezer>', '[FIND] <food_food>']
}

Input:
Scene_Objects:['water_glass', 'filing_cabinet', 'juice', 'milk', 'hanger', 'kitchen_cabinet', 'bathroom_counter', 'button', 'food_bacon', 'stovefan', 'mat', 'shoe-shine_kit', 'tvstand', 'electric_shaver', 'food_peanut_butter', 'form', 'dining_room', 'cutting_board', 'cup', 'photoframe', 'coffe_maker', 'television', 'water', 'wooden_spoon', 'kettle', 'kitchen_counter', 'chessboard', 'dresser', 'sink', 'spoon']
Task:Drink
response:

Go to kitchen. Open the the cabinet. Locate the water glass. Pour water into glass. Drag the bottle close to mouth. Drink water.

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


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

Here is an example plan to achieve a goal for reference:
Scene_Objects:['spectacles', 'filing_cabinet', 'tablelamp', 'microwave', 'toilet', 'chair', 'freezer', 'walllamp', 'cpuscreen', 'wallshelf', 'hanger', 'floor', 'ceiling', 'character', 'desk', 'computer', 'button', 'clothes_jacket', 'tvstand', 'mousepad', 'closetdrawer', 'wall', 'nightstand', 'powersocket', 'bed', 'check', 'food_food', 'food_onion', 'dresser', 'light']
Task:Put on glasses
response:
{
    "thoughts": Put on glasses.,
    "actions": ['[WALK] <bedroom>', '[WALK] <dresser>', '[FIND] <dresser>', '[FIND] <spectacles>', '[GRAB] <spectacles>', '[PUTON] <spectacles>']
}

Input:
Scene_Objects:['fork', 'filing_cabinet', 'tablelamp', 'chair', 'walllamp', 'ground_coffee', 'drawing', 'orchid', 'needle', 'cpuscreen', 'floor', 'ceiling', 'bookshelf', 'remote_control', 'ceilinglamp', 'tvstand', 'mat', 'mousepad', 'wall', 'powersocket', 'bed', 'television', 'curtain', 'doorjamb', 'hair', 'clothes_dress', 'door', 'table', 'clothes_skirt', 'scrabble']
Task:Watch TV
response:

Walk into the living room/den. Turn on the television. Switch channels to find a program with remote. I find a program and look at the screen.

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


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

Here is an example plan to achieve a goal for reference:
Scene_Objects:['pot', 'tablelamp', 'chair', 'freezer', 'drawing', 'orchid', 'cpuscreen', 'floor', 'ceiling', 'desk', 'keyboard', 'computer', 'food_bacon', 'stovefan', 'mat', 'ceilinglamp', 'tvstand', 'mousepad', 'closetdrawer', 'wall', 'nightstand', 'photoframe', 'novel', 'television', 'mouse', 'kitchen_counter', 'door', 'sink', 'clothes_skirt', 'clothes_shirt']
Task:Read book
response:
{
    "thoughts": Go to home office, find the book. Sit in the chair and read the book.,
    "actions": ['[WALK] <home_office>', '[WALK] <novel>', '[FIND] <novel>', '[GRAB] <novel>', '[FIND] <chair>', '[SIT] <chair>', '[READ] <novel>']
}

Input:
Scene_Objects:['food_bread', 'walllamp', 'toothbrush', 'drawing', 'orchid', 'hanger', 'bathroom_counter', 'floor', 'ceiling', 'tea_bag', 'toaster', 'ceilinglamp', 'window', 'homework', 'food_noodles', 'couch', 'candle', 'pillow', 'dining_room', 'wall', 'powersocket', 'toy', 'food_food', 'toilet_paper', 'tray', 'curtain', 'food_onion', 'shoes', 'door', 'table']
Task:Relax on sofa
response:

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

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


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

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

Input:
Scene_Objects:['tablelamp', 'food_salt', 'chair', 'freezer', 'walllamp', 'orchid', 'cpuscreen', 'floor', 'ceiling', 'desk', 'keyboard', 'computer', 'clothes_jacket', 'ceilinglamp', 'mat', 'mousepad', 'pillow', 'wall', 'nightstand', 'photoframe', 'razor', 'television', 'food_rice', 'mouse', 'kitchen_counter', 'dresser', 'door', 'bathroom_cabinet', 'table', 'dirt']
Task:Work
response:

I go to my office. I switch the computer on and sit on the office chair. I look at the computer screen to see what needs to be done. I use my mouse to navigate to the relevant directory, then release it. I type code with my keyboard. When I'm done, I look at the computer again to evaluate what I've done. Then I switch off the computer using the mouse and put back the mouse.

[WALK] <home_office>
[WALK] <computer>
[FIND] <computer>
[SWITCHON] <computer>
[FIND] <chair>
[SIT] <chair>
[TURNTO] <computer>
[LOOKAT] <computer>
[FIND] <mouse>
[GRAB] <mouse>
[PUTOBJBACK] <mouse>
[FIND] <keyboard>
[TYPE] <keyboard>
[TURNTO] <computer>
[LOOKAT] <computer>
[GRAB] <mouse>
[SWITCHOFF] <computer>
[PUTOBJBACK] <mouse>


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

Here is an example plan to achieve a goal for reference:
Scene_Objects:['food_pizza', 'food_salt', 'drawing', 'wallshelf', 'hanger', 'floor', 'ceiling', 'character', 'desk', 'bookshelf', 'computer', 'mat', 'faucet', 'closetdrawer', 'pillow', 'dining_room', 'wall', 'nightstand', 'powersocket', 'toy', 'novel', 'toothbrush_holder', 'wine', 'doorjamb', 'shaving_cream', 'kitchen_counter', 'door', 'sink', 'clothes_scarf', 'light']
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:['sheets', 'tablelamp', 'chair', 'freezer', 'cat', 'drawing', 'cpuscreen', 'floor', 'ceiling', 'phone', 'desk', 'bookshelf', 'keyboard', 'computer', 'toaster', 'stereo', 'faucet', 'picture', 'mousepad', 'couch', 'wall', 'nightstand', 'powersocket', 'cup', 'doorjamb', 'mouse', 'kitchen_counter', 'door', 'home_office', 'light']
Task:Listen to music
response:

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

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


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

Here is an example plan to achieve a goal for reference:
Scene_Objects:['measuring_cup', 'microwave', 'chair', 'walllamp', 'cat', 'wallshelf', 'floor', 'character', 'desk', 'tea_bag', 'toaster', 'plate', 'couch', 'dining_room', 'box', 'newspaper', 'bed', 'toilet_paper', 'curtain', 'coffee_pot', 'mouse', 'kettle', 'cupboard', 'controller', 'clothes_dress', 'sink', 'bathroom_cabinet', 'table', 'dishwasher', 'soap']
Task:Pet cat
response:
{
    "thoughts": Find Cat in living room.  Walk to cat.  Pet cat.,
    "actions": ['[WALK] <home_office>', '[WALK] <cat>', '[FIND] <cat>', '[TURNTO] <cat>', '[LOOKAT] <cat>', '[TOUCH] <cat>']
}

Input:
Scene_Objects:['sponge', 'tablelamp', 'microwave', 'chair', 'walllamp', 'trashcan', 'food_butter', 'orchid', 'floor', 'dvd_player', 'desk', 'toaster', 'tvstand', 'oil', 'wall', 'bench', 'basket_for_clothes', 'photoframe', 'coffe_maker', 'razor', 'wooden_spoon', 'curtain', 'coffee_pot', 'mouse', 'pencil', 'kitchen_counter', 'dishrack', 'cupboard', 'spoon', 'dishwasher']
Task:Wash dishes by hand
response:

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

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


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

Here is an example plan to achieve a goal for reference:
Scene_Objects:['food_pizza', 'beer', 'chair', 'detergent', 'trashcan', 'drawing', 'cpuscreen', 'hanger', 'bathroom_counter', 'dvd_player', 'stamp', 'bookshelf', 'toaster', 'ceilinglamp', 'faucet', 'homework', 'floor_lamp', 'window', 'food_orange', 'dining_room', 'nightstand', 'bench', 'food_cheese', 'television', 'doorjamb', 'lighter', 'cupboard', 'home_office', 'dishwasher', 'laser_pointer']
Task:Turn off light
response:
{
    "thoughts": Walk to the lamp.  Find the switch.  Click the switch off.,
    "actions": ['[WALK] <bedroom>', '[WALK] <floor_lamp>', '[SWITCHOFF] <floor_lamp>']
}

Input:
Scene_Objects:['food_pizza', 'toilet', 'trashcan', 'food_carrot', 'food_egg', 'ceiling', 'folder', 'stamp', 'bookshelf', 'toaster', 'laptop', 'shower', 'food_noodles', 'couch', 'form', 'nightstand', 'powersocket', 'bench', 'toy', 'bed', 'keys', 'novel', 'doorjamb', 'hairbrush', 'cupboard', 'conditioner', 'spoon', 'bathroom_cabinet', 'table', 'board_game']
Task:Pick up phone
response:

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

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


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

Here is an example plan to achieve a goal for reference:
Scene_Objects:['dry_pasta', 'microwave', 'toilet', 'jelly', 'drawing', 'floor', 'ceiling', 'character', 'desk', 'bookshelf', 'ceilinglamp', 'deck_of_cards', 'stereo', 'shower', 'window', 'couch', 'candle', 'microphone', 'wall', 'powersocket', 'box', 'photoframe', 'television', 'tray', 'towel_rack', 'sink', 'napkin', 'bathroom_cabinet', 'table', 'home_office']
Task:Relax on sofa
response:
{
    "thoughts": walk to living room, walk to sofa, sit on sofa.,
    "actions": ['[WALK] <home_office>', '[WALK] <couch>', '[SIT] <couch>']
}

Input:
Scene_Objects:['filing_cabinet', 'trashcan', 'food_carrot', 'knifeblock', 'drawing', 'cpuscreen', 'clothes_underwear', 'floor', 'bedroom', 'alcohol', 'laptop', 'tvstand', 'stereo', 'faucet', 'mat', 'couch', 'clothes_hat', 'nightstand', 'bench', 'oven', 'toy', 'coffe_maker', 'television', 'coin', 'kitchen_counter', 'cupboard', 'home_office', 'bathroom_cabinet', 'dishwasher', 'board_game']
Task:Listen to music
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:['filing_cabinet', 'tablelamp', 'measuring_cup', 'walllamp', 'ceilingfan', 'drawing', 'bathroom_counter', 'floor', 'ceiling', 'phone', 'toaster', 'ceilinglamp', 'tvstand', 'balanceball', 'window', 'clothes_socks', 'food_noodles', 'couch', 'broom', 'wall', 'newspaper', 'light_bulb', 'novel', 'television', 'curtain', 'doorjamb', 'lighter', 'cupboard', 'table', 'light']
Task:Change TV channel
response:
{
    "thoughts": Walk to the living room. Find remote control. Grab remote control. Walk to television. Look at television. Switch on remote control.,
    "actions": ['[WALK] <home_office>', '[WALK] <remote_control>', '[FIND] <remote_control>', '[GRAB] <remote_control>', '[WALK] <television>', '[TURNTO] <television>', '[LOOKAT] <television>', '[SWITCHON] <television>']
}

Input:
Scene_Objects:['beer', 'bathroom', 'trashcan', 'drawing', 'bathroom_counter', 'floor', 'ceiling', 'button', 'brush', 'mat', 'toaster', 'faucet', 'picture', 'iron', 'pillow', 'broom', 'wall', 'oven', 'keys', 'novel', 'coin', 'tray', 'conditioner', 'door', 'sink', 'bathroom_cabinet', 'soap', 'clothes_shirt', 'scrabble', 'hands_both']
Task:Wash hands
response:

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

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


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

Here is an example plan to achieve a goal for reference:
Scene_Objects:['toilet', 'wallshelf', 'hanger', 'bathroom_counter', 'floor', 'ceiling', 'character', 'desk', 'keyboard', 'face', 'computer', 'ceilinglamp', 'tvstand', 'faucet', 'closetdrawer', 'couch', 'pillow', 'wall', 'nightstand', 'oven', 'wall_clock', 'face_soap', 'food_food', 'coffe_maker', 'tray', 'door', 'sink', 'bathtub', 'bathroom_cabinet', 'shoe_rack']
Task:Wash face
response:
{
    "thoughts": Run warm water. Cleanse my face with soap. Rinse my face with water.,
    "actions": ['[WALK] <bathroom>', '[WALK] <sink>', '[FIND] <faucet>', '[SWITCHON] <faucet>', '[FIND] <face_soap>', '[GRAB] <face_soap>', '[FIND] <face>', '[SCRUB] <face>', '[PUTOBJBACK] <face_soap>', '[WASH] <face>', '[RINSE] <face>', '[SWITCHOFF] <faucet>']
}

Input:
Scene_Objects:['chair', 'freezer', 'ground_coffee', 'walllamp', 'cpuscreen', 'hanger', 'floor', 'ceiling', 'phone', 'bedroom', 'ceilinglamp', 'tvstand', 'stereo', 'food_orange', 'cup', 'bed', 'keys', 'novel', 'food_food', 'coffe_maker', 'mouthwash', 'coin', 'check', 'diary', 'coffee_pot', 'mouse', 'dresser', 'hair', 'table', 'light']
Task:Listen to music
response:

I go to my bedroom, and then I switch on the radio

[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:['dry_pasta', 'toilet', 'nail_polish', 'detergent', 'cat', 'trashcan', 'milk', 'knifeblock', 'phone', 'ceiling', 'desk', 'keyboard', 'mousepad', 'couch', 'pillow', 'bench', 'oven', 'cup', 'bed', 'light_bulb', 'food_food', 'lighter', 'kitchen_counter', 'hairbrush', 'dresser', 'laundry_detergent', 'table', 'clothes_skirt', 'tooth_paste', 'dirt']
Task:Pet cat
response:
{
    "thoughts": Petting a cat may sound simple.Letting the Cat Come to You.Extend a hand or finger and allow the cat a chance to touch her nose to you. When a cat bumps her head into your hand, it's a signal she wants attention.Focusing on Areas with Scent Glands. Feed with food.,
    "actions": ['[WALK] <home_office>', '[WALK] <cat>', '[FIND] <cat>', '[TURNTO] <cat>', '[LOOKAT] <cat>', '[FIND] <cup>', '[GRAB] <cup>', '[WALK] <milk>', '[FIND] <milk>', '[GRAB] <milk>', '[POUR] <milk> <cup>', '[TURNTO] <cat>', '[POINTAT] <cat>']
}

Input:
Scene_Objects:['spectacles', 'sponge', 'food_bread', 'blender', 'chair', 'walllamp', 'orchid', 'knife', 'cpuscreen', 'floor', 'ceiling', 'desk', 'keyboard', 'bookshelf', 'computer', 'ceilinglamp', 'mat', 'tvstand', 'window', 'mousepad', 'clothes_socks', 'wall', 'oven', 'cup', 'television', 'mouse', 'cupboard', 'door', 'home_office', 'table']
Task:Browse internet
response:

go to the office, turn computer on, open an browser or any application to open any website.

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


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

Here is an example plan to achieve a goal for reference:
Scene_Objects:['pot', 'filing_cabinet', 'band-aids', 'freezer', 'bathroom', 'detergent', 'food_butter', 'drawing', 'wallshelf', 'bookshelf', 'computer', 'tvstand', 'shower', 'homework', 'clothes_pants', 'bowl', 'nightstand', 'wall', 'oven', 'cup', 'photoframe', 'food_food', 'toilet_paper', 'coffe_maker', 'wine', 'tray', 'kitchen_counter', 'cupboard', 'door', 'bathroom_cabinet']
Task:Pet cat
response:
{
    "thoughts": Find the cat.  Pet the cat.,
    "actions": ['[WALK] <home_office>', '[WALK] <cat>', '[FIND] <cat>', '[TOUCH] <cat>']
}

Input:
Scene_Objects:['pot', 'tablelamp', 'microwave', 'toilet', 'freezer', 'cpuscreen', 'ceiling', 'desk', 'computer', 'button', 'piano_bench', 'mop_bucket', 'mat', 'stereo', 'food_noodles', 'mousepad', 'wall', 'bench', 'bed', 'novel', 'oven_mitts', 'curtain', 'doorjamb', 'centerpiece', 'kettle', 'cupboard', 'table', 'dishwasher', 'instrument_violin', 'laser_pointer']
Task:Wash dishes with dishwasher
response:

[WALK] <dining_room>
[WALK] <bowl>
[FIND] <bowl>
[GRAB] <bowl>
[WALK] <dining_room>
[WASH] <bowl>
[WALK] <detergent>
[FIND] <detergent>
[RINSE] <detergent>


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

Here is an example plan to achieve a goal for reference:
Scene_Objects:['pot', 'mop', 'microwave', 'walllamp', 'knifeblock', 'bathroom_counter', 'floor', 'ceiling', 'computer', 'toaster', 'ceilinglamp', 'plate', 'faucet', 'iron', 'window', 'laptop', 'dish_soap', 'wall', 'oven', 'coffe_maker', 'check', 'tray', 'rag', 'towel_rack', 'kitchen_counter', 'dishrack', 'dresser', 'cupboard', 'sink', 'bathroom_cabinet']
Task:Wash dishes
response:
{
    "thoughts": Run hot water into tub of dirty dishes in the sink.  Add liquid soap.  Scrub dishes with wash rag. Rinse and place on drying rack.,
    "actions": ['[WALK] <dining_room>', '[WALK] <sink>', '[FIND] <faucet>', '[SWITCHON] <faucet>', '[FIND] <dish_soap>', '[GRAB] <dish_soap>', '[POUR] <dish_soap> <sink>', '[PUTOBJBACK] <dish_soap>', '[FIND] <rag>', '[GRAB] <rag>', '[FIND] <plate>', '[GRAB] <plate>', '[SCRUB] <plate>', '[RINSE] <plate>', '[FIND] <dishrack>', '[PUTBACK] <plate> <dishrack>', '[FIND] <plate>', '[GRAB] <plate>', '[SCRUB] <plate>', '[RINSE] <plate>', '[PUTBACK] <plate> <dishrack>', '[SWITCHOFF] <faucet>', '[PUTOBJBACK] <rag>']
}

Input:
Scene_Objects:['tablelamp', 'tea', 'microwave', 'chair', 'walllamp', 'blow_dryer', 'bathroom', 'knifeblock', 'wallshelf', 'floor', 'ceiling', 'ceilinglamp', 'plate', 'mousepad', 'food_noodles', 'couch', 'closetdrawer', 'food_jam', 'form', 'pillow', 'wall', 'nightstand', 'razor', 'television', 'shaving_cream', 'kitchen_counter', 'bathroom_cabinet', 'dishwasher', 'soap', 'teeth']
Task:Text friends while sitting on couch
response:

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


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

Here is an example plan to achieve a goal for reference:
Scene_Objects:['filing_cabinet', 'tablelamp', 'chair', 'walllamp', 'bathroom', 'knife', 'drawing', 'wallshelf', 'orchid', 'hanger', 'cpuscreen', 'floor', 'character', 'keyboard', 'purse', 'homework', 'mousepad', 'wall', 'pasta', 'bench', 'keys', 'television', 'wooden_spoon', 'towel_rack', 'kettle', 'kitchen_counter', 'hair', 'conditioner', 'home_office', 'table']
Task:Hang up car keys
response:
{
    "thoughts": Open the front door. Enter the entrance hall. Take out car keys from purse. Hang car keys up on hook on the wall.,
    "actions": ['[WALK] <home_office>', '[WALK] <purse>', '[FIND] <purse>', '[OPEN] <purse>', '[FIND] <keys>', '[GRAB] <keys>', '[CLOSE] <purse>']
}

Input:
Scene_Objects:['pot', 'food_salt', 'microwave', 'toilet', 'dog', 'detergent', 'orchid', 'wallshelf', 'food_egg', 'cpuscreen', 'phone', 'stamp', 'bedroom', 'bookshelf', 'bookmark', 'shower', 'mousepad', 'food_jam', 'towel', 'pasta', 'bed', 'novel', 'food_food', 'curtain', 'centerpiece', 'shaving_cream', 'dresser', 'cupboard', 'table', 'creditcard']
Task:Walk through
response:

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


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

Here is an example plan to achieve a goal for reference:
Scene_Objects:['sheets', 'fork', 'crayon', 'tea', 'toilet', 'bathroom', 'orchid', 'hanger', 'floor', 'character', 'bedroom', 'tea_bag', 'keyboard', 'purse', 'toaster', 'mat', 'deck_of_cards', 'window', 'food_orange', 'pillow', 'photoframe', 'food_food', 'coffe_maker', 'food_donut', 'towel_rack', 'mouse', 'pencil', 'dresser', 'door', 'sink']
Task:Open door
response:
{
    "thoughts": Open the door when leaving or coming in.,
    "actions": ['[WALK] <home_office>']
}

Input:
Scene_Objects:['sponge', 'microwave', 'knifeblock', 'kitchen_cabinet', 'floor', 'ceiling', 'toaster', 'mat', 'plate', 'faucet', 'window', 'dish_soap', 'food_noodles', 'closetdrawer', 'couch', 'towel', 'dining_room', 'wall', 'wine', 'rag', 'shaving_cream', 'kitchen_counter', 'chessboard', 'dresser', 'cupboard', 'conditioner', 'sink', 'table', 'dishwasher', 'soap']
Task:Wash dishes
response:

Run warm water in the sink. Pour dish washing liquid on the dishes. Pick up dishes and wash them individually with a sponge. Rinse suds off under running water. Dry dishes with towel.

[WALK] <dining_room>
[WALK] <sink>
[FIND] <faucet>
[SWITCHON] <faucet>
[FIND] <dish_soap>
[GRAB] <dish_soap>
[FIND] <sponge>
[GRAB] <sponge>
[POUR] <dish_soap> <sponge>
[PUTOBJBACK] <dish_soap>
[FIND] <plate>
[GRAB] <plate>
[SCRUB] <plate>
[WASH] <plate>
[RINSE] <plate>
[RINSE] <sponge>
[SWITCHOFF] <faucet>
[PUTOBJBACK] <sponge>
[FIND] <towel>
[GRAB] <towel>
[WIPE] <plate>
[PUTOBJBACK] <towel>
[WALK] <kitchen_cabinet>
[OPEN] <kitchen_cabinet>
[PUTIN] <plate> <kitchen_cabinet>
[CLOSE] <kitchen_cabinet>


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

Here is an example plan to achieve a goal for reference:
Scene_Objects:['glue', 'filing_cabinet', 'tablelamp', 'microwave', 'freezer', 'ground_coffee', 'walllamp', 'bathroom', 'trashcan', 'floor', 'ceiling', 'phone', 'computer', 'toaster', 'stovefan', 'homework', 'wall', 'novel', 'coffe_maker', 'television', 'coffee_filter', 'water', 'tray', 'after_shave', 'diary', 'kitchen_counter', 'cupboard', 'laundry_detergent', 'food_steak', 'dishwasher']
Task:Make coffee
response:
{
    "thoughts": 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.,
    "actions": ['[WALK] <dining_room>', '[WALK] <coffe_maker>', '[FIND] <coffe_maker>', '[OPEN] <coffe_maker>', '[FIND] <coffee_filter>', '[GRAB] <coffee_filter>', '[PUTBACK] <coffee_filter> <coffe_maker>', '[FIND] <ground_coffee>', '[GRAB] <ground_coffee>', '[PUTBACK] <ground_coffee> <coffe_maker>', '[WALK] <water>', '[FIND] <water>', '[GRAB] <water>', '[POUR] <water> <coffe_maker>', '[CLOSE] <coffe_maker>', '[SWITCHON] <coffe_maker>']
}

Input:
Scene_Objects:['dry_pasta', 'microwave', 'freezer', 'walllamp', 'detergent', 'dough', 'floor', 'phone', 'ceiling', 'tea_bag', 'bookshelf', 'keyboard', 'toaster', 'laptop', 'tvstand', 'faucet', 'mousepad', 'dining_room', 'wall', 'box', 'cup', 'photoframe', 'coffe_maker', 'tray', 'doorjamb', 'kitchen_counter', 'dishrack', 'cupboard', 'sink', 'dishwasher']
Task:Make popcorn
response:

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

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


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

Here is an example plan to achieve a goal for reference:
Scene_Objects:['toilet', 'chair', 'walllamp', 'bathroom', 'wallshelf', 'cpuscreen', 'hanger', 'floor', 'ceiling', 'phone', 'desk', 'keyboard', 'envelope', 'computer', 'mop_bucket', 'stovefan', 'mat', 'tvstand', 'toaster', 'foundation', 'mousepad', 'pillow', 'wall', 'standingmirror', 'photoframe', 'toilet_paper', 'oven_mitts', 'tray', 'mouse', 'sink']
Task:Read book
response:
{
    "thoughts": go to living room,find the text book on the self ,sat on the chair ,open and read the book,
    "actions": ['[WALK] <home_office>', '[WALK] <novel>', '[FIND] <novel>', '[GRAB] <novel>', '[WALK] <home_office>', '[WALK] <chair>', '[FIND] <chair>', '[SIT] <chair>', '[READ] <novel>']
}

Input:
Scene_Objects:['sheets', 'beer', 'toilet', 'chair', 'band-aids', 'walllamp', 'bathroom', 'detergent', 'bills', 'knife', 'knifeblock', 'hanger', 'bedroom', 'button', 'plate', 'tvstand', 'iron', 'window', 'food_noodles', 'candle', 'nightstand', 'child', 'check', 'food_food', 'toothbrush_holder', 'razor', 'food_donut', 'cupboard', 'home_office', 'bathroom_cabinet']
Task:Greet guests
response:

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


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

Here is an example plan to achieve a goal for reference:
Scene_Objects:['microwave', 'toilet', 'chair', 'freezer', 'detergent', 'trashcan', 'drawing', 'wallshelf', 'clothes_underwear', 'floor', 'ceiling', 'phone', 'computer', 'toaster', 'mat', 'tvstand', 'shower', 'closetdrawer', 'wall', 'oven', 'cup', 'novel', 'water', 'drinking_glass', 'doorjamb', 'mouse', 'kitchen_counter', 'comb', 'cupboard', 'door']
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:['tablelamp', 'chair', 'ground_coffee', 'walllamp', 'food_carrot', 'orchid', 'drawing', 'floor', 'ceiling', 'bedroom', 'bookshelf', 'keyboard', 'mail', 'mat', 'faucet', 'wall', 'nightstand', 'powersocket', 'oven', 'cup', 'photoframe', 'bed', 'novel', 'curtain', 'doorjamb', 'diary', 'cupboard', 'door', 'sink', 'instrument_guitar']
Task:Read book
response:

Walk over to the bookshelf. Pick storybook off the shelf. Sit on bed. Open storybook and read out loud.

[WALK] <bedroom>
[WALK] <bookshelf>
[FIND] <novel>
[GRAB] <novel>
[TURNTO] <novel>
[LOOKAT] <novel>
[WALK] <bed>
[SIT] <bed>
[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:['glue', 'crayon', 'microwave', 'food_butter', 'drawing', 'knifeblock', 'floor', 'bedroom', 'envelope', 'stovefan', 'ceilinglamp', 'mat', 'balanceball', 'window', 'couch', 'clothes_hat', 'wall', 'nightstand', 'oven', 'basket_for_clothes', 'television', 'after_shave', 'cards', 'kitchen_counter', 'cupboard', 'laundry_detergent', 'hairdryer', 'spoon', 'table', 'light']
Task:Relax on sofa
response:
{
    "thoughts": Walk to the living room. Walk to the sofa and sit on the sofa.,
    "actions": ['[WALK] <home_office>', '[WALK] <couch>', '[SIT] <couch>']
}

Input:
Scene_Objects:['filing_cabinet', 'chair', 'knifeblock', 'knife', 'orchid', 'floor', 'ceiling', 'phone', 'keyboard', 'mail', 'stovefan', 'ceilinglamp', 'deck_of_cards', 'stereo', 'pillow', 'dining_room', 'wall', 'cup', 'bed', 'novel', 'coffe_maker', 'doorjamb', 'kitchen_counter', 'cupboard', 'controller', 'laundry_detergent', 'hairdryer', 'sink', 'home_office', 'dishwasher']
Task:Make coffee
response:

[WALK] <dining_room>
[WALK] <coffe_maker>
[FIND] <coffe_maker>
[SWITCHON] <coffe_maker>


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

Here is an example plan to achieve a goal for reference:
Scene_Objects:['tablelamp', 'chair', 'walllamp', 'drawing', 'wallshelf', 'hanger', 'floor', 'ceiling', 'desk', 'remote_control', 'computer', 'mat', 'tvstand', 'ceilinglamp', 'shower', 'closetdrawer', 'couch', 'food_orange', 'pillow', 'food_kiwi', 'wall', 'photoframe', 'newspaper', 'television', 'food_donut', 'food_rice', 'doorjamb', 'mouse', 'cd', 'dresser']
Task:Watch TV
response:
{
    "thoughts": turn on the tv,
    "actions": ['[WALK] <home_office>', '[WALK] <television>', '[FIND] <television>', '[SWITCHON] <television>', '[FIND] <remote_control>', '[TOUCH] <remote_control>']
}

Input:
Scene_Objects:['dry_pasta', 'pot', 'fork', 'scissors', 'food_ice_cream', 'microwave', 'walllamp', 'knifeblock', 'knife', 'wallshelf', 'floor', 'ceiling', 'phone', 'alcohol', 'clothes_jacket', 'toaster', 'stovefan', 'faucet', 'couch', 'wall', 'nightstand', 'oven', 'food_food', 'tray', 'rag', 'pencil', 'kitchen_counter', 'cupboard', 'sink', 'colander']
Task:Clean
response:

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

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


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

Here is an example plan to achieve a goal for reference:
Scene_Objects:['food_bread', 'filing_cabinet', 'tablelamp', 'food_salt', 'toilet', 'chair', 'bathroom', 'trashcan', 'drawing', 'floor', 'character', 'desk', 'purse', 'computer', 'table_cloth', 'stovefan', 'ceilinglamp', 'tvstand', 'shower', 'foundation', 'couch', 'pillow', 'nightstand', 'powersocket', 'novel', 'tray', 'mouse', 'bathroom_cabinet', 'soap', 'teeth']
Task:Pet cat
response:
{
    "thoughts": First I need to find the cat in the living room. Then I walk over to the cat and pet it gently.,
    "actions": ['[WALK] <home_office>', '[WALK] <cat>', '[FIND] <cat>', '[WALK] <cat>', '[TOUCH] <cat>']
}

Input:
Scene_Objects:['sponge', 'filing_cabinet', 'juice', 'microwave', 'knifeblock', 'wallshelf', 'bathroom_counter', 'floor', 'ceiling', 'computer', 'piano_bench', 'toaster', 'ceilinglamp', 'plate', 'faucet', 'stovefan', 'tvstand', 'dish_soap', 'wall', 'pasta', 'coffee_filter', 'tray', 'doorjamb', 'mouse', 'kitchen_counter', 'shoes', 'dishrack', 'cupboard', 'sink', 'scrabble']
Task:Wash dishes
response:

Place all of the dirty dishes in a sink full of clean, soapy water.  Wash them.  Rinse them in fresh, running water.  Place them in the strainer to dry.

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