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

Here is an example plan to achieve a goal for reference:
Scene_Objects:['glue', 'pot', 'toilet', 'chair', 'freezer', 'band-aids', 'bathroom', 'food_carrot', 'drawing', 'floor', 'mat', 'window', 'couch', 'clothes_hat', 'form', 'pillow', 'bench', 'food_food', 'check', 'coffe_maker', 'toilet_paper', 'ice', 'centerpiece', 'doorjamb', 'cupboard', 'home_office', 'table', 'light', 'bathroom_cabinet', 'scrabble']
Task:Eat dinner
response:
{
    "thoughts": In our dining room, my family eats dinner. Once the food has been prepared, we gather at the dining room table and prepare to eat.,
    "actions": ['[WALK] <dining_room>', '[WALK] <food_food>', '[FIND] <food_food>', '[GRAB] <food_food>', '[WALK] <dining_room>', '[WALK] <table>', '[PUTBACK] <food_food> <table>', '[WALK] <dining_room>', '[WALK] <food_food>', '[FIND] <food_food>', '[GRAB] <food_food>', '[WALK] <dining_room>', '[WALK] <table>', '[PUTBACK] <food_food> <table>', '[WALK] <chair>', '[PULL] <chair>', '[SIT] <chair>', '[TURNTO] <food_food>', '[LOOKAT] <food_food>', '[TURNTO] <food_food>', '[LOOKAT] <food_food>']
}

Input:
Scene_Objects:['pot', 'food_bread', 'chair', 'food_carrot', 'cpuscreen', 'bathroom_counter', 'character', 'bedroom', 'keyboard', 'food_bacon', 'bookmark', 'stovefan', 'ceilinglamp', 'tvstand', 'picture', 'window', 'pillow', 'bench', 'love_seat', 'photoframe', 'novel', 'coin', 'curtain', 'towel_rack', 'mouse', 'pencil', 'sink', 'light', 'table', 'instrument_violin']
Task:Read book
response:

Obtain a book from the book shelf. Sit in the easy chair.  Read the book.  Mark the stopping point with a bookmark.  Put the book back on the book shelf.

[WALK] <home_office>
[WALK] <novel>
[FIND] <novel>
[GRAB] <novel>
[FIND] <love_seat>
[SIT] <love_seat>
[READ] <novel>
[FIND] <bookmark>
[GRAB] <bookmark>
[PUTBACK] <bookmark> <novel>
[PUTOBJBACK] <novel>


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

Here is an example plan to achieve a goal for reference:
Scene_Objects:['tablelamp', 'microwave', 'toilet', 'freezer', 'walllamp', 'trashcan', 'drawing', 'cpuscreen', 'wallshelf', 'hanger', 'floor', 'ceiling', 'character', 'food_bacon', 'mat', 'ceilinglamp', 'shower', 'wall', 'wall_clock', 'cup', 'photoframe', 'bed', 'food_food', 'tray', 'doorjamb', 'mouse', 'kitchen_counter', 'cupboard', 'door', 'coffee']
Task:Drink
response:
{
    "thoughts": Walk into kitchen, look for cup, walk to cup, look for refrigerator, walk to refrigerator, open door, grab water, pour water into cup,
    "actions": ['[WALK] <dining_room>', '[WALK] <cup>', '[FIND] <cup>', '[TURNTO] <cup>', '[LOOKAT] <cup>', '[WALK] <cup>', '[FIND] <freezer>', '[TURNTO] <freezer>', '[LOOKAT] <freezer>', '[WALK] <freezer>', '[GRAB] <cup>', '[WALK] <water>', '[FIND] <water>', '[GRAB] <water>', '[POUR] <water> <cup>']
}

Input:
Scene_Objects:['food_pizza', 'chair', 'freezer', 'walllamp', 'food_carrot', 'knifeblock', 'floor', 'ceiling', 'desk', 'keyboard', 'computer', 'toaster', 'mat', 'faucet', 'window', 'oil', 'couch', 'wall', 'bench', 'powersocket', 'photoframe', 'bed', 'television', 'curtain', 'after_shave', 'towel_rack', 'kitchen_counter', 'bathtub', 'sink', 'light']
Task:Open bathroom window
response:

Make sure bathroom window is unlocked. Lift up bathroom window so it is open.

[WALK] <bathroom>
[WALK] <window>
[FIND] <window>
[OPEN] <window>


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

Here is an example plan to achieve a goal for reference:
Scene_Objects:['dry_pasta', 'tablelamp', 'chair', 'walllamp', 'orchid', 'floor', 'ceiling', 'phone', 'bookshelf', 'remote_control', 'computer', 'ceilinglamp', 'tvstand', 'window', 'oil', 'closetdrawer', 'couch', 'pillow', 'dining_room', 'nightstand', 'wall', 'oven', 'bed', 'coffe_maker', 'television', 'curtain', 'dresser', 'door', 'instrument_guitar', 'table']
Task:Watch TV
response:
{
    "thoughts": I go to the living room, switch on the tv, take the remote and sit on the sofa.,
    "actions": ['[WALK] <home_office>', '[WALK] <remote_control>', '[FIND] <remote_control>', '[GRAB] <remote_control>', '[FIND] <couch>', '[SIT] <couch>', '[FIND] <television>', '[SWITCHON] <television>', '[TURNTO] <television>', '[WATCH] <television>']
}

Input:
Scene_Objects:['walllamp', 'drawing', 'orchid', 'wallshelf', 'knifeblock', 'knife', 'bathroom_counter', 'floor', 'ceiling', 'bookshelf', 'mat', 'tvstand', 'ceilinglamp', 'shower', 'window', 'couch', 'pillow', 'wall', 'powersocket', 'photoframe', 'light_bulb', 'television', 'curtain', 'doorjamb', 'cd', 'pajamas', 'door', 'table', 'light', 'dishwasher']
Task:Watch TV
response:

Sitting on the couch watching my favorite television show.

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


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

Here is an example plan to achieve a goal for reference:
Scene_Objects:['sheets', 'tablelamp', 'microwave', 'walllamp', 'milk', 'clothes_underwear', 'character', 'bedroom', 'keyboard', 'clothes_socks', 'candle', 'clothes_pants', 'wall', 'nightstand', 'powersocket', 'basket_for_clothes', 'photoframe', 'bed', 'food_food', 'curtain', 'diary', 'shoes', 'headset', 'laundry_detergent', 'sink', 'home_office', 'table', 'colander', 'clothes_shirt', 'washing_machine']
Task:Wash clothes
response:
{
    "thoughts": I grab the basket for clothes from the bedroom. I carry it and walk to the washing machine. I open the washing machine. I grab the dirty clothes. I put the clothes in the washing machine. I grab the laundry detergent and put it in the washing machine. I close the washing machine. I switch on the washing machine.,
    "actions": ['[WALK] <bedroom>', '[WALK] <basket_for_clothes>', '[FIND] <basket_for_clothes>', '[GRAB] <basket_for_clothes>', '[WALK] <washing_machine>', '[DROP] <basket_for_clothes>', '[OPEN] <washing_machine>', '[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>', '[FIND] <laundry_detergent>', '[GRAB] <laundry_detergent>', '[PUTBACK] <laundry_detergent> <washing_machine>', '[GRAB] <laundry_detergent>', '[PUTOBJBACK] <laundry_detergent>', '[CLOSE] <washing_machine>', '[SWITCHON] <washing_machine>']
}

Input:
Scene_Objects:['pot', 'tea', 'microwave', 'chair', 'freezer', 'walllamp', 'milk', 'knifeblock', 'knife', 'drawing', 'floor', 'ceiling', 'shampoo', 'desk', 'bookshelf', 'stovefan', 'toaster', 'faucet', 'food_jam', 'pillow', 'wall', 'oven', 'powersocket', 'cup', 'photoframe', 'tray', 'kitchen_counter', 'cupboard', 'controller', 'sink']
Task:Get something to drink
response:

Walk into the kitchen and to the cupboard to get a cup, walk to the fridge to look for a beverage to enjoy, open the freezer and get ice, pour beverage and enjoy

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


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', 'tea', 'chair', 'detergent', 'toothbrush', 'orchid', 'knifeblock', 'cpuscreen', 'kitchen_cabinet', 'floor', 'phone', 'bedroom', 'keyboard', 'ceilinglamp', 'faucet', 'window', 'dish_soap', 'food_jam', 'food_orange', 'pillow', 'wall', 'oven', 'bed', 'novel', 'coffe_maker', 'kitchen_counter', 'dishrack', 'cupboard', 'table', 'dishwasher']
Task:Wash dishes with dishwasher
response:
{
    "thoughts": I walk to the kitchen. I open the dishwasher. I open the kitchen cabinet. I reach inside the cabinet and grab the box of dish soap. I add some soap to the open dishwasher. I put the box of dish soap back in the kitchen cabinet. I close the kitchen cabinet and then I close the dishwasher. I turn the dishwasher on and wait.,
    "actions": ['[WALK] <dining_room>', '[WALK] <dishwasher>', '[FIND] <dishwasher>', '[OPEN] <dishwasher>', '[FIND] <kitchen_cabinet>', '[OPEN] <kitchen_cabinet>', '[FIND] <dish_soap>', '[GRAB] <dish_soap>', '[PUTBACK] <dish_soap> <dishwasher>', '[GRAB] <dish_soap>', '[PUTIN] <dish_soap> <kitchen_cabinet>', '[CLOSE] <kitchen_cabinet>', '[CLOSE] <dishwasher>', '[SWITCHON] <dishwasher>']
}

Input:
Scene_Objects:['pot', 'filing_cabinet', 'dog', 'bathroom', 'knife', 'phone', 'character', 'desk', 'clothes_jacket', 'mat', 'ceilinglamp', 'window', 'mousepad', 'pillow', 'dining_room', 'photoframe', 'keys', 'coffe_maker', 'food_food', 'check', 'ice', 'tray', 'towel_rack', 'mouse', 'shoes', 'cupboard', 'bathtub', 'home_office', 'light', 'bathroom_cabinet']
Task:Get ready to leave
response:

