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', 'ceilingfan', 'knifeblock', 'orchid', 'clothes_underwear', 'hanger', 'floor', 'ceiling', 'phone', 'character', 'desk', 'computer', 'couch', 'broom', 'wall', 'coffe_maker', 'video_game_controller', 'wine', 'doorjamb', 'towel_rack', 'cards', 'pencil', 'kitchen_counter', 'mouse', 'dresser', 'cupboard', 'door', 'light', 'board_game']
Task:Turn on light
response:
{
    "thoughts": Walk over to light switch. Turn on lights.,
    "actions": ['[WALK] <light>', '[SWITCHON] <light>']
}

Input:
Scene_Objects:['filing_cabinet', 'food_bread', 'toilet', 'chair', 'cat', 'trashcan', 'ceilingfan', 'orchid', 'cpuscreen', 'longboard', 'desk', 'remote_control', 'button', 'food_bacon', 'foundation', 'couch', 'dining_room', 'oven', 'bench', 'basket_for_clothes', 'cup', 'bed', 'check', 'toothbrush_holder', 'doorjamb', 'coffee_pot', 'vacuum_cleaner', 'controller', 'spoon', 'table']
Task:Change TV channel
response:

Walk into living room. Find television remote control. Pick up remote control. Press button.

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


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

Here is an example plan to achieve a goal for reference:
Scene_Objects:['pot', 'filing_cabinet', 'beer', 'freezer', 'walllamp', 'bathroom', 'bathroom_counter', 'character', 'bedroom', 'desk', 'ceilinglamp', 'tvstand', 'faucet', 'clothes_socks', 'clothes_pants', 'towel', 'bench', 'basket_for_clothes', 'bed', 'coin', 'food_donut', 'curtain', 'towel_rack', 'mouse', 'cd', 'comb', 'laundry_detergent', 'bathtub', 'bathroom_cabinet', 'washing_machine']
Task:Wash clothes
response:
{
    "thoughts": Go to kitchen, find washing machine, find laundry, put laundry in washing machine, find soap, put soap in washing machine, turn on.,
    "actions": ['[WALK] <dining_room>', '[WALK] <washing_machine>', '[FIND] <washing_machine>', '[FIND] <basket_for_clothes>', '[GRAB] <basket_for_clothes>', '[OPEN] <washing_machine>', '[PUTBACK] <basket_for_clothes> <washing_machine>', '[WALK] <laundry_detergent>', '[FIND] <laundry_detergent>', '[GRAB] <laundry_detergent>', '[POUR] <laundry_detergent> <washing_machine>', '[CLOSE] <washing_machine>', '[SWITCHON] <washing_machine>']
}

Input:
Scene_Objects:['food_ice_cream', 'microwave', 'freezer', 'ceilingfan', 'knifeblock', 'drawing', 'orchid', 'floor', 'ceiling', 'dvd_player', 'character', 'bookshelf', 'clothes_jacket', 'ceilinglamp', 'tvstand', 'deck_of_cards', 'mousepad', 'couch', 'food_jam', 'pillow', 'food_kiwi', 'wall', 'powersocket', 'bed', 'food_food', 'ice', 'mouse', 'door', 'dishwasher', 'scrabble']
Task:Cook some food
response:

Walk Into Kitchen. Open Refrigerator. Grab Food. Walk to Microwave. Insert food into microwave. Cook until warm.

[WALK] <dining_room>
[WALK] <freezer>
[OPEN] <freezer>
[FIND] <food_food>
[CLOSE] <freezer>
[WALK] <microwave>
[SWITCHON] <microwave>
[SWITCHOFF] <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:['filing_cabinet', 'bathroom', 'bathroom_counter', 'floor', 'ceiling', 'bedroom', 'purse', 'stovefan', 'mat', 'toaster', 'faucet', 'shower', 'plate', 'closetdrawer', 'towel', 'wall', 'wall_clock', 'oven', 'toy', 'hands_both', 'coin', 'tray', 'mouse', 'sink', 'bathtub', 'bathroom_cabinet', 'table', 'home_office', 'soap', 'teeth']
Task:Wash hands
response:
{
    "thoughts": Go to the bathroom. Turn on the sink. Rinse hands. Apply soap and scrub your hands together. Rinse hands again. Turn off faucet. Dry hands on a towel.,
    "actions": ['[WALK] <bathroom>', '[WALK] <faucet>', '[FIND] <faucet>', '[SWITCHON] <faucet>', '[FIND] <hands_both>', '[RINSE] <hands_both>', '[FIND] <soap>', '[GRAB] <soap>', '[SCRUB] <hands_both>', '[PUTOBJBACK] <soap>', '[RINSE] <hands_both>', '[SWITCHOFF] <faucet>', '[FIND] <towel>', '[GRAB] <towel>', '[WIPE] <hands_both>', '[PUTOBJBACK] <towel>']
}

Input:
Scene_Objects:['freezer', 'bathroom', 'ceilingfan', 'food_carrot', 'drawing', 'bathroom_counter', 'floor', 'ceiling', 'computer', 'food_bacon', 'toaster', 'ceilinglamp', 'tvstand', 'balanceball', 'stovefan', 'window', 'couch', 'food_orange', 'wall', 'powersocket', 'cutting_board', 'bed', 'novel', 'mouthwash', 'television', 'curtain', 'towel_rack', 'home_office', 'table', 'clothes_skirt']
Task:Watch TV
response:

I come home and go to the sofa for turn off the tv and relax

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


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

Here is an example plan to achieve a goal for reference:
Scene_Objects:['freezer', 'band-aids', 'dough', 'cpuscreen', 'food_egg', 'floor', 'ceiling', 'dvd_player', 'desk', 'bedroom', 'keyboard', 'computer', 'clothes_jacket', 'ceilinglamp', 'mat', 'mousepad', 'wall', 'powersocket', 'cup', 'bed', 'photoframe', 'newspaper', 'water', 'food_donut', 'doorjamb', 'mouse', 'door', 'light', 'table', 'shoe_rack']
Task:Drink
response:
{
    "thoughts": Feeling tired after hard work I opened the fridge and grabbed cool water and drank from the glass.,
    "actions": ['[WALK] <dining_room>', '[WALK] <freezer>', '[FIND] <freezer>', '[OPEN] <freezer>', '[FIND] <cup>', '[GRAB] <cup>', '[CLOSE] <freezer>', '[FIND] <water>', '[GRAB] <water>', '[FIND] <cup>', '[POUR] <water> <cup>', '[FIND] <cup>', '[DRINK] <cup>']
}

Input:
Scene_Objects:['tablelamp', 'mop', 'walllamp', 'drawing', 'bathroom_counter', 'floor', 'ceiling', 'envelope', 'stovefan', 'faucet', 'couch', 'form', 'wall', 'bench', 'photoframe', 'coffe_maker', 'television', 'food_donut', 'wine', 'tray', 'after_shave', 'mouse', 'paper_towel', 'door', 'sink', 'bathroom_cabinet', 'dishwasher', 'clothes_skirt', 'soap', 'hands_both']
Task:Wash hands
response:

I walk to the bathroom and find the sink. I grab the soap and rub some on my hands. I turn the faucet on and put my hands in the water. I rinse my hands and then turn off the faucet. Then I dry my hands on a paper towel.

[WALK] <bathroom>
[WALK] <sink>
[FIND] <sink>
[FIND] <soap>
[GRAB] <soap>
[FIND] <hands_both>
[SCRUB] <hands_both>
[FIND] <faucet>
[SWITCHON] <faucet>
[RINSE] <hands_both>
[FIND] <paper_towel>
[GRAB] <paper_towel>
[WIPE] <hands_both>


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

Here is an example plan to achieve a goal for reference:
Scene_Objects:['sheets', 'microwave', 'chair', 'walllamp', 'bills', 'cpuscreen', 'floor', 'ceiling', 'phone', 'desk', 'keyboard', 'computer', 'ceilinglamp', 'tvstand', 'window', 'mousepad', 'dining_room', 'wall', 'nightstand', 'powersocket', 'oven', 'photoframe', 'food_food', 'television', 'doorjamb', 'towel_rack', 'mouse', 'bathroom_cabinet', 'table', 'home_office']
Task:Work
response:
{
    "thoughts": Sit at a desk.  Turn on computer.  Sign onto mTurk.  Perform tasks.,
    "actions": ['[WALK] <home_office>', '[WALK] <chair>', '[FIND] <chair>', '[SIT] <chair>', '[FIND] <computer>', '[SWITCHON] <computer>', '[TURNTO] <computer>', '[LOOKAT] <computer>', '[FIND] <keyboard>', '[TYPE] <keyboard>']
}

Input:
Scene_Objects:['tablelamp', 'microwave', 'cd_player', 'freezer', 'detergent', 'trashcan', 'food_carrot', 'drawing', 'knifeblock', 'hanger', 'floor', 'phone', 'character', 'button', 'toaster', 'ceilinglamp', 'stovefan', 'window', 'food_noodles', 'couch', 'wall', 'wall_clock', 'bench', 'powersocket', 'television', 'towel_rack', 'dresser', 'sink', 'table', 'light']
Task:Listen to music
response:

Walk to living room, walk to cd player, turn on cd player, press play button, walk to sofa, sit in sofa and listen to music

[WALK] <home_office>
[WALK] <cd_player>
[SWITCHON] <cd_player>
[FIND] <button>
[PUSH] <button>
[WALK] <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:['water_glass', 'food_pizza', 'pot', 'microwave', 'bathroom', 'bills', 'knifeblock', 'cpuscreen', 'drawing', 'longboard', 'floor', 'phone', 'folder', 'bedroom', 'keyboard', 'mail', 'food_bacon', 'piano_bench', 'button', 'table_cloth', 'shower', 'couch', 'dining_room', 'wall', 'powersocket', 'cutting_board', 'water', 'tray', 'pencil', 'door']
Task:Drink
response:
{
    "thoughts": Drinking a glass of water,
    "actions": ['[WALK] <dining_room>', '[WALK] <water>', '[FIND] <water>', '[GRAB] <water>', '[FIND] <water_glass>', '[POUR] <water> <water_glass>', '[FIND] <water_glass>', '[GRAB] <water_glass>', '[DRINK] <water_glass>']
}

Input:
Scene_Objects:['glue', 'tablelamp', 'chair', 'walllamp', 'bathroom', 'trashcan', 'ceilingfan', 'hanger', 'floor', 'ceiling', 'phone', 'desk', 'computer', 'laptop', 'balanceball', 'mousepad', 'pillow', 'wall', 'cup', 'bed', 'television', 'razor', 'doorjamb', 'kitchen_counter', 'dresser', 'cupboard', 'door', 'spoon', 'light', 'vase']
Task:Turn on light
response:

