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', 'beer', 'microwave', 'ceilingfan', 'food_carrot', 'drawing', 'floor', 'ceiling', 'phone', 'bedroom', 'toaster', 'ceilinglamp', 'tvstand', 'balanceball', 'plate', 'window', 'mat', 'oil', 'couch', 'dining_room', 'wall', 'bed', 'light_bulb', 'coffe_maker', 'television', 'curtain', 'kettle', 'door', 'napkin', 'table']
Task:Relax on sofa
response:
{
    "thoughts": I walk to my living room and switch on the television, and lay on the sofa.,
    "actions": ['[WALK] <home_office>', '[WALK] <television>', '[FIND] <television>', '[SWITCHON] <television>', '[FIND] <couch>', '[LIE] <couch>']
}

Input:
Scene_Objects:['tablelamp', 'toilet', 'chair', 'bathroom', 'trashcan', 'ceilingfan', 'food_carrot', 'drawing', 'cpuscreen', 'hanger', 'floor', 'ceiling', 'phone', 'desk', 'keyboard', 'bookshelf', 'purse', 'computer', 'table_cloth', 'brush', 'ceilinglamp', 'balanceball', 'mousepad', 'wall', 'nightstand', 'doorjamb', 'mouse', 'napkin', 'light', 'vase']
Task:Wash monitor
response:

Clean the grime off of my monitor screen when not in use

[WALK] <home_office>
[WALK] <computer>
[FIND] <computer>
[TURNTO] <computer>
[LOOKAT] <computer>
[SWITCHOFF] <computer>
[FIND] <brush>
[TURNTO] <brush>
[LOOKAT] <brush>
[GRAB] <brush>
[WIPE] <computer>
[DROP] <brush>
[FIND] <napkin>
[GRAB] <napkin>
[WASH] <napkin>
[WIPE] <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:['chair', 'walllamp', 'drawing', 'wallshelf', 'floor', 'ceiling', 'desk', 'keyboard', 'bookshelf', 'mat', 'ceilinglamp', 'tvstand', 'faucet', 'shower', 'mousepad', 'couch', 'pillow', 'dining_room', 'wall', 'powersocket', 'food_food', 'television', 'doorjamb', 'mouse', 'cupboard', 'conditioner', 'door', 'bathroom_cabinet', 'light', 'table']
Task:Look at painting
response:
{
    "thoughts": Walk to the painting.  Look up at the painting.  Admire it on the wall.,
    "actions": ['[WALK] <home_office>', '[WALK] <drawing>', '[FIND] <drawing>', '[TURNTO] <drawing>', '[LOOKAT] <drawing>']
}

Input:
Scene_Objects:['microwave', 'detergent', 'drawing', 'hanger', 'floor', 'ceiling', 'phone', 'bookshelf', 'purse', 'food_cake', 'computer', 'ceilinglamp', 'mat', 'electric_shaver', 'pillow', 'dining_room', 'wall', 'toy', 'cup', 'television', 'vacuum_cleaner', 'shoes', 'comb', 'dresser', 'cupboard', 'food_steak', 'hairdryer', 'sink', 'bathroom_cabinet', 'dishwasher']
Task:Clean room
response:

Pick up his toys, vacuum the garbage off the floor.

[WALK] <bedroom>
[WALK] <toy>
[FIND] <toy>
[GRAB] <toy>
[WALK] <dresser>
[OPEN] <dresser>
[PUTBACK] <toy> <dresser>
[FIND] <toy>
[GRAB] <toy>
[WALK] <dresser>
[PUTBACK] <toy> <dresser>
[CLOSE] <dresser>
[WALK] <dresser>
[FIND] <vacuum_cleaner>
[GRAB] <vacuum_cleaner>
[PULL] <vacuum_cleaner>
[PLUGIN] <vacuum_cleaner>
[SWITCHON] <vacuum_cleaner>
[PULL] <vacuum_cleaner>
[PUSH] <vacuum_cleaner>
[PULL] <vacuum_cleaner>
[PUSH] <vacuum_cleaner>
[PULL] <vacuum_cleaner>
[PUSH] <vacuum_cleaner>
[SWITCHOFF] <vacuum_cleaner>
[PLUGOUT] <vacuum_cleaner>
[WALK] <dresser>
[OPEN] <dresser>
[PUTIN] <vacuum_cleaner> <dresser>
[CLOSE] <dresser>


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:['ironing_board', 'sheets', 'tablelamp', 'detergent', 'knifeblock', 'bathroom_counter', 'phone', 'desk', 'keyboard', 'computer', 'ceilinglamp', 'tvstand', 'iron', 'window', 'couch', 'pillow', 'bowl', 'nightstand', 'food_cheese', 'video_game_controller', 'tray', 'curtain', 'doorjamb', 'towel_rack', 'kitchen_counter', 'pajamas', 'bag', 'dishwasher', 'board_game', 'clothes_shirt']
Task:Iron shirt
response:
{
    "thoughts": Set up an ironing board and an iron.  Lay a shirt on board.  Run iron over shirt until it is free of wrinkles.,
    "actions": ['[WALK] <bedroom>', '[WALK] <ironing_board>', '[FIND] <ironing_board>', '[FIND] <clothes_shirt>', '[GRAB] <clothes_shirt>', '[PUTBACK] <clothes_shirt> <ironing_board>', '[FIND] <iron>', '[GRAB] <iron>', '[PLUGIN] <iron>', '[PLUGOUT] <iron>', '[PUTOBJBACK] <iron>']
}

Input:
Scene_Objects:['filing_cabinet', 'blender', 'crayon', 'toilet', 'chair', 'freezer', 'drawing', 'hanger', 'floor', 'ceiling', 'bookshelf', 'computer', 'clothes_jacket', 'ceilinglamp', 'window', 'pillow', 'wall', 'pasta', 'powersocket', 'toy', 'box', 'cup', 'check', 'coffe_maker', 'toothbrush_holder', 'doorjamb', 'dresser', 'door', 'light', 'scrabble']
Task:Pick up toys
response:

Pickup toys from around the room. Organize toys back into their appropriate spaces on the shelves and into the toy boxes.

[WALK] <bedroom>
[WALK] <toy>
[FIND] <toy>
[GRAB] <toy>
[WALK] <filing_cabinet>
[OPEN] <filing_cabinet>
[PUTBACK] <toy> <filing_cabinet>
[CLOSE] <filing_cabinet>
[FIND] <toy>
[GRAB] <toy>
[WALK] <dresser>
[OPEN] <dresser>
[PUTBACK] <toy> <dresser>
[CLOSE] <dresser>
[FIND] <toy>
[GRAB] <toy>
[WALK] <filing_cabinet>
[OPEN] <filing_cabinet>
[PUTBACK] <toy> <filing_cabinet>
[CLOSE] <filing_cabinet>


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

Here is an example plan to achieve a goal for reference:
Scene_Objects:['pot', 'tablelamp', 'crayon', 'microwave', 'dog', 'band-aids', 'walllamp', 'trashcan', 'knifeblock', 'orchid', 'floor', 'desk', 'bookshelf', 'computer', 'piano_bench', 'plate', 'faucet', 'dish_soap', 'food_jam', 'form', 'wall', 'photoframe', 'doorjamb', 'kettle', 'kitchen_counter', 'dishrack', 'cupboard', 'pajamas', 'sink', 'table']
Task:Wash dishes by hand
response:
{
    "thoughts": Walk to the kitchen and turn to the sink. Put the plate into the sink. Grab and squeeze the dish soap. Scrub the plate then rinse it. Put the plate into the dish rack.,
    "actions": ['[WALK] <dining_room>', '[WALK] <sink>', '[FIND] <sink>', '[TURNTO] <sink>', '[FIND] <plate>', '[GRAB] <plate>', '[PUTBACK] <plate> <sink>', '[FIND] <dish_soap>', '[GRAB] <dish_soap>', '[SQUEEZE] <dish_soap>', '[SCRUB] <plate>', '[RINSE] <plate>', '[GRAB] <plate>', '[FIND] <dishrack>', '[PUTBACK] <plate> <dishrack>']
}

Input:
Scene_Objects:['filing_cabinet', 'chair', 'band-aids', 'freezer', 'trashcan', 'drawing', 'orchid', 'cpuscreen', 'floor', 'ceiling', 'desk', 'keyboard', 'envelope', 'computer', 'bookmark', 'brush', 'ceilinglamp', 'mat', 'electric_shaver', 'mousepad', 'towel', 'wall', 'powersocket', 'light_bulb', 'novel', 'curtain', 'doorjamb', 'mouse', 'door', 'light', 'colander', 'board_game']
Task:Read to child
response:

[WALK] <bedroom>
[WALK] <child>
[FIND] <child>
[GREET] <child>
[WALK] <filing_cabinet>
[OPEN] <filing_cabinet>
[FIND] <novel>
[GRAB] <novel>
[WALK] <chair>
[PULL] <chair>
[SIT] <chair>
[TURNTO] <novel>
[LOOKAT] <novel>
[TURNTO] <novel>
[POINTAT] <novel>
[TURNTO] <novel>
[POINTAT] <novel>
[READ] <novel>
[READ] <novel>
[READ] <novel>


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

Here is an example plan to achieve a goal for reference:
Scene_Objects:['filing_cabinet', 'chair', 'walllamp', 'bathroom', 'drawing', 'orchid', 'cpuscreen', 'floor', 'ceiling', 'dvd_player', 'desk', 'keyboard', 'computer', 'ceilinglamp', 'tvstand', 'faucet', 'mat', 'mousepad', 'wall', 'nightstand', 'powersocket', 'coffe_maker', 'check', 'television', 'wine', 'doorjamb', 'mouse', 'cupboard', 'controller', 'table']
Task:Browse internet
response:
{
    "thoughts": I go to my desk. I turn on the computer. I open a web page and look at it.,
    "actions": ['[WALK] <home_office>', '[WALK] <computer>', '[FIND] <computer>', '[SWITCHON] <computer>', '[TURNTO] <computer>', '[LOOKAT] <computer>']
}

Input:
Scene_Objects:['bathroom', 'detergent', 'cat', 'knife', 'food_egg', 'character', 'stamp', 'bedroom', 'desk', 'mat', 'ceilinglamp', 'shower', 'faucet', 'stereo', 'window', 'oil', 'mousepad', 'clothes_hat', 'towel', 'pillow', 'dining_room', 'powersocket', 'coin', 'console', 'towel_rack', 'dishrack', 'cupboard', 'maindoor', 'sink', 'bag']
Task:Keep cats out of room
response:

Stand in the doorway and create a loud noise so the cats will stay out.

[WALK] <bedroom>
[WALK] <cat>
[FIND] <cat>
[TURNTO] <cat>
[LOOKAT] <cat>
[FIND] <cat>
[TURNTO] <cat>
[LOOKAT] <cat>


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

Here is an example plan to achieve a goal for reference:
Scene_Objects:['spectacles', 'tablelamp', 'beer', 'chair', 'walllamp', 'bathroom', 'wallshelf', 'floor', 'ceiling', 'ceilinglamp', 'mat', 'stereo', 'couch', 'pillow', 'bowl', 'wall', 'nightstand', 'powersocket', 'cup', 'toilet_paper', 'television', 'after_shave', 'rag', 'doorjamb', 'coffee_pot', 'dishrack', 'instrument_guitar', 'table', 'soap', 'laser_pointer']
Task:Relax on sofa
response:
{
    "thoughts": walk to living room, walk to sofa, sit in sofa,
    "actions": ['[WALK] <home_office>', '[WALK] <couch>', '[SIT] <couch>']
}