Get your jacket and shoes on, locate the keys off the side table, walk out the front door and secure building with keys when you leave

[WALK] <home_office>
[WALK] <shoes>
[FIND] <shoes>
[GRAB] <shoes>
[PUTON] <shoes>
[FIND] <keys>
[GRAB] <keys>


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

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

Input:
Scene_Objects:['sheets', 'toilet', 'trashcan', 'drawing', 'orchid', 'knifeblock', 'floor', 'ceiling', 'bedroom', 'keyboard', 'stovefan', 'mousepad', 'couch', 'pillow', 'wall', 'wall_clock', 'powersocket', 'newspaper', 'coffee_table', 'novel', 'bed', 'oven_mitts', 'doorjamb', 'pencil', 'chessboard', 'dresser', 'door', 'food_steak', 'table', 'light']
Task:Read magazine
response:

Get magazine off coffee table. Sit in arm chair. Open magazine to first page. Read until finished.

[WALK] <home_office>
[WALK] <coffee_table>
[FIND] <newspaper>
[GRAB] <newspaper>
[FIND] <couch>
[SIT] <couch>
[READ] <newspaper>
[PUTBACK] <newspaper> <coffee_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:['spectacles', 'filing_cabinet', 'chair', 'walllamp', 'bathroom', 'cpuscreen', 'floor', 'ceiling', 'phone', 'desk', 'keyboard', 'bookshelf', 'computer', 'ceilinglamp', 'tvstand', 'mousepad', 'dining_room', 'wall', 'powersocket', 'oven', 'newspaper', 'bed', 'television', 'doorjamb', 'mouse', 'kitchen_counter', 'shoes', 'cupboard', 'bathroom_cabinet', 'table']
Task:Use computer
response:
{
    "thoughts": Sit at desk, use the computer mouse,
    "actions": ['[WALK] <home_office>', '[WALK] <chair>', '[FIND] <chair>', '[SIT] <chair>', '[FIND] <computer>', '[SWITCHON] <computer>', '[FIND] <mouse>', '[GRAB] <mouse>', '[FIND] <mousepad>', '[PUTBACK] <mouse> <mousepad>', '[TURNTO] <computer>', '[POINTAT] <computer>']
}

Input:
Scene_Objects:['tablelamp', 'blender', 'chair', 'bathroom', 'detergent', 'drawing', 'cpuscreen', 'floor', 'phone', 'desk', 'mat', 'tvstand', 'clothes_pants', 'wall', 'nightstand', 'powersocket', 'photoframe', 'bed', 'novel', 'check', 'keys', 'tray', 'after_shave', 'curtain', 'doorjamb', 'kitchen_counter', 'cupboard', 'door', 'bathtub', 'tooth_paste']
Task:Read
response:

[WALK] <bedroom>
[WALK] <desk>
[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:['spectacles', 'tablelamp', 'microwave', 'chair', 'wallshelf', 'hanger', 'floor', 'phone', 'food_bacon', 'piano_bench', 'stovefan', 'ceilinglamp', 'shower', 'mousepad', 'closetdrawer', 'powersocket', 'television', 'coin', 'food_donut', 'ice', 'rag', 'pencil', 'shoes', 'dresser', 'clothes_dress', 'clothes_scarf', 'sink', 'bathroom_cabinet', 'light', 'home_office']
Task:Hang up jacket
response:
{
    "thoughts": I put clothes on hangers and hang them in the closet,
    "actions": ['[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>']
}

Input:
Scene_Objects:['crayon', 'chair', 'freezer', 'blow_dryer', 'bathroom', 'cat', 'trashcan', 'orchid', 'bathroom_counter', 'floor', 'desk', 'keyboard', 'shower', 'window', 'mousepad', 'microphone', 'dining_room', 'wall', 'pasta', 'bench', 'oven', 'newspaper', 'check', 'television', 'tray', 'curtain', 'towel_rack', 'mouse', 'home_office', 'bathroom_cabinet']
Task:Read newspaper
response:

Pull out dining room chair. Sit in dining room chair. Open newspaper to section you'd like to read. Read section. Keep reading all sections you'd like.

[WALK] <dining_room>
[WALK] <newspaper>
[FIND] <newspaper>
[GRAB] <newspaper>
[FIND] <chair>
[SIT] <chair>
[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:['tablelamp', 'food_ice_cream', 'measuring_cup', 'freezer', 'ceilingfan', 'cpuscreen', 'longboard', 'ceiling', 'character', 'bedroom', 'toaster', 'stereo', 'balanceball', 'oil', 'couch', 'food_orange', 'pillow', 'food_kiwi', 'nightstand', 'photoframe', 'coffe_maker', 'rag', 'doorjamb', 'towel_rack', 'shoes', 'controller', 'napkin', 'bathroom_cabinet', 'laser_pointer', 'dirt']
Task:Pick up phone
response:
{
    "thoughts": Go to the living room.  Find the telephone.  Lift up the receiver.,
    "actions": ['[WALK] <home_office>', '[WALK] <phone>', '[FIND] <phone>', '[GRAB] <phone>']
}

Input:
Scene_Objects:['walllamp', 'knifeblock', 'knife', 'cpuscreen', 'ceiling', 'bookshelf', 'purse', 'face', 'mail', 'mat', 'deck_of_cards', 'tvstand', 'homework', 'pillow', 'dining_room', 'nightstand', 'powersocket', 'box', 'photoframe', 'bed', 'novel', 'check', 'coffe_maker', 'mirror', 'tray', 'hair', 'clothes_dress', 'sink', 'bathroom_cabinet', 'home_office']
Task:Check appearance in mirror
response:

Walk to full-length mirror. Look in mirror. Make sure everything about your appearance is adequate. Adjust clothes as needed.

[WALK] <bedroom>
[WALK] <mirror>
[FIND] <mirror>
[TURNTO] <mirror>
[LOOKAT] <mirror>
[FIND] <face>
[TURNTO] <face>
[LOOKAT] <face>
[FIND] <hair>
[TURNTO] <hair>
[LOOKAT] <hair>
[FIND] <clothes_dress>
[TURNTO] <clothes_dress>
[LOOKAT] <clothes_dress>


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', 'dog', 'bathroom', 'trashcan', 'drawing', 'orchid', 'wallshelf', 'floor', 'ceiling', 'character', 'desk', 'shower', 'electric_shaver', 'window', 'couch', 'pillow', 'wall', 'nightstand', 'newspaper', 'bed', 'food_food', 'doorjamb', 'towel_rack', 'mouse', 'kitchen_counter', 'cupboard', 'door', 'bathroom_cabinet', 'table', 'light']
Task:Relax on sofa
response:
{
    "thoughts": I walk to the living room and find the sofa. I sit on the sofa and get comfortable.,
    "actions": ['[WALK] <home_office>', '[WALK] <couch>', '[FIND] <couch>', '[SIT] <couch>']
}

Input:
Scene_Objects:['tablelamp', 'chair', 'knifeblock', 'drawing', 'cpuscreen', 'orchid', 'floor', 'phone', 'bedroom', 'keyboard', 'mat', 'tvstand', 'floor_lamp', 'teeth', 'couch', 'pillow', 'wall', 'nightstand', 'powersocket', 'bed', 'ice', 'tray', 'after_shave', 'doorjamb', 'centerpiece', 'mouse', 'dresser', 'light', 'coffee', 'creditcard']
Task:Turn on lights
response:

Walk to your lamp, switch it on, and lay on your bed

[WALK] <bedroom>
[WALK] <floor_lamp>
[FIND] <floor_lamp>
[TURNTO] <floor_lamp>
[SWITCHON] <floor_lamp>
[FIND] <bed>
[LIE] <bed>


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

Here is an example plan to achieve a goal for reference:
Scene_Objects:['filing_cabinet', 'juice', 'freezer', 'blow_dryer', 'trashcan', 'drawing', 'cpuscreen', 'longboard', 'floor', 'bookmark', 'ceilinglamp', 'mat', 'window', 'couch', 'microphone', 'clothes_hat', 'pillow', 'wall', 'bench', 'cup', 'keys', 'television', 'towel_rack', 'cd', 'cupboard', 'conditioner', 'door', 'home_office', 'table', 'vase']
Task:Relax on sofa
response:
{
    "thoughts": Go to the living room and relax on the sofa with a book,
    "actions": ['[RUN] <home_office>', '[WALK] <novel>', '[FIND] <novel>', '[GRAB] <novel>', '[WALK] <couch>', '[SIT] <couch>', '[TURNTO] <novel>', '[LOOKAT] <novel>', '[FIND] <bookmark>', '[GRAB] <bookmark>', '[DROP] <bookmark>', '[TURNTO] <novel>', '[LOOKAT] <novel>', '[READ] <novel>', '[READ] <novel>', '[READ] <novel>']
}

Input:
Scene_Objects:['pot', 'tablelamp', 'microwave', 'chair', 'freezer', 'cat', 'cpuscreen', 'bathroom_counter', 'floor', 'phone', 'character', 'stovefan', 'mat', 'tvstand', 'stereo', 'iron', 'food_kiwi', 'powersocket', 'newspaper', 'novel', 'coffe_maker', 'tray', 'doorjamb', 'towel_rack', 'mouse', 'kitchen_counter', 'conditioner', 'bathtub', 'home_office', 'electrical_outlet']
Task:Turn on radio
response:

Go to the radio.  Switch on the power button.  Tune the station.  Set the volume.  Listen to the music.

[WALK] <home_office>
[WALK] <stereo>
[FIND] <stereo>
[FIND] <electrical_outlet>
[TURNTO] <electrical_outlet>
[PLUGIN] <stereo>
[SWITCHON] <electrical_outlet>
[SWITCHON] <stereo>


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

Here is an example plan to achieve a goal for reference:
Scene_Objects:['blender', 'chair', 'shampoo', 'ceiling', 'folder', 'face', 'computer', 'ceilinglamp', 'tvstand', 'balanceball', 'picture', 'oil', 'food_orange', 'dining_room', 'bench', 'box', 'newspaper', 'check', 'video_game_controller', 'mirror', 'curtain', 'towel_rack', 'hair', 'clothes_dress', 'laundry_detergent', 'bathroom_cabinet', 'table', 'clothes_skirt', 'vase', 'scrabble']
Task:Check appearance in mirror
response:
{
    "thoughts": Walk to full-length mirror. Look in mirror. Make sure everything about your appearance is adequate. Adjust clothes as needed.,
    "actions": ['[WALK] <bedroom>', '[WALK] <mirror>', '[FIND] <mirror>', '[TURNTO] <mirror>', '[LOOKAT] <mirror>', '[FIND] <face>', '[TURNTO] <face>', '[LOOKAT] <face>', '[FIND] <hair>', '[TURNTO] <hair>', '[LOOKAT] <hair>', '[FIND] <clothes_dress>', '[TURNTO] <clothes_dress>', '[LOOKAT] <clothes_dress>']
}

Input:
Scene_Objects:['sheets', 'pot', 'filing_cabinet', 'tablelamp', 'mop', 'microwave', 'toilet', 'band-aids', 'bathroom', 'trashcan', 'wallshelf', 'character', 'computer', 'mat', 'faucet', 'couch', 'dining_room', 'wall', 'newspaper', 'oven_mitts', 'tray', 'curtain', 'rag', 'doorjamb', 'towel_rack', 'mouse', 'sink', 'bathroom_cabinet', 'table', 'scrabble']
Task:Shut front door
response:

Close the storm door. Lock the storm 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:['tablelamp', 'freezer', 'walllamp', 'ground_coffee', 'trashcan', 'drawing', 'cpuscreen', 'floor', 'phone', 'ceiling', 'character', 'bookshelf', 'food_cake', 'mat', 'tvstand', 'shoe-shine_kit', 'homework', 'oil', 'couch', 'food_peanut_butter', 'pillow', 'dining_room', 'wall', 'bench', 'oven', 'powersocket', 'toilet_paper', 'kitchen_counter', 'door', 'tooth_paste']
Task:Pick up phone
response:
{
    "thoughts": walk over and pick up the phone,
    "actions": ['[WALK] <phone>', '[GRAB] <phone>']
}

Input:
Scene_Objects:['pot', 'tablelamp', 'microwave', 'walllamp', 'bathroom', 'knifeblock', 'drawing', 'wallshelf', 'floor', 'desk', 'keyboard', 'mat', 'tvstand', 'shower', 'faucet', 'stereo', 'wall', 'nightstand', 'powersocket', 'photoframe', 'television', 'toothbrush_holder', 'curtain', 'doorjamb', 'towel_rack', 'kitchen_counter', 'cupboard', 'bathtub', 'table', 'dishwasher']
Task:Put in chair
response:

Take a comfortable chair. Place it in the entrance hall

[WALK] <home_office>
[WALK] <chair>
[FIND] <chair>
[GRAB] <chair>
[WALK] <home_office>
[WALK] <floor>
[FIND] <floor>
[PUTBACK] <chair> <floor>


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

Here is an example plan to achieve a goal for reference:
Scene_Objects:['microwave', 'toilet', 'freezer', 'walllamp', 'bathroom', 'orchid', 'drawing', 'wallshelf', 'hanger', 'bathroom_counter', 'ceiling', 'desk', 'computer', 'ceilinglamp', 'shower', 'window', 'mousepad', 'closetdrawer', 'pillow', 'wall', 'wall_clock', 'powersocket', 'photoframe', 'bed', 'food_food', 'mouse', 'vacuum_cleaner', 'bathtub', 'sink', 'table']
Task:Pick up phone
response:
{
    "thoughts": Walk into the living room, walk over to phone, grab the phone, put it to your ear .,
    "actions": ['[WALK] <home_office>', '[WALK] <phone>', '[GRAB] <phone>']
}

Input:
Scene_Objects:['walllamp', 'orchid', 'wallshelf', 'floor', 'ceiling', 'bedroom', 'bookshelf', 'mat', 'tvstand', 'ceilinglamp', 'shower', 'window', 'mousepad', 'dining_room', 'wall', 'nightstand', 'powersocket', 'photoframe', 'keys', 'television', 'curtain', 'food_onion', 'doorjamb', 'mouse', 'dresser', 'pajamas', 'sink', 'home_office', 'light', 'instrument_guitar']
Task:Turn off TV
response:

[WALK] <home_office>
[WALK] <television>
[SWITCHOFF] <television>


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

Here is an example plan to achieve a goal for reference:
Scene_Objects:['sheets', 'tablelamp', 'blender', 'freezer', 'walllamp', 'dough', 'orchid', 'drawing', 'floor', 'ceiling', 'remote_control', 'ceilinglamp', 'tvstand', 'mat', 'shower', 'window', 'picture', 'couch', 'pillow', 'bowl', 'wall', 'powersocket', 'television', 'curtain', 'doorjamb', 'coffee_pot', 'dishrack', 'door', 'sink', 'table']
Task:Watch TV
response:
{
    "thoughts": Turn on the TV, sit on the couch, find a show, and watch it.,
    "actions": ['[WALK] <home_office>', '[WALK] <television>', '[FIND] <television>', '[FIND] <remote_control>', '[FIND] <couch>', '[SIT] <couch>', '[SWITCHON] <television>', '[TURNTO] <television>', '[LOOKAT] <television>']
}

Input:
Scene_Objects:['spectacles', 'tablelamp', 'blender', 'microwave', 'chair', 'walllamp', 'cpuscreen', 'bathroom_counter', 'ceiling', 'character', 'mail', 'food_bacon', 'mat', 'stereo', 'faucet', 'homework', 'shower', 'dining_room', 'wall', 'oven', 'keys', 'television', 'food_onion', 'coffee_pot', 'towel_rack', 'kitchen_counter', 'laundry_detergent', 'bag', 'spoon', 'table']
Task:Put away keys
response:

[WALK] <home_office>
[WALK] <keys>
[FIND] <keys>
[GRAB] <keys>
[FIND] <bag>
[OPEN] <bag>
[PUTBACK] <keys> <bag>
[CLOSE] <bag>


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', 'drawing', 'wallshelf', 'floor', 'ceiling', 'shampoo', 'character', 'desk', 'bookshelf', 'mat', 'deck_of_cards', 'couch', 'pillow', 'wall', 'powersocket', 'cup', 'food_cheese', 'photoframe', 'bed', 'coffee_filter', 'wine', 'curtain', 'doorjamb', 'kitchen_counter', 'pajamas', 'door', 'food_steak', 'bag', 'light', 'electrical_outlet']
Task:Turn on light
response:
{
    "thoughts": I walk to the living room. I find the electric outlet. I switch on the light.,
    "actions": ['[WALK] <home_office>', '[WALK] <electrical_outlet>', '[FIND] <electrical_outlet>', '[FIND] <light>', '[SWITCHON] <light>']
}

Input:
Scene_Objects:['spectacles', 'glue', 'tea', 'chair', 'freezer', 'walllamp', 'knifeblock', 'bathroom_counter', 'floor', 'phone', 'bedroom', 'keyboard', 'bookshelf', 'food_bacon', 'tvstand', 'faucet', 'window', 'mousepad', 'wall', 'powersocket', 'photoframe', 'coffe_maker', 'toilet_paper', 'diary', 'mouse', 'chessboard', 'spoon', 'home_office', 'table', 'light']
Task:Sit in chair
response:

[WALK] <dining_room>
[WALK] <chair>
[FIND] <chair>
[PULL] <chair>
[SIT] <chair>


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

Here is an example plan to achieve a goal for reference:
Scene_Objects:['glue', 'tablelamp', 'microwave', 'freezer', 'drawing', 'phone', 'bookshelf', 'toaster', 'stovefan', 'tvstand', 'mousepad', 'couch', 'clothes_hat', 'food_orange', 'wall', 'photoframe', 'clothes_gloves', 'bed', 'check', 'television', 'food_rice', 'tray', 'doorjamb', 'dresser', 'hairdryer', 'sink', 'bathtub', 'bathroom_cabinet', 'light', 'door']
Task:Listen to music
response:
{
    "thoughts": I go to my bedroom, and then I switch on the radio,
    "actions": ['[WALK] <bedroom>', '[WALK] <stereo>', '[FIND] <stereo>', '[SWITCHON] <stereo>']
}

Input:
Scene_Objects:['walllamp', 'nail_polish', 'trashcan', 'milk', 'drawing', 'wallshelf', 'bathroom_counter', 'ceiling', 'phone', 'bedroom', 'bookshelf', 'computer', 'faucet', 'pillow', 'wall', 'photoframe', 'toilet_paper', 'check', 'coffe_maker', 'wine', 'after_shave', 'towel_rack', 'comb', 'controller', 'sink', 'bathroom_cabinet', 'light', 'table', 'instrument_violin', 'teeth']
Task:Get toilet paper
response:

There are extra toilet papers in the bottom cabinet.

[WALK] <bathroom>
[WALK] <bathroom_cabinet>
[FIND] <bathroom_cabinet>
[OPEN] <bathroom_cabinet>
[FIND] <toilet_paper>
[GRAB] <toilet_paper>
[CLOSE] <bathroom_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', 'microwave', 'chair', 'freezer', 'wallshelf', 'cpuscreen', 'floor', 'phone', 'desk', 'remote_control', 'computer', 'button', 'toaster', 'mat', 'shower', 'food_peanut_butter', 'food_kiwi', 'nightstand', 'oven', 'photoframe', 'television', 'oven_mitts', 'tray', 'kettle', 'cards', 'pencil', 'kitchen_counter', 'towel_rack', 'bathtub', 'table']
Task:Change TV channel
response:
{
    "thoughts": Walk into living room. Find television remote control. Pick up remote control. Press button.,
    "actions": ['[WALK] <home_office>', '[WALK] <remote_control>', '[FIND] <remote_control>', '[GRAB] <remote_control>', '[FIND] <button>', '[PUSH] <button>']
}

Input:
Scene_Objects:['spectacles', 'pot', 'scissors', 'microwave', 'chair', 'freezer', 'drawing', 'orchid', 'cpuscreen', 'floor', 'ceiling', 'toaster', 'tvstand', 'faucet', 'dining_room', 'wall', 'bed', 'novel', 'food_food', 'mouthwash', 'rag', 'doorjamb', 'mouse', 'kitchen_counter', 'dresser', 'cupboard', 'home_office', 'bathroom_cabinet', 'soap', 'shoe_rack']
Task:Added meat to freezer
response:

After shopping for groceries, i returned home, i walked to the dining room and placed meat items in freezer located in the dining room. I opened up the bags from the grocery store, removed all the meat items, and after opening the freezer door, i placed the meat items into the freezer, and closed the door.

[WALK] <dining_room>
[WALK] <freezer>
[FIND] <freezer>
[OPEN] <freezer>
[FIND] <food_food>
[GRAB] <food_food>
[PUTBACK] <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:['jelly', 'freezer', 'walllamp', 'bathroom', 'bills', 'needle', 'drawing', 'character', 'table_cloth', 'toaster', 'picture', 'floor_lamp', 'window', 'mousepad', 'microphone', 'food_kiwi', 'wall', 'wall_clock', 'newspaper', 'bed', 'television', 'tray', 'cupboard', 'controller', 'door', 'sink', 'bathtub', 'bathroom_cabinet', 'light', 'home_office']
Task:Turn on light
response:
{
    "thoughts": I go to bedroom and locate a lamp. This lamp can be turned on by touch, as it has capacitive sensing. So I do it.,
    "actions": ['[WALK] <bedroom>', '[WALK] <floor_lamp>', '[FIND] <floor_lamp>', '[TOUCH] <floor_lamp>', '[SWITCHON] <floor_lamp>']
}

Input:
Scene_Objects:['pot', 'tablelamp', 'microwave', 'toilet', 'chair', 'freezer', 'drawing', 'knifeblock', 'orchid', 'bathroom_counter', 'floor', 'bookshelf', 'keyboard', 'mat', 'shoe-shine_kit', 'window', 'foundation', 'cup', 'photoframe', 'check', 'coffe_maker', 'centerpiece', 'kitchen_counter', 'shoes', 'bathtub', 'sink', 'bathroom_cabinet', 'light', 'napkin', 'instrument_violin']
Task:Look at mirror
response:

I look at my reflection to check my cleanliness.

[WALK] <bathroom>
[WALK] <mirror>
[FIND] <mirror>
[TURNTO] <mirror>
[LOOKAT] <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:['tablelamp', 'mop', 'walllamp', 'drawing', 'wallshelf', 'floor', 'ceiling', 'phone', 'desk', 'bookshelf', 'computer', 'toaster', 'mat', 'tvstand', 'ceilinglamp', 'couch', 'candle', 'pillow', 'wall', 'powersocket', 'photoframe', 'light_bulb', 'check', 'television', 'rag', 'doorjamb', 'kitchen_counter', 'door', 'bathroom_cabinet', 'light']
Task:Relax on sofa
response:
{
    "thoughts": I go to the living room, switch off the light, sit in the sofa and do nothing.,
    "actions": ['[WALK] <home_office>', '[WALK] <light>', '[FIND] <light>', '[SWITCHOFF] <light>', '[FIND] <couch>', '[SIT] <couch>', '[LIE] <couch>']
}

Input:
Scene_Objects:['filing_cabinet', 'tablelamp', 'toilet', 'chair', 'walllamp', 'detergent', 'trashcan', 'food_carrot', 'knifeblock', 'drawing', 'cpuscreen', 'knife', 'bathroom_counter', 'desk', 'keyboard', 'bookshelf', 'table_cloth', 'toaster', 'ceilinglamp', 'faucet', 'mousepad', 'pillow', 'dining_room', 'oven', 'photoframe', 'food_food', 'kitchen_counter', 'dresser', 'sink', 'home_office']
Task:Turn off light
response:

Walk to the lamp.  Find the switch.  Click the switch off.

[WALK] <bedroom>
[WALK] <floor_lamp>
[SWITCHOFF] <floor_lamp>


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

Here is an example plan to achieve a goal for reference:
Scene_Objects:['sheets', 'microwave', 'chair', 'freezer', 'food_butter', 'drawing', 'food_egg', 'floor', 'ceiling', 'character', 'stovefan', 'ceilinglamp', 'faucet', 'shower', 'couch', 'wall', 'nightstand', 'bench', 'oven', 'cup', 'novel', 'ice', 'curtain', 'doorjamb', 'kettle', 'pencil', 'headset', 'sink', 'bathroom_cabinet', 'light']
Task:Drink
response:
{
    "thoughts": Walk into kitchen, look for cup, walk to cup, look for refrigerator, walk to refrigerator, open door, grab water, pour water into cup,
    "actions": ['[WALK] <dining_room>', '[WALK] <cup>', '[FIND] <cup>', '[TURNTO] <cup>', '[LOOKAT] <cup>', '[WALK] <cup>', '[FIND] <freezer>', '[TURNTO] <freezer>', '[LOOKAT] <freezer>', '[WALK] <freezer>', '[GRAB] <cup>', '[WALK] <water>', '[FIND] <water>', '[GRAB] <water>', '[POUR] <water> <cup>']
}

Input:
Scene_Objects:['pot', 'microwave', 'toilet', 'freezer', 'trashcan', 'drawing', 'wallshelf', 'cpuscreen', 'floor', 'desk', 'bookshelf', 'toaster', 'mat', 'ceilinglamp', 'plate', 'window', 'couch', 'pillow', 'wall', 'nightstand', 'bench', 'photoframe', 'coffe_maker', 'food_rice', 'dresser', 'cupboard', 'bathroom_cabinet', 'table', 'dishwasher', 'home_office']
Task:Set up table
response:

Get dishes. Place dishes neatly around table. Get food. Place food on middle of table.

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

[PUTBACK] <plate>

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

[PUTBACK] <plate>

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

[PUTBACK] <plate>

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

[PUTBACK] <food_food>

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

[PUTBACK] <food_food>


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

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

Input:
Scene_Objects:['tablelamp', 'chair', 'bathroom', 'trashcan', 'orchid', 'drawing', 'cpuscreen', 'knifeblock', 'floor', 'dvd_player', 'computer', 'bookmark', 'brush', 'ceilinglamp', 'faucet', 'electric_shaver', 'floor_lamp', 'mousepad', 'wall', 'powersocket', 'novel', 'food_food', 'check', 'television', 'after_shave', 'cupboard', 'sink', 'home_office', 'table', 'tooth_paste']
Task:Turn on light
response:

Twist the lamp switch until the light goes on.

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


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

Here is an example plan to achieve a goal for reference:
Scene_Objects:['walllamp', 'orchid', 'wallshelf', 'floor', 'ceiling', 'bedroom', 'bookshelf', 'mat', 'tvstand', 'ceilinglamp', 'shower', 'window', 'mousepad', 'dining_room', 'wall', 'nightstand', 'powersocket', 'photoframe', 'keys', 'television', 'curtain', 'food_onion', 'doorjamb', 'mouse', 'dresser', 'pajamas', 'sink', 'home_office', 'light', 'instrument_guitar']
Task:Turn off TV
response:
{
    "thoughts": Walk over to tv and press power button,
    "actions": ['[WALK] <home_office>', '[WALK] <television>', '[SWITCHOFF] <television>']
}

Input:
Scene_Objects:['fork', 'pot', 'sheets', 'chair', 'freezer', 'walllamp', 'milk', 'knife', 'drawing', 'kitchen_cabinet', 'floor', 'ceiling', 'toaster', 'mat', 'stovefan', 'window', 'food_jam', 'pillow', 'wall', 'bed', 'photoframe', 'food_food', 'check', 'curtain', 'towel_rack', 'mouse', 'kitchen_counter', 'cupboard', 'home_office', 'table']
Task:Look in refrigerator
response:

Approach the refrigerator. Use the handle to open the refrigerator door. Look at each shelf of the refrigerator. Look in each refrigerator drawer. Close the refrigerator door.

[WALK] <dining_room>
[WALK] <freezer>
[FIND] <freezer>
[TURNTO] <freezer>
[WALK] <freezer>
[OPEN] <freezer>
[TURNTO] <freezer>
[LOOKAT] <freezer>
[FIND] <kitchen_cabinet>
[OPEN] <kitchen_cabinet>
[FIND] <food_food>
[CLOSE] <kitchen_cabinet>
[CLOSE] <freezer>


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

Here is an example plan to achieve a goal for reference:
Scene_Objects:['sheets', 'juice', 'tea', 'toilet', 'freezer', 'walllamp', 'dough', 'drawing', 'food_egg', 'floor', 'dvd_player', 'character', 'alcohol', 'stovefan', 'mat', 'shower', 'closetdrawer', 'clothes_hat', 'food_jam', 'wall', 'powersocket', 'curtain', 'doorjamb', 'mouse', 'kitchen_counter', 'laundry_detergent', 'door', 'light', 'dishwasher', 'table']
Task:Go to toilet
response:
{
    "thoughts": I walk to the entrance of the bathroom. I turn to the door. I open the door to the bathroom. I walk inside of the bathroom. I find the toilet inside of the bathroom and walk over to it. I turn and look at the toilet.,
    "actions": ['[WALK] <bathroom>', '[WALK] <toilet>', '[FIND] <toilet>', '[TURNTO] <toilet>', '[LOOKAT] <toilet>', '[WALK] <toilet>', '[TURNTO] <toilet>']
}

Input:
Scene_Objects:['sponge', 'pot', 'dog', 'walllamp', 'knifeblock', 'cpuscreen', 'floor', 'ceiling', 'phone', 'bedroom', 'keyboard', 'computer', 'stovefan', 'faucet', 'oil', 'pillow', 'wall', 'wall_clock', 'oven', 'pasta', 'keys', 'check', 'tray', 'food_onion', 'kitchen_counter', 'cupboard', 'door', 'sink', 'bathtub', 'light']
Task:Keep an eye on stove as something is cooking
response:

Watch whatever is cooking on the stove so it doesn't burn or pour. Turn off heat when done

[WALK] <dining_room>
[WALK] <oven>
[FIND] <pot>
[TURNTO] <pot>
[LOOKAT] <pot>
[FIND] <wall_clock>
[TURNTO] <wall_clock>
[LOOKAT] <wall_clock>
[SWITCHOFF] <oven>


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

Here is an example plan to achieve a goal for reference:
Scene_Objects:['spectacles', 'pot', 'scissors', 'microwave', 'chair', 'freezer', 'drawing', 'orchid', 'cpuscreen', 'floor', 'ceiling', 'toaster', 'tvstand', 'faucet', 'dining_room', 'wall', 'bed', 'novel', 'food_food', 'mouthwash', 'rag', 'doorjamb', 'mouse', 'kitchen_counter', 'dresser', 'cupboard', 'home_office', 'bathroom_cabinet', 'soap', 'shoe_rack']
Task:Added meat to freezer
response:
{
    "thoughts": After shopping for groceries, i returned home, i walked to the dining room and placed meat items in freezer located in the dining room. I opened up the bags from the grocery store, removed all the meat items, and after opening the freezer door, i placed the meat items into the freezer, and closed the door.,
    "actions": ['[WALK] <dining_room>', '[WALK] <freezer>', '[FIND] <freezer>', '[OPEN] <freezer>', '[FIND] <food_food>', '[GRAB] <food_food>', '[PUTBACK] <food_food> <freezer>', '[CLOSE] <freezer>']
}

Input:
Scene_Objects:['filing_cabinet', 'tablelamp', 'microwave', 'toilet', 'freezer', 'knifeblock', 'drawing', 'wallshelf', 'ceiling', 'phone', 'desk', 'keyboard', 'face', 'toaster', 'laptop', 'tvstand', 'shower', 'stereo', 'homework', 'oil', 'towel', 'oven', 'basket_for_clothes', 'tray', 'towel_rack', 'hair', 'cupboard', 'door', 'bathtub', 'clothes_shirt']
Task:Rain welcome
response:

The robot would greet me and then hand me a towel.  It would make an appropriate quip about the weather while I dried off.  It would receive the wet towel when I was done.

[WALK] <bedroom>
[WALK] <towel>
[FIND] <towel>
[GRAB] <towel>
[FIND] <face>
[WIPE] <face>
[FIND] <hair>
[WIPE] <hair>
[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:['food_bread', 'tablelamp', 'chair', 'freezer', 'drawing', 'orchid', 'needle', 'floor', 'phone', 'mail', 'mat', 'plate', 'faucet', 'stereo', 'couch', 'dustpan', 'dining_room', 'wall', 'bench', 'oven', 'toy', 'cup', 'newspaper', 'standingmirror', 'food_food', 'razor', 'console', 'towel_rack', 'bathtub', 'table']
Task:Set up table
response:
{
    "thoughts": Get dishes. Place dishes neatly around table. Get food. Place food on middle of table.,
    "actions": ['[WALK] <dining_room>', '[WALK] <plate>', '[FIND] <plate>', '[GRAB] <plate>', '[WALK] <dining_room>', '[WALK] <table>', '[PUTBACK] <plate> <table>', '[WALK] <dining_room>', '[WALK] <plate>', '[FIND] <plate>', '[GRAB] <plate>', '[WALK] <dining_room>', '[WALK] <table>', '[PUTBACK] <plate> <table>', '[WALK] <dining_room>', '[WALK] <plate>', '[FIND] <plate>', '[GRAB] <plate>', '[WALK] <dining_room>', '[WALK] <table>', '[PUTBACK] <plate> <table>', '[WALK] <dining_room>', '[WALK] <food_food>', '[FIND] <food_food>', '[GRAB] <food_food>', '[WALK] <dining_room>', '[WALK] <table>', '[PUTBACK] <food_food> <table>', '[WALK] <dining_room>', '[WALK] <food_food>', '[FIND] <food_food>', '[GRAB] <food_food>', '[WALK] <dining_room>', '[WALK] <table>', '[PUTBACK] <food_food> <table>']
}

Input:
Scene_Objects:['glue', 'filing_cabinet', 'tablelamp', 'chair', 'bathroom', 'drawing', 'wallshelf', 'clothes_underwear', 'hanger', 'character', 'bookshelf', 'clothes_jacket', 'piano_bench', 'ceilinglamp', 'shower', 'mousepad', 'teeth', 'pillow', 'check', 'toothbrush_holder', 'coin', 'doorjamb', 'mouse', 'kitchen_counter', 'bathtub', 'sink', 'bathroom_cabinet', 'table', 'dishwasher', 'coffee']
Task:Close door
response:


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

Here is an example plan to achieve a goal for reference:
Scene_Objects:['tablelamp', 'jelly', 'drawing', 'floor', 'bedroom', 'table_cloth', 'stovefan', 'mat', 'plate', 'window', 'couch', 'wall', 'nightstand', 'wall_clock', 'cutting_board', 'bed', 'novel', 'tray', 'curtain', 'doorjamb', 'diary', 'mouse', 'pencil', 'cd', 'clothes_dress', 'bathroom_cabinet', 'table', 'light', 'vase', 'laser_pointer']
Task:Read book
response:
{
    "thoughts": I would go lie down in my bed and open the book and start reading.,
    "actions": ['[WALK] <bedroom>', '[WALK] <bed>', '[FIND] <bed>', '[LIE] <bed>', '[FIND] <novel>', '[GRAB] <novel>', '[READ] <novel>']
}

Input:
Scene_Objects:['dry_pasta', 'pot', 'measuring_cup', 'microwave', 'chair', 'orchid', 'floor', 'ceiling', 'phone', 'desk', 'bedroom', 'cleaning_solution', 'keyboard', 'mop_bucket', 'stovefan', 'faucet', 'couch', 'clothes_pants', 'coffe_maker', 'mirror', 'curtain', 'rag', 'coffee_pot', 'towel_rack', 'kitchen_counter', 'dresser', 'cupboard', 'door', 'sink', 'dishwasher']
Task:Clean mirror
response:

Spray the mirror with a cleaner, take a dry rag and wipe the mirror down until its clean.

[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>
[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:['pot', 'food_bread', 'microwave', 'chair', 'knifeblock', 'drawing', 'keyboard', 'button', 'stovefan', 'toaster', 'shower', 'window', 'dustpan', 'pillow', 'dining_room', 'nightstand', 'tape', 'novel', 'television', 'tray', 'curtain', 'after_shave', 'doorjamb', 'kitchen_counter', 'cupboard', 'clothes_dress', 'sink', 'bathroom_cabinet', 'light', 'dishwasher']
Task:Browse internet
response:
{
    "thoughts": I pick up my phone. I touch it to navigate to the web browser. I can swipe and tap the screen to visit different websites. Then I read or watch the content within those websites.,
    "actions": ['[WALK] <home_office>', '[WALK] <phone>', '[FIND] <phone>', '[GRAB] <phone>', '[TOUCH] <phone>', '[TURNTO] <phone>', '[LOOKAT] <phone>']
}

Input:
Scene_Objects:['tablelamp', 'food_salt', 'microwave', 'freezer', 'walllamp', 'bathroom', 'cpuscreen', 'bathroom_counter', 'ceiling', 'keyboard', 'computer', 'food_bacon', 'table_cloth', 'ceilinglamp', 'faucet', 'picture', 'clothes_socks', 'towel', 'dining_room', 'wall', 'pasta', 'bed', 'centerpiece', 'kitchen_counter', 'door', 'bathtub', 'home_office', 'light', 'table', 'colander']
Task:Clean screen
response:

Use a soft rag to wipe the screen until there are no marks on it.

[WALK] <home_office>
[WALK] <rag>
[FIND] <rag>
[GRAB] <rag>
[WALK] <computer>
[WIPE] <computer>
[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:['chair', 'walllamp', 'blow_dryer', 'orchid', 'cpuscreen', 'floor', 'ceiling', 'desk', 'keyboard', 'thread', 'computer', 'mat', 'ceilinglamp', 'tvstand', 'mousepad', 'closetdrawer', 'couch', 'pillow', 'dining_room', 'wall', 'photoframe', 'television', 'doorjamb', 'mouse', 'dresser', 'door', 'sink', 'light', 'table', 'creditcard']
Task:Browse internet
response:
{
    "thoughts": Walk to home office. Walk to computer. Switch on Computer.,
    "actions": ['[WALK] <home_office>', '[WALK] <computer>', '[SWITCHON] <computer>']
}

Input:
Scene_Objects:['filing_cabinet', 'mop', 'chair', 'bathroom', 'food_carrot', 'woman', 'drawing', 'orchid', 'bathroom_counter', 'floor', 'ceiling', 'man', 'keyboard', 'mat', 'faucet', 'window', 'foundation', 'nightstand', 'powersocket', 'cup', 'coffe_maker', 'food_food', 'television', 'tray', 'towel_rack', 'cd', 'dresser', 'sink', 'clothes_scarf', 'light']
Task:Greet guests
response:

Stand next to the door. When the door opens from the outside, greet the guests.

[RUN] <home_office>
[WALK] <woman>
[FIND] <woman>
[TURNTO] <woman>
[LOOKAT] <woman>
[GREET] <woman>
[FIND] <man>
[TURNTO] <man>
[LOOKAT] <man>
[GREET] <man>


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_pizza', 'tablelamp', 'food_ice_cream', 'crayon', 'shampoo', 'keyboard', 'mail', 'bookmark', 'stovefan', 'faucet', 'pillow', 'dining_room', 'broom', 'wall', 'love_seat', 'photoframe', 'novel', 'food_food', 'wine', 'tray', 'after_shave', 'shaving_cream', 'kettle', 'headset', 'pajamas', 'laundry_detergent', 'door', 'bathroom_cabinet', 'shoe_rack']
Task:Read book
response:
{
    "thoughts": Obtain a book from the book shelf. Sit in the easy chair.  Read the book.  Mark the stopping point with a bookmark.  Put the book back on the book shelf.,
    "actions": ['[WALK] <home_office>', '[WALK] <novel>', '[FIND] <novel>', '[GRAB] <novel>', '[FIND] <love_seat>', '[SIT] <love_seat>', '[READ] <novel>', '[FIND] <bookmark>', '[GRAB] <bookmark>', '[PUTBACK] <bookmark> <novel>', '[PUTOBJBACK] <novel>']
}

Input:
Scene_Objects:['microwave', 'dog', 'freezer', 'walllamp', 'cat', 'knifeblock', 'bills', 'desk', 'bookshelf', 'keyboard', 'computer', 'ceilinglamp', 'faucet', 'clothes_hat', 'broom', 'powersocket', 'bench', 'coffe_maker', 'food_food', 'television', 'mirror', 'rag', 'lighter', 'towel_rack', 'mouse', 'dresser', 'sink', 'table', 'clothes_skirt', 'shoe_rack']
Task:Clean mirror
response:

Spray glass cleaner on mirror. Wipe with a clean cloth.

[WALK] <bathroom>
[WALK] <cleaning_solution>
[FIND] <cleaning_solution>
[GRAB] <cleaning_solution>
[WALK] <mirror>
[PUTOBJBACK] <cleaning_solution>
[FIND] <rag>
[GRAB] <rag>
[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:['measuring_cup', 'microwave', 'chair', 'walllamp', 'cat', 'wallshelf', 'floor', 'character', 'desk', 'tea_bag', 'toaster', 'plate', 'couch', 'dining_room', 'box', 'newspaper', 'bed', 'toilet_paper', 'curtain', 'coffee_pot', 'mouse', 'kettle', 'cupboard', 'controller', 'clothes_dress', 'sink', 'bathroom_cabinet', 'table', 'dishwasher', 'soap']
Task:Pet cat
response:
{
    "thoughts": Find Cat in living room.  Walk to cat.  Pet cat.,
    "actions": ['[WALK] <home_office>', '[WALK] <cat>', '[FIND] <cat>', '[TURNTO] <cat>', '[LOOKAT] <cat>', '[TOUCH] <cat>']
}

Input:
Scene_Objects:['fork', 'pot', 'tablelamp', 'chair', 'walllamp', 'trashcan', 'knifeblock', 'bathroom_counter', 'keyboard', 'computer', 'brush', 'tvstand', 'shower', 'faucet', 'mousepad', 'wall', 'bench', 'cup', 'bed', 'photoframe', 'clothes_gloves', 'tray', 'wooden_spoon', 'towel_rack', 'dresser', 'cupboard', 'door', 'bathtub', 'napkin', 'bathroom_cabinet']
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:['tablelamp', 'food_salt', 'toilet', 'chair', 'bathroom', 'cat', 'trashcan', 'drawing', 'orchid', 'wallshelf', 'clothes_underwear', 'phone', 'ceiling', 'dvd_player', 'desk', 'stovefan', 'faucet', 'shower', 'closetdrawer', 'dining_room', 'wall', 'wall_clock', 'powersocket', 'oven', 'photoframe', 'bed', 'tray', 'mouse', 'dresser', 'home_office']
Task:Keep cats out of room
response:
{
    "thoughts": Stand in the doorway and create a loud noise so the cats will stay out.,
    "actions": ['[WALK] <bedroom>', '[WALK] <cat>', '[FIND] <cat>', '[TURNTO] <cat>', '[LOOKAT] <cat>', '[FIND] <cat>', '[TURNTO] <cat>', '[LOOKAT] <cat>']
}

Input:
Scene_Objects:['sponge', 'pot', 'filing_cabinet', 'tablelamp', 'microwave', 'walllamp', 'knifeblock', 'wallshelf', 'cpuscreen', 'floor', 'ceiling', 'character', 'mat', 'plate', 'faucet', 'ceilinglamp', 'dish_soap', 'mousepad', 'couch', 'dining_room', 'wall', 'oven', 'bench', 'basket_for_clothes', 'towel_rack', 'kitchen_counter', 'dishrack', 'cupboard', 'sink', 'light']
Task:Wash dirty dishes
response:

Wet the sponge, apply soap to sponge, scrub dishes, rinse dishes, place on dish rack.

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


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

Here is an example plan to achieve a goal for reference:
Scene_Objects:['pot', 'tablelamp', 'chair', 'walllamp', 'drawing', 'orchid', 'cpuscreen', 'wallshelf', 'hanger', 'floor', 'phone', 'ceiling', 'desk', 'keyboard', 'computer', 'mat', 'ceilinglamp', 'tvstand', 'mousepad', 'couch', 'pillow', 'wall', 'nightstand', 'oven', 'powersocket', 'keys', 'television', 'tray', 'doorjamb', 'towel_rack', 'mouse', 'dresser', 'door', 'light']
Task:Write an email
response:
{
    "thoughts": I need to send an email to my friend so I go into my office and sit down at the desk. I turn on the computer and type the email.,
    "actions": ['[WALK] <home_office>', '[WALK] <desk>', '[FIND] <desk>', '[TURNTO] <desk>', '[LOOKAT] <desk>', '[FIND] <chair>', '[SIT] <chair>', '[FIND] <computer>', '[SWITCHON] <computer>', '[FIND] <keyboard>', '[TYPE] <keyboard>']
}

Input:
Scene_Objects:['pot', 'filing_cabinet', 'food_salt', 'microwave', 'toilet', 'freezer', 'bathroom', 'trashcan', 'knife', 'cpuscreen', 'ceiling', 'bedroom', 'bookshelf', 'brush', 'stovefan', 'toaster', 'window', 'couch', 'wall_clock', 'powersocket', 'toy', 'bed', 'television', 'ice', 'curtain', 'mouse', 'dresser', 'controller', 'bathroom_cabinet', 'shoe_rack']
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:['freezer', 'walllamp', 'bathroom', 'drawing', 'cpuscreen', 'floor', 'ceiling', 'character', 'remote_control', 'computer', 'mat', 'ceilinglamp', 'tvstand', 'window', 'electric_shaver', 'mousepad', 'couch', 'pillow', 'wall', 'nightstand', 'powersocket', 'photoframe', 'television', 'curtain', 'mouse', 'kitchen_counter', 'dresser', 'bathtub', 'table', 'light']
Task:Watch TV
response:
{
    "thoughts": watching TV from sofa,
    "actions": ['[WALK] <home_office>', '[WALK] <television>', '[FIND] <television>', '[PLUGIN] <television>', '[SWITCHON] <television>', '[FIND] <couch>', '[SIT] <couch>', '[FIND] <remote_control>', '[GRAB] <remote_control>', '[DROP] <remote_control>', '[TURNTO] <television>', '[LOOKAT] <television>']
}

Input:
Scene_Objects:['filing_cabinet', 'tea', 'chair', 'knifeblock', 'knife', 'cpuscreen', 'wallshelf', 'floor', 'phone', 'character', 'desk', 'bedroom', 'bookshelf', 'food_bacon', 'mat', 'shoe-shine_kit', 'food_jam', 'wall', 'powersocket', 'oven', 'photoframe', 'novel', 'mouthwash', 'coffee_filter', 'tray', 'curtain', 'vacuum_cleaner', 'dresser', 'bathtub', 'soap']
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:['chair', 'walllamp', 'bathroom', 'orchid', 'knife', 'cpuscreen', 'floor', 'ceiling', 'phone', 'desk', 'keyboard', 'computer', 'button', 'table_cloth', 'ceilinglamp', 'mousepad', 'closetdrawer', 'dining_room', 'wall', 'powersocket', 'shelf', 'television', 'doorjamb', 'mouse', 'dresser', 'door', 'home_office', 'light', 'table', 'laser_pointer']
Task:Write an email
response:
{
    "thoughts": Find the computer.  Turn on the computer.  Open the e-mail program.  Create a new message.  Write the message.,
    "actions": ['[WALK] <home_office>', '[WALK] <computer>', '[FIND] <computer>', '[SWITCHON] <computer>']
}

Input:
Scene_Objects:['pot', 'tablelamp', 'chair', 'freezer', 'walllamp', 'milk', 'floor', 'keyboard', 'table_cloth', 'stovefan', 'mat', 'tvstand', 'faucet', 'window', 'couch', 'clothes_hat', 'pillow', 'dining_room', 'toy', 'basket_for_clothes', 'coffe_maker', 'video_game_controller', 'tray', 'doorjamb', 'kettle', 'dresser', 'cupboard', 'clothes_dress', 'sink', 'table']
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:['filing_cabinet', 'chair', 'walllamp', 'knifeblock', 'orchid', 'cpuscreen', 'floor', 'ceiling', 'dvd_player', 'desk', 'keyboard', 'computer', 'bookmark', 'stovefan', 'ceilinglamp', 'mat', 'mousepad', 'oil', 'food_peanut_butter', 'broom', 'wall', 'novel', 'diary', 'mouse', 'cupboard', 'clothes_dress', 'door', 'table', 'light', 'dirt']
Task:Browse internet
response:
{
    "thoughts": Go to office. Turn on computer. Pull out chair. Sit in chair. Use keyboard and mouse.,
    "actions": ['[WALK] <home_office>', '[WALK] <computer>', '[FIND] <computer>', '[SWITCHON] <computer>', '[FIND] <chair>', '[PULL] <chair>', '[SIT] <chair>', '[TURNTO] <computer>', '[LOOKAT] <computer>', '[FIND] <keyboard>', '[TYPE] <keyboard>', '[FIND] <mouse>', '[GRAB] <mouse>']
}

Input:
Scene_Objects:['filing_cabinet', 'beer', 'crayon', 'freezer', 'walllamp', 'bathroom', 'detergent', 'wallshelf', 'floor', 'ceiling', 'purse', 'computer', 'mat', 'tvstand', 'shower', 'window', 'couch', 'food_peanut_butter', 'dining_room', 'wall', 'photoframe', 'bed', 'television', 'curtain', 'diary', 'cupboard', 'controller', 'bathroom_cabinet', 'table', 'dishwasher']
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:['food_salt', 'chair', 'ground_coffee', 'food_butter', 'dough', 'drawing', 'floor', 'desk', 'bookmark', 'mat', 'faucet', 'floor_lamp', 'window', 'mousepad', 'couch', 'dustpan', 'pillow', 'wall', 'nightstand', 'oven', 'cup', 'novel', 'television', 'curtain', 'doorjamb', 'chessboard', 'controller', 'maindoor', 'home_office', 'table']
Task:Read book
response:
{
    "thoughts": First I walk into the living room, I find the lamp and switch it on. Then I find a book, grab it, sit in the sofa, open the book and read it. When I'm finished, I find a bookmark, grab it and put it in the book. Then I close the book, put it back, and switch off the lamp.,
    "actions": ['[WALK] <home_office>', '[WALK] <floor_lamp>', '[FIND] <floor_lamp>', '[SWITCHON] <floor_lamp>', '[FIND] <novel>', '[GRAB] <novel>', '[FIND] <couch>', '[SIT] <couch>', '[READ] <novel>', '[FIND] <bookmark>', '[GRAB] <bookmark>', '[PUTBACK] <bookmark> <novel>', '[PUTOBJBACK] <novel>', '[SWITCHOFF] <floor_lamp>']
}

Input:
Scene_Objects:['sponge', 'pot', 'microwave', 'walllamp', 'cat', 'food_carrot', 'knifeblock', 'floor', 'ceiling', 'toaster', 'faucet', 'window', 'dish_soap', 'dining_room', 'wall', 'oven', 'cup', 'drinking_glass', 'curtain', 'mouse', 'kitchen_counter', 'cd', 'dishrack', 'shoes', 'dresser', 'cupboard', 'sink', 'spoon', 'bathroom_cabinet', 'bathtub']
Task:Clean dishes
response:

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


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

Here is an example plan to achieve a goal for reference:
Scene_Objects:['fork', 'pot', 'tablelamp', 'microwave', 'dog', 'walllamp', 'trashcan', 'knifeblock', 'knife', 'kitchen_cabinet', 'floor', 'ceiling', 'toaster', 'stovefan', 'plate', 'faucet', 'ceilinglamp', 'oil', 'wall', 'oven', 'coffe_maker', 'drinking_glass', 'tray', 'kitchen_counter', 'cupboard', 'sink', 'spoon', 'bag', 'dishwasher', 'colander']
Task:Unload dishwasher
response:
{
    "thoughts": Open the dishwasher door. Take out all of the dishes and silverware. Put the dishes and silverware in their drawers and cabinets. Close the dishwasher door.,
    "actions": ['[WALK] <dining_room>', '[WALK] <dishwasher>', '[FIND] <dishwasher>', '[OPEN] <dishwasher>', '[FIND] <drinking_glass>', '[GRAB] <drinking_glass>', '[FIND] <cupboard>', '[OPEN] <cupboard>', '[PUTBACK] <drinking_glass> <cupboard>', '[FIND] <fork>', '[GRAB] <fork>', '[FIND] <kitchen_cabinet>', '[OPEN] <kitchen_cabinet>', '[PUTIN] <fork> <kitchen_cabinet>', '[FIND] <knife>', '[GRAB] <knife>', '[PUTIN] <knife> <kitchen_cabinet>', '[FIND] <spoon>', '[GRAB] <spoon>', '[PUTIN] <spoon> <kitchen_cabinet>', '[FIND] <plate>', '[GRAB] <plate>', '[PUTIN] <plate> <kitchen_cabinet>', '[CLOSE] <kitchen_cabinet>', '[CLOSE] <dishwasher>']
}

Input:
Scene_Objects:['sheets', 'food_ice_cream', 'toilet', 'walllamp', 'dough', 'drawing', 'knifeblock', 'cpuscreen', 'clothes_underwear', 'floor', 'ceiling', 'character', 'bedroom', 'window', 'couch', 'pillow', 'wall', 'powersocket', 'basket_for_clothes', 'bed', 'food_food', 'television', 'doorjamb', 'mouse', 'pencil', 'dishrack', 'door', 'home_office', 'light', 'bathroom_cabinet']
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', 'food_bread', 'tablelamp', 'juice', 'cd_player', 'band-aids', 'walllamp', 'cpuscreen', 'bathroom_counter', 'ceiling', 'desk', 'stovefan', 'stereo', 'homework', 'food_orange', 'nightstand', 'bench', 'bed', 'newspaper', 'photoframe', 'coffe_maker', 'check', 'food_onion', 'curtain', 'doorjamb', 'dresser', 'door', 'sink', 'bathtub', 'light']
Task:Listen to music
response:
{
    "thoughts": I walk in the living room, then I go the the stereo and the cd player and turn them on.,
    "actions": ['[WALK] <home_office>', '[WALK] <stereo>', '[FIND] <stereo>', '[SWITCHON] <stereo>', '[FIND] <cd_player>', '[SWITCHON] <cd_player>']
}

Input:
Scene_Objects:['sponge', 'drawing', 'orchid', 'cpuscreen', 'floor', 'ceiling', 'shampoo', 'character', 'desk', 'bookmark', 'mat', 'mousepad', 'couch', 'food_orange', 'pillow', 'wall', 'wall_clock', 'bed', 'photoframe', 'coffe_maker', 'check', 'doorjamb', 'towel_rack', 'door', 'bathtub', 'home_office', 'table', 'light', 'instrument_guitar', 'scrabble']
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:['food_oatmeal', 'microwave', 'freezer', 'bathroom', 'nail_polish', 'dough', 'food_carrot', 'orchid', 'drawing', 'knife', 'kitchen_cabinet', 'floor', 'ceiling', 'desk', 'brush', 'mat', 'couch', 'pillow', 'food_cereal', 'wall', 'food_vegetable', 'food_food', 'television', 'console', 'cards', 'kitchen_counter', 'cupboard', 'hair', 'door', 'light']
Task:Put groceries in Fridge
response:
{
    "thoughts": Walk to kitchen, find groceries in cabinet and move them to fridge and close fridge.,
    "actions": ['[WALK] <dining_room>', '[WALK] <kitchen_cabinet>', '[FIND] <kitchen_cabinet>', '[FIND] <food_vegetable>', '[GRAB] <food_vegetable>', '[FIND] <freezer>', '[OPEN] <freezer>', '[PUTIN] <food_vegetable> <freezer>', '[FIND] <food_carrot>', '[GRAB] <food_carrot>', '[PUTIN] <food_carrot> <freezer>', '[FIND] <food_cereal>', '[GRAB] <food_cereal>', '[PUTIN] <food_cereal> <freezer>', '[FIND] <food_oatmeal>', '[GRAB] <food_oatmeal>', '[PUTIN] <food_oatmeal> <freezer>', '[FIND] <food_food>', '[GRAB] <food_food>', '[PUTIN] <food_food> <freezer>', '[FIND] <freezer>', '[CLOSE] <freezer>']
}

Input:
Scene_Objects:['glue', 'pot', 'filing_cabinet', 'walllamp', 'orchid', 'bathroom_counter', 'floor', 'phone', 'character', 'desk', 'computer', 'brush', 'toaster', 'mat', 'shower', 'faucet', 'electric_shaver', 'mousepad', 'dining_room', 'nightstand', 'oven', 'toy', 'cup', 'food_onion', 'mouse', 'dresser', 'cupboard', 'door', 'bathroom_cabinet', 'dishwasher']
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:['tablelamp', 'microwave', 'freezer', 'bathroom', 'cpuscreen', 'desk', 'tea_bag', 'alcohol', 'tvstand', 'oven', 'tape', 'cutting_board', 'cup', 'clothes_gloves', 'novel', 'toilet_paper', 'television', 'coffee_filter', 'wooden_spoon', 'mouse', 'cd', 'controller', 'maindoor', 'sink', 'home_office', 'light', 'dishwasher', 'soap', 'dirt', 'shoe_rack']
Task:Listen to music
response:
{
    "thoughts": Walk into living room. Turn on radio.,
    "actions": ['[WALK] <home_office>', '[WALK] <stereo>', '[FIND] <stereo>', '[SWITCHON] <stereo>']
}

Input:
Scene_Objects:['pot', 'food_bread', 'juice', 'food_ice_cream', 'food_oatmeal', 'microwave', 'chair', 'freezer', 'walllamp', 'ground_coffee', 'milk', 'knifeblock', 'drawing', 'knife', 'floor', 'ceiling', 'stovefan', 'toaster', 'mat', 'faucet', 'ceilinglamp', 'bowl', 'wall', 'oven', 'bench', 'cup', 'coffe_maker', 'food_donut', 'tray', 'kitchen_counter', 'cupboard', 'sink', 'napkin', 'table', 'dishwasher']
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:['pot', 'detergent', 'ceilingfan', 'trashcan', 'drawing', 'knife', 'floor', 'ceiling', 'toaster', 'ceilinglamp', 'tvstand', 'balanceball', 'faucet', 'window', 'picture', 'couch', 'wall', 'pasta', 'novel', 'coffe_maker', 'television', 'curtain', 'doorjamb', 'kitchen_counter', 'dresser', 'maindoor', 'table', 'light', 'vase', 'tooth_paste']
Task:Watch TV
response:
{
    "thoughts": I sit on my couch and watch TV in my living room,
    "actions": ['[WALK] <home_office>', '[WALK] <television>', '[SWITCHON] <television>', '[TURNTO] <television>', '[LOOKAT] <television>', '[TOUCH] <television>', '[TURNTO] <television>', '[LOOKAT] <television>', '[TOUCH] <television>', '[TURNTO] <television>', '[LOOKAT] <television>', '[WALK] <couch>', '[SIT] <couch>', '[TURNTO] <television>', '[LOOKAT] <television>', '[WATCH] <television>', '[WATCH] <television>', '[WATCH] <television>']
}

Input:
Scene_Objects:['filing_cabinet', 'tablelamp', 'microwave', 'dough', 'drawing', 'wallshelf', 'floor', 'character', 'bedroom', 'purse', 'mat', 'ceilinglamp', 'couch', 'food_jam', 'dining_room', 'wall', 'nightstand', 'oven', 'bench', 'bed', 'food_food', 'coffe_maker', 'tray', 'towel_rack', 'mouse', 'headset', 'laundry_detergent', 'sink', 'home_office', 'table']
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', '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:['glue', 'filing_cabinet', 'crayon', 'mop', 'toilet', 'chair', 'cpuscreen', 'floor', 'phone', 'character', 'desk', 'bookshelf', 'stovefan', 'toaster', 'tvstand', 'faucet', 'stereo', 'electric_shaver', 'wall', 'oven', 'food_food', 'television', 'mirror', 'curtain', 'lighter', 'coffee_pot', 'cupboard', 'hairdryer', 'bathroom_cabinet', 'dishwasher']
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:['sheets', 'pot', 'chair', 'freezer', 'detergent', 'trashcan', 'dough', 'clothes_underwear', 'folder', 'stamp', 'bookshelf', 'clothes_jacket', 'table_cloth', 'mousepad', 'couch', 'food_jam', 'clothes_hat', 'pillow', 'nightstand', 'bench', 'oven', 'cutting_board', 'bed', 'food_food', 'check', 'doorjamb', 'console', 'cupboard', 'home_office', 'table']
Task:Pick up phone
response:
{
    "thoughts": i go find the phone. i pick up the phone,
    "actions": ['[WALK] <home_office>', '[WALK] <phone>', '[FIND] <phone>', '[GRAB] <phone>']
}

Input:
Scene_Objects:['tablelamp', 'chair', 'freezer', 'food_carrot', 'milk', 'knifeblock', 'floor', 'ceiling', 'phone', 'bedroom', 'purse', 'toaster', 'stovefan', 'shower', 'faucet', 'couch', 'form', 'pillow', 'wall', 'oven', 'food_food', 'oven_mitts', 'shaving_cream', 'kitchen_counter', 'cd', 'dresser', 'cupboard', 'bathtub', 'table', 'tooth_paste']
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:['food_salt', 'crayon', 'microwave', 'food_carrot', 'orchid', 'knifeblock', 'bills', 'floor', 'bedroom', 'stamp', 'envelope', 'clothes_jacket', 'bookmark', 'toaster', 'faucet', 'towel', 'dining_room', 'wall', 'coffe_maker', 'food_food', 'video_game_controller', 'tray', 'lighter', 'diary', 'kitchen_counter', 'cupboard', 'sink', 'soap', 'scrabble', 'hands_both']
Task:Wash hands
response:
{
    "thoughts": I have had my lunch and walked towards the sink and applied soap to my hands and washed cleanly.,
    "actions": ['[WALK] <dining_room>', '[WALK] <sink>', '[FIND] <soap>', '[GRAB] <soap>', '[FIND] <hands_both>', '[WASH] <hands_both>', '[FIND] <towel>', '[GRAB] <towel>', '[WIPE] <hands_both>']
}

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

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:['toilet', 'freezer', 'food_butter', 'knifeblock', 'bathroom_counter', 'floor', 'ceiling', 'phone', 'bookshelf', 'mop_bucket', 'ceilinglamp', 'tvstand', 'iron', 'window', 'mousepad', 'microphone', 'towel', 'dining_room', 'bowl', 'wall', 'powersocket', 'bench', 'cup', 'novel', 'television', 'coin', 'rag', 'doorjamb', 'headset', 'light']
Task:Turn on light
response:
{
    "thoughts": I walk in to the living room. I find the light switch. I turn on the lights.,
    "actions": ['[WALK] <home_office>', '[WALK] <light>', '[FIND] <light>', '[SWITCHON] <light>']
}

Input:
Scene_Objects:['dry_pasta', 'toilet', 'chair', 'freezer', 'walllamp', 'drawing', 'orchid', 'knifeblock', 'wallshelf', 'cpuscreen', 'floor', 'ceiling', 'desk', 'tea_bag', 'computer', 'deck_of_cards', 'mousepad', 'couch', 'pillow', 'wall', 'child', 'bed', 'coin', 'coffee_filter', 'doorjamb', 'centerpiece', 'door', 'table', 'light', 'dishwasher']
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:['blow_dryer', 'bathroom', 'food_carrot', 'bathroom_counter', 'floor', 'ceiling', 'desk', 'stamp', 'bedroom', 'food_cake', 'computer', 'shower', 'picture', 'oven', 'basket_for_clothes', 'photoframe', 'food_food', 'check', 'towel_rack', 'mouse', 'pencil', 'shoes', 'comb', 'hairbrush', 'cupboard', 'laundry_detergent', 'sink', 'napkin', 'light', 'washing_machine']
Task:Wash clothes
response:
{
    "thoughts": Pick up my dirty clothes, load the washer, add detergent, turn on washer,
    "actions": ['[WALK] <bedroom>', '[WALK] <basket_for_clothes>', '[GRAB] <basket_for_clothes>', '[WALK] <home_office>', '[WALK] <washing_machine>', '[OPEN] <washing_machine>', '[PUTBACK] <basket_for_clothes> <washing_machine>', '[FIND] <laundry_detergent>', '[GRAB] <laundry_detergent>', '[PUTBACK] <laundry_detergent> <washing_machine>', '[RUN] <washing_machine>']
}

Input:
Scene_Objects:['sheets', 'sponge', 'tablelamp', 'mop', 'bathroom', 'drawing', 'orchid', 'knifeblock', 'wallshelf', 'floor', 'ceiling', 'stamp', 'wine_glass', 'clothes_socks', 'couch', 'pillow', 'wall', 'nightstand', 'food_cheese', 'bed', 'photoframe', 'food_food', 'check', 'doorjamb', 'door', 'sink', 'bag', 'bathroom_cabinet', 'table', 'light']
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:['pot', 'tablelamp', 'walllamp', 'orchid', 'floor', 'ceiling', 'character', 'desk', 'table_cloth', 'toaster', 'ceilinglamp', 'plate', 'faucet', 'stovefan', 'dish_soap', 'mousepad', 'couch', 'wall', 'powersocket', 'bed', 'coffe_maker', 'food_food', 'kitchen_counter', 'cupboard', 'controller', 'sink', 'dishwasher', 'soap', 'clothes_shirt', 'teeth']
Task:Wash dishes with dishwasher
response:
{
    "thoughts": Walk to the kitchen. Open the dishwasher. Grab plate and put it in the dishwasher. Grab dish soap and put it in the dishwasher. Switch on the dishwasher.,
    "actions": ['[WALK] <dining_room>', '[WALK] <dishwasher>', '[FIND] <dishwasher>', '[OPEN] <dishwasher>', '[FIND] <plate>', '[GRAB] <plate>', '[PUTBACK] <plate> <dishwasher>', '[FIND] <dish_soap>', '[GRAB] <dish_soap>', '[PUTBACK] <dish_soap> <dishwasher>', '[CLOSE] <dishwasher>', '[SWITCHON] <dishwasher>']
}

Input:
Scene_Objects:['pot', 'microwave', 'walllamp', 'nail_polish', 'knifeblock', 'drawing', 'wallshelf', 'kitchen_cabinet', 'floor', 'ceiling', 'bathroom_counter', 'character', 'desk', 'faucet', 'stereo', 'shower', 'mousepad', 'couch', 'wall', 'oven', 'cup', 'photoframe', 'television', 'doorjamb', 'kitchen_counter', 'chessboard', 'cupboard', 'sink', 'table', 'dirt']
Task:Get glass of water
response:

Get a glass from a cabinet. Hold it under the sink and turn the cold water on. Fill the glass. Turn off the water.

[WALK] <dining_room>
[WALK] <kitchen_cabinet>
[FIND] <kitchen_cabinet>
[OPEN] <kitchen_cabinet>
[FIND] <cup>
[GRAB] <cup>
[CLOSE] <kitchen_cabinet>
[WALK] <sink>
[FIND] <faucet>
[SWITCHON] <faucet>
[PUTBACK] <cup> <sink>
[GRAB] <cup>
[SWITCHOFF] <faucet>


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

Here is an example plan to achieve a goal for reference:
Scene_Objects:['filing_cabinet', 'measuring_cup', 'ground_coffee', 'walllamp', 'trashcan', 'drawing', 'wallshelf', 'hanger', 'floor', 'ceiling', 'keyboard', 'stovefan', 'toaster', 'mat', 'faucet', 'shower', 'wall', 'nightstand', 'oven', 'coffe_maker', 'coffee_filter', 'water', 'tray', 'kitchen_counter', 'cd', 'cupboard', 'controller', 'hairdryer', 'sink', 'home_office']
Task:Make coffee
response:
{
    "thoughts": Walk to Kitchen and find coffee maker, find coffee filter and place it in coffee maker. Find ground coffee and water. put both in coffee maker. Close the coffee maker and switch it on.,
    "actions": ['[WALK] <dining_room>', '[WALK] <coffe_maker>', '[FIND] <coffe_maker>', '[OPEN] <coffe_maker>', '[FIND] <coffee_filter>', '[GRAB] <coffee_filter>', '[PUTBACK] <coffee_filter> <coffe_maker>', '[FIND] <ground_coffee>', '[GRAB] <ground_coffee>', '[PUTBACK] <ground_coffee> <coffe_maker>', '[WALK] <water>', '[FIND] <water>', '[GRAB] <water>', '[POUR] <water> <coffe_maker>', '[CLOSE] <coffe_maker>', '[SWITCHON] <coffe_maker>']
}

Input:
Scene_Objects:['fork', 'filing_cabinet', 'blender', 'chair', 'freezer', 'walllamp', 'nail_polish', 'detergent', 'drawing', 'knife', 'wallshelf', 'bathroom_counter', 'floor', 'desk', 'computer', 'mat', 'ceilinglamp', 'plate', 'faucet', 'mousepad', 'candle', 'microphone', 'bowl', 'wall', 'nightstand', 'bench', 'bed', 'keys', 'food_food', 'table']
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>