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', 'chair', 'trashcan', 'ceilingfan', 'drawing', 'cpuscreen', 'floor', 'ceiling', 'phone', 'desk', 'keyboard', 'bookshelf', 'computer', 'piano_bench', 'bookmark', 'ceilinglamp', 'balanceball', 'mousepad', 'wall', 'nightstand', 'powersocket', 'doorjamb', 'mouse', 'dresser', 'maindoor', 'light', 'instrument_violin', 'shoe_rack']
Task:Write an email
response:
{
    "thoughts": Compose an email in the home office.,
    "actions": ['[WALK] <home_office>', '[WALK] <computer>', '[FIND] <computer>', '[SWITCHON] <computer>', '[FIND] <keyboard>', '[TYPE] <keyboard>']
}

Input:
Scene_Objects:['tablelamp', 'chair', 'walllamp', 'cpuscreen', 'hanger', 'floor', 'ceiling', 'desk', 'bedroom', 'keyboard', 'bookshelf', 'computer', 'toaster', 'ceilinglamp', 'tvstand', 'faucet', 'electric_shaver', 'mousepad', 'wall', 'wall_clock', 'powersocket', 'coffe_maker', 'television', 'tray', 'doorjamb', 'mouse', 'bathtub', 'sink', 'home_office', 'table']
Task:Work
response:

Walk to home office, walk to desk, sit in chair, turn on computer, look at computer, click mouse and type on keyboard.

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


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

Here is an example plan to achieve a goal for reference:
Scene_Objects:['filing_cabinet', 'shoe_rack', 'food_salt', 'mop', 'microwave', 'dog', 'jelly', 'walllamp', 'drawing', 'needle', 'food_egg', 'desk', 'stamp', 'computer', 'ceilinglamp', 'window', 'mousepad', 'food_orange', 'pillow', 'bench', 'cup', 'oven_mitts', 'wooden_spoon', 'pencil', 'dresser', 'maindoor', 'bag', 'table', 'instrument_violin', 'creditcard']
Task:Listen to music
response:
{
    "thoughts": go to radio. run on radio.,
    "actions": ['[WALK] <stereo>', '[SWITCHON] <stereo>']
}

Input:
Scene_Objects:['chair', 'freezer', 'walllamp', 'orchid', 'cpuscreen', 'floor', 'ceiling', 'desk', 'keyboard', 'computer', 'toaster', 'ceilinglamp', 'tvstand', 'faucet', 'stereo', 'window', 'shower', 'mousepad', 'wall', 'powersocket', 'bench', 'clothes_gloves', 'television', 'tray', 'rag', 'doorjamb', 'towel_rack', 'mouse', 'bathtub', 'table']
Task:Work
response:

I walk into home office. I walk to desk. I sit at chair. I turn on computer.

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


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