push any ligth button to turn it on, for example in the living room

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


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

Here is an example plan to achieve a goal for reference:
Scene_Objects:['chair', 'walllamp', 'blow_dryer', 'knifeblock', 'drawing', 'cpuscreen', 'bathroom_counter', 'floor', 'ceiling', 'folder', 'desk', 'food_cake', 'stovefan', 'toaster', 'deck_of_cards', 'faucet', 'candle', 'pillow', 'dining_room', 'oven', 'photoframe', 'check', 'food_food', 'television', 'bathroom_cabinet', 'table', 'dishwasher', 'soap', 'board_game', 'clothes_shirt']
Task:Pet cat
response:
{
    "thoughts": Walk to living room. Find cat. Walk to cat. Pull cat.,
    "actions": ['[WALK] <home_office>', '[WALK] <cat>', '[FIND] <cat>', '[WALK] <cat>', '[PULL] <cat>']
}

Input:
Scene_Objects:['filing_cabinet', 'blender', 'jelly', 'freezer', 'chair', 'drawing', 'clothes_underwear', 'bathroom_counter', 'floor', 'button', 'stovefan', 'ceilinglamp', 'brush', 'deck_of_cards', 'window', 'oil', 'couch', 'clothes_hat', 'dining_room', 'broom', 'wall', 'mouthwash', 'television', 'kitchen_counter', 'dishrack', 'sink', 'bathroom_cabinet', 'table', 'home_office', 'scrabble']
Task:Relax on sofa
response:

walk to living room ,find sofa ,sit on sofa

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


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

Here is an example plan to achieve a goal for reference:
Scene_Objects:['nail_polish', 'orchid', 'drawing', 'bathroom_counter', 'floor', 'ceiling', 'thread', 'faucet', 'couch', 'dining_room', 'wall', 'nightstand', 'bench', 'wall_clock', 'photoframe', 'coffe_maker', 'food_food', 'lighter', 'doorjamb', 'towel_rack', 'diary', 'shoes', 'comb', 'door', 'sink', 'bathroom_cabinet', 'table', 'soap', 'dirt', 'hands_both']
Task:Wash hands
response:
{
    "thoughts": Go to the bathroom. turn on the water in the sink. apply soap to hands. rub hands together. rinse hands with water. turn off the water.,
    "actions": ['[WALK] <bathroom>', '[WALK] <sink>', '[FIND] <sink>', '[FIND] <soap>', '[GRAB] <soap>', '[FIND] <hands_both>', '[SCRUB] <hands_both>', '[RINSE] <hands_both>', '[WIPE] <hands_both>']
}

Input:
Scene_Objects:['spectacles', 'cpuscreen', 'bathroom_counter', 'longboard', 'phone', 'desk', 'bookshelf', 'computer', 'stovefan', 'tvstand', 'shower', 'balanceball', 'window', 'foundation', 'clothes_socks', 'bowl', 'newspaper', 'bed', 'check', 'food_food', 'television', 'razor', 'food_rice', 'cards', 'cupboard', 'maindoor', 'napkin', 'bathroom_cabinet', 'table', 'dishwasher']
Task:Turn on light
response:

I go to bedroom and locate a lamp. This lamp can be turned on by touch, as it has capacitive sensing. So I do it.

[WALK] <bedroom>
[WALK] <floor_lamp>
[FIND] <floor_lamp>
[TOUCH] <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:['sheets', 'tablelamp', 'food_ice_cream', 'walllamp', 'trashcan', 'ceilingfan', 'drawing', 'longboard', 'floor', 'bookshelf', 'computer', 'faucet', 'balanceball', 'window', 'iron', 'food_peanut_butter', 'food_jam', 'wall', 'nightstand', 'bench', 'powersocket', 'basket_for_clothes', 'novel', 'check', 'coffee_filter', 'shaving_cream', 'pencil', 'maindoor', 'sink', 'hairdryer']
Task:Pick up phone
response:

Enter the Home office, then walk to the phone, pickup the phone.