Input:
Scene_Objects:['glue', 'filing_cabinet', 'food_pizza', 'knifeblock', 'bathroom_counter', 'floor', 'ceiling', 'cleaning_solution', 'mail', 'brush', 'toaster', 'tvstand', 'balanceball', 'window', 'food_noodles', 'mousepad', 'food_peanut_butter', 'clothes_hat', 'dining_room', 'pasta', 'bench', 'photoframe', 'oven_mitts', 'ice', 'rag', 'dresser', 'cupboard', 'food_steak', 'maindoor', 'table']
Task:Clean  mirror
response:

GET CLEANING CLOTH, SPRAY CLEANER ON CLOTH, CLEAN MIRROR

[WALK] <bathroom>
[WALK] <cleaning_solution>
[FIND] <cleaning_solution>
[GRAB] <cleaning_solution>
[FIND] <rag>
[GRAB] <rag>
[POUR] <cleaning_solution> <rag>
[PUTOBJBACK] <cleaning_solution>
[WALK] <mirror>
[WIPE] <mirror>
[WIPE] <mirror>
[WIPE] <mirror>
[PUTOBJBACK] <rag>


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

Here is an example plan to achieve a goal for reference:
Scene_Objects:['tablelamp', 'chair', 'walllamp', 'detergent', 'cpuscreen', 'hanger', 'floor', 'ceiling', 'character', 'desk', 'keyboard', 'computer', 'button', 'toaster', 'ceilinglamp', 'tvstand', 'mousepad', 'closetdrawer', 'broom', 'wall', 'pasta', 'powersocket', 'shelf', 'check', 'television', 'doorjamb', 'mouse', 'dresser', 'light', 'table']
Task:Work
response:
{
    "thoughts": I walk to the living room. I find the computer and turn it on. I look at the computer screen. I move and click the mouse to select buttons on the screen.,
    "actions": ['[WALK] <home_office>', '[WALK] <computer>', '[FIND] <computer>', '[SWITCHON] <computer>', '[TURNTO] <computer>', '[LOOKAT] <computer>', '[FIND] <mouse>', '[PUSH] <mouse>', '[FIND] <button>', '[PUSH] <button>']
}

Input:
Scene_Objects:['sheets', 'tablelamp', 'toilet', 'trashcan', 'ceilingfan', 'drawing', 'cpuscreen', 'hanger', 'floor', 'ceiling', 'desk', 'keyboard', 'computer', 'table_cloth', 'ceilinglamp', 'tvstand', 'balanceball', 'window', 'mousepad', 'couch', 'pillow', 'broom', 'wall', 'nightstand', 'television', 'ice', 'curtain', 'mouse', 'maindoor', 'table']
Task:Straighten paintings on wall
response:

Go up to the painting and tilt it which ever way it is uneven until it looks straight.

[WALK] <home_office>
[WALK] <wall>
[WALK] <drawing>
[FIND] <drawing>
[TURNTO] <drawing>
[LOOKAT] <drawing>
[TOUCH] <drawing>
[PULL] <drawing>
[PUSH] <drawing>
[WALK] <drawing>
[FIND] <drawing>
[TURNTO] <drawing>
[LOOKAT] <drawing>
[TOUCH] <drawing>
[PULL] <drawing>
[PUSH] <drawing>
[WALK] <drawing>
[FIND] <drawing>
[TURNTO] <drawing>
[LOOKAT] <drawing>
[TOUCH] <drawing>
[PULL] <drawing>
[PUSH] <drawing>
[TURNTO] <drawing>
[LOOKAT] <drawing>
[TURNTO] <drawing>
[LOOKAT] <drawing>
[TURNTO] <drawing>
[LOOKAT] <drawing>


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

Here is an example plan to achieve a goal for reference:
Scene_Objects:['tablelamp', 'measuring_cup', 'chair', 'orchid', 'drawing', 'cpuscreen', 'wallshelf', 'floor', 'ceiling', 'desk', 'tea_bag', 'keyboard', 'bookshelf', 'computer', 'alcohol', 'stovefan', 'mat', 'ceilinglamp', 'tvstand', 'stereo', 'floor_lamp', 'mousepad', 'wall', 'nightstand', 'novel', 'video_game_controller', 'television', 'mouse', 'door', 'napkin']
Task:Study
response:
{
    "thoughts": Study norwegian,
    "actions": ['[WALK] <home_office>', '[WALK] <floor_lamp>', '[FIND] <floor_lamp>', '[SWITCHON] <floor_lamp>', '[FIND] <novel>', '[GRAB] <novel>', '[FIND] <chair>', '[SIT] <chair>', '[READ] <novel>']
}

Input:
Scene_Objects:['toilet', 'drawing', 'bathroom_counter', 'floor', 'ceiling', 'bedroom', 'cleaning_solution', 'faucet', 'balanceball', 'window', 'clothes_socks', 'food_orange', 'wall', 'powersocket', 'bench', 'cutting_board', 'photoframe', 'novel', 'check', 'rag', 'lighter', 'mouse', 'kitchen_counter', 'hair', 'sink', 'bathroom_cabinet', 'home_office', 'tooth_paste', 'scrabble', 'dirt']
Task:Wash sink
response:

[WALK] <bathroom>
[WALK] <cleaning_solution>
[FIND] <cleaning_solution>
[GRAB] <cleaning_solution>
[FIND] <sink>
[POUR] <cleaning_solution> <sink>
[FIND] <faucet>
[SWITCHON] <faucet>
[SCRUB] <sink>
[WASH] <sink>


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

Here is an example plan to achieve a goal for reference:
Scene_Objects:['microwave', 'chair', 'walllamp', 'wallshelf', 'ceiling', 'phone', 'keyboard', 'thread', 'piano_bench', 'brush', 'mat', 'ceilinglamp', 'window', 'oil', 'closetdrawer', 'mousepad', 'food_peanut_butter', 'candle', 'nightstand', 'powersocket', 'newspaper', 'novel', 'television', 'doorjamb', 'kitchen_counter', 'comb', 'cupboard', 'home_office', 'table', 'instrument_violin']
Task:Turn on light
response:
{
    "thoughts": Twist the lamp switch until the light goes on.,
    "actions": ['[WALK] <home_office>', '[WALK] <floor_lamp>', '[FIND] <floor_lamp>', '[SWITCHON] <floor_lamp>']
}

Input:
Scene_Objects:['tablelamp', 'microwave', 'dog', 'blow_dryer', 'trashcan', 'orchid', 'bathroom_counter', 'longboard', 'ceiling', 'character', 'bedroom', 'computer', 'mop_bucket', 'stereo', 'shower', 'window', 'food_peanut_butter', 'food_orange', 'bench', 'oven', 'bed', 'toilet_paper', 'television', 'razor', 'curtain', 'towel_rack', 'cupboard', 'door', 'dishwasher', 'soap']
Task:Put umbrella away
response:

Place the umbrella in the umbrella bucket point first.

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


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

Here is an example plan to achieve a goal for reference:
Scene_Objects:['sheets', 'pot', 'tablelamp', 'microwave', 'detergent', 'clothes_underwear', 'ceiling', 'character', 'desk', 'mail', 'table_cloth', 'bookmark', 'shoe-shine_kit', 'faucet', 'electric_shaver', 'mousepad', 'candle', 'food_jam', 'food_orange', 'nightstand', 'powersocket', 'newspaper', 'coin', 'food_onion', 'pencil', 'dresser', 'home_office', 'dishwasher', 'tooth_paste', 'coffee']
Task:Browse internet
response:
{
    "thoughts": The task is browse and surf on the internet regarding a particular topic,
    "actions": ['[WALK] <bedroom>', '[WALK] <laptop>', '[FIND] <laptop>', '[SWITCHON] <laptop>', '[TURNTO] <laptop>', '[LOOKAT] <laptop>', '[WATCH] <laptop>']
}

Input:
Scene_Objects:['walllamp', 'drawing', 'hanger', 'bathroom_counter', 'floor', 'ceiling', 'folder', 'bedroom', 'bookshelf', 'computer', 'ceilinglamp', 'deck_of_cards', 'pillow', 'dining_room', 'wall', 'bench', 'toy', 'box', 'photoframe', 'clothes_gloves', 'novel', 'video_game_controller', 'cards', 'vacuum_cleaner', 'dresser', 'controller', 'maindoor', 'napkin', 'dishwasher', 'instrument_violin']
Task:Pick up toys
response:

Bend down and pick up the toys off of the floor.

[WALK] <bedroom>
[WALK] <toy>
[FIND] <toy>
[GRAB] <toy>
[WALK] <dresser>
[OPEN] <dresser>
[PUTIN] <toy> <dresser>
[FIND] <toy>
[GRAB] <toy>
[WALK] <dresser>
[PUTIN] <toy> <dresser>
[FIND] <toy>
[WALK] <dresser>
[GRAB] <toy>
[PUTIN] <toy> <dresser>
[CLOSE] <dresser>


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

Here is an example plan to achieve a goal for reference:
Scene_Objects:['dry_pasta', 'scissors', 'crayon', 'toilet', 'jelly', 'walllamp', 'nail_polish', 'detergent', 'food_cake', 'alcohol', 'piano_bench', 'toaster', 'food_noodles', 'garbage_can', 'pillow', 'broom', 'oven', 'toy', 'food_vegetable', 'food_food', 'television', 'oven_mitts', 'doorjamb', 'pencil', 'headset', 'sink', 'bathroom_cabinet', 'table', 'dishwasher', 'pantry']
Task:Organize pantry
response:
{
    "thoughts": Remove all perishable foods from the pantry, check dates and throw away any old food. Decide on an efficient ad neat arrangement for the food and replace it in the pantry accordingly.,
    "actions": ['[WALK] <dining_room>', '[WALK] <pantry>', '[FIND] <food_food>', '[GRAB] <food_food>', '[TURNTO] <food_food>', '[LOOKAT] <food_food>', '[FIND] <garbage_can>', '[PUTBACK] <food_food> <garbage_can>', '[FIND] <food_vegetable>', '[GRAB] <food_vegetable>', '[TURNTO] <food_vegetable>', '[LOOKAT] <food_vegetable>', '[PUTBACK] <food_vegetable> <garbage_can>', '[FIND] <dry_pasta>', '[GRAB] <dry_pasta>', '[TURNTO] <dry_pasta>', '[LOOKAT] <dry_pasta>', '[PUTOBJBACK] <dry_pasta>', '[FIND] <food_food>', '[TURNTO] <food_food>', '[LOOKAT] <food_food>', '[PUSH] <food_food>', '[FIND] <food_noodles>', '[GRAB] <food_noodles>', '[TURNTO] <food_noodles>', '[LOOKAT] <food_noodles>', '[PUTOBJBACK] <food_noodles>']
}

Input:
Scene_Objects:['tablelamp', 'toilet', 'chair', 'freezer', 'bathroom', 'detergent', 'ceilingfan', 'milk', 'cpuscreen', 'clothes_underwear', 'floor', 'ceiling', 'desk', 'keyboard', 'bookshelf', 'computer', 'bookmark', 'ceilinglamp', 'balanceball', 'mousepad', 'wall', 'nightstand', 'food_rice', 'mouse', 'pencil', 'pajamas', 'maindoor', 'board_game', 'teeth', 'shoe_rack']
Task:Wipe down baseboards please
response:

Use a rag to get all the dust off the baseboards please.

[WALK] <home_office>
[WALK] <rag>
[FIND] <rag>
[GRAB] <rag>
[WALK] <wall>
[PUTOBJBACK] <rag>


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

Here is an example plan to achieve a goal for reference:
Scene_Objects:['filing_cabinet', 'toilet', 'freezer', 'ground_coffee', 'bathroom', 'food_carrot', 'toothbrush', 'orchid', 'knife', 'cpuscreen', 'hanger', 'bathroom_counter', 'floor', 'bookshelf', 'button', 'mat', 'shower', 'mousepad', 'oil', 'closetdrawer', 'microphone', 'oven', 'cutting_board', 'check', 'centerpiece', 'diary', 'clothes_dress', 'clothes_scarf', 'napkin', 'tooth_paste']
Task:Pet cat
response:
{
    "thoughts": Walk into the living room. Walk up to the cat. Pet the cat with your hand.,
    "actions": ['[WALK] <home_office>', '[WALK] <cat>', '[FIND] <cat>', '[TOUCH] <cat>']
}

Input:
Scene_Objects:['tablelamp', 'measuring_cup', 'freezer', 'walllamp', 'bathroom', 'hanger', 'phone', 'desk', 'bookshelf', 'ceilinglamp', 'shoe-shine_kit', 'balanceball', 'faucet', 'couch', 'nightstand', 'wall', 'bench', 'powersocket', 'clothes_gloves', 'check', 'television', 'food_onion', 'after_shave', 'curtain', 'shaving_cream', 'mouse', 'maindoor', 'sink', 'bag', 'home_office']
Task:Open front door
response:

Walk over to the front door, turn the knob, and open the door.


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', 'filing_cabinet', 'tablelamp', 'tea', 'microwave', 'chair', 'drawing', 'orchid', 'floor', 'computer', 'food_bacon', 'table_cloth', 'stovefan', 'toaster', 'homework', 'mousepad', 'couch', 'powersocket', 'oven', 'bench', 'check', 'oven_mitts', 'coffee_filter', 'curtain', 'rag', 'doorjamb', 'kitchen_counter', 'shoes', 'bathtub', 'dishwasher']
Task:Pet cat
response:
{
    "thoughts": I walk into the living room and I pet the cat,
    "actions": ['[WALK] <home_office>', '[WALK] <cat>', '[TOUCH] <cat>']
}

Input:
Scene_Objects:['pot', 'filing_cabinet', 'ground_coffee', 'trashcan', 'drawing', 'bathroom_counter', 'floor', 'shampoo', 'character', 'computer', 'ceilinglamp', 'mat', 'iron', 'plate', 'window', 'couch', 'dining_room', 'wall', 'powersocket', 'basket_for_clothes', 'photoframe', 'newspaper', 'video_game_controller', 'television', 'centerpiece', 'doorjamb', 'towel_rack', 'door', 'bathroom_cabinet', 'table']
Task:Read book
response:

Sit on a couch, grab a book, open it, and scan the pages

[WALK] <home_office>
[WALK] <novel>
[FIND] <novel>
[GRAB] <novel>
[WALK] <couch>
[SIT] <couch>
[TURNTO] <novel>
[LOOKAT] <novel>
[READ] <novel>
[READ] <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_bread', 'scissors', 'toilet', 'freezer', 'ground_coffee', 'ceilingfan', 'knifeblock', 'orchid', 'hanger', 'floor', 'bedroom', 'tea_bag', 'envelope', 'clothes_jacket', 'toaster', 'balanceball', 'faucet', 'iron', 'bed', 'coffe_maker', 'wooden_spoon', 'cards', 'headset', 'dresser', 'napkin', 'spoon', 'vase', 'instrument_violin', 'laser_pointer', 'creditcard']
Task:Receive credit card
response:
{
    "thoughts": hear the dooble, go to door, take de envelope, open it with a scissor, take the creditcard,
    "actions": ['[WALK] <home_office>', '[WALK] <envelope>', '[FIND] <envelope>', '[GRAB] <envelope>', '[WALK] <home_office>', '[WALK] <scissors>', '[FIND] <scissors>', '[OPEN] <envelope>', '[FIND] <creditcard>', '[GRAB] <creditcard>']
}

Input:
Scene_Objects:['filing_cabinet', 'mop', 'chair', 'band-aids', 'drawing', 'cpuscreen', 'floor', 'ceiling', 'desk', 'bookshelf', 'keyboard', 'computer', 'stovefan', 'mat', 'laptop', 'toaster', 'foundation', 'pillow', 'wall', 'powersocket', 'bench', 'novel', 'doorjamb', 'mouse', 'kitchen_counter', 'door', 'napkin', 'light', 'soap', 'instrument_violin']
Task:Turn off light
response:

[WALK] <bedroom>
[WALK] <light>
[FIND] <light>
[TURNTO] <light>
[SWITCHOFF] <light>


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

Here is an example plan to achieve a goal for reference:
Scene_Objects:['pot', 'drawing', 'hanger', 'floor', 'ceiling', 'bedroom', 'remote_control', 'computer', 'button', 'brush', 'mat', 'ceilinglamp', 'window', 'closetdrawer', 'couch', 'pillow', 'wall', 'wall_clock', 'standingmirror', 'coffe_maker', 'television', 'food_rice', 'wine', 'curtain', 'doorjamb', 'diary', 'pencil', 'door', 'bathroom_cabinet', 'table']
Task:Change TV channel
response:
{
    "thoughts": walk to living room, look at the television, switch on the television, grab the remote control, press the channel button in remote control, now the tv channel is changed,
    "actions": ['[WALK] <home_office>', '[WALK] <television>', '[FIND] <television>', '[TURNTO] <television>', '[LOOKAT] <television>', '[SWITCHON] <television>', '[FIND] <remote_control>', '[GRAB] <remote_control>', '[FIND] <button>', '[GRAB] <button>']
}

Input:
Scene_Objects:['microwave', 'chair', 'detergent', 'trashcan', 'dough', 'food_egg', 'hanger', 'floor', 'ceiling', 'phone', 'thread', 'clothes_jacket', 'toaster', 'ceilinglamp', 'shoe-shine_kit', 'brush', 'wall', 'toilet_paper', 'television', 'wooden_spoon', 'kitchen_counter', 'vacuum_cleaner', 'dresser', 'cupboard', 'laundry_detergent', 'light', 'dishwasher', 'board_game', 'clothes_shirt', 'teeth']
Task:Sweep hallway please
response:

Vacuum all the way up and down the hallway.  Get all the dirt and crumbs out of carpet please.

[WALK] <home_office>
[WALK] <dresser>
[OPEN] <dresser>
[FIND] <vacuum_cleaner>
[GRAB] <vacuum_cleaner>
[PULL] <vacuum_cleaner>
[PLUGIN] <vacuum_cleaner>
[SWITCHON] <vacuum_cleaner>
[PULL] <vacuum_cleaner>
[PUSH] <vacuum_cleaner>
[PULL] <vacuum_cleaner>
[PUSH] <vacuum_cleaner>
[PULL] <vacuum_cleaner>
[PUSH] <vacuum_cleaner>
[SWITCHOFF] <vacuum_cleaner>
[PLUGOUT] <vacuum_cleaner>
[WALK] <dresser>
[PUTIN] <vacuum_cleaner> <dresser>
[CLOSE] <dresser>


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', 'food_salt', 'toilet', 'chair', 'freezer', 'walllamp', 'drawing', 'orchid', 'cpuscreen', 'wallshelf', 'hanger', 'floor', 'ceiling', 'phone', 'desk', 'keyboard', 'computer', 'mat', 'ceilinglamp', 'tvstand', 'mousepad', 'couch', 'pillow', 'wall', 'nightstand', 'television', 'doorjamb', 'mouse', 'dresser', 'door']
Task:Work
response:
{
    "thoughts": I need to complete work on my computer, so I will be pulling out my chair, turning on my computer and begin my task.,
    "actions": ['[WALK] <home_office>', '[WALK] <chair>', '[FIND] <chair>', '[PULL] <chair>', '[FIND] <computer>', '[SWITCHON] <computer>']
}

Input:
Scene_Objects:['blender', 'walllamp', 'bathroom', 'trashcan', 'food_carrot', 'drawing', 'floor', 'phone', 'bedroom', 'stamp', 'keyboard', 'table_cloth', 'stovefan', 'ceilinglamp', 'window', 'couch', 'towel', 'wall', 'oven', 'bed', 'photoframe', 'clothes_gloves', 'television', 'doorjamb', 'laundry_detergent', 'door', 'maindoor', 'home_office', 'table', 'clothes_shirt']
Task:Read magazine
response:

Please sit on the couch and read a magazine

[WALK] <home_office>
[WALK] <newspaper>
[FIND] <newspaper>
[GRAB] <newspaper>
[WALK] <couch>
[SIT] <couch>
[TURNTO] <newspaper>
[LOOKAT] <newspaper>
[READ] <newspaper>
[READ] <newspaper>
[READ] <newspaper>


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