Here is an example plan to achieve a goal for reference:
Scene_Objects:['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:['microwave', 'toilet', 'freezer', 'walllamp', 'food_carrot', 'orchid', 'drawing', 'wallshelf', 'bathroom_counter', 'floor', 'character', 'shoe-shine_kit', 'faucet', 'couch', 'form', 'wall', 'bench', 'toy', 'cup', 'coffe_maker', 'television', 'doorjamb', 'towel_rack', 'mouse', 'cupboard', 'door', 'sink', 'bathroom_cabinet', 'home_office', 'soap']
Task:Wash hands
response:

walk to bathroom, find sink, turn on faucet, put soap in hands, wash and rinse hands,

[WALK] <bathroom>
[WALK] <sink>
[FIND] <sink>
[FIND] <soap>
[WASH] <soap>
[RINSE] <soap>


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

Here is an example plan to achieve a goal for reference:
Scene_Objects:['filing_cabinet', 'tablelamp', 'blender', 'measuring_cup', 'toilet', 'drawing', 'needle', 'hanger', 'floor', 'computer', 'mat', 'mousepad', 'wall', 'nightstand', 'powersocket', 'cutting_board', 'bed', 'novel', 'food_food', 'video_game_controller', 'coffe_maker', 'tray', 'food_onion', 'doorjamb', 'lighter', 'cd', 'clothes_dress', 'bathroom_cabinet', 'light', 'soap']
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:['filing_cabinet', 'crayon', 'microwave', 'toilet', 'chair', 'trashcan', 'drawing', 'wallshelf', 'bedroom', 'desk', 'keyboard', 'stovefan', 'laptop', 'toaster', 'window', 'closetdrawer', 'couch', 'broom', 'wall', 'powersocket', 'bench', 'photoframe', 'novel', 'coffe_maker', 'tray', 'doorjamb', 'towel_rack', 'dresser', 'cupboard', 'door']
Task:Read book
response:

go to bedroom, sit down, pick up book, read

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


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

Here is an example plan to achieve a goal for reference:
Scene_Objects:['tablelamp', 'tea', 'chair', 'walllamp', 'orchid', 'cpuscreen', 'wallshelf', 'hanger', 'floor', 'ceiling', 'phone', 'desk', 'keyboard', 'computer', 'toaster', 'ceilinglamp', 'tvstand', 'mat', 'mousepad', 'couch', 'pillow', 'wall', 'nightstand', 'television', 'doorjamb', 'mouse', 'vacuum_cleaner', 'dresser', 'door', 'home_office']
Task:Vacuum
response:
{
    "thoughts": Keep my keyboard vacuumed and free of debris.,
    "actions": ['[WALK] <home_office>', '[WALK] <computer>', '[FIND] <vacuum_cleaner>', '[SWITCHON] <vacuum_cleaner>', '[SWITCHOFF] <vacuum_cleaner>']
}

Input:
Scene_Objects:['chair', 'walllamp', 'drawing', 'bathroom_counter', 'floor', 'ceiling', 'remote_control', 'computer', 'button', 'toaster', 'mat', 'ceilinglamp', 'tvstand', 'faucet', 'window', 'clothes_socks', 'couch', 'pillow', 'dining_room', 'wall', 'wall_clock', 'television', 'curtain', 'towel_rack', 'mouse', 'dresser', 'bathtub', 'bathroom_cabinet', 'table', 'coffee']
Task:Change TV channel
response:

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


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

Here is an example plan to achieve a goal for reference:
Scene_Objects:['blow_dryer', 'drawing', 'knife', 'hanger', 'floor', 'ceiling', 'shampoo', 'desk', 'keyboard', 'remote_control', 'thread', 'computer', 'alcohol', 'bookmark', 'mat', 'ceilinglamp', 'window', 'closetdrawer', 'couch', 'pillow', 'wall', 'wall_clock', 'tape', 'standingmirror', 'bed', 'television', 'curtain', 'doorjamb', 'instrument_guitar', 'table']
Task:Change TV channel
response:
{
    "thoughts": Changing channel,
    "actions": ['[WALK] <home_office>', '[WALK] <television>', '[FIND] <television>', '[SWITCHON] <television>', '[FIND] <couch>', '[SIT] <couch>', '[FIND] <remote_control>', '[GRAB] <remote_control>', '[TURNTO] <television>', '[POINTAT] <television>', '[DROP] <remote_control>']
}

Input:
Scene_Objects:['tablelamp', 'toilet', 'orchid', 'drawing', 'wallshelf', 'bathroom_counter', 'floor', 'ceiling', 'desk', 'bedroom', 'bookshelf', 'toaster', 'ceilinglamp', 'faucet', 'pillow', 'wall', 'bench', 'bed', 'coffe_maker', 'food_food', 'television', 'mouse', 'shoes', 'cupboard', 'sink', 'bathroom_cabinet', 'light', 'soap', 'clothes_shirt', 'hands_both']
Task:Wash hands
response:

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


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

Here is an example plan to achieve a goal for reference:
Scene_Objects:['filing_cabinet', 'toilet', 'ceilingfan', 'food_egg', 'hanger', 'ceiling', 'dvd_player', 'character', 'thread', 'clothes_jacket', 'toaster', 'deck_of_cards', 'foundation', 'mousepad', 'oil', 'pillow', 'oven', 'toy', 'food_food', 'check', 'lighter', 'centerpiece', 'dishrack', 'coffee', 'hair', 'laundry_detergent', 'maindoor', 'sink', 'door', 'teeth']
Task:Turn on light
response:
{
    "thoughts": I walk into my bedroom, go to the lamp and use the switch to turn it on.,
    "actions": ['[WALK] <bedroom>', '[WALK] <floor_lamp>', '[FIND] <floor_lamp>', '[TURNTO] <floor_lamp>', '[LOOKAT] <floor_lamp>', '[WALK] <floor_lamp>', '[SWITCHON] <floor_lamp>']
}

Input:
Scene_Objects:['microwave', 'toilet', 'chair', 'bathroom', 'toothbrush', 'cpuscreen', 'bathroom_counter', 'floor', 'ceiling', 'bedroom', 'bookshelf', 'computer', 'toaster', 'faucet', 'closetdrawer', 'couch', 'pillow', 'wall', 'wall_clock', 'oven', 'nightstand', 'television', 'toothbrush_holder', 'curtain', 'mouse', 'shoes', 'clothes_dress', 'sink', 'bathroom_cabinet', 'tooth_paste']
Task:Brush teeth
response:

go to bathroom. grab toothbrush. put toothpaste on toothbrush. brush teeth. turn on faucet. rinse toothbrush and mouth. put toothbrush away.


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', 'jelly', 'bathroom', 'detergent', 'dough', 'orchid', 'floor', 'bedroom', 'mat', 'dish_soap', 'mousepad', 'dining_room', 'wall', 'nightstand', 'oven', 'food_cheese', 'photoframe', 'coffe_maker', 'food_food', 'ice', 'tray', 'kitchen_counter', 'headset', 'dishrack', 'dresser', 'cupboard', 'door', 'home_office', 'dishwasher']
Task:Wash dishes with dishwasher
response:
{
    "thoughts": I go to the dishwasher and put dish soap. I close the dishwasher and turn it on.,
    "actions": ['[WALK] <dining_room>', '[WALK] <dishwasher>', '[FIND] <dishwasher>', '[OPEN] <dishwasher>', '[FIND] <dish_soap>', '[GRAB] <dish_soap>', '[PUTBACK] <dish_soap> <dishwasher>', '[GRAB] <dish_soap>', '[PUTBACK] <dish_soap> <dishwasher>', '[CLOSE] <dishwasher>', '[SWITCHON] <dishwasher>']
}

Input:
Scene_Objects:['pot', 'bathroom', 'trashcan', 'food_butter', 'drawing', 'floor', 'ceiling', 'phone', 'mat', 'ceilinglamp', 'window', 'couch', 'pillow', 'wall', 'wall_clock', 'powersocket', 'nightstand', 'food_food', 'check', 'television', 'curtain', 'doorjamb', 'towel_rack', 'kitchen_counter', 'dresser', 'door', 'sink', 'spoon', 'home_office', 'light']
Task:Turn on light
response:

walk in kitchen. switch on light. walk in living room. switch on light.walk in entrance hall. switch on light.

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


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

Here is an example plan to achieve a goal for reference:
Scene_Objects:['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', 'check', 'television', 'tray', 'doorjamb', 'towel_rack', 'mouse', 'dresser', 'door', 'light']
Task:Do homework
response:
{
    "thoughts": I do my online homework on the computer.  I use Pearson My Math Lab for math class and excel for my engineering class.,
    "actions": ['[WALK] <home_office>', '[WALK] <desk>', '[FIND] <chair>', '[SIT] <chair>', '[FIND] <computer>', '[SWITCHON] <computer>', '[TURNTO] <computer>', '[LOOKAT] <computer>', '[FIND] <check>', '[GRAB] <check>', '[READ] <check>', '[FIND] <keyboard>', '[TYPE] <keyboard>']
}

Input:
Scene_Objects:['blow_dryer', 'cat', 'needle', 'hanger', 'bathroom_counter', 'floor', 'ceiling', 'bookshelf', 'keyboard', 'computer', 'mop_bucket', 'mat', 'faucet', 'mousepad', 'teeth', 'towel', 'wall', 'nightstand', 'bench', 'novel', 'doorjamb', 'towel_rack', 'kitchen_counter', 'laundry_detergent', 'door', 'sink', 'bathroom_cabinet', 'light', 'instrument_violin', 'hands_both']
Task:Wash teeth
response:

I need to rinse my dentures off and put them back in my mouth.

[WALK] <bathroom>
[WALK] <light>
[FIND] <light>
[SWITCHON] <light>
[WALK] <sink>
[FIND] <faucet>
[SWITCHON] <faucet>
[FIND] <teeth>
[GRAB] <teeth>
[WASH] <teeth>
[PUTOBJBACK] <teeth>
[SWITCHOFF] <faucet>
[FIND] <towel>
[GRAB] <towel>
[FIND] <hands_both>
[SCRUB] <hands_both>
[PUTOBJBACK] <towel>
[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:['spectacles', 'juice', 'nail_polish', 'wallshelf', 'floor', 'ceiling', 'face', 'mat', 'iron', 'shower', 'stereo', 'clothes_socks', 'food_jam', 'wall_clock', 'light_bulb', 'food_food', 'razor', 'mirror', 'food_rice', 'curtain', 'centerpiece', 'towel_rack', 'hair', 'clothes_dress', 'napkin', 'bathroom_cabinet', 'home_office', 'table', 'soap', 'shoe_rack']
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:['tablelamp', 'toilet', 'bathroom', 'orchid', 'cpuscreen', 'wallshelf', 'floor', 'phone', 'character', 'bedroom', 'toaster', 'ceilinglamp', 'stovefan', 'wall_clock', 'powersocket', 'bed', 'food_food', 'television', 'wooden_spoon', 'kitchen_counter', 'dresser', 'cupboard', 'door', 'sink', 'hairdryer', 'home_office', 'light', 'clothes_skirt', 'bathtub', 'bathroom_cabinet']
Task:Read book
response:

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


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

Here is an example plan to achieve a goal for reference:
Scene_Objects:['filing_cabinet', 'chair', 'walllamp', 'bathroom', 'drawing', 'wallshelf', 'hanger', 'floor', 'ceiling', 'desk', 'remote_control', 'computer', 'clothes_jacket', 'mat', 'tvstand', 'ceilinglamp', 'picture', 'closetdrawer', 'couch', 'pillow', 'wall', 'pasta', 'photoframe', 'coffe_maker', 'television', 'doorjamb', 'cards', 'dresser', 'door', 'colander']
Task:Change TV channel
response:
{
    "thoughts": I walk into the living room. I sit on the couch and grab the remote. Then I turn on the TV and change the channel.,
    "actions": ['[WALK] <home_office>', '[WALK] <couch>', '[FIND] <couch>', '[SIT] <couch>', '[FIND] <remote_control>', '[GRAB] <remote_control>', '[FIND] <television>', '[SWITCHON] <television>']
}

Input:
Scene_Objects:['pot', 'microwave', 'detergent', 'toothbrush', 'orchid', 'drawing', 'hanger', 'bathroom_counter', 'floor', 'ceiling', 'keyboard', 'toaster', 'ceilinglamp', 'window', 'teeth', 'couch', 'pillow', 'nightstand', 'wall_clock', 'wall', 'powersocket', 'cup', 'photoframe', 'toothbrush_holder', 'doorjamb', 'towel_rack', 'home_office', 'table', 'tooth_paste', 'coffee']
Task:Wash teeth
response:

walk to bathroom, look at the toothbrush holder, grab the toothbrush from the toothbrush holder, find the toothpaste, squeeze the toothpaste into toothbrush, now wash the teeth

[WALK] <bathroom>
[WALK] <toothbrush_holder>
[FIND] <toothbrush_holder>
[TURNTO] <toothbrush_holder>
[LOOKAT] <toothbrush_holder>
[FIND] <toothbrush>
[GRAB] <toothbrush>
[FIND] <tooth_paste>
[SQUEEZE] <tooth_paste>
[FIND] <teeth>
[WASH] <teeth>


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', 'bathroom', 'drawing', 'orchid', 'wallshelf', 'floor', 'ceiling', 'bookshelf', 'remote_control', 'toaster', 'mat', 'tvstand', 'ceilinglamp', 'shower', 'window', 'couch', 'pillow', 'wall', 'powersocket', 'photoframe', 'television', 'curtain', 'after_shave', 'doorjamb', 'mouse', 'dresser', 'door', 'table', 'light', 'dishwasher']
Task:Change TV channel
response:
{
    "thoughts": I go in the living room. Then I find the remote, sit on the couch and turn on the television. Then I use the remote the change the TV channel.,
    "actions": ['[WALK] <home_office>', '[WALK] <remote_control>', '[FIND] <remote_control>', '[FIND] <couch>', '[SIT] <couch>', '[FIND] <television>', '[SWITCHON] <television>']
}

Input:
Scene_Objects:['food_bread', 'measuring_cup', 'chair', 'trashcan', 'toothbrush', 'cpuscreen', 'hanger', 'ceiling', 'character', 'keyboard', 'alcohol', 'mat', 'closetdrawer', 'form', 'dining_room', 'nightstand', 'oven', 'bench', 'bed', 'photoframe', 'food_food', 'coffe_maker', 'toothbrush_holder', 'tray', 'towel_rack', 'kitchen_counter', 'bathtub', 'sink', 'home_office', 'tooth_paste']
Task:Wash teeth
response:

WALK TO THE BATHROOM USE PASTE AND BRUSH TO WASH YOUR TEETH

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


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

Here is an example plan to achieve a goal for reference:
Scene_Objects:['filing_cabinet', 'tablelamp', 'crayon', 'freezer', 'bathroom', 'food_carrot', 'drawing', 'knifeblock', 'floor', 'desk', 'ceilinglamp', 'stereo', 'window', 'couch', 'food_orange', 'pillow', 'form', 'dining_room', 'wall', 'bench', 'coffe_maker', 'television', 'rag', 'pencil', 'comb', 'table', 'tooth_paste', 'clothes_shirt', 'scrabble', 'creditcard']
Task:Relax on sofa
response:
{
    "thoughts": I walk to the living room and stand in front of the sofa. Then I turn and sit on the sofa and lean my back against the pillow and my feet on the floor.,
    "actions": ['[WALK] <home_office>', '[WALK] <couch>', '[FIND] <couch>', '[TURNTO] <couch>', '[SIT] <couch>']
}

Input:
Scene_Objects:['water_glass', 'chair', 'freezer', 'walllamp', 'drawing', 'wallshelf', 'cpuscreen', 'floor', 'ceiling', 'phone', 'keyboard', 'computer', 'mat', 'tvstand', 'ceilinglamp', 'window', 'mousepad', 'closetdrawer', 'couch', 'pillow', 'wall', 'bench', 'photoframe', 'television', 'curtain', 'doorjamb', 'cupboard', 'sink', 'bathroom_cabinet', 'table']
Task:Relax on sofa
response:

[WALK] <home_office>
[WALK] <couch>
[FIND] <couch>
[SIT] <couch>
[FIND] <water_glass>
[GRAB] <water_glass>
[DRINK] <water_glass>


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

Here is an example plan to achieve a goal for reference:
Scene_Objects:['toilet', 'chair', 'walllamp', 'milk', 'drawing', 'bathroom_counter', 'floor', 'phone', 'character', 'bedroom', 'keyboard', 'toaster', 'mat', 'tvstand', 'ceilinglamp', 'plate', 'window', 'couch', 'pillow', 'wall', 'wall_clock', 'check', 'television', 'curtain', 'mouse', 'door', 'home_office', 'table', 'bathroom_cabinet', 'light']
Task:Do homework
response:
{
    "thoughts": Sit on the couch in the Living room and pick u some papers,
    "actions": ['[WALK] <home_office>', '[WALK] <couch>', '[FIND] <couch>', '[SIT] <couch>', '[FIND] <check>', '[GRAB] <check>', '[DROP] <check>']
}

Input:
Scene_Objects:['chair', 'walllamp', 'cpuscreen', 'floor', 'ceiling', 'dvd_player', 'desk', 'keyboard', 'computer', 'ceilinglamp', 'tvstand', 'faucet', 'window', 'mousepad', 'couch', 'pillow', 'wall', 'powersocket', 'bench', 'oven', 'cutting_board', 'coffe_maker', 'television', 'doorjamb', 'mouse', 'dresser', 'food_steak', 'sink', 'bathroom_cabinet', 'table']
Task:Browse internet
response:

I sit at my computer desk and open the browser.

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


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

Here is an example plan to achieve a goal for reference:
Scene_Objects:['food_bread', 'chair', 'detergent', 'food_carrot', 'clothes_underwear', 'hanger', 'floor', 'ceiling', 'phone', 'computer', 'bookmark', 'toaster', 'balanceball', 'wall', 'powersocket', 'photoframe', 'coffee_filter', 'tray', 'doorjamb', 'cards', 'mouse', 'shaving_cream', 'shoes', 'dresser', 'cupboard', 'door', 'napkin', 'home_office', 'light', 'vase']
Task:Turn on light
response:
{
    "thoughts": switching on light in an area,
    "actions": ['[WALK] <home_office>', '[WALK] <light>', '[FIND] <light>', '[SWITCHON] <light>']
}

Input:
Scene_Objects:['sheets', 'tablelamp', 'microwave', 'toilet', 'bathroom', 'toothbrush', 'drawing', 'cpuscreen', 'hanger', 'bathroom_counter', 'phone', 'bedroom', 'computer', 'button', 'toaster', 'mat', 'stereo', 'foundation', 'window', 'couch', 'bench', 'oven', 'cup', 'check', 'television', 'tray', 'dresser', 'home_office', 'light', 'bathroom_cabinet']
Task:Listen to music
response:

Walk into living room, look for radio, grab on button

[WALK] <home_office>
[WALK] <stereo>
[FIND] <stereo>
[TURNTO] <stereo>
[LOOKAT] <stereo>
[FIND] <button>
[GRAB] <button>


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

Here is an example plan to achieve a goal for reference:
Scene_Objects:['sheets', 'tablelamp', 'food_ice_cream', 'walllamp', 'trashcan', 'ceilingfan', 'drawing', 'longboard', 'floor', 'bookshelf', 'computer', 'faucet', 'balanceball', 'window', 'iron', 'food_peanut_butter', 'food_jam', 'wall', 'nightstand', 'bench', 'powersocket', 'basket_for_clothes', 'novel', 'check', 'coffee_filter', 'shaving_cream', 'pencil', 'maindoor', 'sink', 'hairdryer']
Task:Pick up phone
response:
{
    "thoughts": Enter the Home office, then walk to the phone, pickup the phone.,
    "actions": ['[WALK] <home_office>', '[WALK] <phone>', '[GRAB] <phone>']
}

Input:
Scene_Objects:['tablelamp', 'chair', 'walllamp', 'nail_polish', 'trashcan', 'orchid', 'drawing', 'cpuscreen', 'hanger', 'floor', 'ceiling', 'desk', 'keyboard', 'computer', 'ceilinglamp', 'tvstand', 'mousepad', 'closetdrawer', 'wall', 'powersocket', 'bench', 'bed', 'coffe_maker', 'television', 'food_donut', 'doorjamb', 'mouse', 'door', 'table', 'shoe_rack']
Task:Work
response:

Walk to living-room. Look at the desk where Computer stays. Sit in chair. Switch on computer. Work on computer. Switch off computer.

[WALK] <home_office>
[WALK] <desk>
[FIND] <desk>
[TURNTO] <desk>
[LOOKAT] <desk>
[FIND] <chair>
[SIT] <chair>
[FIND] <computer>
[SWITCHON] <computer>
[TURNTO] <computer>
[WATCH] <computer>
[SWITCHOFF] <computer>


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

Here is an example plan to achieve a goal for reference:
Scene_Objects:['walllamp', 'ceilingfan', 'drawing', 'needle', 'cpuscreen', 'hanger', 'bathroom_counter', 'floor', 'ceiling', 'bookshelf', 'remote_control', 'ceilinglamp', 'tvstand', 'balanceball', 'window', 'homework', 'clothes_socks', 'couch', 'pillow', 'wall', 'powersocket', 'food_cheese', 'bed', 'television', 'wooden_spoon', 'curtain', 'doorjamb', 'bathroom_cabinet', 'table', 'laser_pointer']
Task:Watch TV
response:
{
    "thoughts": Walk into the living room. Sit down on the sofa. Pick up the remote control. Turn on the television with the remote control. Put down the remote control. Watch the television.,
    "actions": ['[WALK] <home_office>', '[WALK] <couch>', '[SIT] <couch>', '[FIND] <remote_control>', '[GRAB] <remote_control>', '[FIND] <television>', '[SWITCHON] <television>', '[PUTOBJBACK] <remote_control>', '[TURNTO] <television>', '[WATCH] <television>']
}

Input:
Scene_Objects:['chair', 'walllamp', 'orchid', 'cpuscreen', 'floor', 'ceiling', 'character', 'desk', 'keyboard', 'computer', 'ceilinglamp', 'tvstand', 'window', 'mousepad', 'dining_room', 'wall', 'wall_clock', 'powersocket', 'oven', 'bed', 'television', 'doorjamb', 'centerpiece', 'mouse', 'door', 'bathtub', 'sink', 'napkin', 'table', 'light']
Task:Work
response:

Sit down on chair in front of computer, turn on computer, find mouse.

[WALK] <home_office>
[WALK] <chair>
[FIND] <chair>
[SIT] <chair>
[FIND] <computer>
[SWITCHON] <computer>
[FIND] <mouse>
[GRAB] <mouse>
[TURNTO] <computer>
[LOOKAT] <computer>


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

Here is an example plan to achieve a goal for reference:
Scene_Objects:['tablelamp', 'crayon', 'detergent', 'trashcan', 'orchid', 'wallshelf', 'bathroom_counter', 'ceiling', 'keyboard', 'stovefan', 'tvstand', 'shower', 'window', 'mousepad', 'dining_room', 'wall', 'basket_for_clothes', 'television', 'centerpiece', 'kitchen_counter', 'comb', 'dresser', 'cupboard', 'clothes_dress', 'laundry_detergent', 'door', 'sink', 'table', 'clothes_shirt', 'washing_machine']
Task:Wash clothes
response:
{
    "thoughts": Walk to the kitchen. Find the washing machine. Open the washing machine. Find the basket for clothes. Find the clothes_dress. Grab the clothes_dress. Put the clothes_dress into the washing machine. Find the clothes_shirt. Grab the clothes_shirt. Put the clothes_shirt into the washing machine. Close the washing machine. Switch on the washing machine.,
    "actions": ['[WALK] <dining_room>', '[WALK] <washing_machine>', '[FIND] <washing_machine>', '[OPEN] <washing_machine>', '[FIND] <basket_for_clothes>', '[FIND] <clothes_dress>', '[GRAB] <clothes_dress>', '[PUTBACK] <clothes_dress> <washing_machine>', '[FIND] <clothes_shirt>', '[GRAB] <clothes_shirt>', '[PUTBACK] <clothes_shirt> <basket_for_clothes>', '[CLOSE] <washing_machine>', '[SWITCHON] <washing_machine>']
}

Input:
Scene_Objects:['pot', 'tablelamp', 'drawing', 'wallshelf', 'floor', 'ceiling', 'bedroom', 'keyboard', 'envelope', 'stovefan', 'toaster', 'faucet', 'shower', 'mousepad', 'couch', 'pillow', 'dining_room', 'wall', 'oven', 'bench', 'food_vegetable', 'bed', 'coffe_maker', 'check', 'water', 'tray', 'curtain', 'towel_rack', 'kitchen_counter', 'cupboard']
Task:Cook some food
response:

walk to kicthen , find stove , find cooking pot , find vegetables , find water  ,put vegetables in cooking pot, pour water to cooking pot,put cooking pot on stove, switch on stove

[WALK] <dining_room>
[WALK] <oven>
[FIND] <oven>
[FIND] <pot>
[FIND] <food_vegetable>
[FIND] <water>
[GRAB] <water>
[WASH] <food_vegetable>
[POUR] <water> <pot>
[FIND] <pot>
[GRAB] <pot>
[PUTBACK] <pot> <oven>
[SWITCHON] <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:['sponge', 'sheets', 'filing_cabinet', 'food_bread', 'toilet', 'ground_coffee', 'drawing', 'cpuscreen', 'bathroom_counter', 'floor', 'ceiling', 'desk', 'keyboard', 'alcohol', 'table_cloth', 'tvstand', 'balanceball', 'shower', 'plate', 'iron', 'mousepad', 'wall', 'oven', 'photoframe', 'light_bulb', 'coffe_maker', 'centerpiece', 'mouse', 'dresser', 'maindoor']
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:['microwave', 'chair', 'freezer', 'orchid', 'drawing', 'cpuscreen', 'hanger', 'floor', 'ceiling', 'desk', 'bookshelf', 'keyboard', 'food_cake', 'envelope', 'computer', 'ceilinglamp', 'window', 'mousepad', 'clothes_socks', 'closetdrawer', 'wall', 'toy', 'cup', 'coffe_maker', 'doorjamb', 'mouse', 'dresser', 'door', 'light', 'table']
Task:Browse internet
response:

I turn on computer. I use keyboard to type. I open browser. I search.

[WALK] <bedroom>
[WALK] <computer>
[FIND] <keyboard>
[TYPE] <keyboard>
[TURNTO] <computer>
[LOOKAT] <computer>


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

Here is an example plan to achieve a goal for reference:
Scene_Objects:['microwave', 'freezer', 'drawing', 'wallshelf', 'cpuscreen', 'hanger', 'floor', 'ceiling', 'dvd_player', 'character', 'keyboard', 'bookshelf', 'computer', 'stovefan', 'toaster', 'window', 'mousepad', 'closetdrawer', 'clothes_pants', 'pillow', 'wall', 'nightstand', 'wall_clock', 'television', 'tray', 'curtain', 'mouse', 'kitchen_counter', 'dresser', 'clothes_shirt']
Task:Organize closet
response:
{
    "thoughts": Organize the hanging clothes in my closet by color and type and get rid of clothes I don't wear.,
    "actions": ['[WALK] <bedroom>', '[WALK] <dresser>', '[OPEN] <dresser>', '[FIND] <clothes_pants>', '[GRAB] <clothes_pants>', '[PULL] <clothes_pants>', '[PUTIN] <clothes_pants> <dresser>', '[FIND] <clothes_pants>', '[GRAB] <clothes_pants>', '[PULL] <clothes_pants>', '[PUTIN] <clothes_pants> <dresser>', '[FIND] <clothes_shirt>', '[GRAB] <clothes_shirt>', '[PUSH] <clothes_shirt>', '[PUTIN] <clothes_shirt> <dresser>', '[FIND] <clothes_shirt>', '[GRAB] <clothes_shirt>', '[PUSH] <clothes_shirt>', '[PUTIN] <clothes_shirt> <dresser>', '[FIND] <clothes_shirt>', '[GRAB] <clothes_shirt>', '[CLOSE] <dresser>', '[WALK] <basket_for_clothes>', '[PUTBACK] <clothes_shirt> <basket_for_clothes>']
}

Input:
Scene_Objects:['filing_cabinet', 'walllamp', 'cat', 'drawing', 'orchid', 'wallshelf', 'hanger', 'floor', 'ceiling', 'bookshelf', 'keyboard', 'toaster', 'mat', 'tvstand', 'ceilinglamp', 'faucet', 'window', 'plate', 'couch', 'pillow', 'wall', 'newspaper', 'coffe_maker', 'television', 'curtain', 'doorjamb', 'kitchen_counter', 'bathtub', 'light', 'table']
Task:Pet cat
response:

My cat looks like it wants attention, so I will go pet it on the couch.

[WALK] <home_office>
[WALK] <light>
[FIND] <light>
[SWITCHON] <light>
[FIND] <cat>
[WALK] <couch>
[SIT] <couch>
[TURNTO] <cat>
[TOUCH] <cat>


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

Here is an example plan to achieve a goal for reference:
Scene_Objects:['dry_pasta', 'tablelamp', 'measuring_cup', 'toilet', 'freezer', 'bathroom', 'cpuscreen', 'character', 'desk', 'bedroom', 'table_cloth', 'mat', 'shower', 'stereo', 'microphone', 'clothes_hat', 'pillow', 'nightstand', 'wall_clock', 'oven', 'keys', 'light_bulb', 'check', 'razor', 'tray', 'doorjamb', 'dresser', 'clothes_dress', 'bag', 'dishwasher']
Task:Listen to music
response:
{
    "thoughts": I find a radio. I turn on the radio. I listen to music.,
    "actions": ['[WALK] <home_office>', '[WALK] <stereo>', '[FIND] <stereo>', '[SWITCHON] <stereo>']
}

Input:
Scene_Objects:['filing_cabinet', 'microwave', 'walllamp', 'detergent', 'cat', 'drawing', 'orchid', 'wallshelf', 'hanger', 'bathroom_counter', 'floor', 'desk', 'bookshelf', 'mat', 'tvstand', 'ceilinglamp', 'window', 'couch', 'dustpan', 'pillow', 'wall', 'wall_clock', 'television', 'tray', 'curtain', 'towel_rack', 'kitchen_counter', 'cupboard', 'table', 'light']
Task:Pet cat
response:

I see my cat on the couch so I walk over, sit down and pet the cat.

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


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

Here is an example plan to achieve a goal for reference:
Scene_Objects:['spectacles', 'tablelamp', 'toilet', 'chair', 'bathroom', 'orchid', 'knifeblock', 'floor', 'phone', 'desk', 'keyboard', 'food_cake', 'foundation', 'floor_lamp', 'pillow', 'nightstand', 'powersocket', 'box', 'basket_for_clothes', 'razor', 'tray', 'doorjamb', 'cupboard', 'bathtub', 'spoon', 'home_office', 'table', 'bathroom_cabinet', 'light', 'dishwasher']
Task:Turn on light
response:
{
    "thoughts": walk to living room, find lamp, switch on.,
    "actions": ['[WALK] <home_office>', '[WALK] <floor_lamp>', '[FIND] <floor_lamp>']
}

Input:
Scene_Objects:['tablelamp', 'microwave', 'freezer', 'band-aids', 'cat', 'orchid', 'cpuscreen', 'hanger', 'bathroom_counter', 'phone', 'folder', 'desk', 'tea_bag', 'keyboard', 'stovefan', 'toaster', 'shower', 'faucet', 'couch', 'bench', 'photoframe', 'coffe_maker', 'television', 'tray', 'vacuum_cleaner', 'hairbrush', 'dresser', 'door', 'bathtub', 'light']
Task:Pet cat
response:

Find the cat; pet the cat by touching it

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


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

Here is an example plan to achieve a goal for reference:
Scene_Objects:['sheets', 'microwave', 'toilet', 'chair', 'band-aids', 'cat', 'food_carrot', 'knife', 'foundation', 'electric_shaver', 'mousepad', 'clothes_socks', 'pillow', 'dining_room', 'nightstand', 'oven', 'toy', 'check', 'coffe_maker', 'television', 'curtain', 'doorjamb', 'kitchen_counter', 'chessboard', 'cupboard', 'conditioner', 'door', 'food_steak', 'clothes_skirt', 'duster']
Task:Dust
response:
{
    "thoughts": Get a broom or duster with long handle. Dust blades of ceiling fan.,
    "actions": ['[WALK] <bedroom>', '[WALK] <duster>', '[FIND] <duster>', '[GRAB] <duster>', '[PUTOBJBACK] <duster>']
}

Input:
Scene_Objects:['toilet', 'walllamp', 'trashcan', 'drawing', 'floor', 'phone', 'computer', 'toaster', 'mat', 'tvstand', 'ceilinglamp', 'faucet', 'window', 'shower', 'closetdrawer', 'couch', 'pillow', 'dining_room', 'wall', 'novel', 'coffe_maker', 'television', 'tray', 'curtain', 'cupboard', 'controller', 'door', 'bathtub', 'table', 'light']
Task:Read book
response:

Walk to the couch in the living room, sit on ti and read the book

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


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

Here is an example plan to achieve a goal for reference:
Scene_Objects:['sheets', 'microwave', 'detergent', 'orchid', 'knifeblock', 'floor', 'ceiling', 'bookshelf', 'mail', 'toaster', 'stovefan', 'faucet', 'closetdrawer', 'pillow', 'food_kiwi', 'wall', 'nightstand', 'oven', 'photoframe', 'television', 'coin', 'drinking_glass', 'water', 'curtain', 'kitchen_counter', 'vacuum_cleaner', 'cupboard', 'sink', 'dishwasher', 'coffee']
Task:Drink
response:
{
    "thoughts": I walk to the kitchen and approach the sink. I take a drinking glass and set it under the faucet. I turn the faucet until the water fills the glass, then turn it back. Finally I lift the glass out of the sink and drink the water.,
    "actions": ['[WALK] <dining_room>', '[WALK] <sink>', '[FIND] <drinking_glass>', '[GRAB] <drinking_glass>', '[PUTBACK] <drinking_glass> <sink>', '[FIND] <faucet>', '[SWITCHON] <faucet>', '[SWITCHOFF] <faucet>', '[GRAB] <drinking_glass>', '[FIND] <water>', '[DRINK] <drinking_glass>']
}

Input:
Scene_Objects:['filing_cabinet', 'tablelamp', 'microwave', 'toilet', 'dog', 'chair', 'walllamp', 'drawing', 'cpuscreen', 'wallshelf', 'hanger', 'floor', 'desk', 'envelope', 'mat', 'tvstand', 'ceilinglamp', 'shower', 'window', 'mousepad', 'couch', 'pillow', 'wall', 'nightstand', 'television', 'oven_mitts', 'curtain', 'controller', 'home_office', 'table']
Task:Relax on sofa
response:

I walk into the living room. I cross the room to the couch. I sit down and relax.

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


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

Here is an example plan to achieve a goal for reference:
Scene_Objects:['spectacles', 'pot', 'filing_cabinet', 'tablelamp', 'mop', 'toilet', 'walllamp', 'cat', 'drawing', 'floor', 'ceiling', 'character', 'bookshelf', 'food_cake', 'piano_bench', 'shower', 'faucet', 'pillow', 'wall', 'photoframe', 'bed', 'curtain', 'doorjamb', 'diary', 'dresser', 'cupboard', 'door', 'bathroom_cabinet', 'soap', 'instrument_violin']
Task:Go to toilet
response:
{
    "thoughts": Walk to the bathroom.  Find the toilet.  Lift the top of the toilet.  Sit on the toilet.,
    "actions": ['[WALK] <bathroom>', '[WALK] <toilet>', '[FIND] <toilet>', '[OPEN] <toilet>', '[SIT] <toilet>']
}

Input:
Scene_Objects:['filing_cabinet', 'microwave', 'toilet', 'freezer', 'trashcan', 'drawing', 'knife', 'hanger', 'floor', 'ceiling', 'desk', 'bookshelf', 'mat', 'shower', 'window', 'food_kiwi', 'wall', 'bench', 'newspaper', 'food_food', 'coffe_maker', 'food_onion', 'curtain', 'doorjamb', 'towel_rack', 'kitchen_counter', 'cupboard', 'door', 'sink', 'home_office']
Task:Put groceries in Fridge
response:

walk to kitchen, walk to fridge, look at bags, grab groceries, put groceries in fridge.

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


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

Here is an example plan to achieve a goal for reference:
Scene_Objects:['pot', 'microwave', 'freezer', 'walllamp', 'food_butter', 'dough', 'food_carrot', 'drawing', 'food_egg', 'kitchen_cabinet', 'floor', 'ceiling', 'bathroom_counter', 'food_chicken', 'food_cake', 'stovefan', 'mat', 'faucet', 'oil', 'wall', 'pasta', 'powersocket', 'oven', 'wall_clock', 'cutting_board', 'food_food', 'coffe_maker', 'oven_mitts', 'wooden_spoon', 'tray', 'doorjamb', 'coffee_pot', 'kitchen_counter', 'maindoor', 'sink', 'bathroom_cabinet', 'light']
Task:Cook some food
response:
{
    "thoughts": I walk into the kitchen and walk over the cabinent. I pull out a pan and walk to the stove. I put the pan on the stove and walk over to the fridge. I pull out out meat from the fridge and walk back over the stove. Then I put the meat in the pan.,
    "actions": ['[WALK] <dining_room>', '[WALK] <light>', '[FIND] <light>', '[SWITCHON] <light>', '[WALK] <kitchen_cabinet>', '[FIND] <pot>', '[GRAB] <pot>', '[WALK] <oven>', '[PUTBACK] <pot> <oven>', '[WALK] <freezer>', '[OPEN] <freezer>', '[FIND] <food_chicken>', '[GRAB] <food_chicken>', '[WALK] <oven>', '[PUTBACK] <food_chicken> <oven>']
}

Input:
Scene_Objects:['food_pizza', 'filing_cabinet', 'nail_polish', 'toothbrush', 'cpuscreen', 'wallshelf', 'bathroom_counter', 'floor', 'ceiling', 'phone', 'computer', 'stovefan', 'ceilinglamp', 'faucet', 'closetdrawer', 'pillow', 'wall', 'wall_clock', 'food_food', 'toothbrush_holder', 'tray', 'dresser', 'cupboard', 'controller', 'door', 'sink', 'bathroom_cabinet', 'home_office', 'light', 'tooth_paste']
Task:Wash teeth
response:

I go into the bathroom, go to the sink, get toothbrush and toothpaste. Put toothpaste on the toothbrush, brush teeth, turn on faucet, rinse brush, and return toothbrush.


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

Here is an example plan to achieve a goal for reference:
Scene_Objects:['food_salt', 'microwave', 'toilet', 'walllamp', 'cat', 'food_carrot', 'drawing', 'cpuscreen', 'wallshelf', 'floor', 'ceiling', 'desk', 'bookshelf', 'mop_bucket', 'stovefan', 'mat', 'stereo', 'couch', 'wall', 'powersocket', 'bed', 'novel', 'wooden_spoon', 'doorjamb', 'kitchen_counter', 'controller', 'door', 'food_steak', 'spoon', 'light']
Task:Turn on light
response:
{
    "thoughts": I walk to wall. I put my hand on the switch. I push the button. I turn on the lights.,
    "actions": ['[WALK] <light>', '[FIND] <light>', '[SWITCHON] <light>']
}

Input:
Scene_Objects:['pot', 'microwave', 'toilet', 'freezer', 'walllamp', 'trashcan', 'drawing', 'wallshelf', 'floor', 'ceiling', 'food_chicken', 'stovefan', 'mat', 'toaster', 'shower', 'faucet', 'window', 'closetdrawer', 'couch', 'wall', 'wall_clock', 'oven', 'coffe_maker', 'tray', 'doorjamb', 'mouse', 'kitchen_counter', 'cupboard', 'door', 'sink']
Task:Cook some food
response:

I walk in the kitchen, I open the fridge and remove the Chicken. I grab frying fan and put it on stove. I put chicken in the frying pan and I cook food.

[WALK] <dining_room>
[WALK] <freezer>
[FIND] <freezer>
[OPEN] <freezer>
[FIND] <food_chicken>
[GRAB] <food_chicken>
[FIND] <pot>
[GRAB] <pot>
[FIND] <oven>
[PUTBACK] <pot> <oven>
[PUTBACK] <food_chicken> <oven>


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

Here is an example plan to achieve a goal for reference:
Scene_Objects:['fork', 'scissors', 'microwave', 'bathroom', 'nail_polish', 'toothbrush', 'cpuscreen', 'bathroom_counter', 'floor', 'bookshelf', 'mat', 'faucet', 'window', 'electric_shaver', 'couch', 'pillow', 'dining_room', 'wall', 'oven', 'photoframe', 'newspaper', 'keys', 'television', 'curtain', 'doorjamb', 'diary', 'sink', 'spoon', 'table', 'soap']
Task:Relax on sofa
response:
{
    "thoughts": Walk into the living room. Walk to the sofa and sit on it. Put your feet up on the sofa and lay down.,
    "actions": ['[WALK] <home_office>', '[WALK] <couch>', '[SIT] <couch>', '[LIE] <couch>']
}

Input:
Scene_Objects:['tablelamp', 'walllamp', 'trashcan', 'drawing', 'floor', 'ceiling', 'bookshelf', 'mat', 'tvstand', 'ceilinglamp', 'shower', 'window', 'closetdrawer', 'couch', 'pillow', 'dining_room', 'wall', 'nightstand', 'oven', 'food_food', 'coffe_maker', 'television', 'tray', 'curtain', 'mouse', 'pencil', 'kitchen_counter', 'vacuum_cleaner', 'sink', 'table']
Task:Relax on sofa
response:

I walk to the living room. I sit in the sofa and I relax.

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


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

Here is an example plan to achieve a goal for reference:
Scene_Objects:['scissors', 'toilet', 'chair', 'walllamp', 'ceilingfan', 'bathroom_counter', 'floor', 'phone', 'character', 'mail', 'computer', 'toaster', 'foundation', 'clothes_socks', 'food_peanut_butter', 'dining_room', 'wall', 'oven', 'powersocket', 'tape', 'cup', 'coffe_maker', 'video_game_controller', 'television', 'tray', 'curtain', 'cd', 'maindoor', 'bathroom_cabinet', 'dishwasher']
Task:Wash dishes with dishwasher
response:
{
    "thoughts": I walk to the kitchen. I take plate. I open the dishwasher. I put plate in the dishwasher. I switch on the dishwasher.,
    "actions": ['[WALK] <dining_room>', '[WALK] <plate>', '[FIND] <plate>', '[GRAB] <plate>', '[WALK] <dishwasher>', '[OPEN] <dishwasher>', '[PUTBACK] <plate> <dishwasher>', '[CLOSE] <dishwasher>', '[SWITCHON] <dishwasher>']
}

Input:
Scene_Objects:['microwave', 'toilet', 'jelly', 'dog', 'walllamp', 'bathroom', 'cpuscreen', 'hanger', 'bedroom', 'keyboard', 'toaster', 'ceilinglamp', 'stereo', 'window', 'couch', 'pillow', 'dining_room', 'wall', 'powersocket', 'oven', 'photoframe', 'coffe_maker', 'television', 'curtain', 'mouse', 'cupboard', 'bathtub', 'home_office', 'light', 'bathroom_cabinet']
Task:Listen to music
response:

I walk into the bedroom. I walk to stereo. I turn on stereo.

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


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

Here is an example plan to achieve a goal for reference:
Scene_Objects:['filing_cabinet', 'food_ice_cream', 'chair', 'wallshelf', 'bathroom_counter', 'floor', 'ceiling', 'phone', 'desk', 'keyboard', 'stovefan', 'mat', 'faucet', 'shower', 'window', 'mousepad', 'couch', 'towel', 'wall', 'bed', 'photoframe', 'curtain', 'after_shave', 'kitchen_counter', 'sink', 'bathroom_cabinet', 'light', 'soap', 'hands_both', 'shoe_rack']
Task:Wash hands
response:
{
    "thoughts": Wash hands with soap and hot water,
    "actions": ['[WALK] <bathroom>', '[WALK] <sink>', '[FIND] <faucet>', '[SWITCHON] <faucet>', '[FIND] <soap>', '[GRAB] <soap>', '[FIND] <hands_both>', '[SCRUB] <hands_both>', '[PUTOBJBACK] <soap>', '[RINSE] <hands_both>', '[SWITCHOFF] <faucet>', '[FIND] <towel>', '[GRAB] <towel>', '[WIPE] <hands_both>', '[PUTOBJBACK] <towel>']
}

Input:
Scene_Objects:['filing_cabinet', 'shoe_rack', 'tablelamp', 'microwave', 'toilet', 'walllamp', 'bathroom', 'orchid', 'hanger', 'floor', 'ceiling', 'bookshelf', 'computer', 'toaster', 'ceilinglamp', 'plate', 'faucet', 'shower', 'mat', 'window', 'dish_soap', 'couch', 'pillow', 'wall', 'basket_for_clothes', 'bed', 'towel_rack', 'light', 'dishwasher', 'creditcard']
Task:Wash dishes with dishwasher
response:

Wash a plate using the dishwasher in the kitchen.

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


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

Here is an example plan to achieve a goal for reference:
Scene_Objects:['filing_cabinet', 'crayon', 'cat', 'cpuscreen', 'hanger', 'floor', 'ceiling', 'character', 'desk', 'keyboard', 'food_cake', 'computer', 'brush', 'electric_shaver', 'mousepad', 'closetdrawer', 'wall', 'wall_clock', 'powersocket', 'toy', 'food_food', 'towel_rack', 'mouse', 'dresser', 'pajamas', 'sink', 'napkin', 'light', 'colander', 'tooth_paste']
Task:Pick up toys
response:
{
    "thoughts": Pickup toys from around the room. Organize toys back into their appropriate spaces on the shelves and into the toy boxes.,
    "actions": ['[WALK] <bedroom>', '[WALK] <toy>', '[FIND] <toy>', '[GRAB] <toy>', '[WALK] <filing_cabinet>', '[OPEN] <filing_cabinet>', '[PUTBACK] <toy> <filing_cabinet>', '[CLOSE] <filing_cabinet>', '[FIND] <toy>', '[GRAB] <toy>', '[WALK] <dresser>', '[OPEN] <dresser>', '[PUTBACK] <toy> <dresser>', '[CLOSE] <dresser>', '[FIND] <toy>', '[GRAB] <toy>', '[WALK] <filing_cabinet>', '[OPEN] <filing_cabinet>', '[PUTBACK] <toy> <filing_cabinet>', '[CLOSE] <filing_cabinet>']
}

Input:
Scene_Objects:['filing_cabinet', 'microwave', 'toilet', 'bathroom', 'food_butter', 'milk', 'orchid', 'floor', 'ceiling', 'character', 'bedroom', 'desk', 'bookshelf', 'computer', 'ceilinglamp', 'shower', 'window', 'mousepad', 'closetdrawer', 'couch', 'clothes_hat', 'wall', 'coffe_maker', 'television', 'tray', 'curtain', 'dresser', 'bathtub', 'bathroom_cabinet', 'table']
Task:Pick up phone
response:

Walk to the entrance hall. Find the telephone. Grab the telephone.

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


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

Here is an example plan to achieve a goal for reference:
Scene_Objects:['pot', 'filing_cabinet', 'microwave', 'food_butter', 'knife', 'wallshelf', 'bathroom_counter', 'phone', 'character', 'bedroom', 'keyboard', 'computer', 'faucet', 'electric_shaver', 'mousepad', 'wall', 'powersocket', 'oven', 'shelf', 'cup', 'bed', 'food_rice', 'tray', 'mouse', 'headset', 'comb', 'dresser', 'conditioner', 'home_office', 'table']
Task:Brush teeth
response:
{
    "thoughts": go to the bathroom and brush your teeth,
    "actions": ['[WALK] <bathroom>', '[WALK] <toothbrush>', '[FIND] <toothbrush>', '[GRAB] <toothbrush>', '[WALK] <tooth_paste>', '[FIND] <tooth_paste>', '[GRAB] <tooth_paste>', '[POUR] <tooth_paste> <toothbrush>']
}

Input:
Scene_Objects:['food_salt', 'freezer', 'walllamp', 'drawing', 'hanger', 'floor', 'ceiling', 'bookshelf', 'mat', 'tvstand', 'ceilinglamp', 'shower', 'window', 'couch', 'pillow', 'wall', 'nightstand', 'powersocket', 'bed', 'coffe_maker', 'television', 'ice', 'tray', 'curtain', 'doorjamb', 'kitchen_counter', 'headset', 'cupboard', 'sink', 'table']
Task:Relax on sofa
response:

I walk to the sofa, and lie down on the sofa.


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', 'walllamp', 'detergent', 'toothbrush', 'drawing', 'cpuscreen', 'food_egg', 'phone', 'character', 'computer', 'piano_bench', 'shoe-shine_kit', 'faucet', 'food_noodles', 'mousepad', 'clothes_hat', 'towel', 'broom', 'cutting_board', 'shelf', 'keys', 'novel', 'food_food', 'check', 'wooden_spoon', 'towel_rack', 'sink', 'table', 'light', 'coffee']
Task:Change TV channel
response:
{
    "thoughts": I pull up my online classes on the computer to look at what the assigned reading is. I get my textbook, notebook, and mechanical pencil. As I'm reading, I take notes over important points. I then use those notes to complete the assignment for the week. Frequently that involves writing a post on an online discussion board that answers a question related to things from the reading.,
    "actions": ['[WALK] <home_office>', '[WALK] <remote_control>', '[GRAB] <remote_control>', '[TURNTO] <remote_control>', '[POINTAT] <remote_control>']
}

Input:
Scene_Objects:['dry_pasta', 'filing_cabinet', 'freezer', 'walllamp', 'cpuscreen', 'wallshelf', 'ceiling', 'computer', 'shower', 'window', 'mousepad', 'couch', 'dining_room', 'wall_clock', 'oven', 'powersocket', 'bench', 'cup', 'bed', 'photoframe', 'check', 'coffe_maker', 'razor', 'mouse', 'cupboard', 'laundry_detergent', 'door', 'home_office', 'light', 'washing_machine']
Task:Wash clothes
response:

"I walk to entrance hall" "I walk to bedroom" "I find basket of clothes" "I lift basket of  clothes" "I walk to kitchen" "I find washing machine" "I open washing machine " "I put laundry in washing machine" "I add laundry detergent" " "I close washing machine lid" "I switch washing machine on"


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

Here is an example plan to achieve a goal for reference:
Scene_Objects:['sheets', 'scissors', 'freezer', 'walllamp', 'ground_coffee', 'bathroom', 'ceilingfan', 'clothes_underwear', 'bathroom_counter', 'character', 'thread', 'piano_bench', 'toaster', 'deck_of_cards', 'homework', 'couch', 'dustpan', 'powersocket', 'newspaper', 'clothes_gloves', 'novel', 'coffe_maker', 'doorjamb', 'chessboard', 'cd', 'napkin', 'home_office', 'instrument_guitar', 'clothes_skirt', 'light']
Task:Close door
response:
{
    "thoughts": Push the door shut until it latches.,
    "actions": ['[RUN] <home_office>']
}

Input:
Scene_Objects:['tablelamp', 'toilet', 'jelly', 'freezer', 'orchid', 'food_egg', 'bathroom_counter', 'floor', 'phone', 'bedroom', 'computer', 'food_bacon', 'plate', 'faucet', 'shower', 'window', 'dish_soap', 'mousepad', 'couch', 'wall', 'wall_clock', 'powersocket', 'bench', 'shoes', 'hairbrush', 'cupboard', 'sink', 'bathtub', 'bathroom_cabinet', 'home_office']
Task:Wash dishes by hand
response:

Make some dish water, grab a dish rag, put dishes in dish water and wash.

[RUN] <sink>
[FIND] <dish_soap>
[GRAB] <dish_soap>
[FIND] <plate>
[PUTBACK] <dish_soap> <plate>
[RINSE] <dish_soap>
[FIND] <plate>
[WASH] <plate>


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

Here is an example plan to achieve a goal for reference:
Scene_Objects:['sheets', 'mop', 'bathroom', 'knife', 'hanger', 'bathroom_counter', 'ceiling', 'bedroom', 'desk', 'food_cake', 'window', 'electric_shaver', 'microphone', 'food_jam', 'dining_room', 'wall', 'photoframe', 'food_food', 'television', 'curtain', 'mouse', 'kitchen_counter', 'cd', 'chessboard', 'dresser', 'hairbrush', 'clothes_scarf', 'bathroom_cabinet', 'dishwasher', 'instrument_violin']
Task:Put on coat
response:
{
    "thoughts": I remove my scarf from a coat peg in the entrance hall.  I wrap the scarf around my neck,
    "actions": ['[WALK] <home_office>', '[WALK] <hanger>', '[TURNTO] <hanger>', '[LOOKAT] <hanger>', '[FIND] <clothes_scarf>', '[GRAB] <clothes_scarf>', '[PUTON] <clothes_scarf>']
}

Input:
Scene_Objects:['pot', 'microwave', 'chair', 'freezer', 'walllamp', 'cat', 'trashcan', 'milk', 'hanger', 'bathroom_counter', 'desk', 'mousepad', 'closetdrawer', 'clothes_pants', 'pillow', 'dining_room', 'nightstand', 'wall', 'oven', 'cup', 'bed', 'coffe_maker', 'tray', 'curtain', 'chessboard', 'shoes', 'hairbrush', 'cupboard', 'bathroom_cabinet', 'table']
Task:Pet cat
response:

Petting a cat may sound simple.Letting the Cat Come to You.Extend a hand or finger and allow the cat a chance to touch her nose to you. When a cat bumps her head into your hand, it's a signal she wants attention.Focusing on Areas with Scent Glands. Feed with food.

[WALK] <home_office>
[WALK] <cat>
[FIND] <cat>
[TURNTO] <cat>
[LOOKAT] <cat>
[FIND] <cup>
[GRAB] <cup>
[WALK] <milk>
[FIND] <milk>
[GRAB] <milk>
[POUR] <milk> <cup>
[TURNTO] <cat>
[POINTAT] <cat>


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

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

Input:
Scene_Objects:['water_glass', 'food_salt', 'microwave', 'freezer', 'orchid', 'cpuscreen', 'ceiling', 'character', 'bedroom', 'desk', 'food_bacon', 'bookmark', 'toaster', 'stovefan', 'faucet', 'shower', 'mousepad', 'wall', 'wall_clock', 'oven', 'bench', 'coffe_maker', 'television', 'water', 'tray', 'doorjamb', 'kitchen_counter', 'cupboard', 'sink', 'light']
Task:Drink
response:

I go to the kitchen, take a glass from the cupboard, fill with water and drink

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


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

Here is an example plan to achieve a goal for reference:
Scene_Objects:['tea', 'walllamp', 'detergent', 'cat', 'ceilingfan', 'drawing', 'knifeblock', 'floor', 'ceiling', 'desk', 'remote_control', 'mail', 'button', 'stovefan', 'ceilinglamp', 'tvstand', 'balanceball', 'window', 'clothes_socks', 'couch', 'wall', 'bench', 'clothes_gloves', 'coffe_maker', 'television', 'curtain', 'coffee_pot', 'home_office', 'table', 'coffee']
Task:Change TV channel
response:
{
    "thoughts": walk to living room, look at the television, switch on the television, grab the remote control, press the channel button in remote control, now the tv channel is changed,
    "actions": ['[WALK] <home_office>', '[WALK] <television>', '[FIND] <television>', '[TURNTO] <television>', '[LOOKAT] <television>', '[SWITCHON] <television>', '[FIND] <remote_control>', '[GRAB] <remote_control>', '[FIND] <button>', '[GRAB] <button>']
}

Input:
Scene_Objects:['tablelamp', 'toilet', 'bathroom', 'cat', 'dough', 'knife', 'bathroom_counter', 'floor', 'keyboard', 'computer', 'brush', 'laptop', 'plate', 'faucet', 'deck_of_cards', 'window', 'closetdrawer', 'couch', 'dining_room', 'nightstand', 'wall', 'oven', 'bench', 'television', 'towel_rack', 'kitchen_counter', 'dresser', 'cupboard', 'sink', 'bathtub']
Task:Pet cat
response:

Every time this animal is seen, you must approach it and show compassion for it by petting it in a gentle manner.

[WALK] <home_office>
[WALK] <bedroom>
[WALK] <bedroom>
[WALK] <home_office>
[WALK] <home_office>
[WALK] <cat>
[FIND] <cat>
[FIND] <brush>
[GRAB] <brush>


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', 'blender', 'microwave', 'toilet', 'detergent', 'drawing', 'wallshelf', 'bathroom_counter', 'floor', 'character', 'keyboard', 'computer', 'brush', 'mat', 'laptop', 'faucet', 'ceilinglamp', 'window', 'dustpan', 'pillow', 'wall', 'nightstand', 'powersocket', 'bed', 'towel_rack', 'mouse', 'kitchen_counter', 'pajamas', 'dishwasher']
Task:Go to sleep
response:
{
    "thoughts": go to bedroom, put pajamas on, lie in bed, sleep,
    "actions": ['[WALK] <bedroom>', '[WALK] <pajamas>', '[FIND] <pajamas>', '[GRAB] <pajamas>', '[PUTON] <pajamas>', '[FIND] <bed>', '[LIE] <bed>']
}

Input:
Scene_Objects:['chair', 'walllamp', 'cpuscreen', 'hanger', 'floor', 'ceiling', 'desk', 'keyboard', 'computer', 'stovefan', 'ceilinglamp', 'tvstand', 'shower', 'window', 'mousepad', 'wall', 'nightstand', 'powersocket', 'bench', 'photoframe', 'television', 'tray', 'curtain', 'doorjamb', 'mouse', 'cd', 'sink', 'bathtub', 'table', 'dirt']
Task:Write an email
response:

I go to my office and sit at my desk. Turn on the computer and type my email at the keyboard.

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


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

Here is an example plan to achieve a goal for reference:
Scene_Objects:['filing_cabinet', 'microwave', 'chair', 'knife', 'knifeblock', 'orchid', 'drawing', 'floor', 'phone', 'character', 'bedroom', 'remote_control', 'computer', 'button', 'mat', 'tvstand', 'faucet', 'shower', 'oil', 'dining_room', 'powersocket', 'newspaper', 'ice', 'tray', 'doorjamb', 'towel_rack', 'dresser', 'door', 'home_office', 'table']
Task:Change TV channel
response:
{
    "thoughts": I pick up the remote. I press button on remote.,
    "actions": ['[WALK] <bedroom>', '[WALK] <remote_control>', '[FIND] <remote_control>', '[GRAB] <remote_control>', '[FIND] <button>', '[PUSH] <button>']
}

Input:
Scene_Objects:['tablelamp', 'beer', 'toilet', 'freezer', 'walllamp', 'bathroom', 'drawing', 'wallshelf', 'ceiling', 'phone', 'character', 'keyboard', 'toaster', 'mat', 'floor_lamp', 'oil', 'pillow', 'dining_room', 'nightstand', 'wall_clock', 'bench', 'novel', 'television', 'curtain', 'doorjamb', 'dresser', 'door', 'sink', 'bathroom_cabinet', 'table']
Task:Read book
response:

Turn a light on and read a book in the bedroom.

[WALK] <bedroom>
[WALK] <floor_lamp>
[FIND] <floor_lamp>
[SWITCHON] <floor_lamp>
[FIND] <novel>
[GRAB] <novel>
[READ] <novel>


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

Here is an example plan to achieve a goal for reference:
Scene_Objects:['pot', 'bathroom', 'trashcan', 'food_butter', 'drawing', 'floor', 'ceiling', 'phone', 'mat', 'ceilinglamp', 'window', 'couch', 'pillow', 'wall', 'wall_clock', 'powersocket', 'nightstand', 'food_food', 'check', 'television', 'curtain', 'doorjamb', 'towel_rack', 'kitchen_counter', 'dresser', 'door', 'sink', 'spoon', 'home_office', 'light']
Task:Turn on light
response:
{
    "thoughts": walk in kitchen. switch on light. walk in living room. switch on light.walk in entrance hall. switch on light.,
    "actions": ['[WALK] <dining_room>', '[WALK] <light>', '[FIND] <light>', '[SWITCHON] <light>', '[WALK] <home_office>', '[WALK] <home_office>']
}

Input:
Scene_Objects:['sheets', 'filing_cabinet', 'crayon', 'toilet', 'bathroom', 'nail_polish', 'trashcan', 'food_carrot', 'hanger', 'floor', 'computer', 'toaster', 'window', 'food_jam', 'nightstand', 'oven', 'bench', 'tape', 'photoframe', 'food_food', 'coffe_maker', 'television', 'toilet_paper', 'doorjamb', 'dresser', 'pajamas', 'cupboard', 'door', 'sink', 'home_office']
Task:Listen to music
response:

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

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


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

Here is an example plan to achieve a goal for reference:
Scene_Objects:['fork', 'microwave', 'chair', 'detergent', 'trashcan', 'knifeblock', 'floor', 'ceiling', 'character', 'bookshelf', 'purse', 'computer', 'toaster', 'mat', 'tvstand', 'clothes_socks', 'food_peanut_butter', 'microphone', 'food_jam', 'pillow', 'wall', 'powersocket', 'after_shave', 'doorjamb', 'cd', 'pajamas', 'laundry_detergent', 'door', 'light', 'tooth_paste']
Task:Turn on light
response:
{
    "thoughts": Coming home turning on lights.,
    "actions": ['[WALK] <home_office>', '[WALK] <light>', '[FIND] <light>', '[SWITCHON] <light>']
}

Input:
Scene_Objects:['filing_cabinet', 'tablelamp', 'chair', 'walllamp', 'bathroom', 'trashcan', 'cpuscreen', 'wallshelf', 'floor', 'ceiling', 'character', 'desk', 'bedroom', 'keyboard', 'computer', 'toaster', 'ceilinglamp', 'tvstand', 'mousepad', 'oil', 'couch', 'wall', 'wall_clock', 'powersocket', 'oven', 'food_food', 'television', 'doorjamb', 'mouse', 'table']
Task:Work
response:

turn computer on, open application to work with

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


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

Here is an example plan to achieve a goal for reference:
Scene_Objects:['fork', 'pot', 'food_bread', 'scissors', 'microwave', 'freezer', 'milk', 'knifeblock', 'drawing', 'bathroom_counter', 'floor', 'ceiling', 'mail', 'food_bacon', 'ceilinglamp', 'shower', 'faucet', 'bowl', 'food_kiwi', 'wall', 'oven', 'cup', 'bed', 'coffe_maker', 'video_game_controller', 'diary', 'dishrack', 'controller', 'conditioner', 'home_office']
Task:Get glass of milk
response:
{
    "thoughts": Get an empty glass. Take milk from refrigerator and open it. Pour milk into glass.,
    "actions": ['[WALK] <dining_room>', '[WALK] <cup>', '[FIND] <cup>', '[GRAB] <cup>', '[WALK] <freezer>', '[OPEN] <freezer>', '[FIND] <milk>', '[GRAB] <milk>', '[POUR] <milk> <cup>', '[PUTOBJBACK] <milk>', '[CLOSE] <freezer>']
}

Input:
Scene_Objects:['microwave', 'toilet', 'freezer', 'trashcan', 'drawing', 'wallshelf', 'bathroom_counter', 'floor', 'ceiling', 'piano_bench', 'stovefan', 'mat', 'tvstand', 'shower', 'stereo', 'mousepad', 'closetdrawer', 'pillow', 'dining_room', 'wall', 'bench', 'photoframe', 'tray', 'doorjamb', 'kitchen_counter', 'cupboard', 'door', 'bathtub', 'sink', 'table']
Task:Put groceries in Fridge
response:

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

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


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

Here is an example plan to achieve a goal for reference:
Scene_Objects:['pot', 'tablelamp', 'chair', 'drawing', 'orchid', 'cpuscreen', 'floor', 'phone', 'ceiling', 'desk', 'keyboard', 'computer', 'mat', 'laptop', 'ceilinglamp', 'tvstand', 'mousepad', 'wall', 'nightstand', 'oven', 'powersocket', 'television', 'tray', 'doorjamb', 'towel_rack', 'mouse', 'dishrack', 'door', 'light', 'shoe_rack']
Task:Browse internet
response:
{
    "thoughts": Walk to home office, walk to desk, sit in chair, turn on laptop, grab mouse, open a web page to look at it, move mouse, keep looking at laptop screen.,
    "actions": ['[WALK] <home_office>', '[WALK] <desk>', '[FIND] <chair>', '[SIT] <chair>', '[FIND] <laptop>', '[SWITCHON] <laptop>', '[FIND] <mouse>', '[GRAB] <mouse>', '[TURNTO] <laptop>', '[LOOKAT] <laptop>', '[TOUCH] <mouse>', '[TURNTO] <laptop>', '[LOOKAT] <laptop>']
}

Input:
Scene_Objects:['tablelamp', 'walllamp', 'trashcan', 'drawing', 'bathroom_counter', 'floor', 'bookshelf', 'mail', 'stovefan', 'mat', 'tvstand', 'ceilinglamp', 'shower', 'window', 'couch', 'pillow', 'wall', 'oven', 'toy', 'mouthwash', 'television', 'wine', 'tray', 'curtain', 'cd', 'dresser', 'bathtub', 'sink', 'table', 'light']
Task:Relax on sofa
response:

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

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


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

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

Input:
Scene_Objects:['microwave', 'toilet', 'floor', 'ceiling', 'phone', 'bedroom', 'bookshelf', 'keyboard', 'toaster', 'ceilinglamp', 'plate', 'faucet', 'shower', 'window', 'tvstand', 'pillow', 'wall', 'wall_clock', 'powersocket', 'photoframe', 'coffe_maker', 'water', 'doorjamb', 'mouse', 'kitchen_counter', 'dresser', 'cupboard', 'sink', 'light', 'table']
Task:Drink
response:

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

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


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

Here is an example plan to achieve a goal for reference:
Scene_Objects:['scissors', 'bathroom', 'ceilingfan', 'drawing', 'bathroom_counter', 'floor', 'ceiling', 'character', 'bookshelf', 'remote_control', 'toaster', 'ceilinglamp', 'tvstand', 'balanceball', 'laptop', 'window', 'couch', 'dining_room', 'food_kiwi', 'wall', 'toilet_paper', 'razor', 'television', 'curtain', 'diary', 'towel_rack', 'door', 'bathroom_cabinet', 'table', 'creditcard']
Task:Watch TV
response:
{
    "thoughts": Sit on the couch and use the remote control to turn on the TV,
    "actions": ['[WALK] <home_office>', '[WALK] <couch>', '[FIND] <couch>', '[SIT] <couch>', '[FIND] <remote_control>', '[GRAB] <remote_control>', '[FIND] <television>', '[SWITCHON] <television>', '[PUTOBJBACK] <remote_control>', '[TURNTO] <television>', '[WATCH] <television>']
}

Input:
Scene_Objects:['tablelamp', 'food_salt', 'orchid', 'hanger', 'floor', 'phone', 'ceiling', 'character', 'toaster', 'mat', 'plate', 'faucet', 'shower', 'window', 'closetdrawer', 'powersocket', 'oven', 'cup', 'curtain', 'doorjamb', 'mouse', 'comb', 'cupboard', 'clothes_dress', 'door', 'bathtub', 'home_office', 'table', 'dishwasher', 'dirt']
Task:Wash dishes with dishwasher
response:

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

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


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

Here is an example plan to achieve a goal for reference:
Scene_Objects:['spectacles', 'pot', 'filing_cabinet', 'beer', 'crayon', 'walllamp', 'drawing', 'food_egg', 'bathroom_counter', 'floor', 'bookshelf', 'mat', 'iron', 'electric_shaver', 'window', 'closetdrawer', 'couch', 'pillow', 'wall', 'toy', 'cup', 'light_bulb', 'novel', 'food_food', 'check', 'toothbrush_holder', 'television', 'curtain', 'doorjamb', 'table']
Task:Read book
response:
{
    "thoughts": I go to the book case, I select a book, I go back and sit down, then I read.,
    "actions": ['[WALK] <filing_cabinet>', '[FIND] <novel>', '[GRAB] <novel>', '[WALK] <couch>', '[READ] <novel>']
}

Input:
Scene_Objects:['pot', 'filing_cabinet', 'freezer', 'cpuscreen', 'hanger', 'bathroom_counter', 'phone', 'bedroom', 'desk', 'bookshelf', 'toaster', 'ceilinglamp', 'mat', 'faucet', 'window', 'mousepad', 'closetdrawer', 'pillow', 'dining_room', 'broom', 'nightstand', 'oven', 'bench', 'coffe_maker', 'check', 'towel_rack', 'mouse', 'cupboard', 'light', 'table']
Task:Listen to music
response:

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

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


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

Here is an example plan to achieve a goal for reference:
Scene_Objects:['water_glass', 'food_bread', 'food_ice_cream', 'crayon', 'microwave', 'chair', 'drawing', 'cpuscreen', 'bathroom_counter', 'floor', 'phone', 'bookshelf', 'computer', 'mat', 'ceilinglamp', 'faucet', 'tvstand', 'window', 'wall', 'bench', 'powersocket', 'clothes_gloves', 'water', 'tray', 'cupboard', 'sink', 'bathroom_cabinet', 'table', 'light', 'instrument_violin']
Task:Drink
response:
{
    "thoughts": walk to kitchen, hold drinking glass, lift glass, pour water in drinking glass,
    "actions": ['[WALK] <dining_room>', '[WALK] <table>', '[FIND] <table>', '[FIND] <water_glass>', '[GRAB] <water_glass>', '[FIND] <water>', '[GRAB] <water>', '[WALK] <water>', '[POUR] <water> <water_glass>', '[DRINK] <water_glass>']
}

Input:
Scene_Objects:['tablelamp', 'beer', 'freezer', 'bathroom', 'drawing', 'wallshelf', 'bathroom_counter', 'floor', 'phone', 'bedroom', 'computer', 'ceilinglamp', 'mat', 'faucet', 'couch', 'clothes_pants', 'wall', 'wall_clock', 'bench', 'powersocket', 'nightstand', 'photoframe', 'novel', 'tray', 'curtain', 'doorjamb', 'sink', 'napkin', 'bathroom_cabinet', 'hands_both']
Task:Wash hands
response:

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


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

Here is an example plan to achieve a goal for reference:
Scene_Objects:['filing_cabinet', 'food_salt', 'freezer', 'orchid', 'wallshelf', 'clothes_underwear', 'cpuscreen', 'phone', 'character', 'bedroom', 'keyboard', 'toaster', 'mat', 'plate', 'picture', 'foundation', 'dish_soap', 'clothes_socks', 'pillow', 'powersocket', 'cutting_board', 'basket_for_clothes', 'bed', 'television', 'curtain', 'diary', 'cupboard', 'sink', 'spoon', 'home_office']
Task:Wash dishes by hand
response:
{
    "thoughts": Pick up dish.  Put in soapy water.  Wash dish.,
    "actions": ['[WALK] <dining_room>', '[WALK] <dish_soap>', '[FIND] <dish_soap>', '[GRAB] <dish_soap>', '[FIND] <plate>', '[GRAB] <plate>', '[PUTBACK] <dish_soap> <plate>', '[SCRUB] <plate>', '[RINSE] <plate>', '[WIPE] <plate>']
}

Input:
Scene_Objects:['filing_cabinet', 'food_salt', 'freezer', 'walllamp', 'bathroom', 'trashcan', 'orchid', 'wallshelf', 'phone', 'desk', 'toaster', 'stovefan', 'mat', 'shower', 'mousepad', 'closetdrawer', 'pillow', 'wall', 'powersocket', 'bench', 'bed', 'photoframe', 'curtain', 'doorjamb', 'towel_rack', 'kitchen_counter', 'bathtub', 'sink', 'bathroom_cabinet', 'light']
Task:Pet cat
response:

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

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


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

Here is an example plan to achieve a goal for reference:
Scene_Objects:['chair', 'freezer', 'walllamp', 'drawing', 'wallshelf', 'floor', 'character', 'keyboard', 'bookshelf', 'toaster', 'mat', 'tvstand', 'ceilinglamp', 'window', 'closetdrawer', 'couch', 'pillow', 'wall', 'nightstand', 'powersocket', 'wall_clock', 'toilet_paper', 'mouthwash', 'television', 'food_food', 'coffe_maker', 'curtain', 'doorjamb', 'bathroom_cabinet', 'table']
Task:Relax on sofa
response:
{
    "thoughts": walk to living room, find sofa, sit in sofa,
    "actions": ['[WALK] <home_office>', '[WALK] <couch>', '[FIND] <couch>', '[WALK] <couch>', '[SIT] <couch>']
}

Input:
Scene_Objects:['water_glass', 'microwave', 'freezer', 'wallshelf', 'hanger', 'floor', 'ceiling', 'desk', 'bookshelf', 'button', 'toaster', 'stovefan', 'mat', 'faucet', 'shower', 'couch', 'wall', 'wall_clock', 'oven', 'keys', 'coffe_maker', 'water', 'tray', 'curtain', 'coffee_pot', 'kitchen_counter', 'cupboard', 'sink', 'bathroom_cabinet', 'tooth_paste']
Task:Drink
response:

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

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


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

Here is an example plan to achieve a goal for reference:
Scene_Objects:['spectacles', 'chair', 'walllamp', 'orchid', 'knifeblock', 'cpuscreen', 'bathroom_counter', 'floor', 'ceiling', 'shampoo', 'desk', 'bedroom', 'keyboard', 'computer', 'mat', 'ceilinglamp', 'tvstand', 'iron', 'mousepad', 'closetdrawer', 'pillow', 'wall', 'bed', 'television', 'doorjamb', 'mouse', 'door', 'home_office', 'light', 'table']
Task:Write an email
response:
{
    "thoughts": enter office, find computer, turn it on,,
    "actions": ['[WALK] <home_office>', '[WALK] <computer>', '[FIND] <computer>', '[SWITCHON] <computer>', '[FIND] <keyboard>', '[TOUCH] <keyboard>', '[TYPE] <keyboard>']
}

Input:
Scene_Objects:['sheets', 'blender', 'microwave', 'toilet', 'freezer', 'detergent', 'cat', 'food_carrot', 'cpuscreen', 'floor', 'ceiling', 'phone', 'bedroom', 'desk', 'ceilinglamp', 'faucet', 'oil', 'dining_room', 'nightstand', 'wall_clock', 'oven', 'bed', 'television', 'coffee_filter', 'tray', 'mouse', 'dresser', 'hair', 'light', 'table']
Task:Listen to music
response:

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

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


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

Here is an example plan to achieve a goal for reference:
Scene_Objects:['pot', 'detergent', 'drawing', 'floor', 'ceiling', 'bookshelf', 'computer', 'stovefan', 'ceilinglamp', 'laptop', 'shower', 'window', 'oil', 'clothes_socks', 'couch', 'food_orange', 'pillow', 'wall', 'novel', 'coffe_maker', 'television', 'food_rice', 'rag', 'doorjamb', 'cupboard', 'door', 'sink', 'napkin', 'table', 'light']
Task:Relax
response:
{
    "thoughts": Lie down on the couch.,
    "actions": ['[WALK] <home_office>', '[WALK] <couch>', '[LIE] <couch>']
}

Input:
Scene_Objects:['filing_cabinet', 'measuring_cup', 'walllamp', 'bathroom', 'drawing', 'wallshelf', 'floor', 'ceiling', 'bookshelf', 'bookmark', 'mat', 'tvstand', 'ceilinglamp', 'window', 'couch', 'pillow', 'wall', 'bench', 'cup', 'photoframe', 'novel', 'check', 'coffe_maker', 'television', 'tray', 'curtain', 'doorjamb', 'bathroom_cabinet', 'light', 'table']
Task:Read book
response:

I go to the book case, I select a book, I go back and sit down, then I read.

[WALK] <filing_cabinet>
[FIND] <novel>
[GRAB] <novel>
[WALK] <couch>
[READ] <novel>


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

Here is an example plan to achieve a goal for reference:
Scene_Objects:['sponge', 'chair', 'freezer', 'walllamp', 'food_carrot', 'drawing', 'knife', 'hanger', 'floor', 'phone', 'ceiling', 'keyboard', 'computer', 'brush', 'deck_of_cards', 'food_jam', 'bowl', 'dining_room', 'wall', 'bench', 'razor', 'doorjamb', 'mouse', 'dishrack', 'dresser', 'cupboard', 'door', 'sink', 'table', 'light']
Task:Pick up phone
response:
{
    "thoughts": Pick up phone,
    "actions": ['[WALK] <table>', '[FIND] <phone>', '[TURNTO] <phone>', '[LOOKAT] <phone>', '[GRAB] <phone>']
}

Input:
Scene_Objects:['tablelamp', 'chair', 'freezer', 'walllamp', 'bathroom', 'orchid', 'cpuscreen', 'floor', 'ceiling', 'desk', 'bedroom', 'keyboard', 'computer', 'toaster', 'mat', 'tvstand', 'mousepad', 'pillow', 'dining_room', 'wall', 'coffee_table', 'novel', 'television', 'tray', 'curtain', 'doorjamb', 'diary', 'mouse', 'cupboard', 'light']
Task:Read book
response:

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

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


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

Here is an example plan to achieve a goal for reference:
Scene_Objects:['tea', 'microwave', 'walllamp', 'detergent', 'drawing', 'wallshelf', 'floor', 'ceiling', 'computer', 'button', 'food_bacon', 'bookmark', 'mat', 'tvstand', 'ceilinglamp', 'couch', 'pillow', 'dining_room', 'wall', 'powersocket', 'food_cheese', 'photoframe', 'coffee_table', 'novel', 'mouthwash', 'television', 'doorjamb', 'diary', 'clothes_scarf', 'sink']
Task:Read book
response:
{
    "thoughts": Sit down in recliner.  Pick up novel off of coffee table.  Open novel to last read page.  Begin reading,
    "actions": ['[WALK] <home_office>', '[WALK] <coffee_table>', '[FIND] <novel>', '[GRAB] <novel>', '[FIND] <couch>', '[SIT] <couch>', '[FIND] <bookmark>', '[READ] <novel>']
}

Input:
Scene_Objects:['filing_cabinet', 'toilet', 'chair', 'freezer', 'walllamp', 'ceiling', 'bedroom', 'keyboard', 'toaster', 'ceilinglamp', 'window', 'mousepad', 'closetdrawer', 'couch', 'clothes_pants', 'food_orange', 'nightstand', 'bench', 'photoframe', 'bed', 'food_food', 'tray', 'mouse', 'kitchen_counter', 'dresser', 'laundry_detergent', 'bathtub', 'bathroom_cabinet', 'table', 'washing_machine']
Task:Wash clothes
response:

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