[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:['pot', 'microwave', 'toilet', 'chair', 'detergent', 'food_butter', 'toothbrush', 'drawing', 'floor', 'ceiling', 'toaster', 'mat', 'plate', 'faucet', 'shower', 'dish_soap', 'wall', 'nightstand', 'cup', 'coffe_maker', 'coffee_filter', 'drinking_glass', 'tray', 'wooden_spoon', 'kitchen_counter', 'cupboard', 'sink', 'coffee_cup', 'dishwasher', 'shoe_rack']
Task:Clean dishes
response:
{
    "thoughts": Wash dishes in the sink then place them in the dishwasher. Put detergent in the dishwasher and turn it on when full.,
    "actions": ['[WALK] <dining_room>', '[WALK] <sink>', '[FIND] <faucet>', '[SWITCHON] <faucet>', '[FIND] <dish_soap>', '[GRAB] <dish_soap>', '[FIND] <drinking_glass>', '[WASH] <drinking_glass>', '[FIND] <coffee_cup>', '[WASH] <coffee_cup>', '[FIND] <plate>', '[WASH] <plate>', '[GRAB] <coffee_cup>', '[PUTBACK] <coffee_cup> <plate>', '[FIND] <dishwasher>', '[OPEN] <dishwasher>', '[GRAB] <drinking_glass>', '[PUTBACK] <drinking_glass> <dishwasher>', '[GRAB] <plate>', '[PUTBACK] <plate> <dishwasher>', '[FIND] <detergent>', '[GRAB] <detergent>', '[PUTBACK] <detergent> <dishwasher>', '[CLOSE] <dishwasher>', '[SWITCHON] <dishwasher>']
}

Input:
Scene_Objects:['sheets', 'filing_cabinet', 'food_ice_cream', 'beer', 'microwave', 'freezer', 'walllamp', 'floor', 'ceiling', 'phone', 'dvd_player', 'stovefan', 'ceilinglamp', 'toaster', 'mousepad', 'wall', 'wall_clock', 'cup', 'bed', 'food_food', 'coin', 'food_rice', 'water', 'pencil', 'shoes', 'controller', 'napkin', 'bathroom_cabinet', 'table', 'dishwasher']
Task:Drink
response:

Feeling tired after hard work I opened the fridge and grabbed cool water and drank from the glass.

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


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

Here is an example plan to achieve a goal for reference:
Scene_Objects:['tablelamp', 'microwave', 'chair', 'freezer', 'bathroom', 'trashcan', 'drawing', 'cpuscreen', 'wallshelf', 'bathroom_counter', 'floor', 'phone', 'mail', 'stovefan', 'ceilinglamp', 'tvstand', 'window', 'mousepad', 'pillow', 'wall_clock', 'child', 'check', 'coffe_maker', 'tray', 'doorjamb', 'mouse', 'dresser', 'sink', 'bathroom_cabinet', 'home_office']
Task:Greet guests
response:
{
    "thoughts": Say hi,
    "actions": ['[WALK] <home_office>', '[WALK] <child>', '[FIND] <child>', '[GREET] <child>']
}

Input:
Scene_Objects:['pot', 'blender', 'crayon', 'measuring_cup', 'freezer', 'nail_polish', 'cat', 'floor', 'dvd_player', 'character', 'bedroom', 'tea_bag', 'piano_bench', 'toaster', 'foundation', 'window', 'couch', 'photoframe', 'check', 'toilet_paper', 'curtain', 'centerpiece', 'shaving_cream', 'mouse', 'chessboard', 'headset', 'sink', 'napkin', 'spoon', 'light']
Task:Read book
response:

pick up  the book open the book and read

[WALK] <bedroom>
[WALK] <novel>
[GRAB] <novel>
[READ] <novel>


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

Here is an example plan to achieve a goal for reference:
Scene_Objects:['food_ice_cream', 'toilet', 'walllamp', 'nail_polish', 'dough', 'orchid', 'wallshelf', 'floor', 'ceiling', 'bookshelf', 'remote_control', 'keyboard', 'computer', 'stovefan', 'mat', 'tvstand', 'ceilinglamp', 'shower', 'window', 'wall', 'nightstand', 'powersocket', 'photoframe', 'television', 'curtain', 'doorjamb', 'cards', 'dishrack', 'door', 'light']
Task:Change TV channel
response:
{
    "thoughts": first i will go to living room and then take the remote and swtitch on television after that il change the channel,
    "actions": ['[WALK] <home_office>', '[WALK] <television>', '[FIND] <television>', '[SWITCHON] <television>', '[FIND] <remote_control>', '[TURNTO] <remote_control>', '[POINTAT] <remote_control>', '[TOUCH] <remote_control>', '[TURNTO] <television>', '[WATCH] <television>']
}

Input:
Scene_Objects:['fork', 'filing_cabinet', 'blow_dryer', 'trashcan', 'drawing', 'knife', 'hanger', 'bathroom_counter', 'floor', 'ceiling', 'character', 'desk', 'toaster', 'faucet', 'picture', 'towel', 'dining_room', 'wall', 'nightstand', 'powersocket', 'photoframe', 'novel', 'food_food', 'controller', 'door', 'sink', 'bathroom_cabinet', 'clothes_skirt', 'soap', 'board_game']
Task:Wash hands
response:

I walk into the bathroom. Walk to the sink. Turn on tap. Get soap. Wash and rinse hands. Turn off tap. Dry hands.

[WALK] <bathroom>
[WALK] <sink>
[FIND] <sink>
[TURNTO] <sink>
[LOOKAT] <sink>
[WALK] <sink>
[FIND] <faucet>
[SWITCHON] <faucet>
[FIND] <soap>
[GRAB] <soap>
[RINSE] <soap>
[SWITCHOFF] <faucet>
[FIND] <towel>
[GRAB] <towel>


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

Here is an example plan to achieve a goal for reference:
Scene_Objects:['scissors', 'detergent', 'orchid', 'wallshelf', 'bedroom', 'tea_bag', 'bookshelf', 'ceilinglamp', 'laptop', 'faucet', 'window', 'couch', 'broom', 'wall', 'oven', 'cutting_board', 'toy', 'cup', 'standingmirror', 'razor', 'television', 'tray', 'after_shave', 'towel_rack', 'mouse', 'kitchen_counter', 'controller', 'bathtub', 'vase', 'soap']
Task:Pick up phone
response:
{
    "thoughts": walk to living room, walk to the phone reach for the phone and pick up the phone.,
    "actions": ['[WALK] <home_office>', '[WALK] <phone>', '[FIND] <phone>', '[TOUCH] <phone>', '[GRAB] <phone>']
}

Input:
Scene_Objects:['pot', 'tablelamp', 'freezer', 'blow_dryer', 'ceilingfan', 'drawing', 'floor', 'ceiling', 'bedroom', 'remote_control', 'ceilinglamp', 'tvstand', 'balanceball', 'stereo', 'window', 'shoe-shine_kit', 'couch', 'microphone', 'food_jam', 'wall', 'coffe_maker', 'check', 'television', 'curtain', 'sink', 'napkin', 'bathroom_cabinet', 'table', 'colander', 'tooth_paste']
Task:Watch TV
response:

Walk to the living room. Find the television. Walk to the television. Switch on the television. Find the sofa. Walk to the sofa. Sit on the sofa. Find the remote control. Grab the remote control. Look at the television.

[WALK] <home_office>
[WALK] <television>
[FIND] <television>
[WALK] <television>
[SWITCHON] <television>
[FIND] <couch>
[WALK] <couch>
[SIT] <couch>
[FIND] <remote_control>
[GRAB] <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:['filing_cabinet', 'tablelamp', 'microwave', 'toilet', 'chair', 'bathroom', 'detergent', 'trashcan', 'toothbrush', 'knifeblock', 'bathroom_counter', 'character', 'keyboard', 'computer', 'food_bacon', 'tvstand', 'nightstand', 'oven', 'bench', 'powersocket', 'cup', 'bed', 'ice', 'diary', 'cards', 'dresser', 'hairbrush', 'home_office', 'dishwasher', 'scrabble']
Task:Listen to music
response:
{
    "thoughts": go to radio. run on radio.,
    "actions": ['[WALK] <stereo>', '[SWITCHON] <stereo>']
}

Input:
Scene_Objects:['spectacles', 'food_ice_cream', 'cd_player', 'orchid', 'bedroom', 'purse', 'computer', 'stovefan', 'mat', 'ceilinglamp', 'stereo', 'tvstand', 'balanceball', 'clothes_socks', 'couch', 'food_jam', 'powersocket', 'oven', 'cutting_board', 'photoframe', 'novel', 'check', 'television', 'wine', 'food_onion', 'pencil', 'vacuum_cleaner', 'door', 'sink', 'instrument_violin']
Task:Listen to music
response:

I walk in the living room, then I go the the stereo and the cd player and turn them on.

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


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

Here is an example plan to achieve a goal for reference:
Scene_Objects:['pot', 'food_bread', 'juice', 'toilet', 'chair', 'freezer', 'ground_coffee', 'walllamp', 'food_butter', 'food_carrot', 'drawing', 'floor', 'ceiling', 'stovefan', 'mat', 'ceilinglamp', 'shower', 'food_peanut_butter', 'food_jam', 'bowl', 'wall', 'nightstand', 'oven', 'powersocket', 'cup', 'food_cheese', 'photoframe', 'coffe_maker', 'food_food', 'tray', 'doorjamb', 'kitchen_counter', 'cupboard', 'door', 'food_steak', 'light', 'dishwasher', 'table']
Task:Grab some juice
response:
{
    "thoughts": I go to the fridge, and grab some juice out of it. I then get a glass, and pour the juice into the glass.,
    "actions": ['[WALK] <dining_room>', '[WALK] <cupboard>', '[FIND] <cupboard>', '[OPEN] <cupboard>', '[FIND] <cup>', '[GRAB] <cup>', '[CLOSE] <cupboard>', '[WALK] <freezer>', '[OPEN] <freezer>', '[FIND] <juice>', '[GRAB] <juice>', '[POUR] <juice> <cup>', '[PUTOBJBACK] <juice>', '[CLOSE] <freezer>', '[FIND] <table>', '[PUTBACK] <cup> <table>']
}

Input:
Scene_Objects:['pot', 'food_bread', 'toilet', 'chair', 'freezer', 'floor', 'ceiling', 'thread', 'table_cloth', 'ceilinglamp', 'faucet', 'food_peanut_butter', 'dining_room', 'wall', 'nightstand', 'powersocket', 'tape', 'photoframe', 'bed', 'food_food', 'cards', 'kitchen_counter', 'dishrack', 'dresser', 'hair', 'pajamas', 'door', 'home_office', 'dishwasher', 'vase']
Task:Put groceries in Fridge
response:

go to the kitchen and put the groceries in the fridge

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


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

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

Input:
Scene_Objects:['toilet', 'detergent', 'drawing', 'orchid', 'cpuscreen', 'hanger', 'bathroom_counter', 'floor', 'character', 'desk', 'keyboard', 'thread', 'table_cloth', 'tvstand', 'balanceball', 'shower', 'mousepad', 'couch', 'wall', 'photoframe', 'bed', 'toilet_paper', 'food_onion', 'towel_rack', 'mouse', 'kitchen_counter', 'cd', 'hairbrush', 'bathroom_cabinet', 'light']
Task:Go to toilet
response:


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

Here is an example plan to achieve a goal for reference:
Scene_Objects:['chair', 'walllamp', 'detergent', 'cpuscreen', 'hanger', 'floor', 'ceiling', 'desk', 'keyboard', 'computer', 'mail', 'button', 'clothes_jacket', 'ceilinglamp', 'mousepad', 'closetdrawer', 'wall', 'wall_clock', 'powersocket', 'keys', 'television', 'ice', 'doorjamb', 'mouse', 'pencil', 'headset', 'dresser', 'sink', 'light', 'table']
Task:Write an email
response:
{
    "thoughts": Switch on computer, Use keybord and mouse to open e-mail provider, type requested e-mail, click send, close e-mail provider, turn off computer,
    "actions": ['[WALK] <home_office>', '[WALK] <computer>', '[FIND] <computer>', '[SWITCHON] <computer>', '[FIND] <mouse>', '[FIND] <keyboard>', '[FIND] <mail>', '[OPEN] <mail>', '[TYPE] <keyboard>', '[FIND] <button>', '[PUSH] <button>', '[CLOSE] <mail>', '[SWITCHOFF] <computer>']
}

Input:
Scene_Objects:['toilet', 'chair', 'ceilingfan', 'drawing', 'needle', 'floor', 'ceiling', 'folder', 'character', 'keyboard', 'remote_control', 'button', 'toaster', 'ceilinglamp', 'tvstand', 'balanceball', 'mat', 'window', 'couch', 'dining_room', 'wall', 'pasta', 'light_bulb', 'television', 'curtain', 'doorjamb', 'kitchen_counter', 'shoes', 'table', 'shoe_rack']
Task:Change TV channel
response:

Walk into the Living room.  Find the television remote.  Use it to turn on the television.  Point the remote at the television. Press the channel button on the remote.

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


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

Here is an example plan to achieve a goal for reference:
Scene_Objects:['pot', 'food_pizza', 'filing_cabinet', 'blender', 'toilet', 'drawing', 'needle', 'food_egg', 'clothes_underwear', 'bathroom_counter', 'phone', 'keyboard', 'computer', 'table_cloth', 'closetdrawer', 'clothes_hat', 'nightstand', 'oven', 'basket_for_clothes', 'photoframe', 'check', 'television', 'coin', 'food_donut', 'diary', 'towel_rack', 'headset', 'comb', 'hairdryer', 'napkin']
Task:Drink
response:
{
    "thoughts": Drink water,
    "actions": ['[WALK] <dining_room>', '[WALK] <water_glass>', '[FIND] <water_glass>', '[GRAB] <water_glass>', '[DRINK] <water_glass>']
}

Input:
Scene_Objects:['fork', 'sheets', 'chair', 'dog', 'walllamp', 'orchid', 'cpuscreen', 'longboard', 'phone', 'character', 'desk', 'table_cloth', 'clothes_hat', 'towel', 'wall_clock', 'oven', 'bed', 'light_bulb', 'food_food', 'drinking_glass', 'water', 'curtain', 'after_shave', 'console', 'headset', 'cupboard', 'maindoor', 'spoon', 'bathroom_cabinet', 'light']
Task:Drink
response:

I walk to the kitchen. Take a glass out of the cabinet. Then I walk to the sink and turn the water on and fill the glass. Then I take a drink.

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


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

Here is an example plan to achieve a goal for reference:
Scene_Objects:['pot', 'jelly', 'chair', 'phone', 'ceiling', 'desk', 'bedroom', 'table_cloth', 'bookmark', 'stovefan', 'mat', 'tvstand', 'stereo', 'shoe-shine_kit', 'faucet', 'toaster', 'mousepad', 'powersocket', 'cutting_board', 'shelf', 'food_cheese', 'television', 'wooden_spoon', 'after_shave', 'food_onion', 'doorjamb', 'shoes', 'dishrack', 'vase', 'electrical_outlet']
Task:Turn on radio
response:
{
    "thoughts": Go to the radio.  Switch on the power button.  Tune the station.  Set the volume.  Listen to the music.,
    "actions": ['[WALK] <home_office>', '[WALK] <stereo>', '[FIND] <stereo>', '[FIND] <electrical_outlet>', '[TURNTO] <electrical_outlet>', '[PLUGIN] <stereo>', '[SWITCHON] <electrical_outlet>', '[SWITCHON] <stereo>']
}

Input:
Scene_Objects:['spectacles', 'food_salt', 'toilet', 'chair', 'food_butter', 'ceilingfan', 'cpuscreen', 'floor', 'ceiling', 'dvd_player', 'character', 'desk', 'bedroom', 'bookshelf', 'keyboard', 'food_cake', 'computer', 'shoe-shine_kit', 'faucet', 'mousepad', 'oil', 'wall', 'nightstand', 'bed', 'mouse', 'kitchen_counter', 'vacuum_cleaner', 'cupboard', 'sink', 'bathroom_cabinet']
Task:Read book
response:

go to living room,find the text book on the self ,sat on the chair ,open and read the book

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


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

Here is an example plan to achieve a goal for reference:
Scene_Objects:['tablelamp', 'microwave', 'chair', 'walllamp', 'trashcan', 'drawing', 'cpuscreen', 'floor', 'ceiling', 'phone', 'desk', 'keyboard', 'computer', 'ceilinglamp', 'tvstand', 'mousepad', 'couch', 'dining_room', 'wall', 'powersocket', 'oven', 'television', 'tray', 'doorjamb', 'towel_rack', 'mouse', 'dresser', 'door', 'bathroom_cabinet', 'table']
Task:Turn on computer
response:
{
    "thoughts": Push power button.,
    "actions": ['[WALK] <home_office>', '[WALK] <computer>', '[SWITCHON] <computer>']
}

Input:
Scene_Objects:['water_glass', 'filing_cabinet', 'beer', 'freezer', 'cpuscreen', 'floor', 'ceiling', 'desk', 'bedroom', 'keyboard', 'food_cake', 'button', 'ceilinglamp', 'mat', 'pillow', 'wall', 'cup', 'basket_for_clothes', 'bed', 'check', 'coffe_maker', 'food_donut', 'tray', 'pencil', 'kitchen_counter', 'dresser', 'cupboard', 'food_steak', 'table', 'vase']
Task:Drink
response:

walk to kitchen ,find fridge ,open fridge ,find water  glass , drink from water glass

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


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

Here is an example plan to achieve a goal for reference:
Scene_Objects:['filing_cabinet', 'walllamp', 'bathroom', 'drawing', 'orchid', 'hanger', 'floor', 'ceiling', 'desk', 'ceilinglamp', 'tvstand', 'mat', 'window', 'couch', 'clothes_hat', 'pillow', 'dining_room', 'wall', 'powersocket', 'clothes_gloves', 'television', 'razor', 'curtain', 'doorjamb', 'console', 'mouse', 'door', 'bag', 'table', 'dishwasher']
Task:Change TV channel
response:
{
    "thoughts": I walk in living room. I find TV remote. I grab TV remote. I sit on sofa. I switch on TV. I switch channel.,
    "actions": ['[WALK] <home_office>', '[WALK] <remote_control>', '[FIND] <remote_control>', '[GRAB] <remote_control>', '[WALK] <couch>', '[SIT] <couch>', '[FIND] <television>', '[SWITCHON] <television>', '[TURNTO] <remote_control>', '[LOOKAT] <remote_control>', '[PUSH] <remote_control>']
}

Input:
Scene_Objects:['juice', 'food_ice_cream', 'blow_dryer', 'detergent', 'ceilingfan', 'drawing', 'hanger', 'longboard', 'floor', 'ceiling', 'phone', 'bedroom', 'keyboard', 'remote_control', 'ceilinglamp', 'tvstand', 'balanceball', 'faucet', 'window', 'shoe-shine_kit', 'couch', 'food_orange', 'wall', 'tape', 'television', 'curtain', 'kitchen_counter', 'conditioner', 'bathroom_cabinet', 'table']
Task:Relax on sofa
response:

For relaxing walk to living room. Find the sofa to relax. Arrange the sofa to relax. Sit on the sofa to relaxing.

[WALK] <home_office>
[WALK] <couch>
[FIND] <couch>
[FIND] <conditioner>
[FIND] <remote_control>
[FIND] <television>
[SWITCHON] <television>
[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:['glue', 'walllamp', 'ceilingfan', 'drawing', 'hanger', 'floor', 'bedroom', 'computer', 'ceilinglamp', 'deck_of_cards', 'iron', 'window', 'electric_shaver', 'couch', 'food_orange', 'wall', 'wall_clock', 'bed', 'novel', 'check', 'television', 'toothbrush_holder', 'wooden_spoon', 'after_shave', 'towel_rack', 'dresser', 'conditioner', 'maindoor', 'table', 'vase']
Task:Relax on sofa
response:
{
    "thoughts": Walk to the living room. Find the sofa. Walk to the sofa. Lie in the sofa.,
    "actions": ['[WALK] <home_office>', '[WALK] <couch>', '[FIND] <couch>', '[WALK] <couch>', '[LIE] <couch>']
}

Input:
Scene_Objects:['filing_cabinet', 'drawing', 'clothes_underwear', 'bathroom_counter', 'ceiling', 'purse', 'clothes_jacket', 'table_cloth', 'stovefan', 'shoe-shine_kit', 'faucet', 'shower', 'window', 'clothes_socks', 'clothes_pants', 'microphone', 'wall', 'nightstand', 'pasta', 'photoframe', 'razor', 'wine', 'hairbrush', 'clothes_dress', 'hairdryer', 'sink', 'bathroom_cabinet', 'dishwasher', 'vase', 'washing_machine']
Task:Wash clothes
response:

Walk to bathroom, open cabinet and collect clothes and put them into washing machine and wash clothes


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

Here is an example plan to achieve a goal for reference:
Scene_Objects:['tablelamp', 'microwave', 'chair', 'walllamp', 'orchid', 'knifeblock', 'cpuscreen', 'wallshelf', 'bathroom_counter', 'floor', 'ceiling', 'remote_control', 'computer', 'ceilinglamp', 'tvstand', 'window', 'closetdrawer', 'couch', 'pillow', 'dining_room', 'wall', 'nightstand', 'television', 'curtain', 'shaving_cream', 'dresser', 'home_office', 'table', 'bathroom_cabinet', 'shoe_rack']
Task:Watch TV
response:
{
    "thoughts": Watch favorite shows, netflix, hulu,
    "actions": ['[WALK] <home_office>', '[WALK] <remote_control>', '[FIND] <remote_control>', '[GRAB] <remote_control>', '[WALK] <couch>', '[SIT] <couch>', '[FIND] <television>', '[SWITCHON] <television>', '[PUTBACK] <remote_control> <couch>', '[TURNTO] <television>', '[WATCH] <television>']
}

Input:
Scene_Objects:['sponge', 'freezer', 'walllamp', 'knifeblock', 'cpuscreen', 'hanger', 'floor', 'ceiling', 'envelope', 'clothes_jacket', 'toaster', 'faucet', 'wall', 'oven', 'coffe_maker', 'television', 'drinking_glass', 'tray', 'curtain', 'lighter', 'coffee_pot', 'kitchen_counter', 'paper_towel', 'dishrack', 'comb', 'dresser', 'cupboard', 'sink', 'table', 'dishwasher']
Task:Wash dishes with dishwasher
response:

wipe loose dirt, place in the dishwasher, turn on the dishwasher

[WALK] <dining_room>
[WALK] <faucet>
[FIND] <faucet>
[SWITCHON] <faucet>
[FIND] <dishwasher>
[OPEN] <dishwasher>
[FIND] <drinking_glass>
[GRAB] <drinking_glass>
[FIND] <paper_towel>
[GRAB] <paper_towel>
[WIPE] <drinking_glass>
[RINSE] <drinking_glass>
[PUTBACK] <drinking_glass> <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', 'filing_cabinet', 'toilet', 'detergent', 'dough', 'bills', 'wallshelf', 'clothes_underwear', 'ceiling', 'keyboard', 'table_cloth', 'faucet', 'electric_shaver', 'mousepad', 'couch', 'dustpan', 'form', 'dining_room', 'newspaper', 'photoframe', 'food_food', 'coffe_maker', 'check', 'wooden_spoon', 'tray', 'rag', 'instrument_guitar', 'soap', 'washing_machine', 'coffee']
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:['sponge', 'chair', 'freezer', 'walllamp', 'food_carrot', 'drawing', 'knife', 'hanger', 'floor', 'phone', 'ceiling', 'keyboard', 'computer', 'brush', 'deck_of_cards', 'food_jam', 'bowl', 'dining_room', 'wall', 'bench', 'razor', 'doorjamb', 'mouse', 'dishrack', 'dresser', 'cupboard', 'door', 'sink', 'table', 'light']
Task:Pick up phone
response:

[WALK] <table>
[FIND] <phone>
[TURNTO] <phone>
[LOOKAT] <phone>
[GRAB] <phone>


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

Here is an example plan to achieve a goal for reference:
Scene_Objects:['pot', 'microwave', 'toilet', 'chair', 'freezer', 'walllamp', 'ground_coffee', 'food_butter', 'food_carrot', 'bills', 'floor', 'ceiling', 'bedroom', 'computer', 'table_cloth', 'tvstand', 'shower', 'faucet', 'wall', 'oven', 'newspaper', 'photoframe', 'bed', 'coffee_filter', 'curtain', 'kitchen_counter', 'cupboard', 'controller', 'dishwasher', 'clothes_shirt']
Task:Make popcorn
response:
{
    "thoughts": Lay popcorn bag flat inside microwave and press popcorn button to start.,
    "actions": ['[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>']
}

Input:
Scene_Objects:['freezer', 'ground_coffee', 'nail_polish', 'bathroom', 'food_butter', 'bills', 'phone', 'bedroom', 'food_cake', 'envelope', 'bookmark', 'ceilinglamp', 'tvstand', 'stereo', 'shower', 'balanceball', 'dining_room', 'food_kiwi', 'powersocket', 'toy', 'cup', 'photoframe', 'food_food', 'television', 'tray', 'dishrack', 'maindoor', 'home_office', 'dishwasher', 'vase']
Task:Listen to music
response:

walk into living room, walk to stereo, turn on stereo, listen to music

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


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

Here is an example plan to achieve a goal for reference:
Scene_Objects:['food_bread', 'filing_cabinet', 'microwave', 'walllamp', 'drawing', 'orchid', 'wallshelf', 'bathroom_counter', 'phone', 'desk', 'bookshelf', 'toaster', 'ceilinglamp', 'shower', 'faucet', 'couch', 'dining_room', 'nightstand', 'wall_clock', 'oven', 'wall', 'bed', 'water', 'tray', 'towel_rack', 'kitchen_counter', 'bathtub', 'bathroom_cabinet', 'table', 'hands_both']
Task:Wash hands
response:
{
    "thoughts": walk to bathroom, look at the water, wash hands,
    "actions": ['[WALK] <bathroom>', '[WALK] <water>', '[FIND] <water>', '[TURNTO] <water>', '[LOOKAT] <water>', '[FIND] <hands_both>', '[WASH] <hands_both>']
}

Input:
Scene_Objects:['dry_pasta', 'toilet', 'bathroom', 'trashcan', 'ceilingfan', 'toothbrush', 'orchid', 'floor', 'phone', 'bookshelf', 'computer', 'toaster', 'shoe-shine_kit', 'mousepad', 'pillow', 'dining_room', 'box', 'basket_for_clothes', 'keys', 'razor', 'toothbrush_holder', 'coin', 'wine', 'doorjamb', 'cards', 'door', 'napkin', 'home_office', 'soap', 'tooth_paste']
Task:Brush teeth
response:

today morning i went to bathroom and took my toothbrush and paste from tooth brush holder and brushed and cleaned my teeth well


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

Here is an example plan to achieve a goal for reference:
Scene_Objects:['sheets', 'toilet', 'bathroom', 'bills', 'orchid', 'cpuscreen', 'floor', 'phone', 'character', 'bedroom', 'piano_bench', 'toaster', 'mat', 'ceilinglamp', 'window', 'foundation', 'electric_shaver', 'oil', 'closetdrawer', 'couch', 'broom', 'nightstand', 'wall', 'cup', 'bed', 'check', 'toothbrush_holder', 'sink', 'napkin', 'dishwasher']
Task:Go to sleep
response:
{
    "thoughts": Enter bedroom, turn on the light, and shut door. Change into night clothes. Turn off light. Turn down comforter, climb into bed, lay head on pillow, and cover up with comforter. Close eyes and drift off to sleep.,
    "actions": ['[WALK] <bedroom>', '[WALK] <bed>', '[FIND] <bed>', '[LIE] <bed>', '[FIND] <sheets>', '[PULL] <sheets>']
}

Input:
Scene_Objects:['filing_cabinet', 'food_salt', 'beer', 'microwave', 'chair', 'bathroom', 'trashcan', 'dough', 'knifeblock', 'floor', 'computer', 'stovefan', 'mat', 'balanceball', 'faucet', 'window', 'couch', 'candle', 'wall', 'toy', 'bed', 'photoframe', 'coffe_maker', 'video_game_controller', 'wooden_spoon', 'curtain', 'dresser', 'pajamas', 'hair', 'maindoor']
Task:Go to sleep
response:

go to bedroom, put pajamas on, lie in bed, sleep

[WALK] <bedroom>
[WALK] <pajamas>
[FIND] <pajamas>
[GRAB] <pajamas>
[PUTON] <pajamas>
[FIND] <bed>
[LIE] <bed>


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

Here is an example plan to achieve a goal for reference:
Scene_Objects:['food_bread', 'microwave', 'toilet', 'freezer', 'trashcan', 'drawing', 'cpuscreen', 'floor', 'ceiling', 'character', 'toaster', 'mat', 'stovefan', 'shower', 'faucet', 'window', 'couch', 'pillow', 'wall', 'oven', 'coffe_maker', 'television', 'tray', 'doorjamb', 'kitchen_counter', 'cupboard', 'food_steak', 'door', 'sink', 'table']
Task:Make toast
response:
{
    "thoughts": Place slices of bread in a toaster ,wait for the bread to pop up .Set aside.,
    "actions": ['[WALK] <dining_room>', '[WALK] <freezer>', '[FIND] <freezer>', '[OPEN] <freezer>', '[FIND] <food_bread>', '[GRAB] <food_bread>', '[CLOSE] <freezer>', '[FIND] <toaster>', '[PLUGIN] <toaster>', '[PUTBACK] <food_bread> <toaster>', '[SWITCHON] <toaster>']
}

Input:
Scene_Objects:['measuring_cup', 'chair', 'walllamp', 'nail_polish', 'ceilingfan', 'drawing', 'food_egg', 'floor', 'bedroom', 'keyboard', 'toaster', 'plate', 'stereo', 'shower', 'dish_soap', 'microphone', 'wall', 'bench', 'oven', 'box', 'check', 'video_game_controller', 'food_food', 'coffe_maker', 'tray', 'kettle', 'console', 'table', 'dishwasher', 'soap']
Task:Wash dishes with dishwasher
response:

I go the in kitchen then grab the plate on the table. I put the plate and dish soap in the dishwasher. Finally, I turn on the dishwasher.

[WALK] <dining_room>
[WALK] <table>
[FIND] <plate>
[GRAB] <plate>
[WALK] <dishwasher>
[OPEN] <dishwasher>
[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:['food_salt', 'toilet', 'dog', 'freezer', 'drawing', 'cpuscreen', 'phone', 'tea_bag', 'food_bacon', 'stovefan', 'mat', 'ceilinglamp', 'window', 'oil', 'food_orange', 'food_cheese', 'clothes_gloves', 'toilet_paper', 'food_food', 'television', 'coffee_filter', 'check', 'curtain', 'kettle', 'mouse', 'food_steak', 'spoon', 'instrument_guitar', 'light', 'dishwasher']
Task:Walk to room
response:
{
    "thoughts": Leave the living room and enter the hall,
    "actions": ['[WALK] <home_office>', '[WALK] <home_office>']
}

Input:
Scene_Objects:['sponge', 'pot', 'food_salt', 'ceilingfan', 'dough', 'food_carrot', 'orchid', 'desk', 'remote_control', 'mail', 'button', 'computer', 'bookmark', 'mop_bucket', 'ceilinglamp', 'tvstand', 'iron', 'shower', 'couch', 'broom', 'bench', 'tape', 'check', 'tray', 'curtain', 'mouse', 'pencil', 'cupboard', 'controller', 'scrabble']
Task:Change TV channel
response:

I pick up the remote. I press button on remote.

[WALK] <bedroom>
[WALK] <remote_control>
[FIND] <remote_control>
[GRAB] <remote_control>
[FIND] <button>
[PUSH] <button>


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

Here is an example plan to achieve a goal for reference:
Scene_Objects:['filing_cabinet', 'tablelamp', 'chair', 'nail_polish', 'food_carrot', 'drawing', 'cpuscreen', 'floor', 'phone', 'desk', 'keyboard', 'stovefan', 'mat', 'tvstand', 'homework', 'window', 'couch', 'pillow', 'nightstand', 'wall', 'powersocket', 'oven', 'bench', 'bed', 'novel', 'coffe_maker', 'toothbrush_holder', 'towel_rack', 'home_office', 'instrument_violin']
Task:Read book
response:
{
    "thoughts": Go to the bedroom. Grab the book out of the nightstand. Lay down in bed. Open the book. Read the book.,
    "actions": ['[WALK] <bedroom>', '[WALK] <nightstand>', '[FIND] <nightstand>', '[OPEN] <nightstand>', '[FIND] <novel>', '[GRAB] <novel>', '[FIND] <bed>', '[TURNTO] <bed>', '[SIT] <bed>', '[READ] <novel>']
}

Input:
Scene_Objects:['pot', 'food_bread', 'blender', 'freezer', 'trashcan', 'food_carrot', 'drawing', 'knifeblock', 'hanger', 'floor', 'ceiling', 'phone', 'computer', 'ceilinglamp', 'plate', 'iron', 'wall', 'nightstand', 'bed', 'food_food', 'check', 'drinking_glass', 'curtain', 'centerpiece', 'coffee_pot', 'cupboard', 'laundry_detergent', 'door', 'dishwasher', 'vase']
Task:Drink
response:

[WALK] <dining_room>
[WALK] <freezer>
[FIND] <freezer>
[OPEN] <freezer>
[FIND] <drinking_glass>
[GRAB] <drinking_glass>
[DRINK] <drinking_glass>
[PUTOBJBACK] <drinking_glass>
[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:['dry_pasta', 'pot', 'food_pizza', 'tablelamp', 'microwave', 'freezer', 'drawing', 'cpuscreen', 'floor', 'ceiling', 'desk', 'keyboard', 'food_bacon', 'stovefan', 'mat', 'shower', 'couch', 'pillow', 'wall', 'oven', 'powersocket', 'food_food', 'television', 'tray', 'doorjamb', 'towel_rack', 'kitchen_counter', 'cupboard', 'door', 'light']
Task:Cook some food
response:
{
    "thoughts": go to the kitchen and cook some thing to eat,
    "actions": ['[WALK] <dining_room>', '[WALK] <freezer>', '[FIND] <freezer>', '[OPEN] <freezer>', '[FIND] <oven>', '[OPEN] <oven>', '[FIND] <food_pizza>', '[GRAB] <food_pizza>', '[PUTIN] <food_pizza> <oven>', '[SWITCHON] <oven>']
}

Input:
Scene_Objects:['sponge', 'pot', 'food_bread', 'toilet', 'orchid', 'drawing', 'cpuscreen', 'bathroom_counter', 'floor', 'longboard', 'shampoo', 'desk', 'stamp', 'keyboard', 'toaster', 'mat', 'deck_of_cards', 'faucet', 'foundation', 'mousepad', 'form', 'wall', 'nightstand', 'photoframe', 'doorjamb', 'mouse', 'cupboard', 'door', 'bathroom_cabinet', 'light']
Task:Go to toilet
response:

Travel through the house and locate the bathroom, and proceed to the toilet.

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


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

Here is an example plan to achieve a goal for reference:
Scene_Objects:['blender', 'microwave', 'toilet', 'toothbrush', 'bills', 'orchid', 'character', 'bedroom', 'stamp', 'stovefan', 'laptop', 'ceilinglamp', 'shower', 'mat', 'faucet', 'towel', 'pillow', 'dining_room', 'oven', 'coffe_maker', 'television', 'toothbrush_holder', 'comb', 'cupboard', 'door', 'sink', 'table', 'soap', 'tooth_paste', 'teeth']
Task:Brush teeth
response:
{
    "thoughts": Walk to bathroom. Find toothbrush.  Find toothpaste.  Put toothpaste on toothbrush.  Brush teeth.,
    "actions": ['[WALK] <bathroom>', '[WALK] <toothbrush_holder>', '[FIND] <toothbrush_holder>', '[FIND] <toothbrush>', '[GRAB] <toothbrush>', '[WALK] <tooth_paste>', '[FIND] <tooth_paste>', '[GRAB] <tooth_paste>', '[POUR] <tooth_paste> <toothbrush>', '[FIND] <teeth>', '[SCRUB] <teeth>']
}

Input:
Scene_Objects:['fork', 'food_bread', 'tablelamp', 'mop', 'chair', 'drawing', 'food_egg', 'bathroom_counter', 'floor', 'phone', 'desk', 'bookmark', 'plate', 'shower', 'tvstand', 'pillow', 'wall', 'bench', 'newspaper', 'check', 'food_food', 'doorjamb', 'console', 'mouse', 'chessboard', 'dresser', 'spoon', 'table', 'light', 'vase']
Task:Set up table
response:

Place your plate on the placemat. The forks will be placed on the left side of the plate and the knife and spoon on the right and place the spoon to the right of the knife. If you want to set out food, place them above the plate.

[WALK] <table>
[FIND] <plate>
[GRAB] <plate>
[DROP] <plate>
[FIND] <fork>
[GRAB] <fork>
[DROP] <fork>
[FIND] <spoon>
[GRAB] <spoon>
[DROP] <spoon>


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

Here is an example plan to achieve a goal for reference:
Scene_Objects:['tablelamp', 'walllamp', 'trashcan', 'drawing', 'bathroom_counter', 'floor', 'bookshelf', 'mail', 'stovefan', 'mat', 'tvstand', 'ceilinglamp', 'shower', 'window', 'couch', 'pillow', 'wall', 'oven', 'toy', 'mouthwash', 'television', 'wine', 'tray', 'curtain', 'cd', 'dresser', 'bathtub', 'sink', 'table', 'light']
Task:Relax on sofa
response:
{
    "thoughts": go to the living room,find the sofa,sat down in the sofa,take some relaxation.,
    "actions": ['[WALK] <home_office>', '[WALK] <couch>', '[FIND] <couch>', '[SIT] <couch>']
}

Input:
Scene_Objects:['food_pizza', 'tablelamp', 'microwave', 'chair', 'detergent', 'ceilingfan', 'hanger', 'bathroom_counter', 'floor', 'ceiling', 'clothes_jacket', 'mat', 'deck_of_cards', 'pillow', 'powersocket', 'photoframe', 'check', 'food_food', 'food_rice', 'wooden_spoon', 'doorjamb', 'shaving_cream', 'kettle', 'cd', 'shoes', 'controller', 'home_office', 'dishwasher', 'board_game', 'clothes_shirt']
Task:Pet cat
response:

Find Cat in living room.  Walk to cat.  Pet cat.

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


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

Here is an example plan to achieve a goal for reference:
Scene_Objects:['filing_cabinet', 'toilet', 'chair', 'trashcan', 'drawing', 'orchid', 'hanger', 'floor', 'phone', 'ceiling', 'desk', 'computer', 'toaster', 'deck_of_cards', 'mousepad', 'closetdrawer', 'couch', 'wall', 'wall_clock', 'powersocket', 'bench', 'television', 'doorjamb', 'cd', 'dresser', 'conditioner', 'door', 'home_office', 'light', 'table']
Task:Pick up phone
response:
{
    "thoughts": I walk to the kitchen and find the phone. I pick up the phone. I hold it to my ear.,
    "actions": ['[WALK] <dining_room>', '[WALK] <phone>', '[FIND] <phone>', '[GRAB] <phone>']
}

Input:
Scene_Objects:['sheets', 'chair', 'freezer', 'cat', 'cpuscreen', 'hanger', 'longboard', 'floor', 'ceiling', 'desk', 'mail', 'clothes_jacket', 'ceilinglamp', 'iron', 'picture', 'oil', 'food_noodles', 'clothes_pants', 'wall', 'novel', 'food_food', 'coffe_maker', 'television', 'tray', 'headset', 'maindoor', 'napkin', 'vase', 'tooth_paste', 'dirt']
Task:Put groceries in Fridge
response:

Walk to kitchen. Open fridge. Put groceries in fridge.

[WALK] <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:['tablelamp', 'beer', 'toilet', 'freezer', 'cpuscreen', 'clothes_underwear', 'wallshelf', 'shampoo', 'character', 'bedroom', 'bookshelf', 'computer', 'stovefan', 'mat', 'ceilinglamp', 'shower', 'clothes_pants', 'dining_room', 'bench', 'powersocket', 'photoframe', 'coffe_maker', 'mouse', 'paper_towel', 'dresser', 'door', 'bathtub', 'bathroom_cabinet', 'light', 'hands_both']
Task:Go to toilet
response:
{
    "thoughts": Walking towards Toilet room, And dispose of human waste. Cleaning your hands with tissue paper or water.,
    "actions": ['[WALK] <bathroom>', '[WALK] <paper_towel>', '[FIND] <paper_towel>', '[TURNTO] <paper_towel>', '[LOOKAT] <paper_towel>', '[GRAB] <paper_towel>', '[FIND] <hands_both>', '[WIPE] <hands_both>']
}

Input:
Scene_Objects:['blow_dryer', 'trashcan', 'hanger', 'floor', 'ceiling', 'bedroom', 'bookmark', 'toaster', 'stovefan', 'tvstand', 'food_jam', 'pillow', 'dining_room', 'bowl', 'wall', 'powersocket', 'clothes_gloves', 'novel', 'coffe_maker', 'coffee_filter', 'tray', 'after_shave', 'curtain', 'cd', 'chessboard', 'cupboard', 'sink', 'dishwasher', 'scrabble', 'coffee']
Task:Make coffee
response:

Enter kitchen, find coffee maker, find coffee filter, pick up coffee filter, put it in coffee maker, find coffee, pour coffee into filter, turn on.

[WALK] <dining_room>
[WALK] <coffe_maker>
[FIND] <coffe_maker>
[FIND] <coffee_filter>
[GRAB] <coffee_filter>
[OPEN] <coffe_maker>
[PUTBACK] <coffee_filter> <coffe_maker>
[WALK] <coffee>
[FIND] <coffee>
[GRAB] <coffee>
[POUR] <coffee> <coffe_maker>
[SWITCHON] <coffe_maker>


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

Here is an example plan to achieve a goal for reference:
Scene_Objects:['filing_cabinet', 'tablelamp', 'tea', 'toilet', 'chair', 'detergent', 'trashcan', 'ceilingfan', 'drawing', 'cpuscreen', 'floor', 'ceiling', 'phone', 'desk', 'keyboard', 'bookshelf', 'computer', 'mail', 'ceilinglamp', 'balanceball', 'mousepad', 'wall', 'nightstand', 'novel', 'food_onion', 'doorjamb', 'mouse', 'napkin', 'light', 'clothes_skirt']
Task:Browse internet
response:
{
    "thoughts": I go to the living room, where my computer is. I locate it, switch it on and type desired URL adress in the web browser.,
    "actions": ['[WALK] <home_office>', '[WALK] <computer>', '[FIND] <computer>', '[SWITCHON] <computer>', '[FIND] <keyboard>', '[TYPE] <keyboard>']
}

Input:
Scene_Objects:['trashcan', 'drawing', 'bathroom_counter', 'floor', 'ceiling', 'longboard', 'bedroom', 'envelope', 'stovefan', 'brush', 'faucet', 'mousepad', 'towel', 'pillow', 'wall', 'photoframe', 'coffe_maker', 'kitchen_counter', 'headset', 'instrument_violin', 'sink', 'maindoor', 'bathroom_cabinet', 'light', 'home_office', 'table', 'soap', 'board_game', 'hands_both', 'creditcard']
Task:Wash hands
response:

Go to bathroom, turn on faucet, wet hands, apply soap, rub hands, rinse hands, turn off faucet, dry hands

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


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

Here is an example plan to achieve a goal for reference:
Scene_Objects:['dry_pasta', 'bathroom', 'ceilingfan', 'knife', 'drawing', 'needle', 'knifeblock', 'bathroom_counter', 'shampoo', 'floor', 'ceiling', 'phone', 'piano_bench', 'faucet', 'window', 'teeth', 'clothes_pants', 'wall', 'photoframe', 'check', 'oven_mitts', 'tray', 'pencil', 'clothes_dress', 'sink', 'bathroom_cabinet', 'home_office', 'clothes_skirt', 'soap', 'hands_both']
Task:Wash hands
response:
{
    "thoughts": 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.,
    "actions": ['[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>']
}

Input:
Scene_Objects:['tablelamp', 'food_salt', 'microwave', 'jelly', 'detergent', 'food_carrot', 'toothbrush', 'needle', 'hanger', 'floor', 'phone', 'shampoo', 'character', 'tvstand', 'iron', 'balanceball', 'stereo', 'mousepad', 'food_jam', 'pillow', 'nightstand', 'toothbrush_holder', 'diary', 'console', 'shaving_cream', 'kitchen_counter', 'sink', 'light', 'dishwasher', 'vase']
Task:Listen to music
response:

Find the playback device you want to listen to. turn on. press play. enjoyu music.

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


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

Here is an example plan to achieve a goal for reference:
Scene_Objects:['microwave', 'freezer', 'walllamp', 'bathroom', 'drawing', 'cpuscreen', 'wallshelf', 'hanger', 'bathroom_counter', 'floor', 'character', 'desk', 'computer', 'food_bacon', 'mat', 'tvstand', 'ceilinglamp', 'plate', 'window', 'shower', 'couch', 'pillow', 'wall', 'nightstand', 'oven', 'television', 'wine', 'curtain', 'home_office', 'table']
Task:Relax on sofa
response:
{
    "thoughts": Walk into the living room. Walk to the sofa and sit on it. Put your feet up on the sofa and lay down.,
    "actions": ['[WALK] <home_office>', '[WALK] <couch>', '[SIT] <couch>', '[LIE] <couch>']
}

Input:
Scene_Objects:['sheets', 'food_bread', 'microwave', 'walllamp', 'ceilingfan', 'food_butter', 'drawing', 'bills', 'bathroom_counter', 'floor', 'ceiling', 'keyboard', 'remote_control', 'button', 'ceilinglamp', 'tvstand', 'balanceball', 'shower', 'window', 'couch', 'food_orange', 'wall', 'bench', 'photoframe', 'keys', 'check', 'food_food', 'television', 'curtain', 'table']
Task:Change TV channel
response:

Go to the living room, Switch on the television. Find the remote and press the change channel button, change the channel

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


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

Here is an example plan to achieve a goal for reference:
Scene_Objects:['tablelamp', 'microwave', 'walllamp', 'nail_polish', 'trashcan', 'drawing', 'orchid', 'floor', 'desk', 'computer', 'food_bacon', 'stovefan', 'mat', 'tvstand', 'ceilinglamp', 'faucet', 'window', 'mousepad', 'couch', 'pillow', 'wall', 'bench', 'coffe_maker', 'television', 'curtain', 'mouse', 'bathtub', 'home_office', 'table', 'bathroom_cabinet']
Task:Relax on sofa
response:
{
    "thoughts": Open coffee maker. Put filter in main basket, put ground coffee in filter, fill reservoir with water, turn on coffee maker.,
    "actions": ['[WALK] <home_office>', '[WALK] <couch>', '[FIND] <couch>', '[SIT] <couch>']
}

Input:
Scene_Objects:['sheets', 'ceilingfan', 'drawing', 'bathroom_counter', 'floor', 'ceiling', 'folder', 'bedroom', 'remote_control', 'toaster', 'ceilinglamp', 'tvstand', 'balanceball', 'plate', 'window', 'oil', 'couch', 'clothes_hat', 'pillow', 'wall', 'nightstand', 'coffe_maker', 'television', 'curtain', 'food_onion', 'controller', 'clothes_dress', 'table', 'clothes_skirt', 'light']
Task:Watch TV
response:

I get home from work and decide to watch tv. I go to the living room and turn on the tv. I sit on the couch and use the remote to switch the channels to find what I want to watch.

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


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

Here is an example plan to achieve a goal for reference:
Scene_Objects:['chair', 'freezer', 'orchid', 'drawing', 'cpuscreen', 'wallshelf', 'hanger', 'floor', 'ceiling', 'desk', 'keyboard', 'bookshelf', 'computer', 'ceilinglamp', 'tvstand', 'shower', 'window', 'mousepad', 'dining_room', 'wall', 'check', 'television', 'wine', 'doorjamb', 'shaving_cream', 'mouse', 'dresser', 'door', 'light', 'table']
Task:Complete surveys on amazon turk
response:
{
    "thoughts": Sit down at computer, Turn computer on. Go online to Amazon mechanical turk, Browse through surveys, Select a survey.,
    "actions": ['[WALK] <chair>', '[SIT] <chair>', '[FIND] <computer>', '[SWITCHON] <computer>', '[TURNTO] <computer>', '[LOOKAT] <computer>', '[FIND] <mouse>', '[GRAB] <mouse>', '[TURNTO] <computer>', '[POINTAT] <computer>', '[FIND] <check>', '[GRAB] <check>', '[READ] <check>', '[PUTOBJBACK] <mouse>', '[FIND] <keyboard>', '[TYPE] <keyboard>']
}

Input:
Scene_Objects:['dry_pasta', 'pot', 'food_pizza', 'toilet', 'freezer', 'nail_polish', 'detergent', 'longboard', 'floor', 'ceiling', 'bedroom', 'computer', 'ceilinglamp', 'tvstand', 'faucet', 'mousepad', 'couch', 'food_peanut_butter', 'form', 'wall', 'nightstand', 'oven', 'food_food', 'ice', 'after_shave', 'doorjamb', 'lighter', 'coffee_pot', 'mouse', 'spoon']
Task:Put groceries in Fridge
response:

[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:['blender', 'wallshelf', 'hanger', 'floor', 'phone', 'ceiling', 'clothes_jacket', 'table_cloth', 'mat', 'floor_lamp', 'window', 'couch', 'pillow', 'wall', 'nightstand', 'light_bulb', 'novel', 'mouthwash', 'television', 'ice', 'curtain', 'after_shave', 'doorjamb', 'console', 'kettle', 'conditioner', 'bathtub', 'sink', 'table', 'vase']
Task:Read book
response:
{
    "thoughts": A person brings a book into the living room and sits down in a comfortable chair.  If it is dark in the room the person turns on the lamp. The book is opened to the next page to be read.  The person begins reading the book until they need to stop for some reason.,
    "actions": ['[WALK] <home_office>', '[WALK] <novel>', '[FIND] <novel>', '[GRAB] <novel>', '[FIND] <couch>', '[SIT] <couch>', '[FIND] <floor_lamp>', '[SWITCHON] <floor_lamp>', '[READ] <novel>']
}

Input:
Scene_Objects:['sponge', 'pot', 'mop', 'band-aids', 'walllamp', 'trashcan', 'ceilingfan', 'knifeblock', 'kitchen_cabinet', 'floor', 'ceiling', 'bathroom_counter', 'desk', 'computer', 'stovefan', 'toaster', 'deck_of_cards', 'shower', 'wall', 'pasta', 'oven', 'cup', 'water', 'tray', 'doorjamb', 'shaving_cream', 'kitchen_counter', 'sauce_pan', 'cupboard', 'dishwasher']
Task:Cook some food
response:

[WALK] <dining_room>
[WALK] <kitchen_cabinet>
[FIND] <kitchen_cabinet>
[OPEN] <kitchen_cabinet>
[FIND] <pasta>
[GRAB] <pasta>
[FIND] <water>
[GRAB] <water>
[FIND] <sauce_pan>
[POUR] <water> <sauce_pan>
[FIND] <oven>
[SWITCHON] <oven>
[PUTBACK] <pasta> <sauce_pan>
[FIND] <sauce_pan>
[GRAB] <sauce_pan>
[PUTBACK] <sauce_pan> <oven>


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

Here is an example plan to achieve a goal for reference:
Scene_Objects:['microwave', 'freezer', 'walllamp', 'bathroom', 'dough', 'wallshelf', 'floor', 'ceiling', 'bedroom', 'bookmark', 'stovefan', 'brush', 'deck_of_cards', 'faucet', 'window', 'closetdrawer', 'dining_room', 'wall', 'oven', 'cutting_board', 'cup', 'bed', 'coffe_maker', 'food_food', 'tray', 'shaving_cream', 'kitchen_counter', 'chessboard', 'clothes_dress', 'conditioner']
Task:Drink
response:
{
    "thoughts": Walk into kitchen, look for cup, walk to cup, look for refrigerator, walk to refrigerator, open door, grab water, pour water into cup,
    "actions": ['[WALK] <dining_room>', '[WALK] <cup>', '[FIND] <cup>', '[TURNTO] <cup>', '[LOOKAT] <cup>', '[WALK] <cup>', '[FIND] <freezer>', '[TURNTO] <freezer>', '[LOOKAT] <freezer>', '[WALK] <freezer>', '[GRAB] <cup>', '[WALK] <water>', '[FIND] <water>', '[GRAB] <water>', '[POUR] <water> <cup>']
}

Input:
Scene_Objects:['pot', 'filing_cabinet', 'freezer', 'detergent', 'food_butter', 'ceilingfan', 'drawing', 'orchid', 'clothes_underwear', 'floor', 'ceiling', 'dvd_player', 'character', 'bedroom', 'remote_control', 'ceilinglamp', 'tvstand', 'balanceball', 'window', 'couch', 'wall', 'nightstand', 'bench', 'coffe_maker', 'television', 'curtain', 'console', 'kitchen_counter', 'door', 'table']
Task:Watch TV
response:

Walk to the living room. Sit on the sofa. Grab the remote and turn on the television.

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


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

Here is an example plan to achieve a goal for reference:
Scene_Objects:['juice', 'crayon', 'walllamp', 'trashcan', 'dough', 'floor', 'phone', 'bedroom', 'tea_bag', 'toaster', 'mat', 'plate', 'ceilinglamp', 'dish_soap', 'wall', 'pasta', 'oven', 'cutting_board', 'food_cheese', 'newspaper', 'coffe_maker', 'check', 'food_food', 'tray', 'towel_rack', 'pencil', 'dresser', 'conditioner', 'home_office', 'dishwasher']
Task:Wash dishes with dishwasher
response:
{
    "thoughts": I walk to the kitchen. I search and find dishwasher. I search dishes. I put dishes inside the dishwasher. I put dish soap in dishwasher. I switch on dishwasher and wait for dishes to be washed.,
    "actions": ['[WALK] <dining_room>', '[WALK] <dishwasher>', '[FIND] <dishwasher>', '[FIND] <plate>', '[GRAB] <plate>', '[OPEN] <dishwasher>', '[PUTBACK] <plate> <dishwasher>', '[FIND] <dish_soap>', '[GRAB] <dish_soap>', '[PUTBACK] <dish_soap> <dishwasher>', '[CLOSE] <dishwasher>', '[SWITCHON] <dishwasher>']
}

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

I need to finish some work on my computer in my home office to meet a deadline for tomorrow.

[WALK] <home_office>
[WALK] <light>
[FIND] <light>
[SWITCHON] <light>
[FIND] <keyboard>
[GRAB] <keyboard>
[FIND] <desk>
[OPEN] <desk>
[PUTBACK] <keyboard> <desk>
[FIND] <mouse>
[GRAB] <mouse>
[FIND] <mousepad>
[PUTBACK] <mouse> <mousepad>
[PLUGIN] <keyboard>
[PLUGIN] <mouse>
[FIND] <computer>
[SWITCHON] <computer>
[FIND] <chair>
[SIT] <chair>
[TURNTO] <computer>
[TYPE] <keyboard>
[GRAB] <mouse>
[TOUCH] <mouse>
[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:['microwave', 'freezer', 'walllamp', 'bathroom', 'orchid', 'wallshelf', 'bathroom_counter', 'floor', 'ceiling', 'dvd_player', 'character', 'bookshelf', 'toaster', 'mat', 'tvstand', 'ceilinglamp', 'shower', 'window', 'laptop', 'couch', 'wall', 'powersocket', 'photoframe', 'television', 'curtain', 'doorjamb', 'lighter', 'dresser', 'sink', '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:['pot', 'scissors', 'juice', 'toilet', 'bills', 'drawing', 'cpuscreen', 'bathroom_counter', 'floor', 'character', 'desk', 'keyboard', 'bookshelf', 'table_cloth', 'brush', 'window', 'mousepad', 'clothes_hat', 'wall', 'nightstand', 'photoframe', 'razor', 'tray', 'mouse', 'cd', 'table', 'dishwasher', 'colander', 'scrabble', 'teeth']
Task:Go to toilet
response:

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


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

Here is an example plan to achieve a goal for reference:
Scene_Objects:['glue', 'walllamp', 'ceilingfan', 'drawing', 'hanger', 'floor', 'bedroom', 'computer', 'ceilinglamp', 'deck_of_cards', 'iron', 'window', 'electric_shaver', 'couch', 'food_orange', 'wall', 'wall_clock', 'bed', 'novel', 'check', 'television', 'toothbrush_holder', 'wooden_spoon', 'after_shave', 'towel_rack', 'dresser', 'conditioner', 'maindoor', 'table', 'vase']
Task:Relax on sofa
response:
{
    "thoughts": Walk to the living room. Find the sofa. Walk to the sofa. Lie in the sofa.,
    "actions": ['[WALK] <home_office>', '[WALK] <couch>', '[FIND] <couch>', '[WALK] <couch>', '[LIE] <couch>']
}

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

walk to kitchen, walk to table, grab water glass and drink water

[WALK] <dining_room>
[WALK] <table>
[FIND] <water_glass>
[GRAB] <water_glass>
[DRINK] <water_glass>
[PUTBACK] <water_glass> <table>


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', '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:
{
    "thoughts": Text while sitting,
    "actions": ['[WALK] <home_office>', '[WALK] <phone>', '[FIND] <phone>', '[GRAB] <phone>', '[WALK] <couch>', '[SIT] <couch>', '[TURNTO] <phone>', '[LOOKAT] <phone>', '[TOUCH] <phone>']
}

Input:
Scene_Objects:['blow_dryer', 'trashcan', 'drawing', 'needle', 'bathroom_counter', 'floor', 'ceiling', 'clothes_jacket', 'brush', 'tvstand', 'faucet', 'balanceball', 'iron', 'wall', 'bench', 'photoframe', 'check', 'razor', 'television', 'food_rice', 'console', 'hairdryer', 'sink', 'clothes_scarf', 'bathroom_cabinet', 'instrument_guitar', 'home_office', 'vase', 'teeth', 'shoe_rack']
Task:Wash teeth
response:

Walk to bathroom.  Find mouthwash or turn on water.  Put mouthwash or water in mouth.  Swish around for 30 seconds.  Spit mouthwash out.

[WALK] <bathroom>
[WALK] <faucet>
[FIND] <faucet>
[SWITCHON] <faucet>
[FIND] <teeth>
[RINSE] <teeth>


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

Here is an example plan to achieve a goal for reference:
Scene_Objects:['pot', 'chair', 'freezer', 'drawing', 'needle', 'cpuscreen', 'hanger', 'floor', 'ceiling', 'desk', 'bookshelf', 'envelope', 'computer', 'ceilinglamp', 'mousepad', 'closetdrawer', 'couch', 'dustpan', 'dining_room', 'wall', 'nightstand', 'powersocket', 'food_food', 'toilet_paper', 'doorjamb', 'coffee_pot', 'mouse', 'kettle', 'dresser', 'light']
Task:Turn on light
response:
{
    "thoughts": walk into living room, walk to light, turn on light switch.,
    "actions": ['[WALK] <home_office>', '[WALK] <light>', '[SWITCHON] <light>']
}

Input:
Scene_Objects:['sheets', 'toilet', 'freezer', 'cat', 'orchid', 'floor', 'ceiling', 'phone', 'desk', 'keyboard', 'bookshelf', 'computer', 'stovefan', 'ceilinglamp', 'tvstand', 'balanceball', 'oil', 'couch', 'clothes_hat', 'wall', 'basket_for_clothes', 'food_food', 'coffe_maker', 'curtain', 'doorjamb', 'towel_rack', 'comb', 'dresser', 'maindoor', 'soap']
Task:Put groceries in Fridge
response:

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


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

Here is an example plan to achieve a goal for reference:
Scene_Objects:['chair', 'walllamp', 'drawing', 'cpuscreen', 'wallshelf', 'bathroom_counter', 'floor', 'ceiling', 'desk', 'keyboard', 'computer', 'toaster', 'ceilinglamp', 'tvstand', 'stovefan', 'mousepad', 'wall', 'wall_clock', 'powersocket', 'nightstand', 'tape', 'newspaper', 'bed', 'television', 'doorjamb', 'mouse', 'sink', 'home_office', 'table', 'light']
Task:Work
response:
{
    "thoughts": Walk to home office. Sit on chair. Switch on computer. type in keyboard.,
    "actions": ['[WALK] <home_office>', '[WALK] <chair>', '[FIND] <chair>', '[SIT] <chair>', '[FIND] <computer>', '[SWITCHON] <computer>', '[FIND] <keyboard>', '[TYPE] <keyboard>']
}

Input:
Scene_Objects:['spectacles', 'pot', 'tea', 'freezer', 'walllamp', 'trashcan', 'food_carrot', 'drawing', 'knifeblock', 'kitchen_cabinet', 'floor', 'ceiling', 'food_chicken', 'folder', 'stovefan', 'ceilinglamp', 'toaster', 'microphone', 'wall', 'bench', 'oven', 'cup', 'food_food', 'tray', 'doorjamb', 'kitchen_counter', 'cupboard', 'controller', 'table', 'dishwasher']
Task:Cook some food
response:

Walk to the kitchen and open the fridge. From the fridge take some chicken and close the fridge. Walk to the table and put the chicken on the table. Plug in oven and put the chicken into the oven.

[WALK] <dining_room>
[WALK] <freezer>
[FIND] <freezer>
[OPEN] <freezer>
[FIND] <food_chicken>
[GRAB] <food_chicken>
[CLOSE] <freezer>
[WALK]

[PUTBACK] <food_chicken>

[FIND] <kitchen_cabinet>
[OPEN] <kitchen_cabinet>
[FIND] <pot>
[GRAB] <pot>
[PUTBACK] <pot>

[FIND] <oven>
[PLUGIN] <oven>
[OPEN] <oven>
[GRAB] <food_chicken>
[PUTIN] <food_chicken> <oven>


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

Here is an example plan to achieve a goal for reference:
Scene_Objects:['sheets', 'ceilingfan', 'drawing', 'bathroom_counter', 'floor', 'ceiling', 'folder', 'bedroom', 'remote_control', 'toaster', 'ceilinglamp', 'tvstand', 'balanceball', 'plate', 'window', 'oil', 'couch', 'clothes_hat', 'pillow', 'wall', 'nightstand', 'coffe_maker', 'television', 'curtain', 'food_onion', 'controller', 'clothes_dress', 'table', 'clothes_skirt', 'light']
Task:Watch TV
response:
{
    "thoughts": I get home from work and decide to watch tv. I go to the living room and turn on the tv. I sit on the couch and use the remote to switch the channels to find what I want to watch.,
    "actions": ['[WALK] <home_office>', '[WALK] <home_office>', '[WALK] <television>', '[FIND] <television>', '[SWITCHON] <television>', '[WALK] <couch>', '[SIT] <couch>', '[TURNTO] <television>', '[LOOKAT] <television>', '[FIND] <remote_control>', '[GRAB] <remote_control>']
}

Input:
Scene_Objects:['filing_cabinet', 'food_ice_cream', 'bathroom', 'trashcan', 'knife', 'drawing', 'bathroom_counter', 'floor', 'ceiling', 'phone', 'desk', 'keyboard', 'food_bacon', 'tvstand', 'faucet', 'oil', 'clothes_pants', 'wall', 'oven', 'photoframe', 'newspaper', 'after_shave', 'shaving_cream', 'sink', 'bathroom_cabinet', 'light', 'clothes_skirt', 'table', 'soap', 'hands_both']
Task:Wash hands
response:

Walk to the sink, turn on the faucet, put soap on hands, rub hands together under the water, rinse off hands, turn off faucet, dry hands

[WALK] <bathroom>
[WALK] <sink>
[FIND] <sink>
[WALK] <sink>
[FIND] <soap>
[FIND] <faucet>
[SWITCHON] <faucet>
[FIND] <hands_both>
[WASH] <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:['sheets', 'blender', 'food_salt', 'crayon', 'tea', 'cat', 'milk', 'knifeblock', 'hanger', 'shampoo', 'bedroom', 'bookshelf', 'computer', 'brush', 'stovefan', 'toaster', 'foundation', 'window', 'mousepad', 'clothes_pants', 'clothes_hat', 'tape', 'bed', 'coffe_maker', 'food_onion', 'after_shave', 'dresser', 'light', 'dishwasher', 'laser_pointer']
Task:Pet cat
response:
{
    "thoughts": Every time this animal is seen, you must approach it and show compassion for it by petting it in a gentle manner.,
    "actions": ['[WALK] <home_office>', '[WALK] <bedroom>', '[WALK] <bedroom>', '[WALK] <home_office>', '[WALK] <home_office>', '[WALK] <cat>', '[FIND] <cat>', '[FIND] <brush>', '[GRAB] <brush>']
}

Input:
Scene_Objects:['mop', 'toilet', 'ceilingfan', 'orchid', 'drawing', 'cpuscreen', 'knifeblock', 'bathroom_counter', 'floor', 'desk', 'keyboard', 'food_cake', 'clothes_jacket', 'table_cloth', 'stovefan', 'mousepad', 'pillow', 'dining_room', 'wall', 'nightstand', 'cup', 'photoframe', 'clothes_gloves', 'light_bulb', 'toilet_paper', 'coin', 'ice', 'mouse', 'cupboard', 'vase']
Task:Go to toilet
response:

I walk into the bath room and go to the toilet

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


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

Here is an example plan to achieve a goal for reference:
Scene_Objects:['sponge', 'pot', 'tablelamp', 'ground_coffee', 'walllamp', 'trashcan', 'knifeblock', 'longboard', 'floor', 'ceiling', 'character', 'bookmark', 'toaster', 'tvstand', 'wall', 'clothes_gloves', 'keys', 'coffe_maker', 'check', 'video_game_controller', 'coffee_filter', 'toilet_paper', 'food_onion', 'curtain', 'kitchen_counter', 'controller', 'hairdryer', 'dishwasher', 'vase', 'soap']
Task:Make coffee
response:
{
    "thoughts": You walk into the kitchen and turn to the coffee maker. You grab the coffee filter and put into the coffee machine, you also grab the ground coffee and put it into the coffee machine. You turn on the coffee machine.,
    "actions": ['[WALK] <dining_room>', '[WALK] <coffe_maker>', '[FIND] <coffe_maker>', '[TURNTO] <coffe_maker>', '[FIND] <coffee_filter>', '[GRAB] <coffee_filter>', '[OPEN] <coffe_maker>', '[PUTBACK] <coffee_filter> <coffe_maker>', '[FIND] <ground_coffee>', '[GRAB] <ground_coffee>', '[PUTBACK] <ground_coffee> <coffe_maker>', '[SWITCHON] <coffe_maker>']
}

Input:
Scene_Objects:['fork', 'tablelamp', 'walllamp', 'bathroom', 'trashcan', 'food_carrot', 'clothes_underwear', 'floor', 'desk', 'toaster', 'plate', 'shower', 'tvstand', 'food_noodles', 'clothes_socks', 'mousepad', 'wall', 'oven', 'cup', 'newspaper', 'coffe_maker', 'toilet_paper', 'food_donut', 'water', 'tray', 'food_onion', 'lighter', 'maindoor', 'spoon', 'dishwasher']
Task:Wash dishes with dishwasher
response:

first i will take all the dishes to the dish washer and with the help of dishwasher and water i will clean all the dishes

[WALK] <dining_room>
[WALK] <dishwasher>
[FIND] <dishwasher>
[OPEN] <dishwasher>
[FIND] <fork>
[GRAB] <fork>
[PUTBACK] <fork> <dishwasher>
[FIND] <plate>
[GRAB] <plate>
[PUTBACK] <plate> <dishwasher>
[FIND] <spoon>
[GRAB] <spoon>
[PUTBACK] <spoon> <dishwasher>
[FIND] <water>
[TURNTO] <water>
[CLOSE] <dishwasher>
[SWITCHON] <dishwasher>