Here is an example plan to achieve a goal for reference:
Scene_Objects:['spectacles', 'toilet', 'chair', 'walllamp', 'trashcan', 'cpuscreen', 'wallshelf', 'floor', 'ceiling', 'desk', 'keyboard', 'computer', 'toaster', 'ceilinglamp', 'tvstand', 'mat', 'mousepad', 'pillow', 'wall', 'nightstand', 'powersocket', 'newspaper', 'television', 'curtain', 'rag', 'doorjamb', 'mouse', 'door', 'bathtub', 'table']
Task:Use computer
response:
{
    "thoughts": Browse reddit,
    "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:['filing_cabinet', 'microwave', 'freezer', 'orchid', 'drawing', 'knifeblock', 'floor', 'folder', 'envelope', 'table_cloth', 'mop_bucket', 'stovefan', 'brush', 'ceilinglamp', 'window', 'foundation', 'couch', 'pillow', 'wall', 'powersocket', 'toy', 'newspaper', 'light_bulb', 'food_donut', 'wooden_spoon', 'doorjamb', 'door', 'maindoor', 'napkin', 'light']
Task:Put toys away
response:

Pick up all the toys on the floor and put them in their correct storage bin or shelf.

[WALK] <bedroom>
[WALK] <toy>
[FIND] <toy>
[GRAB] <toy>
[WALK] <filing_cabinet>
[OPEN] <filing_cabinet>
[PUTBACK] <toy> <filing_cabinet>
[FIND] <toy>
[GRAB] <toy>
[WALK] <filing_cabinet>
[PUTBACK] <toy> <filing_cabinet>
[FIND] <toy>
[GRAB] <toy>
[WALK] <filing_cabinet>
[PUTBACK] <toy> <filing_cabinet>
[CLOSE] <filing_cabinet>


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

Here is an example plan to achieve a goal for reference:
Scene_Objects:['sheets', 'spectacles', 'scissors', 'knife', 'hanger', 'bathroom_counter', 'floor', 'bedroom', 'desk', 'keyboard', 'piano_bench', 'stovefan', 'stereo', 'window', 'wall', 'powersocket', 'cutting_board', 'cup', 'bed', 'console', 'pencil', 'shoes', 'door', 'bathtub', 'bag', 'instrument_guitar', 'table', 'home_office', 'light', 'board_game']
Task:Listen to music
response:
{
    "thoughts": I walk into my room and turn the radio on so that I can listen to music.,
    "actions": ['[WALK] <bedroom>', '[WALK] <stereo>', '[FIND] <stereo>', '[SWITCHON] <stereo>']
}

Input:
Scene_Objects:['pot', 'filing_cabinet', 'toilet', 'chair', 'cat', 'cpuscreen', 'hanger', 'bathroom_counter', 'floor', 'ceiling', 'phone', 'keyboard', 'food_bacon', 'stovefan', 'ceilinglamp', 'iron', 'dustpan', 'pillow', 'wall', 'toy', 'box', 'centerpiece', 'mouse', 'kitchen_counter', 'vacuum_cleaner', 'cd', 'dresser', 'cupboard', 'light', 'table']
Task:Vacuum
response:

Plug in the vacuum. Turn it on. Push it back and forth across the floor until all the debris is gone.

[WALK] <home_office>
[WALK] <dresser>
[OPEN] <dresser>
[FIND] <vacuum_cleaner>
[GRAB] <vacuum_cleaner>
[PULL] <vacuum_cleaner>
[PLUGIN] <vacuum_cleaner>
[SWITCHON] <vacuum_cleaner>
[PULL] <vacuum_cleaner>
[PUSH] <vacuum_cleaner>
[PULL] <vacuum_cleaner>
[PUSH] <vacuum_cleaner>
[PULL] <vacuum_cleaner>
[PUSH] <vacuum_cleaner>
[SWITCHOFF] <vacuum_cleaner>
[PLUGOUT] <vacuum_cleaner>
[WALK] <dresser>
[PUTIN] <vacuum_cleaner> <dresser>
[CLOSE] <dresser>


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

Here is an example plan to achieve a goal for reference:
Scene_Objects:['pot', 'toilet', 'freezer', 'food_carrot', 'drawing', 'hanger', 'floor', 'ceiling', 'shampoo', 'stovefan', 'mat', 'shower', 'window', 'nightstand', 'wall', 'powersocket', 'food_cheese', 'photoframe', 'bed', 'newspaper', 'food_food', 'drinking_glass', 'water', 'curtain', 'doorjamb', 'dresser', 'food_steak', 'door', 'home_office', 'light']
Task:Drink
response:
{
    "thoughts": im feeling thirsty im going to kitchen and open the freezer where i can find some cold water and im going to drink it to end up my thirst,
    "actions": ['[WALK] <dining_room>', '[WALK] <freezer>', '[FIND] <freezer>', '[OPEN] <freezer>', '[FIND] <drinking_glass>', '[GRAB] <drinking_glass>', '[WALK] <water>', '[FIND] <water>', '[GRAB] <water>', '[POUR] <water> <drinking_glass>', '[DRINK] <drinking_glass>']
}

Input:
Scene_Objects:['pot', 'food_bread', 'food_pizza', 'dog', 'freezer', 'bathroom', 'trashcan', 'milk', 'knife', 'orchid', 'floor', 'ceiling', 'bedroom', 'purse', 'toaster', 'ceilinglamp', 'faucet', 'balanceball', 'garbage_can', 'food_dessert', 'wall', 'nightstand', 'oven', 'tape', 'food_cheese', 'food_vegetable', 'novel', 'toothbrush_holder', 'ice', 'colander']
Task:Rotate stock in refrigerator
response:

Throw out expired items, put older items in front.


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

Here is an example plan to achieve a goal for reference:
Scene_Objects:['filing_cabinet', 'freezer', 'bathroom', 'drawing', 'orchid', 'cpuscreen', 'shampoo', 'bedroom', 'bookshelf', 'thread', 'mop_bucket', 'tvstand', 'faucet', 'mousepad', 'towel', 'powersocket', 'bed', 'coffe_maker', 'television', 'oven_mitts', 'tray', 'mouse', 'kitchen_counter', 'dresser', 'door', 'bathtub', 'maindoor', 'home_office', 'bathroom_cabinet', 'table']
Task:Pick up phone
response:
{
    "thoughts": Enter living room. Walk to telephone. Pick up from hook.,
    "actions": ['[WALK] <home_office>', '[WALK] <phone>', '[GRAB] <phone>']
}

Input:
Scene_Objects:['sheets', 'food_pizza', 'filing_cabinet', 'beer', 'measuring_cup', 'chair', 'ground_coffee', 'knifeblock', 'longboard', 'floor', 'ceiling', 'bedroom', 'keyboard', 'computer', 'mail', 'toaster', 'picture', 'dustpan', 'wall', 'bench', 'cutting_board', 'tape', 'cup', 'coffe_maker', 'coffee_filter', 'water', 'after_shave', 'dresser', 'maindoor', 'dishwasher']
Task:Make coffee
response:

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

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


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

Here is an example plan to achieve a goal for reference:
Scene_Objects:['sponge', 'toilet', 'chair', 'walllamp', 'bathroom', 'ground_coffee', 'ceiling', 'character', 'bedroom', 'desk', 'keyboard', 'bookshelf', 'toaster', 'tvstand', 'faucet', 'shower', 'foundation', 'mousepad', 'wall', 'cup', 'newspaper', 'bed', 'coffe_maker', 'doorjamb', 'dresser', 'conditioner', 'door', 'light', 'dishwasher', 'tooth_paste']
Task:Change TV channel
response:
{
    "thoughts": take remote control, push "change channel" button,
    "actions": ['[WALK] <home_office>', '[WALK] <remote_control>', '[FIND] <remote_control>', '[PUSH] <remote_control>']
}

Input:
Scene_Objects:['pot', 'juice', 'food_ice_cream', 'beer', 'food_oatmeal', 'microwave', 'freezer', 'walllamp', 'ground_coffee', 'milk', 'knifeblock', 'drawing', 'food_egg', 'floor', 'ceiling', 'tea_bag', 'bookshelf', 'stovefan', 'ceilinglamp', 'tvstand', 'faucet', 'toaster', 'food_peanut_butter', 'candle', 'pillow', 'bowl', 'wall', 'bench', 'cup', 'newspaper', 'food_food', 'coffe_maker', 'check', 'food_onion', 'cards', 'kitchen_counter', 'cupboard', 'sink', 'table', 'dishwasher', 'laser_pointer']
Task:Cook some food
response:

Put oatmeal into a bowl.  Add milk.  Heat in a microwave.  Put pod of coffee into a coffee maker.  Activate.  Pour juice into a glass.

[WALK] <dining_room>
[WALK] <cupboard>
[FIND] <cupboard>
[OPEN] <cupboard>
[FIND] <bowl>
[GRAB] <bowl>
[FIND] <food_oatmeal>
[GRAB] <food_oatmeal>
[PUTBACK] <food_oatmeal> <bowl>
[GRAB] <food_oatmeal>
[PUTOBJBACK] <food_oatmeal>
[CLOSE] <cupboard>
[WALK] <freezer>
[OPEN] <freezer>
[FIND] <milk>
[GRAB] <milk>
[POUR] <milk> <bowl>
[PUTOBJBACK] <milk>
[CLOSE] <freezer>
[FIND] <microwave>
[OPEN] <microwave>
[PUTIN] <bowl> <microwave>
[CLOSE] <microwave>
[SWITCHON] <microwave>
[FIND] <ground_coffee>
[GRAB] <ground_coffee>
[FIND] <coffe_maker>
[OPEN] <coffe_maker>
[PUTBACK] <ground_coffee> <coffe_maker>
[CLOSE] <coffe_maker>
[SWITCHON] <coffe_maker>
[FIND] <cup>
[GRAB] <cup>
[WALK] <freezer>
[OPEN] <freezer>
[FIND] <juice>
[GRAB] <juice>
[POUR] <juice> <cup>
[PUTOBJBACK] <juice>
[CLOSE] <freezer>
[FIND] <table>
[PUTBACK] <cup> <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:['scissors', 'toilet', 'freezer', 'bathroom', 'cpuscreen', 'bathroom_counter', 'floor', 'ceiling', 'bedroom', 'thread', 'stovefan', 'mat', 'faucet', 'towel', 'dining_room', 'wall', 'wall_clock', 'oven', 'bench', 'nightstand', 'check', 'coffee_filter', 'tray', 'shaving_cream', 'towel_rack', 'pencil', 'mouse', 'sink', 'bathroom_cabinet', 'soap']
Task:Wash hands
response:
{
    "thoughts": I walk into the bathroom. Walk to the sink. Turn on tap. Get soap. Wash and rinse hands. Turn off tap. Dry hands.,
    "actions": ['[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>']
}

Input:
Scene_Objects:['glue', 'pot', 'tablelamp', 'detergent', 'cat', 'knife', 'drawing', 'hanger', 'bathroom_counter', 'desk', 'food_cake', 'purse', 'envelope', 'piano_bench', 'stovefan', 'toaster', 'stereo', 'balanceball', 'floor_lamp', 'powersocket', 'love_seat', 'newspaper', 'bed', 'photoframe', 'video_game_controller', 'diary', 'maindoor', 'light', 'soap', 'board_game']
Task:Read
response:

Sit on an easy chair.  Turn on music.  Take a book and read.  Turn on lamp at night.

[WALK] <home_office>
[WALK] <stereo>
[FIND] <stereo>
[SWITCHON] <stereo>
[FIND] <newspaper>
[GRAB] <newspaper>
[FIND] <love_seat>
[SIT] <love_seat>
[FIND] <floor_lamp>
[SWITCHON] <floor_lamp>
[READ] <newspaper>


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', 'trashcan', 'drawing', 'orchid', 'floor', 'ceiling', 'character', 'computer', 'food_bacon', 'stovefan', 'mat', 'tvstand', 'window', 'mousepad', 'form', 'dining_room', 'wall', 'cutting_board', 'bed', 'clothes_gloves', 'check', 'television', 'oven_mitts', 'curtain', 'mouse', 'hair', 'napkin', 'vase', 'instrument_violin', 'laser_pointer']
Task:Gaze out window
response:
{
    "thoughts": Look at the yard from the window,
    "actions": ['[WALK] <home_office>', '[WALK] <window>', '[FIND] <window>', '[TURNTO] <window>', '[LOOKAT] <window>']
}

Input:
Scene_Objects:['mop', 'bathroom', 'detergent', 'trashcan', 'food_carrot', 'knifeblock', 'floor', 'bedroom', 'thread', 'computer', 'brush', 'plate', 'picture', 'window', 'mousepad', 'clothes_hat', 'pillow', 'wall', 'box', 'bed', 'television', 'curtain', 'food_onion', 'kitchen_counter', 'maindoor', 'table', 'light', 'clothes_shirt', 'dirt', 'teeth']
Task:Read book
response:

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


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

Here is an example plan to achieve a goal for reference:
Scene_Objects:['filing_cabinet', 'tablelamp', 'microwave', 'freezer', 'trashcan', 'drawing', 'orchid', 'ceiling', 'bedroom', 'mail', 'mat', 'tvstand', 'mousepad', 'dining_room', 'wall', 'wall_clock', 'basket_for_clothes', 'coffe_maker', 'tray', 'doorjamb', 'mouse', 'kitchen_counter', 'dresser', 'laundry_detergent', 'door', 'clothes_dress', 'bathroom_cabinet', 'table', 'light', '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:['filing_cabinet', 'chair', 'freezer', 'walllamp', 'knifeblock', 'orchid', 'cpuscreen', 'hanger', 'floor', 'ceiling', 'desk', 'bookshelf', 'bookmark', 'ceilinglamp', 'tvstand', 'balanceball', 'picture', 'mousepad', 'couch', 'wall', 'bed', 'food_food', 'tray', 'after_shave', 'rag', 'doorjamb', 'maindoor', 'bathroom_cabinet', 'dishwasher', 'vase']
Task:Put away groceries
response:

Place groceries in refrigerator from shopping at the grocery store.

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


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

Here is an example plan to achieve a goal for reference:
Scene_Objects:['spectacles', 'fork', 'tablelamp', 'tea', 'band-aids', 'bathroom', 'drawing', 'hanger', 'floor', 'ceiling', 'dvd_player', 'desk', 'remote_control', 'computer', 'food_bacon', 'mat', 'ceilinglamp', 'window', 'mousepad', 'closetdrawer', 'couch', 'clothes_pants', 'pillow', 'wall', 'standingmirror', 'television', 'curtain', 'doorjamb', 'table', 'soap']
Task:Change TV channel
response:
{
    "thoughts": I push my body to be near to the table in front of me, without stand up. I move my right hand to near the TV remote control on the table. I take the TV remote control. I look the number on the remote control. I touch number 3 button. I put back the remote control to the table. I put my body back to the sofa,
    "actions": ['[WALK] <home_office>', '[WALK] <television>', '[FIND] <television>', '[PLUGIN] <television>', '[FIND] <couch>', '[SIT] <couch>', '[FIND] <remote_control>', '[TURNTO] <remote_control>', '[LOOKAT] <remote_control>', '[GRAB] <remote_control>', '[TOUCH] <remote_control>', '[PUTOBJBACK] <remote_control>', '[TURNTO] <television>', '[WATCH] <television>']
}

Input:
Scene_Objects:['tablelamp', 'chair', 'trashcan', 'ceilingfan', 'drawing', 'cpuscreen', 'food_egg', 'floor', 'ceiling', 'phone', 'desk', 'stamp', 'keyboard', 'bookshelf', 'computer', 'table_cloth', 'ceilinglamp', 'balanceball', 'faucet', 'mousepad', 'wall', 'nightstand', 'bench', 'check', 'doorjamb', 'mouse', 'controller', 'maindoor', 'light', 'dishwasher']
Task:Research
response:

I read different articles online to gain a better understanding of a particular business, industry, method, terminology, etc.

[WALK] <home_office>
[WALK] <computer>
[FIND] <computer>
[SWITCHON] <computer>
[TURNTO] <computer>
[LOOKAT] <computer>
[FIND] <check>
[GRAB] <check>
[READ] <check>


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

Here is an example plan to achieve a goal for reference:
Scene_Objects:['freezer', 'walllamp', 'bathroom', 'cpuscreen', 'clothes_underwear', 'bathroom_counter', 'shampoo', 'tvstand', 'faucet', 'stereo', 'clothes_socks', 'couch', 'clothes_pants', 'cutting_board', 'basket_for_clothes', 'photoframe', 'food_food', 'video_game_controller', 'coffe_maker', 'coffee_filter', 'television', 'tray', 'curtain', 'shaving_cream', 'laundry_detergent', 'maindoor', 'spoon', 'home_office', 'clothes_shirt', 'washing_machine']
Task:Wash clothes
response:
{
    "thoughts": I go to the bathroom and open the washing machine there. I take my laundry basket and put each item of laundry into the machine. Then I take the laundry detergent and pour some into the machine. Finally I close the machine and switch it on.,
    "actions": ['[WALK] <bathroom>', '[WALK] <washing_machine>', '[FIND] <washing_machine>', '[OPEN] <washing_machine>', '[FIND] <basket_for_clothes>', '[GRAB] <basket_for_clothes>', '[FIND] <clothes_pants>', '[GRAB] <clothes_pants>', '[PUTBACK] <clothes_pants> <washing_machine>', '[FIND] <clothes_shirt>', '[GRAB] <clothes_shirt>', '[PUTBACK] <clothes_shirt> <washing_machine>', '[FIND] <clothes_underwear>', '[GRAB] <clothes_underwear>', '[PUTBACK] <clothes_underwear> <washing_machine>', '[FIND] <clothes_socks>', '[GRAB] <clothes_socks>', '[PUTBACK] <clothes_socks> <washing_machine>', '[PUTOBJBACK] <basket_for_clothes>', '[FIND] <laundry_detergent>', '[GRAB] <laundry_detergent>', '[POUR] <laundry_detergent> <washing_machine>', '[CLOSE] <washing_machine>', '[SWITCHON] <washing_machine>']
}

Input:
Scene_Objects:['measuring_cup', 'microwave', 'toilet', 'drawing', 'orchid', 'cpuscreen', 'hanger', 'phone', 'food_cake', 'computer', 'ceilinglamp', 'shoe-shine_kit', 'iron', 'stereo', 'electric_shaver', 'homework', 'balanceball', 'picture', 'window', 'dining_room', 'powersocket', 'cup', 'photoframe', 'mirror', 'tray', 'pencil', 'shoes', 'conditioner', 'sink', 'creditcard']
Task:Shave
response:

Pick up razor.  Push the button to turn it on.  Move it in a linear motion against the beard growth.  Make sure to get the bottom of your chin, your cheeks, and mustache area.

[WALK] <bathroom>
[WALK] <electric_shaver>
[FIND] <electric_shaver>
[GRAB] <electric_shaver>
[FIND] <mirror>
[TURNTO] <mirror>
[SWITCHON] <electric_shaver>
[SWITCHOFF] <electric_shaver>
[PUTOBJBACK] <electric_shaver>


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

Here is an example plan to achieve a goal for reference:
Scene_Objects:['tablelamp', 'juice', 'chair', 'freezer', 'walllamp', 'cpuscreen', 'food_egg', 'floor', 'ceiling', 'desk', 'bedroom', 'keyboard', 'computer', 'toaster', 'mat', 'ceilinglamp', 'faucet', 'picture', 'homework', 'mousepad', 'wall', 'oven', 'toy', 'newspaper', 'check', 'television', 'mouse', 'laundry_detergent', 'conditioner', 'laser_pointer']
Task:Push in desk chair
response:
{
    "thoughts": Push the desk chair until it is under the desk.,
    "actions": ['[WALK] <home_office>', '[WALK] <desk>', '[FIND] <chair>', '[TOUCH] <chair>', '[PUSH] <chair>']
}

Input:
Scene_Objects:['fork', 'pot', 'food_bread', 'scissors', 'microwave', 'freezer', 'milk', 'knifeblock', 'drawing', 'bathroom_counter', 'floor', 'ceiling', 'mail', 'food_bacon', 'ceilinglamp', 'shower', 'faucet', 'bowl', 'food_kiwi', 'wall', 'oven', 'cup', 'bed', 'coffe_maker', 'video_game_controller', 'diary', 'dishrack', 'controller', 'conditioner', 'home_office']
Task:Get glass of milk
response:

Get an empty glass. Take milk from refrigerator and open it. Pour milk into glass.

[WALK] <dining_room>
[WALK] <cup>
[FIND] <cup>
[GRAB] <cup>
[WALK] <freezer>
[OPEN] <freezer>
[FIND] <milk>
[GRAB] <milk>
[POUR] <milk> <cup>
[PUTOBJBACK] <milk>
[CLOSE] <freezer>


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

Here is an example plan to achieve a goal for reference:
Scene_Objects:['filing_cabinet', 'tablelamp', 'microwave', 'chair', 'freezer', 'detergent', 'floor', 'phone', 'ceiling', 'bedroom', 'keyboard', 'stovefan', 'shower', 'faucet', 'window', 'closetdrawer', 'wall', 'wall_clock', 'powersocket', 'bench', 'photoframe', 'coffe_maker', 'check', 'television', 'food_food', 'ice', 'rag', 'towel_rack', 'kitchen_counter', 'cupboard']
Task:Turn on light
response:
{
    "thoughts": I go home and it's dark so I can not see anything,
    "actions": ['[WALK] <home_office>', '[WALK] <floor_lamp>', '[FIND] <floor_lamp>', '[SWITCHON] <floor_lamp>']
}

Input:
Scene_Objects:['tablelamp', 'food_salt', 'toilet', 'chair', 'walllamp', 'cat', 'trashcan', 'ceilingfan', 'drawing', 'bills', 'cpuscreen', 'floor', 'ceiling', 'phone', 'desk', 'keyboard', 'bookshelf', 'computer', 'ceilinglamp', 'balanceball', 'mousepad', 'wall', 'nightstand', 'photoframe', 'fax_machine', 'doorjamb', 'mouse', 'light', 'dishwasher', 'printing_paper']
Task:Print out papers
response:

Turn on printer and fill with blank paper. Use computer to click on printing option. Take printed page out of print.


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', 'wallshelf', 'clothes_underwear', 'hanger', 'floor', 'ceiling', 'desk', 'bedroom', 'remote_control', 'computer', 'mat', 'tvstand', 'ceilinglamp', 'shower', 'closetdrawer', 'couch', 'pillow', 'wall', 'photoframe', 'food_food', 'television', 'doorjamb', 'towel_rack', 'pencil', 'shoes', 'dresser', 'sink', 'instrument_violin']
Task:Watch TV
response:
{
    "thoughts": I go to the the living room, sit down on the sofa, and then I switch on the TV with the TV remote,
    "actions": ['[WALK] <home_office>', '[WALK] <remote_control>', '[FIND] <remote_control>', '[GRAB] <remote_control>', '[FIND] <couch>', '[SIT] <couch>', '[FIND] <television>', '[SWITCHON] <television>']
}

Input:
Scene_Objects:['pot', 'tablelamp', 'toilet', 'ceilingfan', 'drawing', 'hanger', 'floor', 'ceiling', 'bookshelf', 'remote_control', 'toaster', 'ceilinglamp', 'tvstand', 'balanceball', 'mat', 'window', 'shoe-shine_kit', 'couch', 'wall', 'video_game_controller', 'television', 'coin', 'curtain', 'kitchen_counter', 'headset', 'dresser', 'controller', 'table', 'dishwasher', 'soap']
Task:Watch TV
response:

I sit down on sofa, get the remote, turn on tv, change channel to show I want to watch

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


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

Here is an example plan to achieve a goal for reference:
Scene_Objects:['tablelamp', 'food_salt', 'toilet', 'drawing', 'orchid', 'wallshelf', 'cpuscreen', 'hanger', 'bathroom_counter', 'floor', 'ceiling', 'bedroom', 'bookshelf', 'tvstand', 'foundation', 'closetdrawer', 'pillow', 'wall', 'nightstand', 'powersocket', 'bed', 'coffe_maker', 'television', 'food_rice', 'doorjamb', 'shoes', 'dresser', 'door', 'light', 'clothes_skirt']
Task:Turn on light
response:
{
    "thoughts": I walk to room. I enter room. I find where the lightswitch is. I turn on the lights with the lightswitch.,
    "actions": ['[WALK] <bedroom>', '[WALK] <light>', '[FIND] <light>', '[TURNTO] <light>', '[LOOKAT] <light>', '[SWITCHON] <light>']
}

Input:
Scene_Objects:['ironing_board', 'dry_pasta', 'food_salt', 'toilet', 'freezer', 'band-aids', 'nail_polish', 'detergent', 'food_carrot', 'knifeblock', 'longboard', 'clothes_jacket', 'mat', 'iron', 'mousepad', 'form', 'towel', 'dining_room', 'cup', 'bed', 'coffe_maker', 'video_game_controller', 'television', 'ice', 'doorjamb', 'towel_rack', 'home_office', 'light', 'vase', 'clothes_shirt']
Task:Iron shirt
response:

Set up an ironing board and an iron.  Lay a shirt on board.  Run iron over shirt until it is free of wrinkles.


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', 'mop', 'walllamp', 'detergent', 'orchid', 'cpuscreen', 'floor', 'ceiling', 'character', 'toaster', 'stereo', 'window', 'wall', 'bed', 'novel', 'coffe_maker', 'coffee_filter', 'water', 'kitchen_counter', 'shoes', 'dresser', 'cupboard', 'sink', 'bathtub', 'spoon', 'light', 'dishwasher', 'table', 'coffee']
Task:Make coffee
response:
{
    "thoughts": Go to the kitchen and make coffee.,
    "actions": ['[RUN] <dining_room>', '[WALK] <coffe_maker>', '[FIND] <coffee_filter>', '[GRAB] <coffee_filter>', '[OPEN] <coffe_maker>', '[PUTBACK] <coffee_filter> <coffe_maker>', '[FIND] <coffee>', '[GRAB] <coffee>', '[POUR] <coffee> <coffe_maker>', '[PUTOBJBACK] <coffee>', '[WALK] <water>', '[FIND] <water>', '[GRAB] <water>', '[POUR] <water> <coffe_maker>', '[SWITCHON] <coffe_maker>']
}

Input:
Scene_Objects:['pot', 'microwave', 'toilet', 'chair', 'freezer', 'detergent', 'ceilingfan', 'drawing', 'bathroom_counter', 'floor', 'ceiling', 'keyboard', 'remote_control', 'button', 'ceilinglamp', 'tvstand', 'balanceball', 'shoe-shine_kit', 'window', 'couch', 'wall', 'bench', 'love_seat', 'food_food', 'check', 'television', 'coffe_maker', 'curtain', 'table', 'dishwasher']
Task:Watch TV
response:

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

Input:
Scene_Objects:['pot', 'food_pizza', 'tablelamp', 'food_salt', 'toilet', 'freezer', 'detergent', 'bills', 'orchid', 'hanger', 'ceiling', 'envelope', 'table_cloth', 'brush', 'mat', 'ceilinglamp', 'shower', 'stovefan', 'nightstand', 'powersocket', 'bench', 'photoframe', 'check', 'food_food', 'wooden_spoon', 'sink', 'napkin', 'instrument_guitar', 'table', 'coffee']
Task:Pull up carpet
response:

Pry up a corner of your old dirty carpet.  Tug as hard as you can until it comes off the tacs. Pull up the pad. Try not to be sick at all the dirt.

[WALK] <home_office>
[WALK] <mat>
[FIND] <mat>
[TOUCH] <mat>
[PULL] <mat>


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

Here is an example plan to achieve a goal for reference:
Scene_Objects:['filing_cabinet', 'tablelamp', 'measuring_cup', 'walllamp', 'ceilingfan', 'drawing', 'bathroom_counter', 'floor', 'ceiling', 'phone', 'toaster', 'ceilinglamp', 'tvstand', 'balanceball', 'window', 'clothes_socks', 'food_noodles', 'couch', 'broom', 'wall', 'newspaper', 'light_bulb', 'novel', 'television', 'curtain', 'doorjamb', 'lighter', 'cupboard', 'table', 'light']
Task:Change TV channel
response:
{
    "thoughts": Walk to the living room. Find remote control. Grab remote control. Walk to television. Look at television. Switch on remote control.,
    "actions": ['[WALK] <home_office>', '[WALK] <remote_control>', '[FIND] <remote_control>', '[GRAB] <remote_control>', '[WALK] <television>', '[TURNTO] <television>', '[LOOKAT] <television>', '[SWITCHON] <television>']
}

Input:
Scene_Objects:['ceilingfan', 'toothbrush', 'drawing', 'food_egg', 'bathroom_counter', 'floor', 'ceiling', 'phone', 'longboard', 'mop_bucket', 'mat', 'tvstand', 'faucet', 'couch', 'clothes_pants', 'towel', 'wall', 'basket_for_clothes', 'photoframe', 'light_bulb', 'wooden_spoon', 'after_shave', 'coffee', 'sink', 'bathroom_cabinet', 'home_office', 'soap', 'laser_pointer', 'hands_both', 'shoe_rack']
Task:Wash hands
response:

Turn faucet clockwise to turn on water.  Place hands under stream of water, pick up soap, rub hands with soap.  Put soap back down.  Rub hands together with soap on them.  Rinse hands under water from faucet.  Turn faucet counterclockwise to turn water off.  Dry hands by rubbing them on a towel.

[WALK] <bathroom>
[WALK] <sink>
[FIND] <faucet>
[SWITCHON] <faucet>
[FIND] <soap>
[GRAB] <soap>
[FIND] <hands_both>
[SCRUB] <hands_both>
[PUTOBJBACK] <soap>
[WASH] <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:['water_glass', 'blender', 'food_salt', 'chair', 'walllamp', 'nail_polish', 'bathroom', 'milk', 'drawing', 'wallshelf', 'clothes_underwear', 'bathroom_counter', 'floor', 'character', 'stamp', 'envelope', 'button', 'stovefan', 'ceilinglamp', 'mat', 'faucet', 'closetdrawer', 'form', 'coffe_maker', 'water', 'mouse', 'dresser', 'hairbrush', 'cupboard', 'table']
Task:Drink
response:
{
    "thoughts": walk to kitchen, hold drinking glass, lift glass, pour water in drinking glass,
    "actions": ['[WALK] <dining_room>', '[WALK] <table>', '[FIND] <table>', '[FIND] <water_glass>', '[GRAB] <water_glass>', '[FIND] <water>', '[GRAB] <water>', '[WALK] <water>', '[POUR] <water> <water_glass>', '[DRINK] <water_glass>']
}

Input:
Scene_Objects:['food_bread', 'scissors', 'crayon', 'freezer', 'walllamp', 'drawing', 'orchid', 'floor', 'ceiling', 'character', 'bookmark', 'toaster', 'ceilinglamp', 'stovefan', 'faucet', 'window', 'homework', 'couch', 'wall', 'child', 'bench', 'photoframe', 'newspaper', 'coffe_maker', 'razor', 'television', 'kitchen_counter', 'cupboard', 'table', 'coffee']
Task:Let baby learn how to walk
response:

The baby tries to stand up and balances on the couch and there are no sharp edges so it's safe.

[WALK] <home_office>
[WALK] <child>
[FIND] <child>
[TOUCH] <child>
[GREET] <child>
[FIND] <couch>
[TURNTO] <couch>
[POINTAT] <couch>
[TURNTO] <child>
[LOOKAT] <child>


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

Here is an example plan to achieve a goal for reference:
Scene_Objects:['microwave', 'chair', 'dog', 'walllamp', 'trashcan', 'cpuscreen', 'floor', 'ceiling', 'desk', 'bedroom', 'keyboard', 'computer', 'table_cloth', 'ceilinglamp', 'tvstand', 'faucet', 'mousepad', 'couch', 'form', 'wall', 'powersocket', 'photoframe', 'mouthwash', 'television', 'doorjamb', 'mouse', 'cupboard', 'bathtub', 'sink', 'table']
Task:Work
response:
{
    "thoughts": go to home office. turn the computer on. begin working,
    "actions": ['[WALK] <home_office>', '[WALK] <computer>', '[FIND] <computer>', '[SWITCHON] <computer>']
}

Input:
Scene_Objects:['measuring_cup', 'drawing', 'orchid', 'cpuscreen', 'bathroom_counter', 'floor', 'ceiling', 'keyboard', 'computer', 'ceilinglamp', 'faucet', 'teeth', 'towel', 'wall', 'nightstand', 'powersocket', 'basket_for_clothes', 'photoframe', 'light_bulb', 'toilet_paper', 'television', 'food_donut', 'tray', 'cards', 'towel_rack', 'laundry_detergent', 'sink', 'bathroom_cabinet', 'soap', 'hands_both']
Task:Hand washing
response:

Turn on the faucet. Soap up your hands. Then rinse under the running water of the faucet. Turn off faucet and dry hands.

[WALK] <bathroom>
[WALK] <sink>
[FIND] <faucet>
[SWITCHON] <faucet>
[FIND] <soap>
[GRAB] <soap>
[FIND] <hands_both>
[SCRUB] <hands_both>
[PUTOBJBACK] <soap>
[WASH] <hands_both>
[SWITCHOFF] <faucet>
[FIND] <towel>
[GRAB] <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:['pot', 'walllamp', 'drawing', 'orchid', 'floor', 'ceiling', 'desk', 'bedroom', 'bookshelf', 'remote_control', 'thread', 'brush', 'ceilinglamp', 'tvstand', 'mat', 'toaster', 'clothes_hat', 'dining_room', 'wall', 'powersocket', 'cup', 'photoframe', 'television', 'doorjamb', 'pencil', 'dresser', 'door', 'home_office', 'table', 'light']
Task:Change TV channel
response:
{
    "thoughts": Change the channel on the TV in the living room,
    "actions": ['[WALK] <home_office>', '[WALK] <television>', '[FIND] <television>', '[SWITCHON] <television>', '[FIND] <remote_control>', '[GRAB] <remote_control>']
}

Input:
Scene_Objects:['filing_cabinet', 'microwave', 'blow_dryer', 'cat', 'trashcan', 'toothbrush', 'drawing', 'floor', 'character', 'desk', 'wine_glass', 'ceilinglamp', 'plate', 'shower', 'window', 'couch', 'pillow', 'dining_room', 'wall', 'nightstand', 'food_cheese', 'bed', 'food_food', 'check', 'television', 'coffee_filter', 'curtain', 'door', 'spoon', 'table']
Task:Entertain
response:

Give guests wine, cheese, crackers and sit and talk

[WALK] <home_office>
[WALK] <food_cheese>
[FIND] <food_cheese>
[FIND] <food_food>
[FIND] <couch>
[SIT] <couch>
[FIND] <wine_glass>
[GRAB] <wine_glass>
[DRINK] <wine_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', 'food_bread', 'toilet', 'bathroom', 'milk', 'drawing', 'floor', 'ceiling', 'bookshelf', 'computer', 'mat', 'ceilinglamp', 'shower', 'mousepad', 'towel', 'wall', 'bench', 'cup', 'photoframe', 'toothbrush_holder', 'water', 'curtain', 'doorjamb', 'kitchen_counter', 'cupboard', 'door', 'sink', 'light', 'clothes_skirt', 'soap']
Task:Take shower
response:
{
    "thoughts": Walk into bathroom. Turn on shower. Take off clothing. Climb into shower. Rinse with water. Soap up body. Rinse off with water. Turn off shower. Climb out of shower. Dry off with towel.,
    "actions": ['[WALK] <bathroom>', '[WALK] <shower>', '[FIND] <shower>', '[TURNTO] <shower>', '[FIND] <water>', '[RINSE] <water>', '[FIND] <soap>', '[WASH] <soap>', '[RINSE] <water>', '[FIND] <towel>', '[GRAB] <towel>', '[SCRUB] <towel>']
}

Input:
Scene_Objects:['sponge', 'pot', 'sheets', 'food_ice_cream', 'food_salt', 'measuring_cup', 'microwave', 'toilet', 'detergent', 'ceilingfan', 'drawing', 'hanger', 'floor', 'keyboard', 'clothes_jacket', 'ceilinglamp', 'plate', 'window', 'floor_lamp', 'mousepad', 'couch', 'pillow', 'wall', 'clothes_gloves', 'novel', 'check', 'television', 'food_rice', 'doorjamb', 'table']
Task:Read book
response:

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.

[WALK] <home_office>
[WALK] <novel>
[FIND] <novel>
[GRAB] <novel>
[FIND] <couch>
[SIT] <couch>
[FIND] <floor_lamp>
[SWITCHON] <floor_lamp>
[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', 'chair', 'walllamp', 'orchid', 'drawing', 'cpuscreen', 'wallshelf', 'hanger', 'floor', 'ceiling', 'phone', 'desk', 'keyboard', 'computer', 'mat', 'ceilinglamp', 'tvstand', 'mousepad', 'couch', 'pillow', 'wall', 'nightstand', 'oven', 'novel', 'television', 'fax_machine', 'doorjamb', 'mouse', 'dresser', 'door']
Task:Browse internet
response:
{
    "thoughts": I walk to the home office. I sit on the chair. I switch on the computer. I look at my monitor. I open the browsing application by click the application using mouse. I type the book that I need to searching for (using keyboard). I found the book that I need. I read the book. I switch on the printer. I print the information that I get. I read carefully the book information that I got. I switch off the printer. I switch of the computer.,
    "actions": ['[WALK] <home_office>', '[WALK] <chair>', '[FIND] <chair>', '[SIT] <chair>', '[FIND] <computer>', '[SWITCHON] <computer>', '[FIND] <fax_machine>', '[SWITCHON] <fax_machine>', '[TURNTO] <computer>', '[LOOKAT] <computer>', '[FIND] <keyboard>', '[TYPE] <keyboard>', '[TURNTO] <computer>', '[LOOKAT] <computer>', '[FIND] <novel>', '[GRAB] <novel>', '[READ] <novel>', '[SWITCHOFF] <fax_machine>', '[SWITCHOFF] <computer>']
}

Input:
Scene_Objects:['fork', 'crayon', 'chair', 'food_butter', 'food_carrot', 'ceilingfan', 'drawing', 'knife', 'hanger', 'bathroom_counter', 'floor', 'phone', 'ceiling', 'thread', 'brush', 'plate', 'wall', 'bench', 'powersocket', 'oven', 'check', 'food_food', 'doorjamb', 'console', 'dresser', 'cupboard', 'door', 'maindoor', 'table', 'light']
Task:Eat
response:

I get my prepared dinner set on the dining table, sit down on chair, pick up utensils, eat food

[WALK] <dining_room>
[WALK] <food_food>
[FIND] <food_food>
[GRAB] <food_food>
[WALK] <dining_room>
[WALK]

[FIND]

[PUTBACK] <food_food>

[FIND] <chair>
[SIT] <chair>
[FIND] <fork>
[GRAB] <fork>
[FIND] <knife>
[GRAB] <knife>
[FIND] <plate>
[EAT] <plate>


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

Here is an example plan to achieve a goal for reference:
Scene_Objects:['sheets', 'water_glass', 'pot', 'spectacles', 'chair', 'freezer', 'walllamp', 'knifeblock', 'cpuscreen', 'ceiling', 'character', 'stovefan', 'mat', 'faucet', 'food_orange', 'wall', 'oven', 'cutting_board', 'food_food', 'water', 'tray', 'food_onion', 'doorjamb', 'mouse', 'kitchen_counter', 'cupboard', 'hair', 'sink', 'instrument_guitar', 'home_office']
Task:Drink
response:
{
    "thoughts": I go to the kitchen, take a glass from the cupboard, fill with water and drink,
    "actions": ['[WALK] <dining_room>', '[WALK] <cupboard>', '[FIND] <cupboard>', '[OPEN] <cupboard>', '[FIND] <water_glass>', '[GRAB] <water_glass>', '[WALK] <water>', '[FIND] <water>', '[GRAB] <water>', '[POUR] <water> <water_glass>', '[DRINK] <water_glass>', '[RINSE] <water_glass>', '[PUTBACK] <water_glass> <cupboard>']
}

Input:
Scene_Objects:['pot', 'tablelamp', 'chair', 'freezer', 'walllamp', 'ground_coffee', 'trashcan', 'knifeblock', 'orchid', 'floor', 'ceiling', 'folder', 'plate', 'faucet', 'tvstand', 'mousepad', 'candle', 'wall', 'pasta', 'oven', 'colander', 'wine', 'tray', 'kitchen_counter', 'dresser', 'cupboard', 'hair', 'sink', 'vase', 'soap']
Task:Wipe down counter
response:

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


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

Here is an example plan to achieve a goal for reference:
Scene_Objects:['microwave', 'toilet', 'walllamp', 'bathroom', 'detergent', 'trashcan', 'woman', 'knifeblock', 'needle', 'cpuscreen', 'desk', 'man', 'keyboard', 'bedroom', 'computer', 'stovefan', 'mat', 'ceilinglamp', 'nightstand', 'oven', 'cup', 'food_food', 'check', 'doorjamb', 'mouse', 'kitchen_counter', 'bathtub', 'bathroom_cabinet', 'table', 'light']
Task:Greet guests
response:
{
    "thoughts": Answer the door. Smile and give a warm hello, or other appropriate greeting. With newcomers to your home, offer your hand to be shook. With old friends it is appropriate to hug, or kiss one another on the cheek.,
    "actions": ['[WALK] <home_office>', '[WALK] <man>', '[FIND] <man>', '[GREET] <man>', '[FIND] <woman>', '[GREET] <woman>']
}

Input:
Scene_Objects:['glue', 'food_bread', 'chair', 'freezer', 'band-aids', 'walllamp', 'food_butter', 'drawing', 'orchid', 'knifeblock', 'floor', 'ceiling', 'button', 'clothes_jacket', 'toaster', 'ceilinglamp', 'microphone', 'wall', 'oven', 'powersocket', 'bed', 'food_food', 'coffe_maker', 'oven_mitts', 'ice', 'tray', 'curtain', 'pencil', 'clothes_dress', 'dishwasher']
Task:Make toast
response:

Place slices of bread in a toaster ,wait for the bread to pop up .Set aside.

[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>


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

Here is an example plan to achieve a goal for reference:
Scene_Objects:['pot', 'tablelamp', 'chair', 'walllamp', 'drawing', 'cpuscreen', 'wallshelf', 'floor', 'phone', 'ceiling', 'desk', 'keyboard', 'computer', 'bookmark', 'mat', 'tvstand', 'mousepad', 'couch', 'pillow', 'wall', 'oven', 'powersocket', 'photoframe', 'novel', 'television', 'tray', 'doorjamb', 'towel_rack', 'mouse', 'comb', 'door', 'light']
Task:Read book
response:
{
    "thoughts": Find book, grab book, fin bookmark, sit down somewhere comfortable, open book, read book, close book after reading.,
    "actions": ['[WALK] <desk>', '[FIND] <novel>', '[FIND] <bookmark>', '[GRAB] <bookmark>', '[FIND] <couch>', '[SIT] <couch>', '[GRAB] <novel>', '[READ] <novel>', '[PUTBACK] <bookmark> <novel>']
}

Input:
Scene_Objects:['filing_cabinet', 'food_salt', 'crayon', 'measuring_cup', 'tea', 'mop', 'chair', 'nail_polish', 'bathroom', 'hanger', 'shampoo', 'phone', 'character', 'thread', 'tvstand', 'food_peanut_butter', 'bench', 'tape', 'food_food', 'mouthwash', 'razor', 'wooden_spoon', 'curtain', 'lighter', 'controller', 'laundry_detergent', 'door', 'bag', 'dishwasher', 'teeth']
Task:Watch fly
response:

Look around for a fly, often on a wall or ceiling.  Follow it's movements.

[WALK] <bedroom>
[WALK] <fly>
[FIND] <fly>
[TURNTO] <fly>
[LOOKAT] <fly>


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

Here is an example plan to achieve a goal for reference:
Scene_Objects:['filing_cabinet', 'food_bread', 'crayon', 'tea', 'freezer', 'walllamp', 'bathroom', 'detergent', 'blow_dryer', 'drawing', 'floor', 'desk', 'thread', 'mop_bucket', 'tvstand', 'towel', 'wall', 'toy', 'cup', 'check', 'razor', 'food_donut', 'wine', 'centerpiece', 'mouse', 'kitchen_counter', 'vacuum_cleaner', 'laundry_detergent', 'light', 'soap']
Task:Vacuum
response:
{
    "thoughts": Robot has a vacuum underneath its feat/body that will allow it to clean the surface of the floor.,
    "actions": ['[WALK] <home_office>', '[WALK] <filing_cabinet>', '[OPEN] <filing_cabinet>', '[FIND] <vacuum_cleaner>', '[GRAB] <vacuum_cleaner>', '[PULL] <vacuum_cleaner>', '[PLUGIN] <vacuum_cleaner>', '[SWITCHON] <vacuum_cleaner>', '[PULL] <vacuum_cleaner>', '[PUSH] <vacuum_cleaner>', '[PULL] <vacuum_cleaner>', '[PUSH] <vacuum_cleaner>', '[WALK] <dining_room>', '[PULL] <vacuum_cleaner>', '[PUSH] <vacuum_cleaner>', '[PULL] <vacuum_cleaner>', '[PUSH] <vacuum_cleaner>', '[WALK] <home_office>', '[SWITCHOFF] <vacuum_cleaner>', '[PLUGOUT] <vacuum_cleaner>', '[WALK] <filing_cabinet>', '[PUTBACK] <vacuum_cleaner> <filing_cabinet>', '[CLOSE] <filing_cabinet>']
}

Input:
Scene_Objects:['trashcan', 'floor', 'ceiling', 'phone', 'computer', 'bookmark', 'toaster', 'mat', 'stereo', 'window', 'food_jam', 'pillow', 'dining_room', 'wall', 'powersocket', 'bed', 'check', 'mouthwash', 'television', 'tray', 'curtain', 'dishrack', 'dresser', 'laundry_detergent', 'hairdryer', 'sink', 'bathroom_cabinet', 'table', 'dishwasher', 'shoe_rack']
Task:Read book
response:

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


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

Here is an example plan to achieve a goal for reference:
Scene_Objects:['sheets', 'filing_cabinet', 'crayon', 'toilet', 'bathroom', 'nail_polish', 'trashcan', 'food_carrot', 'hanger', 'floor', 'computer', 'toaster', 'window', 'food_jam', 'nightstand', 'oven', 'bench', 'tape', 'photoframe', 'food_food', 'coffe_maker', 'television', 'toilet_paper', 'doorjamb', 'dresser', 'pajamas', 'cupboard', 'door', 'sink', 'home_office']
Task:Listen to music
response:
{
    "thoughts": I walk into the living room. I find the stereo and turn it on, and I listen to the music.,
    "actions": ['[WALK] <home_office>', '[WALK] <stereo>', '[FIND] <stereo>', '[SWITCHON] <stereo>']
}

Input:
Scene_Objects:['chair', 'bathroom', 'drawing', 'clothes_underwear', 'bathroom_counter', 'floor', 'character', 'computer', 'mop_bucket', 'bookmark', 'brush', 'ceilinglamp', 'faucet', 'window', 'couch', 'towel', 'dining_room', 'wall', 'newspaper', 'bed', 'television', 'wine', 'rag', 'mouse', 'napkin', 'bathroom_cabinet', 'table', 'dishwasher', 'light', 'soap']
Task:Read book
response:

Pick up a book and open to the last page you were on. Read the book.

[WALK] <home_office>
[WALK] <novel>
[FIND] <novel>
[GRAB] <novel>
[WALK] <couch>
[SIT] <couch>
[FIND] <bookmark>
[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:['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:['fork', 'dry_pasta', 'food_salt', 'chair', 'drawing', 'bills', 'hanger', 'floor', 'phone', 'ceiling', 'toaster', 'plate', 'wall', 'bench', 'powersocket', 'tape', 'cup', 'bed', 'check', 'food_food', 'tray', 'doorjamb', 'pencil', 'dishrack', 'dresser', 'cupboard', 'door', 'table', 'light', 'laser_pointer']
Task:Eat
response:

Serve food on dinning table in appropriate utensils, sit on the chair, eat

[WALK] <dining_room>
[WALK]

[FIND]

[TURNTO]

[FIND] <chair>
[SIT] <chair>
[FIND] <food_food>
[GRAB] <food_food>
[FIND] <plate>
[PUTBACK] <food_food> <plate>
[GRAB] <food_food>
[PUTOBJBACK] <food_food>
[FIND] <fork>
[GRAB] <fork>
[EAT] <plate>


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

Here is an example plan to achieve a goal for reference:
Scene_Objects:['pot', 'food_pizza', 'toilet', 'detergent', 'toothbrush', 'orchid', 'wallshelf', 'hanger', 'bedroom', 'bookshelf', 'computer', 'shower', 'window', 'cutting_board', 'food_cheese', 'novel', 'check', 'mouthwash', 'toothbrush_holder', 'wine', 'doorjamb', 'pajamas', 'hairdryer', 'maindoor', 'bathtub', 'home_office', 'door', 'clothes_skirt', 'tooth_paste', 'teeth']
Task:Wash teeth
response:
{
    "thoughts": walk to bathroom, look at the toothbrush holder, grab the toothbrush from the toothbrush holder, find the toothpaste, squeeze the toothpaste into toothbrush, now wash the teeth,
    "actions": ['[WALK] <bathroom>', '[WALK] <toothbrush_holder>', '[FIND] <toothbrush_holder>', '[TURNTO] <toothbrush_holder>', '[LOOKAT] <toothbrush_holder>', '[FIND] <toothbrush>', '[GRAB] <toothbrush>', '[FIND] <tooth_paste>', '[SQUEEZE] <tooth_paste>', '[FIND] <teeth>', '[WASH] <teeth>']
}

Input:
Scene_Objects:['microwave', 'bathroom', 'cat', 'ceilingfan', 'woman', 'drawing', 'knifeblock', 'floor', 'ceiling', 'bedroom', 'bookshelf', 'ceilinglamp', 'tvstand', 'balanceball', 'window', 'mousepad', 'couch', 'wall', 'child', 'oven', 'toy', 'bed', 'clothes_gloves', 'television', 'curtain', 'centerpiece', 'kitchen_counter', 'spoon', 'table', 'vase']
Task:Watch movie
response:

Sitting and watching  a movie with family

[WALK] <home_office>
[WALK] <child>
[FIND] <child>
[TURNTO] <child>
[LOOKAT] <child>
[GREET] <child>
[FIND] <woman>
[TURNTO] <woman>
[LOOKAT] <woman>
[GREET] <woman>
[WALK] <television>
[SWITCHON] <television>
[TURNTO] <television>
[LOOKAT] <television>
[TOUCH] <television>
[TURNTO] <television>
[LOOKAT] <television>
[TOUCH] <television>
[TURNTO] <television>
[LOOKAT] <television>
[TOUCH] <television>
[WALK] <couch>
[SIT] <couch>
[TURNTO] <television>
[LOOKAT] <television>
[WATCH] <television>
[WATCH] <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:['fork', 'scissors', 'tea', 'freezer', 'walllamp', 'knifeblock', 'knife', 'bills', 'floor', 'toaster', 'mat', 'plate', 'stereo', 'picture', 'tvstand', 'dish_soap', 'microphone', 'wall', 'oven', 'cup', 'light_bulb', 'coffe_maker', 'drinking_glass', 'tray', 'mouse', 'cupboard', 'controller', 'maindoor', 'spoon', 'dishwasher']
Task:Wash dishes with dishwasher
response:
{
    "thoughts": Walk to the kitchen and turn to the dishwasher, put the knife, glass, fork and plate into the dishwasher. Turn on the dishwasher.,
    "actions": ['[WALK] <dining_room>', '[WALK] <dishwasher>', '[FIND] <dishwasher>', '[TURNTO] <dishwasher>', '[FIND] <dish_soap>', '[GRAB] <dish_soap>', '[OPEN] <dishwasher>', '[PUTBACK] <dish_soap> <dishwasher>', '[FIND] <drinking_glass>', '[GRAB] <drinking_glass>', '[PUTBACK] <drinking_glass> <dishwasher>', '[FIND] <fork>', '[GRAB] <fork>', '[PUTBACK] <fork> <dishwasher>', '[FIND] <knife>', '[GRAB] <knife>', '[PUTBACK] <knife> <dishwasher>', '[FIND] <plate>', '[GRAB] <plate>', '[PUTBACK] <plate> <dishwasher>', '[CLOSE] <dishwasher>', '[SWITCHON] <dishwasher>']
}

Input:
Scene_Objects:['microwave', 'freezer', 'trashcan', 'knifeblock', 'drawing', 'food_egg', 'clothes_underwear', 'orchid', 'bathroom_counter', 'ceiling', 'folder', 'cleaning_solution', 'mat', 'faucet', 'broom', 'wall', 'toy', 'box', 'photoframe', 'bed', 'food_food', 'mirror', 'paper_towel', 'dresser', 'maindoor', 'sink', 'bathroom_cabinet', 'table', 'dishwasher', 'vase']
Task:Clean mirror
response:

First spray the mirrors with Windex or window type spray.  Take paper towels and wipe until sparkly clean.  If they have streaks, repeat the process.

[WALK] <bathroom>
[WALK] <bathroom_cabinet>
[OPEN] <bathroom_cabinet>
[FIND] <paper_towel>
[GRAB] <paper_towel>
[CLOSE] <bathroom_cabinet>
[WALK] <mirror>
[FIND] <cleaning_solution>
[RINSE] <cleaning_solution>
[WIPE] <mirror>


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', 'chair', 'freezer', 'walllamp', 'bathroom', 'orchid', 'cpuscreen', 'hanger', 'floor', 'ceiling', 'phone', 'desk', 'keyboard', 'computer', 'mop_bucket', 'ceilinglamp', 'mat', 'electric_shaver', 'mousepad', 'wall', 'powersocket', 'photoframe', 'food_food', 'coffe_maker', 'mouse', 'pencil', 'controller', 'door', 'table', 'teeth']
Task:Work
response:
{
    "thoughts": walk to home office ,find computer ,switch on computer and work,
    "actions": ['[WALK] <home_office>', '[WALK] <computer>', '[FIND] <computer>', '[SWITCHON] <computer>']
}

Input:
Scene_Objects:['pot', 'toilet', 'freezer', 'ground_coffee', 'ceilingfan', 'drawing', 'orchid', 'floor', 'ceiling', 'character', 'video_game_console', 'table_cloth', 'ceilinglamp', 'tvstand', 'balanceball', 'window', 'couch', 'dustpan', 'pillow', 'wall', 'cup', 'video_game_controller', 'television', 'curtain', 'dishrack', 'napkin', 'table', 'vase', 'scrabble', 'shoe_rack']
Task:Play games
response:

[WALK] <home_office>
[WALK] <television>
[PLUGIN] <television>
[SWITCHON] <television>
[FIND] <video_game_console>
[PLUGIN] <video_game_console>
[SWITCHON] <video_game_console>
[FIND] <video_game_console>
[FIND] <video_game_controller>
[GRAB] <video_game_controller>
[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:['microwave', 'cat', 'food_carrot', 'drawing', 'knifeblock', 'cpuscreen', 'wallshelf', 'hanger', 'bathroom_counter', 'ceiling', 'desk', 'bookshelf', 'keyboard', 'mousepad', 'bench', 'newspaper', 'coffe_maker', 'food_food', 'tray', 'curtain', 'mouse', 'door', 'hairdryer', 'sink', 'food_steak', 'light', 'dishwasher', 'spoon', 'table', 'board_game']
Task:Write  school paper
response:
{
    "thoughts": Writing  and drafting a paper for  class work,
    "actions": ['[WALK] <home_office>', '[WALK] <computer>', '[SWITCHON] <computer>', '[SWITCHOFF] <computer>']
}

Input:
Scene_Objects:['pot', 'scissors', 'food_salt', 'toilet', 'band-aids', 'drawing', 'orchid', 'clothes_underwear', 'hanger', 'longboard', 'floor', 'ceiling', 'bedroom', 'bookshelf', 'ceilinglamp', 'mat', 'stereo', 'tvstand', 'towel', 'pillow', 'bowl', 'wall', 'nightstand', 'mouthwash', 'dresser', 'clothes_dress', 'maindoor', 'bathroom_cabinet', 'clothes_skirt', 'creditcard']
Task:Hang up jacket
response:

I put clothes on hangers and hang them in the closet

[WALK] <bedroom>
[WALK] <clothes_dress>
[FIND] <clothes_dress>
[GRAB] <clothes_dress>
[WALK] <dresser>
[FIND] <hanger>
[OPEN] <dresser>
[PUTIN] <clothes_dress> <dresser>
[FIND] <clothes_dress>
[GRAB] <clothes_dress>
[WALK] <dresser>
[PUTIN] <clothes_dress> <dresser>
[CLOSE] <dresser>


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', 'spectacles', 'microwave', 'walllamp', 'drawing', 'orchid', 'hanger', 'floor', 'character', 'desk', 'alcohol', 'stovefan', 'ceilinglamp', 'mat', 'window', 'couch', 'pillow', 'wall', 'oven', 'powersocket', 'cutting_board', 'photoframe', 'light_bulb', 'television', 'curtain', 'kettle', 'napkin', 'bathroom_cabinet', 'table', 'creditcard']
Task:Relax on sofa
response:
{
    "thoughts": walk to living room, walk to sofa, sit on sofa.,
    "actions": ['[WALK] <home_office>', '[WALK] <couch>', '[SIT] <couch>']
}

Input:
Scene_Objects:['sponge', 'toilet', 'bathroom', 'trashcan', 'milk', 'drawing', 'orchid', 'floor', 'ceiling', 'bedroom', 'bookshelf', 'computer', 'clothes_jacket', 'toaster', 'stovefan', 'tvstand', 'picture', 'window', 'dustpan', 'pillow', 'dining_room', 'wall', 'box', 'bed', 'wine', 'curtain', 'kettle', 'home_office', 'light', 'dishwasher']
Task:Look out window
response:

I head into my child's room and look out the window to view the neighborhood from a different area in the house.

[WALK] <bedroom>
[WALK] <window>
[TURNTO] <window>
[LOOKAT] <window>