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

Here is an example plan to achieve a goal for reference:
Scene_Objects:['pot', 'tablelamp', 'crayon', 'toilet', 'drawing', 'wallshelf', 'bathroom_counter', 'floor', 'phone', 'ceiling', 'bedroom', 'mail', 'food_bacon', 'clothes_jacket', 'table_cloth', 'faucet', 'mousepad', 'closetdrawer', 'food_jam', 'nightstand', 'powersocket', 'novel', 'food_food', 'centerpiece', 'diary', 'console', 'cupboard', 'bathroom_cabinet', 'table', 'light']
Task:Pick up phone
response:
{
    "thoughts": Pick up the ringing phone,
    "actions": ['[WALK] <home_office>', '[WALK] <table>', '[FIND] <table>', '[TURNTO] <table>', '[POINTAT] <table>', '[FIND] <phone>', '[GRAB] <phone>', '[PUTOBJBACK] <phone>']
}

Input:
Scene_Objects:['microwave', 'toilet', 'chair', 'trashcan', 'drawing', 'orchid', 'wallshelf', 'cpuscreen', 'floor', 'ceiling', 'phone', 'desk', 'keyboard', 'bookshelf', 'computer', 'floor_lamp', 'mousepad', 'couch', 'dining_room', 'wall', 'nightstand', 'powersocket', 'bed', 'coffe_maker', 'doorjamb', 'cd', 'door', 'bathtub', 'home_office', 'light']
Task:Turn on light
response:

walk to wall, find light switch, turn on lights

[WALK] <home_office>
[WALK] <light>
[FIND] <light>
[PLUGIN] <light>
[FIND] <floor_lamp>
[SWITCHON] <floor_lamp>
[WALK] <bedroom>
[WALK] <light>
[SWITCHON] <light>


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

Here is an example plan to achieve a goal for reference:
Scene_Objects:['filing_cabinet', 'tablelamp', 'toilet', 'freezer', 'orchid', 'drawing', 'wallshelf', 'floor', 'phone', 'bedroom', 'bookshelf', 'stovefan', 'mat', 'shower', 'window', 'mousepad', 'pillow', 'nightstand', 'wall', 'oven', 'wall_clock', 'bed', 'novel', 'curtain', 'towel_rack', 'cupboard', 'door', 'sink', 'light', 'laser_pointer']
Task:Read book
response:
{
    "thoughts": Go to the bedroom. Grab the book out of the nightstand. Lay down in bed. Open the book. Read the book.,
    "actions": ['[WALK] <bedroom>', '[WALK] <nightstand>', '[FIND] <nightstand>', '[OPEN] <nightstand>', '[FIND] <novel>', '[GRAB] <novel>', '[FIND] <bed>', '[TURNTO] <bed>', '[SIT] <bed>', '[READ] <novel>']
}

Input:
Scene_Objects:['freezer', 'walllamp', 'drawing', 'orchid', 'cpuscreen', 'floor', 'phone', 'bookshelf', 'clothes_jacket', 'stovefan', 'mat', 'tvstand', 'ceilinglamp', 'stereo', 'window', 'shower', 'couch', 'pillow', 'wall', 'photoframe', 'food_food', 'television', 'tray', 'curtain', 'doorjamb', 'kitchen_counter', 'dresser', 'cupboard', 'sink', 'table']
Task:Relax on sofa
response:

I walk to the living room and find the sofa. I sit on the sofa and get comfortable.

[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:['microwave', 'toilet', 'freezer', 'trashcan', 'drawing', 'cpuscreen', 'floor', 'stamp', 'bedroom', 'stovefan', 'toaster', 'plate', 'faucet', 'shower', 'dish_soap', 'food_jam', 'towel', 'wall', 'nightstand', 'oven', 'coffe_maker', 'food_food', 'ice', 'tray', 'curtain', 'kitchen_counter', 'cupboard', 'sink', 'bathtub', 'dishwasher']
Task:Wash dishes with dishwasher
response:
{
    "thoughts": I walk into the kitchen and go to the dishwasher. I open the dishwasher and grab the dishes. Iplace the dishes into the dishwasher then close it. I add soap then turn the dishwasher on.,
    "actions": ['[WALK] <dining_room>', '[WALK] <dishwasher>', '[OPEN] <dishwasher>', '[WALK] <kitchen_counter>', '[FIND] <plate>', '[GRAB] <plate>', '[PUTBACK] <plate> <dishwasher>', '[FIND] <dish_soap>', '[GRAB] <dish_soap>', '[PUTBACK] <dish_soap> <dishwasher>', '[CLOSE] <dishwasher>', '[SWITCHON] <dishwasher>']
}

Input:
Scene_Objects:['filing_cabinet', 'tablelamp', 'microwave', 'freezer', 'orchid', 'floor', 'desk', 'computer', 'stovefan', 'ceilinglamp', 'tvstand', 'window', 'mousepad', 'pillow', 'nightstand', 'wall_clock', 'oven', 'wall', 'coffe_maker', 'mouthwash', 'television', 'tray', 'towel_rack', 'pencil', 'kitchen_counter', 'dresser', 'cupboard', 'sink', 'bathroom_cabinet', 'light']
Task:Pick up phone
response:

walk to phone, grab phone, pick up phone, put to ear

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


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

Here is an example plan to achieve a goal for reference:
Scene_Objects:['microwave', 'chair', 'walllamp', 'bathroom', 'orchid', 'cpuscreen', 'floor', 'ceiling', 'desk', 'keyboard', 'food_cake', 'computer', 'food_bacon', 'toaster', 'ceilinglamp', 'tvstand', 'shower', 'mousepad', 'couch', 'wall', 'powersocket', 'bed', 'television', 'doorjamb', 'mouse', 'hairdryer', 'door', 'sink', 'home_office', 'table']
Task:Work
response:
{
    "thoughts": Using desktop computer in home office,
    "actions": ['[WALK] <home_office>', '[WALK] <desk>', '[FIND] <desk>', '[WALK] <desk>', '[FIND] <computer>', '[SWITCHON] <computer>', '[FIND] <chair>', '[PULL] <chair>', '[SIT] <chair>', '[FIND] <mouse>', '[GRAB] <mouse>', '[FIND] <keyboard>', '[TYPE] <keyboard>', '[TURNTO] <computer>', '[LOOKAT] <computer>']
}

Input:
Scene_Objects:['tea', 'toilet', 'dog', 'walllamp', 'trashcan', 'orchid', 'drawing', 'bedroom', 'bookshelf', 'computer', 'toaster', 'ceilinglamp', 'closetdrawer', 'couch', 'pillow', 'wall', 'oven', 'powersocket', 'bench', 'basket_for_clothes', 'tray', 'wooden_spoon', 'kitchen_counter', 'clothes_dress', 'hairdryer', 'sink', 'light', 'table', 'clothes_shirt', 'washing_machine']
Task:Wash clothes
response:

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.


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

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

Input:
Scene_Objects:['filing_cabinet', 'microwave', 'freezer', 'drawing', 'wallshelf', 'bathroom_counter', 'floor', 'ceiling', 'phone', 'bedroom', 'desk', 'ceilinglamp', 'tvstand', 'faucet', 'shower', 'window', 'mat', 'closetdrawer', 'wall', 'wall_clock', 'bed', 'photoframe', 'doorjamb', 'console', 'kitchen_counter', 'door', 'hairdryer', 'sink', 'light', 'clothes_skirt']
Task:Turn on light
response:

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


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

Here is an example plan to achieve a goal for reference:
Scene_Objects:['dry_pasta', 'food_ice_cream', 'toothbrush', 'drawing', 'hanger', 'bathroom_counter', 'floor', 'ceiling', 'phone', 'bedroom', 'bookshelf', 'alcohol', 'brush', 'shoe-shine_kit', 'faucet', 'mousepad', 'closetdrawer', 'candle', 'clothes_pants', 'wall', 'standingmirror', 'food_food', 'television', 'tray', 'coffee_pot', 'towel_rack', 'dresser', 'bathtub', 'bathroom_cabinet', 'vase']
Task:Dust
response:
{
    "thoughts": Using soft brush, carefully dust both Indonesian wedding doll statues.,
    "actions": ['[WALK] <home_office>', '[WALK] <dresser>', '[OPEN] <dresser>', '[FIND] <brush>', '[GRAB] <brush>', '[CLOSE] <dresser>']
}

Input:
Scene_Objects:['chair', 'drawing', 'orchid', 'wallshelf', 'hanger', 'bathroom_counter', 'floor', 'phone', 'ceiling', 'dvd_player', 'bookshelf', 'remote_control', 'button', 'piano_bench', 'ceilinglamp', 'tvstand', 'mat', 'wall', 'wall_clock', 'bench', 'oven', 'nightstand', 'photoframe', 'television', 'doorjamb', 'kitchen_counter', 'cd', 'door', 'table', 'light']
Task:Change TV channel
response:

Walk to TV, grab remote control, press change channel button, repeat pressing change channel button util find the channel wanted, put back remote control

[WALK] <television>
[FIND] <remote_control>
[GRAB] <remote_control>
[FIND] <button>
[TOUCH] <button>
[TURNTO] <television>
[WATCH] <television>
[TOUCH] <button>
[TURNTO] <television>
[WATCH] <television>
[PUTOBJBACK] <remote_control>


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

Here is an example plan to achieve a goal for reference:
Scene_Objects:['pot', 'tablelamp', 'freezer', 'blow_dryer', 'ceilingfan', 'drawing', 'floor', 'ceiling', 'bedroom', 'remote_control', 'ceilinglamp', 'tvstand', 'balanceball', 'stereo', 'window', 'shoe-shine_kit', 'couch', 'microphone', 'food_jam', 'wall', 'coffe_maker', 'check', 'television', 'curtain', 'sink', 'napkin', 'bathroom_cabinet', 'table', 'colander', 'tooth_paste']
Task:Watch TV
response:
{
    "thoughts": Walk to the living room. Find the television. Walk to the television. Switch on the television. Find the sofa. Walk to the sofa. Sit on the sofa. Find the remote control. Grab the remote control. Look at the television.,
    "actions": ['[WALK] <home_office>', '[WALK] <television>', '[FIND] <television>', '[WALK] <television>', '[SWITCHON] <television>', '[FIND] <couch>', '[WALK] <couch>', '[SIT] <couch>', '[FIND] <remote_control>', '[GRAB] <remote_control>', '[TURNTO] <television>', '[LOOKAT] <television>']
}

Input:
Scene_Objects:['sponge', 'filing_cabinet', 'chair', 'drawing', 'orchid', 'wallshelf', 'bathroom_counter', 'floor', 'ceiling', 'desk', 'keyboard', 'table_cloth', 'toaster', 'stovefan', 'tvstand', 'shower', 'faucet', 'closetdrawer', 'nightstand', 'wall', 'bench', 'coffe_maker', 'check', 'television', 'tray', 'pencil', 'shoes', 'sink', 'bathtub', 'light']
Task:Listen to music
response:

[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:['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:['sponge', 'pot', 'scissors', 'tea', 'freezer', 'walllamp', 'wallshelf', 'hanger', 'kitchen_cabinet', 'floor', 'bathroom_counter', 'bedroom', 'bookshelf', 'ceilinglamp', 'dish_soap', 'dining_room', 'nightstand', 'wall_clock', 'bed', 'curtain', 'doorjamb', 'towel_rack', 'dresser', 'door', 'clothes_scarf', 'bathtub', 'light', 'dishwasher', 'table', 'shoe_rack']
Task:Wash dishes with dishwasher
response:

I walk to the kitchen. I open the dishwasher. I open the kitchen cabinet. I reach inside the cabinet and grab the box of dish soap. I add some soap to the open dishwasher. I put the box of dish soap back in the kitchen cabinet. I close the kitchen cabinet and then I close the dishwasher. I turn the dishwasher on and wait.

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


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

Here is an example plan to achieve a goal for reference:
Scene_Objects:['tablelamp', 'chair', 'ground_coffee', 'walllamp', 'food_carrot', 'orchid', 'drawing', 'floor', 'ceiling', 'bedroom', 'bookshelf', 'keyboard', 'mail', 'mat', 'faucet', 'wall', 'nightstand', 'powersocket', 'oven', 'cup', 'photoframe', 'bed', 'novel', 'curtain', 'doorjamb', 'diary', 'cupboard', 'door', 'sink', 'instrument_guitar']
Task:Read book
response:
{
    "thoughts": Walk over to the bookshelf. Pick storybook off the shelf. Sit on bed. Open storybook and read out loud.,
    "actions": ['[WALK] <bedroom>', '[WALK] <bookshelf>', '[FIND] <novel>', '[GRAB] <novel>', '[TURNTO] <novel>', '[LOOKAT] <novel>', '[WALK] <bed>', '[SIT] <bed>', '[READ] <novel>']
}

Input:
Scene_Objects:['filing_cabinet', 'toilet', 'freezer', 'walllamp', 'drawing', 'floor', 'ceiling', 'computer', 'stovefan', 'mat', 'tvstand', 'ceilinglamp', 'shower', 'window', 'couch', 'pillow', 'wall', 'wall_clock', 'powersocket', 'oven', 'box', 'television', 'ice', 'curtain', 'pencil', 'kitchen_counter', 'door', 'hairdryer', 'instrument_guitar', 'table']
Task:Relax on sofa
response:

allow sofa to support weight in order to decrease gravity induced entropy

[WALK] <home_office>
[WALK] <couch>
[FIND] <couch>
[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:['fork', 'pot', 'filing_cabinet', 'tablelamp', 'blender', 'beer', 'toilet', 'jelly', 'freezer', 'blow_dryer', 'detergent', 'orchid', 'knifeblock', 'wallshelf', 'cpuscreen', 'bathroom_counter', 'floor', 'mail', 'computer', 'bookmark', 'stereo', 'window', 'couch', 'microphone', 'check', 'television', 'rag', 'pencil', 'controller', 'dishwasher']
Task:Pet cat
response:
{
    "thoughts": Pet Cat,
    "actions": ['[WALK] <home_office>', '[WALK] <cat>', '[FIND] <cat>', '[WALK] <cat>', '[TURNTO] <cat>', '[LOOKAT] <cat>', '[TOUCH] <cat>']
}

Input:
Scene_Objects:['food_bread', 'filing_cabinet', 'tablelamp', 'food_salt', 'toilet', 'chair', 'bathroom', 'trashcan', 'drawing', 'floor', 'character', 'desk', 'purse', 'computer', 'table_cloth', 'stovefan', 'ceilinglamp', 'tvstand', 'shower', 'foundation', 'couch', 'pillow', 'nightstand', 'powersocket', 'novel', 'tray', 'mouse', 'bathroom_cabinet', 'soap', 'teeth']
Task:Pet cat
response:

First I need to find the cat in the living room. Then I walk over to the cat and pet it gently.

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


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

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

Input:
Scene_Objects:['tablelamp', 'crayon', 'chair', 'walllamp', 'toothbrush', 'wallshelf', 'dvd_player', 'keyboard', 'bookshelf', 'computer', 'alcohol', 'mousepad', 'couch', 'form', 'pillow', 'bowl', 'nightstand', 'wall_clock', 'bench', 'oven', 'powersocket', 'clothes_gloves', 'doorjamb', 'mouse', 'kitchen_counter', 'dresser', 'hairdryer', 'bathtub', 'home_office', 'table']
Task:Write an email
response:

I go to my bed room and sit on the chair and in front of me is my desktop computer and start writing an email.

[WALK] <bathroom>
[WALK] <chair>
[FIND] <chair>
[SIT] <chair>
[FIND] <computer>
[SWITCHON] <computer>
[TURNTO] <computer>
[LOOKAT] <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:['sponge', 'band-aids', 'toothbrush', 'orchid', 'phone', 'desk', 'keyboard', 'bookshelf', 'computer', 'toaster', 'faucet', 'picture', 'shower', 'mousepad', 'candle', 'food_orange', 'oven', 'basket_for_clothes', 'bed', 'check', 'food_food', 'television', 'tray', 'after_shave', 'headset', 'comb', 'dresser', 'laundry_detergent', 'napkin', 'bathroom_cabinet']
Task:Sit in chair
response:
{
    "thoughts": I sit in a chair to rest and eat.,
    "actions": ['[WALK] <dining_room>', '[WALK] <chair>', '[FIND] <chair>', '[PULL] <chair>', '[SIT] <chair>']
}

Input:
Scene_Objects:['sheets', 'filing_cabinet', 'tablelamp', 'tea', 'trashcan', 'drawing', 'orchid', 'floor', 'character', 'desk', 'bookshelf', 'computer', 'toaster', 'mat', 'stovefan', 'tvstand', 'window', 'mousepad', 'couch', 'wall', 'nightstand', 'wall_clock', 'cup', 'bed', 'food_donut', 'curtain', 'towel_rack', 'sink', 'napkin', 'bathtub']
Task:Go to sleep
response:

Enter bedroom, turn on the light, and shut door. Change into night clothes. Turn off light. Turn down comforter, climb into bed, lay head on pillow, and cover up with comforter. Close eyes and drift off to sleep.

[WALK] <bedroom>
[WALK] <bed>
[FIND] <bed>
[LIE] <bed>
[FIND] <sheets>
[PULL] <sheets>


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', 'picture', 'homework', 'mousepad', 'couch', 'pillow', 'wall', 'nightstand', 'oven', 'powersocket', 'keys', 'check', 'television', 'tray', 'doorjamb', 'towel_rack', 'mouse', 'dresser', 'door', 'light']
Task:Work
response:
{
    "thoughts": walk to Office,Walk to desk ,sit down in chair, turn on computer, start homework.,
    "actions": ['[WALK] <home_office>', '[WALK] <desk>', '[FIND] <chair>', '[SIT] <chair>', '[FIND] <computer>', '[SWITCHON] <computer>', '[FIND] <check>', '[FIND] <homework>', '[TURNTO] <homework>', '[LOOKAT] <homework>']
}

Input:
Scene_Objects:['spectacles', 'pot', 'band-aids', 'walllamp', 'drawing', 'wallshelf', 'floor', 'character', 'toaster', 'mat', 'tvstand', 'ceilinglamp', 'window', 'couch', 'clothes_pants', 'pillow', 'dining_room', 'wall', 'bench', 'photoframe', 'television', 'tray', 'curtain', 'kitchen_counter', 'shoes', 'cupboard', 'clothes_dress', 'home_office', 'table', 'clothes_shirt']
Task:Relax on sofa
response:

[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', 'freezer', 'blow_dryer', 'ceilingfan', 'drawing', 'floor', 'ceiling', 'bedroom', 'remote_control', 'ceilinglamp', 'tvstand', 'balanceball', 'stereo', 'window', 'shoe-shine_kit', 'couch', 'microphone', 'food_jam', 'wall', 'coffe_maker', 'check', 'television', 'curtain', 'sink', 'napkin', 'bathroom_cabinet', 'table', 'colander', 'tooth_paste']
Task:Watch TV
response:
{
    "thoughts": Walk to the living room. Find the television. Walk to the television. Switch on the television. Find the sofa. Walk to the sofa. Sit on the sofa. Find the remote control. Grab the remote control. Look at the television.,
    "actions": ['[WALK] <home_office>', '[WALK] <television>', '[FIND] <television>', '[WALK] <television>', '[SWITCHON] <television>', '[FIND] <couch>', '[WALK] <couch>', '[SIT] <couch>', '[FIND] <remote_control>', '[GRAB] <remote_control>', '[TURNTO] <television>', '[LOOKAT] <television>']
}

Input:
Scene_Objects:['tablelamp', 'chair', 'freezer', 'drawing', 'cpuscreen', 'floor', 'ceiling', 'phone', 'character', 'desk', 'bedroom', 'keyboard', 'bookshelf', 'computer', 'ceilinglamp', 'faucet', 'closetdrawer', 'pillow', 'dining_room', 'wall', 'nightstand', 'powersocket', 'oven', 'television', 'doorjamb', 'mouse', 'door', 'sink', 'light', 'instrument_violin']
Task:Turn on light
response:

I enter the bedroom and find the light. Then I turn it on.

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


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

Here is an example plan to achieve a goal for reference:
Scene_Objects:['crayon', 'microwave', 'toilet', 'freezer', 'ground_coffee', 'longboard', 'shampoo', 'character', 'thread', 'food_bacon', 'piano_bench', 'balanceball', 'stereo', 'window', 'picture', 'mousepad', 'pillow', 'toy', 'basket_for_clothes', 'photoframe', 'novel', 'coffe_maker', 'oven_mitts', 'colander', 'doorjamb', 'shaving_cream', 'dresser', 'soap', 'washing_machine', 'creditcard']
Task:Wash clothes
response:
{
    "thoughts": walk to the bathroom, grab the basket for clothes, find soap, put in washing machine, turn on,
    "actions": ['[WALK] <bathroom>', '[WALK] <basket_for_clothes>', '[FIND] <basket_for_clothes>', '[GRAB] <basket_for_clothes>', '[WALK] <washing_machine>', '[OPEN] <washing_machine>', '[PUTBACK] <basket_for_clothes> <washing_machine>', '[FIND] <soap>', '[GRAB] <soap>', '[WALK] <washing_machine>', '[PUTBACK] <soap> <washing_machine>', '[CLOSE] <washing_machine>', '[SWITCHON] <washing_machine>']
}

Input:
Scene_Objects:['microwave', 'toilet', 'chair', 'walllamp', 'trashcan', 'cpuscreen', 'wallshelf', 'hanger', 'bathroom_counter', 'floor', 'ceiling', 'keyboard', 'tvstand', 'faucet', 'mousepad', 'closetdrawer', 'couch', 'food_jam', 'wall', 'nightstand', 'oven', 'newspaper', 'food_food', 'vacuum_cleaner', 'sink', 'bathtub', 'bathroom_cabinet', 'light', 'table', 'hands_both']
Task:Wash hands
response:

I go to the bathroom, walk to the sink, turn on the faucet and then wash my hands under the water.

[WALK] <bathroom>
[WALK] <sink>
[FIND] <faucet>
[TURNTO] <faucet>
[FIND] <hands_both>
[WASH] <hands_both>


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

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

Input:
Scene_Objects:['sheets', 'scissors', 'milk', 'wallshelf', 'cpuscreen', 'hanger', 'phone', 'bedroom', 'bookshelf', 'keyboard', 'table_cloth', 'stovefan', 'tvstand', 'window', 'closetdrawer', 'candle', 'dining_room', 'wall_clock', 'oven', 'bench', 'photoframe', 'television', 'tray', 'kitchen_counter', 'door', 'bathtub', 'sink', 'table', 'soap', 'creditcard']
Task:Listen to music
response:

[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:['tablelamp', 'microwave', 'wallshelf', 'bathroom_counter', 'floor', 'ceiling', 'bookshelf', 'mat', 'plate', 'faucet', 'tvstand', 'clothes_hat', 'pillow', 'wall', 'oven', 'powersocket', 'newspaper', 'photoframe', 'check', 'coffe_maker', 'doorjamb', 'kitchen_counter', 'dishrack', 'cupboard', 'door', 'sink', 'clothes_scarf', 'table', 'clothes_skirt', 'dishwasher']
Task:Wash dishes by hand
response:
{
    "thoughts": Walking towards sink and look at the leftover plates. Scrape dishes to remove leftover food - use a rubber spatula or paper towel. Fill sink or dishpan with clean, hot water. Then wash and rinse to removing residues. Finally leave it to dry.,
    "actions": ['[WALK] <dining_room>', '[WALK] <kitchen_counter>', '[FIND] <plate>', '[TURNTO] <plate>', '[LOOKAT] <plate>', '[GRAB] <plate>', '[SCRUB] <plate>', '[RINSE] <plate>', '[WASH] <plate>', '[PUTBACK] <plate> <kitchen_counter>']
}

Input:
Scene_Objects:['food_pizza', 'filing_cabinet', 'tablelamp', 'microwave', 'chair', 'freezer', 'walllamp', 'bathroom', 'trashcan', 'drawing', 'cpuscreen', 'floor', 'phone', 'bedroom', 'bookshelf', 'mat', 'tvstand', 'ceilinglamp', 'faucet', 'window', 'couch', 'pillow', 'wall', 'photoframe', 'television', 'curtain', 'rag', 'cupboard', 'table', 'colander']
Task:Relax on sofa
response:

I go to the living room and sit in the sofa

[WALK] <home_office>
[WALK] <couch>
[FIND] <couch>
[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:['food_pizza', 'tablelamp', 'chair', 'freezer', 'detergent', 'bathroom_counter', 'desk', 'bedroom', 'keyboard', 'button', 'stovefan', 'ceilinglamp', 'stereo', 'shower', 'window', 'clothes_socks', 'dining_room', 'nightstand', 'wall', 'bench', 'oven', 'powersocket', 'bed', 'television', 'curtain', 'doorjamb', 'dresser', 'napkin', 'bathroom_cabinet', 'soap']
Task:Listen to music
response:
{
    "thoughts": Walk into living room, look for radio, grab on button,
    "actions": ['[WALK] <home_office>', '[WALK] <stereo>', '[FIND] <stereo>', '[TURNTO] <stereo>', '[LOOKAT] <stereo>', '[FIND] <button>', '[GRAB] <button>']
}

Input:
Scene_Objects:['microwave', 'chair', 'dog', 'walllamp', 'trashcan', 'cpuscreen', 'floor', 'ceiling', 'desk', 'bedroom', 'keyboard', 'computer', 'table_cloth', 'ceilinglamp', 'tvstand', 'faucet', 'mousepad', 'couch', 'form', 'wall', 'powersocket', 'photoframe', 'mouthwash', 'television', 'doorjamb', 'mouse', 'cupboard', 'bathtub', 'sink', 'table']
Task:Work
response:

go to home office. turn the computer on. begin working

[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:['tablelamp', 'measuring_cup', 'chair', 'orchid', 'drawing', 'cpuscreen', 'wallshelf', 'floor', 'ceiling', 'desk', 'tea_bag', 'keyboard', 'bookshelf', 'computer', 'alcohol', 'stovefan', 'mat', 'ceilinglamp', 'tvstand', 'stereo', 'floor_lamp', 'mousepad', 'wall', 'nightstand', 'novel', 'video_game_controller', 'television', 'mouse', 'door', 'napkin']
Task:Study
response:
{
    "thoughts": Study norwegian,
    "actions": ['[WALK] <home_office>', '[WALK] <floor_lamp>', '[FIND] <floor_lamp>', '[SWITCHON] <floor_lamp>', '[FIND] <novel>', '[GRAB] <novel>', '[FIND] <chair>', '[SIT] <chair>', '[READ] <novel>']
}

Input:
Scene_Objects:['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:

walk to living room, find sofa, sit in sofa

[WALK] <home_office>
[WALK] <couch>
[FIND] <couch>
[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:['pot', 'tablelamp', 'freezer', 'walllamp', 'food_carrot', 'desk', 'food_cake', 'remote_control', 'button', 'ceilinglamp', 'faucet', 'stereo', 'window', 'mousepad', 'couch', 'wall_clock', 'bench', 'box', 'cup', 'bed', 'keys', 'newspaper', 'food_food', 'ice', 'after_shave', 'maindoor', 'bathroom_cabinet', 'light', 'vase', 'soap']
Task:Watch TV
response:
{
    "thoughts": I walk to the living room and sit on the couch.  I grab the TV remote.  I press the power button on the TV remote and the TV turns on.  I grab the surround sound remote.  I press the power button on the surround sound remote and the system turns on.,
    "actions": ['[WALK] <home_office>', '[WALK] <remote_control>', '[FIND] <remote_control>', '[GRAB] <remote_control>', '[PUSH] <remote_control>', '[FIND] <remote_control>', '[PUSH] <remote_control>']
}

Input:
Scene_Objects:['filing_cabinet', 'chair', 'walllamp', 'bathroom', 'cpuscreen', 'bathroom_counter', 'floor', 'ceiling', 'desk', 'bedroom', 'keyboard', 'bookshelf', 'computer', 'alcohol', 'stovefan', 'ceilinglamp', 'tvstand', 'mousepad', 'couch', 'wall', 'powersocket', 'food_food', 'television', 'curtain', 'doorjamb', 'mouse', 'cupboard', 'door', 'bathroom_cabinet', 'table']
Task:Browse internet
response:

Turn on computer, pull up browser, browse the internet

[WALK] <home_office>
[WALK] <computer>
[FIND] <computer>
[SWITCHON] <computer>
[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:['sheets', 'spectacles', 'glue', 'jelly', 'freezer', 'detergent', 'food_carrot', 'orchid', 'clothes_underwear', 'hanger', 'floor', 'bedroom', 'thread', 'bookmark', 'mat', 'stereo', 'shower', 'mousepad', 'oil', 'nightstand', 'light_bulb', 'coffe_maker', 'television', 'tray', 'pencil', 'shoes', 'bathroom_cabinet', 'dishwasher', 'colander', 'dirt']
Task:Pick up phone
response:
{
    "thoughts": Go to the living room.  Find the telephone.  Lift up the receiver.,
    "actions": ['[WALK] <home_office>', '[WALK] <phone>', '[FIND] <phone>', '[GRAB] <phone>']
}

Input:
Scene_Objects:['tablelamp', 'chair', 'walllamp', 'drawing', 'cpuscreen', 'floor', 'ceiling', 'phone', 'desk', 'keyboard', 'computer', 'brush', 'ceilinglamp', 'tvstand', 'faucet', 'mousepad', 'wall', 'powersocket', 'bench', 'coffe_maker', 'mouthwash', 'television', 'curtain', 'doorjamb', 'towel_rack', 'mouse', 'kettle', 'cupboard', 'sink', 'table']
Task:Browse internet
response:

first i will walk into my home office and i needed to know the today's gold prices so wih the help of keyboard and mouse i will browse and find it

[WALK] <home_office>
[WALK] <chair>
[FIND] <chair>
[SIT] <chair>
[FIND] <keyboard>
[GRAB] <keyboard>
[FIND] <mouse>
[GRAB] <mouse>
[FIND] <computer>
[SWITCHON] <computer>
[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:['pot', 'filing_cabinet', 'toilet', 'chair', 'walllamp', 'ground_coffee', 'orchid', 'bathroom_counter', 'floor', 'ceiling', 'phone', 'bookshelf', 'stovefan', 'tvstand', 'faucet', 'shower', 'electric_shaver', 'towel', 'wall', 'wall_clock', 'oven', 'television', 'tray', 'rag', 'doorjamb', 'dresser', 'sink', 'bathroom_cabinet', 'clothes_skirt', 'laser_pointer']
Task:Take shower
response:
{
    "thoughts": Walk to Bathroom. Open the Bathroom Cabinet. Grab a Towel. Close the Bathroom Cabinet. Rinse the Shower.,
    "actions": ['[WALK] <bathroom>', '[WALK] <bathroom_cabinet>', '[FIND] <bathroom_cabinet>', '[OPEN] <bathroom_cabinet>', '[FIND] <towel>', '[GRAB] <towel>', '[CLOSE] <bathroom_cabinet>', '[FIND] <shower>', '[RINSE] <shower>']
}

Input:
Scene_Objects:['spectacles', 'tablelamp', 'walllamp', 'nail_polish', 'orchid', 'cpuscreen', 'phone', 'folder', 'bedroom', 'desk', 'keyboard', 'ceilinglamp', 'tvstand', 'faucet', 'shower', 'floor_lamp', 'iron', 'mousepad', 'couch', 'powersocket', 'photoframe', 'coffe_maker', 'curtain', 'towel_rack', 'pencil', 'cupboard', 'bathtub', 'napkin', 'light', 'soap']
Task:Turn on light
response:

Walk to the living room, walk to the lamp, switch on the lamp.

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


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

Here is an example plan to achieve a goal for reference:
Scene_Objects:['fork', 'filing_cabinet', 'juice', 'food_ice_cream', 'bathroom', 'orchid', 'floor', 'ceiling', 'phone', 'shampoo', 'bookshelf', 'tvstand', 'stereo', 'shower', 'couch', 'wall', 'wall_clock', 'powersocket', 'oven', 'photoframe', 'food_food', 'television', 'after_shave', 'doorjamb', 'mouse', 'dresser', 'controller', 'home_office', 'light', 'coffee']
Task:Pick up phone
response:
{
    "thoughts": first i will go to home office and switch on the lights and answer the call after then i will put back it and switch off the lights and close the door,
    "actions": ['[RUN] <home_office>', '[WALK] <light>', '[FIND] <light>', '[SWITCHON] <light>', '[FIND] <phone>', '[GRAB] <phone>', '[PUTOBJBACK] <phone>', '[SWITCHOFF] <light>']
}

Input:
Scene_Objects:['toilet', 'walllamp', 'bathroom', 'drawing', 'cpuscreen', 'floor', 'dvd_player', 'desk', 'bedroom', 'bookshelf', 'computer', 'toaster', 'mat', 'tvstand', 'ceilinglamp', 'window', 'closetdrawer', 'couch', 'pillow', 'wall', 'nightstand', 'television', 'tray', 'curtain', 'controller', 'sink', 'bathroom_cabinet', 'table', 'home_office', 'light']
Task:Listen to music
response:

walk to living room, look at the DVD player, switch on the dvd player, look at the sofa, sit on the sofa and listen the music

[WALK] <home_office>
[WALK] <dvd_player>
[FIND] <dvd_player>
[TURNTO] <dvd_player>
[LOOKAT] <dvd_player>
[SWITCHON] <dvd_player>
[FIND] <couch>
[TURNTO] <couch>
[LOOKAT] <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:['cat', 'wallshelf', 'bathroom_counter', 'floor', 'ceiling', 'phone', 'character', 'stovefan', 'mat', 'ceilinglamp', 'faucet', 'iron', 'towel', 'wall', 'wall_clock', 'oven', 'nightstand', 'tape', 'novel', 'food_food', 'television', 'tray', 'mouse', 'sink', 'bathtub', 'bathroom_cabinet', 'light', 'vase', 'soap', 'hands_both']
Task:Wash hands
response:
{
    "thoughts": I go into the bathroom, get my hands wet, add soap, suds up my hands, rinse the soap off, turn the faucet off, dry my hands.,
    "actions": ['[WALK] <bathroom>', '[WALK] <faucet>', '[FIND] <faucet>', '[SWITCHON] <faucet>', '[FIND] <hands_both>', '[RINSE] <hands_both>', '[FIND] <soap>', '[GRAB] <soap>', '[SCRUB] <soap>', '[PUTOBJBACK] <soap>', '[SCRUB] <hands_both>', '[RINSE] <hands_both>', '[SWITCHOFF] <faucet>', '[FIND] <towel>', '[GRAB] <towel>', '[WIPE] <hands_both>', '[PUTOBJBACK] <towel>']
}

Input:
Scene_Objects:['glue', 'filing_cabinet', 'tablelamp', 'food_salt', 'ground_coffee', 'drawing', 'cpuscreen', 'wallshelf', 'hanger', 'bathroom_counter', 'floor', 'ceiling', 'phone', 'food_cake', 'ceilinglamp', 'mat', 'stereo', 'window', 'clothes_socks', 'wall', 'bench', 'cup', 'bed', 'coffe_maker', 'tray', 'curtain', 'doorjamb', 'kitchen_counter', 'light', 'table']
Task:Turn on light
response:

I walk in to the living room. I find the light switch. I turn on the lights.

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


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

Here is an example plan to achieve a goal for reference:
Scene_Objects:['filing_cabinet', 'microwave', 'band-aids', 'drawing', 'longboard', 'floor', 'ceiling', 'folder', 'computer', 'clothes_jacket', 'alcohol', 'ceilinglamp', 'balanceball', 'window', 'foundation', 'couch', 'food_peanut_butter', 'wall', 'powersocket', 'oven', 'television', 'wine', 'towel_rack', 'pencil', 'shoes', 'dresser', 'cupboard', 'table', 'light', 'dishwasher']
Task:Arrange furniture
response:
{
    "thoughts": Move furniture where you want it.,
    "actions": ['[WALK] <home_office>', '[WALK] <coffee_table>', '[PUSH] <coffee_table>', '[WALK] <couch>', '[PUSH] <couch>', '[WALK] <couch>', '[PUSH] <couch>', '[WALK] <filing_cabinet>', '[PUSH] <filing_cabinet>']
}

Input:
Scene_Objects:['fork', 'filing_cabinet', 'food_salt', 'toilet', 'bills', 'hanger', 'bathroom_counter', 'floor', 'character', 'stovefan', 'tvstand', 'faucet', 'mousepad', 'towel', 'dining_room', 'wall', 'cup', 'bed', 'photoframe', 'check', 'coffe_maker', 'water', 'tray', 'curtain', 'doorjamb', 'sink', 'bathroom_cabinet', 'table', 'soap', 'hands_both']
Task:Wash hands
response:

Walk to bathroom. Walk to sink and turn on the water. Grab the soap and wash the hands.

[WALK] <bathroom>
[WALK] <sink>
[FIND] <water>
[TURNTO] <water>
[FIND] <soap>
[GRAB] <soap>
[FIND] <hands_both>
[WASH] <hands_both>


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

Here is an example plan to achieve a goal for reference:
Scene_Objects:['measuring_cup', 'microwave', 'toilet', 'jelly', 'walllamp', 'trashcan', 'knifeblock', 'knife', 'desk', 'keyboard', 'computer', 'button', 'brush', 'window', 'mousepad', 'couch', 'bench', 'cutting_board', 'novel', 'check', 'coffe_maker', 'television', 'toothbrush_holder', 'food_rice', 'curtain', 'headset', 'dresser', 'home_office', 'table', 'dishwasher']
Task:Lock door
response:
{
    "thoughts": Turn the lock.,
    "actions": ['[WALK] <bedroom>']
}

Input:
Scene_Objects:['toilet', 'walllamp', 'bathroom', 'orchid', 'drawing', 'cpuscreen', 'hanger', 'floor', 'folder', 'bedroom', 'computer', 'stovefan', 'window', 'closetdrawer', 'powersocket', 'basket_for_clothes', 'clothes_gloves', 'food_food', 'doorjamb', 'kettle', 'mouse', 'shoes', 'dresser', 'cupboard', 'sink', 'home_office', 'table', 'light', 'soap', 'washing_machine']
Task:Wash clothes
response:

Get dirty clothes out of basket for clothes in bedroom, carry dirty clothes to laundry room, place dirty clothes in washing machine, add laundry detergent to washing machine, turn washing machine on, set type of wash, start washing machine


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

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

Input:
Scene_Objects:['microwave', 'chair', 'walllamp', 'drawing', 'cpuscreen', 'wallshelf', 'floor', 'ceiling', 'desk', 'bedroom', 'keyboard', 'computer', 'mop_bucket', 'stovefan', 'ceilinglamp', 'tvstand', 'homework', 'mousepad', 'couch', 'wall', 'wall_clock', 'powersocket', 'nightstand', 'television', 'doorjamb', 'mouse', 'headset', 'cupboard', 'table', 'shoe_rack']
Task:Write an email
response:

I go to the home office to find the computer. I turn switch computer on , i open the email. i write the email and  send it.

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

Input:
Scene_Objects:['chair', 'bathroom', 'trashcan', 'drawing', 'orchid', 'cpuscreen', 'floor', 'ceiling', 'phone', 'desk', 'stamp', 'keyboard', 'bookshelf', 'computer', 'ceilinglamp', 'dining_room', 'wall', 'powersocket', 'oven', 'bed', 'newspaper', 'television', 'doorjamb', 'kitchen_counter', 'chessboard', 'dresser', 'controller', 'door', 'bathroom_cabinet', 'light']
Task:Turn on light
response:

Walk into the bedroom and walk to the light switch. Flip the switch.

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


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

Here is an example plan to achieve a goal for reference:
Scene_Objects:['pot', 'food_salt', 'toilet', 'chair', 'freezer', 'walllamp', 'drawing', 'orchid', 'wallshelf', 'hanger', 'floor', 'ceiling', 'desk', 'computer', 'mat', 'tvstand', 'ceilinglamp', 'shower', 'closetdrawer', 'couch', 'pillow', 'wall', 'oven', 'tape', 'photoframe', 'television', 'doorjamb', 'kettle', 'mouse', 'dresser']
Task:Watch TV
response:
{
    "thoughts": walk to living room, find the television, switch on the television, find the sofa, walk to sofa, sit in sofa, watch the television,
    "actions": ['[WALK] <home_office>', '[WALK] <television>', '[FIND] <television>', '[SWITCHON] <television>', '[FIND] <couch>', '[WALK] <couch>', '[SIT] <couch>', '[TURNTO] <television>', '[WATCH] <television>']
}

Input:
Scene_Objects:['sheets', 'tablelamp', 'bathroom', 'drawing', 'floor', 'character', 'bedroom', 'stamp', 'computer', 'mat', 'ceilinglamp', 'faucet', 'window', 'mousepad', 'closetdrawer', 'clothes_hat', 'pillow', 'dining_room', 'broom', 'wall', 'bed', 'doorjamb', 'dresser', 'cupboard', 'sink', 'bathroom_cabinet', 'light', 'home_office', 'board_game', 'dirt']
Task:Turn on light
response:

walk to living room ,find electrical outlet , switch on eletrical outlet

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


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

Here is an example plan to achieve a goal for reference:
Scene_Objects:['dry_pasta', 'filing_cabinet', 'toilet', 'walllamp', 'bathroom', 'bathroom_counter', 'phone', 'tea_bag', 'keyboard', 'toaster', 'ceilinglamp', 'tvstand', 'faucet', 'brush', 'foundation', 'window', 'closetdrawer', 'couch', 'broom', 'wall_clock', 'toy', 'food_cheese', 'novel', 'food_donut', 'tray', 'kitchen_counter', 'dresser', 'bathtub', 'light', 'shoe_rack']
Task:Pick up phone
response:
{
    "thoughts": Walk to the living room, Find Phone stand. Find Phone. Pickup the receiver to attend the call.,
    "actions": ['[WALK] <home_office>', '[WALK] <phone>', '[FIND] <phone>', '[GRAB] <phone>']
}

Input:
Scene_Objects:['filing_cabinet', 'beer', 'trashcan', 'dough', 'cpuscreen', 'desk', 'keyboard', 'toaster', 'stovefan', 'tvstand', 'shower', 'faucet', 'window', 'oil', 'couch', 'dining_room', 'cutting_board', 'bed', 'food_food', 'television', 'ice', 'doorjamb', 'towel_rack', 'cd', 'door', 'sink', 'bathtub', 'bathroom_cabinet', 'light', 'home_office']
Task:Pick up phone
response:

I hear the phone ringing in the living room. I walk to the living room and go to the phone. I pick it up and answer the phone.

[WALK] <home_office>
[WALK] <phone>
[FIND] <phone>
[TURNTO] <phone>
[LOOKAT] <phone>
[GRAB] <phone>
[SWITCHON] <phone>


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

Here is an example plan to achieve a goal for reference:
Scene_Objects:['pot', 'microwave', 'chair', 'walllamp', 'drawing', 'wallshelf', 'hanger', 'floor', 'ceiling', 'desk', 'bedroom', 'remote_control', 'computer', 'mat', 'tvstand', 'ceilinglamp', 'closetdrawer', 'couch', 'pillow', 'wall', 'oven', 'toy', 'photoframe', 'mouthwash', 'television', 'doorjamb', 'pencil', 'dresser', 'sink', 'board_game']
Task:Watch TV
response:
{
    "thoughts": Walk to living room, walk to TV, grab TV remote, turn on TV, put down the remote, walk to sofa, sit in soft, watch TV,
    "actions": ['[WALK] <home_office>', '[WALK] <television>', '[FIND] <remote_control>', '[GRAB] <remote_control>', '[SWITCHON] <television>', '[PUTOBJBACK] <remote_control>', '[WALK] <couch>', '[SIT] <couch>', '[WATCH] <television>']
}

Input:
Scene_Objects:['microwave', 'toilet', 'freezer', 'band-aids', 'trashcan', 'drawing', 'hanger', 'bathroom_counter', 'floor', 'ceiling', 'phone', 'character', 'envelope', 'clothes_jacket', 'mat', 'shower', 'stereo', 'microphone', 'wall', 'nightstand', 'bed', 'photoframe', 'food_food', 'rag', 'doorjamb', 'towel_rack', 'kitchen_counter', 'cupboard', 'door', 'light']
Task:Put groceries in Fridge
response:

I take the groceries out of the grocery bags, throw away grocery bags, categorize the food so that I know where it goes in the fridge, open the fridge, and place each item in the fridge before closing the fridge.

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


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

Here is an example plan to achieve a goal for reference:
Scene_Objects:['microwave', 'nail_polish', 'drawing', 'wallshelf', 'hanger', 'floor', 'ceiling', 'shampoo', 'bedroom', 'tea_bag', 'laptop', 'tvstand', 'clothes_socks', 'closetdrawer', 'couch', 'clothes_hat', 'wall', 'nightstand', 'powersocket', 'photoframe', 'coffe_maker', 'check', 'television', 'doorjamb', 'towel_rack', 'cards', 'dresser', 'door', 'home_office', 'light']
Task:Turn on light
response:
{
    "thoughts": I walk into the dining room and turn on the lights,
    "actions": ['[WALK] <dining_room>', '[WALK] <light>', '[FIND] <light>', '[SWITCHON] <light>']
}

Input:
Scene_Objects:['filing_cabinet', 'freezer', 'ground_coffee', 'detergent', 'drawing', 'bathroom_counter', 'floor', 'ceiling', 'character', 'bedroom', 'stovefan', 'toaster', 'faucet', 'shower', 'closetdrawer', 'candle', 'dining_room', 'wall', 'oven', 'photoframe', 'bed', 'coffe_maker', 'coffee_filter', 'tray', 'doorjamb', 'kitchen_counter', 'cupboard', 'door', 'sink', 'table']
Task:Make coffee
response:

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


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

Here is an example plan to achieve a goal for reference:
Scene_Objects:['pot', 'walllamp', 'toothbrush', 'knifeblock', 'orchid', 'cpuscreen', 'drawing', 'shampoo', 'floor', 'ceiling', 'desk', 'mop_bucket', 'stovefan', 'laptop', 'tvstand', 'faucet', 'wall', 'nightstand', 'oven', 'tape', 'food_food', 'tray', 'curtain', 'kettle', 'kitchen_counter', 'cupboard', 'conditioner', 'sink', 'bathroom_cabinet', 'table']
Task:Wipe down counter
response:
{
    "thoughts": Clean counter,
    "actions": ['[WALK] <dining_room>', '[WALK] <rag>', '[FIND] <rag>', '[GRAB] <rag>', '[WALK] <sink>', '[FIND] <faucet>', '[SWITCHON] <faucet>', '[RINSE] <rag>', '[SQUEEZE] <rag>', '[SWITCHOFF] <faucet>', '[WALK] <kitchen_counter>', '[WIPE] <kitchen_counter>']
}

Input:
Scene_Objects:['tablelamp', 'chair', 'trashcan', 'toothbrush', 'orchid', 'wallshelf', 'hanger', 'floor', 'phone', 'keyboard', 'toaster', 'tvstand', 'shower', 'plate', 'oil', 'closetdrawer', 'pillow', 'tape', 'basket_for_clothes', 'photoframe', 'check', 'television', 'toothbrush_holder', 'shaving_cream', 'mouse', 'towel_rack', 'kitchen_counter', 'sink', 'bathtub', 'tooth_paste']
Task:Brush teeth
response:

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

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


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', 'sheets', 'scissors', 'microwave', 'walllamp', 'bathroom', 'detergent', 'trashcan', 'toothbrush', 'floor', 'phone', 'toaster', 'mat', 'tvstand', 'dustpan', 'wall', 'box', 'photoframe', 'coffe_maker', 'check', 'oven_mitts', 'food_rice', 'curtain', 'coffee_pot', 'kitchen_counter', 'cupboard', 'hairdryer', 'dishwasher', 'soap', 'coffee']
Task:Take dishes out of dishwasher
response:
{
    "thoughts": Take clean dishes out of the dishwasher and put away,
    "actions": ['[WALK] <dining_room>', '[WALK] <dishwasher>', '[OPEN] <dishwasher>', '[CLOSE] <dishwasher>']
}

Input:
Scene_Objects:['toilet', 'chair', 'cpuscreen', 'hanger', 'floor', 'ceiling', 'phone', 'desk', 'keyboard', 'bookshelf', 'computer', 'toaster', 'mat', 'stereo', 'faucet', 'mousepad', 'wall', 'wall_clock', 'cup', 'bed', 'photoframe', 'novel', 'coffe_maker', 'television', 'mouse', 'kitchen_counter', 'headset', 'cupboard', 'bathroom_cabinet', 'light']
Task:Listen to music
response:

I walk to my bedroom.  I locate my stereo and turn it on.  I put on my headphones and sit to listen.

[WALK] <bedroom>
[WALK] <stereo>
[FIND] <stereo>
[WALK] <stereo>
[SWITCHON] <stereo>
[FIND] <headset>
[GRAB] <headset>
[PUTON] <headset>
[FIND] <chair>
[SIT] <chair>


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

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

Input:
Scene_Objects:['microwave', 'toilet', 'freezer', 'walllamp', 'trashcan', 'drawing', 'bathroom_counter', 'floor', 'ceiling', 'bedroom', 'table_cloth', 'stovefan', 'toaster', 'mat', 'faucet', 'shower', 'tvstand', 'wall', 'wall_clock', 'oven', 'powersocket', 'coffe_maker', 'food_food', 'tray', 'doorjamb', 'kitchen_counter', 'cupboard', 'door', 'sink', 'table']
Task:Put groceries in Fridge
response:

Walk to kitchen counter, grab a grocery, walk to fridge, open fridge, put the grocery into fridge, and close fridge

[WALK] <dining_room>
[WALK] <kitchen_counter>
[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:['microwave', 'chair', 'freezer', 'band-aids', 'walllamp', 'cat', 'drawing', 'floor', 'alcohol', 'computer', 'mat', 'tvstand', 'ceilinglamp', 'deck_of_cards', 'window', 'shower', 'couch', 'pillow', 'wall', 'wall_clock', 'oven', 'photoframe', 'keys', 'television', 'curtain', 'doorjamb', 'mouse', 'home_office', 'table', 'bathroom_cabinet']
Task:Pet cat
response:
{
    "thoughts": Walk into bedrrom and to the sofa. Sit on the sofa and touch cat.,
    "actions": ['[WALK] <home_office>', '[WALK] <couch>', '[SIT] <couch>', '[FIND] <cat>', '[TOUCH] <cat>']
}

Input:
Scene_Objects:['filing_cabinet', 'microwave', 'toilet', 'chair', 'bathroom', 'orchid', 'wallshelf', 'floor', 'ceiling', 'character', 'keyboard', 'piano_bench', 'ceilinglamp', 'plate', 'faucet', 'window', 'dish_soap', 'wall_clock', 'bed', 'coffe_maker', 'coffee_filter', 'tray', 'towel_rack', 'kitchen_counter', 'dresser', 'door', 'napkin', 'home_office', 'table', 'dishwasher']
Task:Wash dishes with dishwasher
response:

Put dishes in the dishwasher and start the dishwasher.

[RUN] <dining_room>
[WALK] <bowl>
[FIND] <bowl>
[GRAB] <bowl>
[WALK] <dishwasher>
[OPEN] <dishwasher>
[PUTBACK] <bowl> <dishwasher>
[FIND] <plate>
[GRAB] <plate>
[WALK] <dishwasher>
[PUTBACK] <plate> <dishwasher>
[FIND] <dish_soap>
[GRAB] <dish_soap>
[WALK] <dishwasher>
[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:['microwave', 'cpuscreen', 'hanger', 'floor', 'ceiling', 'desk', 'keyboard', 'bookshelf', 'computer', 'plate', 'iron', 'mousepad', 'closetdrawer', 'wall', 'wall_clock', 'powersocket', 'cutting_board', 'clothes_gloves', 'check', 'coffe_maker', 'food_food', 'curtain', 'food_onion', 'mouse', 'comb', 'dresser', 'clothes_dress', 'sink', 'light', 'coffee']
Task:Hang up jacket
response:
{
    "thoughts": I put clothes on hangers and hang them in the closet,
    "actions": ['[WALK] <bedroom>', '[WALK] <clothes_dress>', '[FIND] <clothes_dress>', '[GRAB] <clothes_dress>', '[WALK] <dresser>', '[FIND] <hanger>', '[OPEN] <dresser>', '[PUTIN] <clothes_dress> <dresser>', '[FIND] <clothes_dress>', '[GRAB] <clothes_dress>', '[WALK] <dresser>', '[PUTIN] <clothes_dress> <dresser>', '[CLOSE] <dresser>']
}

Input:
Scene_Objects:['filing_cabinet', 'tablelamp', 'bathroom', 'trashcan', 'drawing', 'orchid', 'floor', 'phone', 'ceiling', 'desk', 'bedroom', 'keyboard', 'computer', 'faucet', 'picture', 'window', 'closetdrawer', 'couch', 'dining_room', 'bed', 'light_bulb', 'keys', 'check', 'video_game_controller', 'tray', 'doorjamb', 'mouse', 'kitchen_counter', 'bathtub', 'home_office']
Task:Pet cat
response:

[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:['fork', 'chair', 'milk', 'drawing', 'cpuscreen', 'shampoo', 'folder', 'bookshelf', 'computer', 'table_cloth', 'ceilinglamp', 'mat', 'oil', 'mousepad', 'couch', 'towel', 'nightstand', 'wall', 'cutting_board', 'cup', 'photoframe', 'bed', 'food_donut', 'mouse', 'kitchen_counter', 'pajamas', 'sink', 'napkin', 'home_office', 'tooth_paste']
Task:Open front door
response:
{
    "thoughts": Walk over to the front door, turn the knob, and open the door.,
    "actions": ['[WALK] <home_office>']
}

Input:
Scene_Objects:['dry_pasta', 'chair', 'freezer', 'walllamp', 'food_butter', 'bills', 'cpuscreen', 'bathroom_counter', 'phone', 'ceiling', 'character', 'bedroom', 'computer', 'stovefan', 'ceilinglamp', 'faucet', 'floor_lamp', 'window', 'mousepad', 'closetdrawer', 'couch', 'oven', 'cup', 'photoframe', 'television', 'kitchen_counter', 'dresser', 'bathroom_cabinet', 'table', 'light']
Task:Turn on light
response:

Walk over to light switch, flip the switch to the on position

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


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

Here is an example plan to achieve a goal for reference:
Scene_Objects:['glue', 'food_pizza', 'toilet', 'chair', 'bathroom_counter', 'floor', 'ceiling', 'cleaning_solution', 'food_bacon', 'mop_bucket', 'toaster', 'stovefan', 'faucet', 'shower', 'mousepad', 'dustpan', 'pillow', 'wall', 'nightstand', 'powersocket', 'coffe_maker', 'console', 'towel_rack', 'kitchen_counter', 'chessboard', 'cupboard', 'pajamas', 'sink', 'napkin', 'hands_both']
Task:Wash hands
response:
{
    "thoughts": Washing hands,
    "actions": ['[WALK] <dining_room>', '[WALK] <faucet>', '[FIND] <faucet>', '[SWITCHON] <faucet>', '[FIND] <hands_both>', '[RINSE] <hands_both>', '[SWITCHOFF] <faucet>', '[FIND] <cleaning_solution>', '[SQUEEZE] <cleaning_solution>', '[SCRUB] <hands_both>', '[SWITCHON] <faucet>', '[RINSE] <hands_both>', '[SWITCHOFF] <faucet>']
}

Input:
Scene_Objects:['scissors', 'microwave', 'toilet', 'walllamp', 'drawing', 'bills', 'wallshelf', 'floor', 'ceiling', 'character', 'computer', 'mat', 'ceilinglamp', 'tvstand', 'couch', 'pillow', 'dining_room', 'wall', 'nightstand', 'oven', 'bench', 'television', 'tray', 'curtain', 'towel_rack', 'pencil', 'kitchen_counter', 'bathtub', 'spoon', 'table']
Task:Watch TV
response:

Walk to the room, in which the TV is located. Turn on TV pressing the power button for the TV. Watch TV.

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


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

Here is an example plan to achieve a goal for reference:
Scene_Objects:['tablelamp', 'chair', 'walllamp', 'drawing', 'orchid', 'cpuscreen', 'wallshelf', 'hanger', 'floor', 'ceiling', 'phone', 'desk', 'keyboard', 'bookshelf', 'computer', 'mat', 'ceilinglamp', 'tvstand', 'mousepad', 'couch', 'pillow', 'wall', 'nightstand', 'oven', 'powersocket', 'television', 'doorjamb', 'mouse', 'dresser', 'door', 'light', 'table']
Task:Draft home
response:
{
    "thoughts": Using mathematics and CAD software design a home,
    "actions": ['[WALK] <home_office>', '[WALK] <chair>', '[FIND] <chair>', '[SIT] <chair>', '[FIND] <computer>', '[SWITCHON] <computer>', '[FIND] <mouse>', '[GRAB] <mouse>', '[TURNTO] <computer>', '[POINTAT] <computer>', '[PUTOBJBACK] <mouse>', '[FIND] <keyboard>', '[TYPE] <keyboard>', '[FIND] <drawing>', '[TURNTO] <drawing>', '[LOOKAT] <drawing>']
}

Input:
Scene_Objects:['sheets', 'filing_cabinet', 'tablelamp', 'juice', 'microwave', 'toilet', 'walllamp', 'orchid', 'bathroom_counter', 'bookshelf', 'bookmark', 'toaster', 'ceilinglamp', 'tvstand', 'faucet', 'window', 'mousepad', 'wall_clock', 'food_food', 'coffe_maker', 'tray', 'curtain', 'doorjamb', 'diary', 'mouse', 'kitchen_counter', 'cupboard', 'bathtub', 'home_office', 'bathroom_cabinet']
Task:Drink
response:

Walk to kitchen. Find water glass. Grab water glass. Find water. Pour water in water glass. Drink water from water glass.

[WALK] <dining_room>
[WALK] <water_glass>
[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:['glue', 'pot', 'filing_cabinet', 'food_bread', 'tablelamp', 'mop', 'toilet', 'freezer', 'walllamp', 'desk', 'keyboard', 'toaster', 'ceilinglamp', 'laptop', 'mousepad', 'dining_room', 'nightstand', 'cup', 'photoframe', 'clothes_gloves', 'novel', 'coffe_maker', 'curtain', 'dresser', 'controller', 'clothes_dress', 'door', 'sink', 'light', 'laser_pointer']
Task:Pet cat
response:
{
    "thoughts": Find a cat in the kitchen and touch it,
    "actions": ['[WALK] <dining_room>', '[WALK] <cat>', '[FIND] <cat>', '[WALK] <cat>', '[TOUCH] <cat>']
}

Input:
Scene_Objects:['dry_pasta', 'walllamp', 'cat', 'drawing', 'orchid', 'cpuscreen', 'hanger', 'bathroom_counter', 'floor', 'character', 'envelope', 'computer', 'toaster', 'mat', 'tvstand', 'ceilinglamp', 'shower', 'window', 'mousepad', 'couch', 'pillow', 'wall', 'wall_clock', 'oven', 'coffe_maker', 'television', 'curtain', 'hair', 'bathroom_cabinet', 'table']
Task:Pet cat
response:

I would walk into the living room. Then sit on the couch and pet the cat.

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


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

Here is an example plan to achieve a goal for reference:
Scene_Objects:['food_salt', 'chair', 'ground_coffee', 'food_butter', 'dough', 'drawing', 'floor', 'desk', 'bookmark', 'mat', 'faucet', 'floor_lamp', 'window', 'mousepad', 'couch', 'dustpan', 'pillow', 'wall', 'nightstand', 'oven', 'cup', 'novel', 'television', 'curtain', 'doorjamb', 'chessboard', 'controller', 'maindoor', 'home_office', 'table']
Task:Read book
response:
{
    "thoughts": First I walk into the living room, I find the lamp and switch it on. Then I find a book, grab it, sit in the sofa, open the book and read it. When I'm finished, I find a bookmark, grab it and put it in the book. Then I close the book, put it back, and switch off the lamp.,
    "actions": ['[WALK] <home_office>', '[WALK] <floor_lamp>', '[FIND] <floor_lamp>', '[SWITCHON] <floor_lamp>', '[FIND] <novel>', '[GRAB] <novel>', '[FIND] <couch>', '[SIT] <couch>', '[READ] <novel>', '[FIND] <bookmark>', '[GRAB] <bookmark>', '[PUTBACK] <bookmark> <novel>', '[PUTOBJBACK] <novel>', '[SWITCHOFF] <floor_lamp>']
}

Input:
Scene_Objects:['dry_pasta', 'filing_cabinet', 'tablelamp', 'toilet', 'chair', 'walllamp', 'bathroom', 'drawing', 'cpuscreen', 'floor', 'bedroom', 'bookshelf', 'mat', 'tvstand', 'ceilinglamp', 'stereo', 'window', 'shower', 'mousepad', 'couch', 'pillow', 'wall', 'check', 'television', 'curtain', 'doorjamb', 'dresser', 'door', 'table', 'colander']
Task:Relax on sofa
response:

walk to living room, walk to sofa, sit in sofa

[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:['microwave', 'freezer', 'walllamp', 'blow_dryer', 'milk', 'bills', 'orchid', 'floor', 'ceiling', 'character', 'food_cake', 'alcohol', 'stovefan', 'homework', 'closetdrawer', 'pillow', 'broom', 'wall', 'oven', 'cutting_board', 'cup', 'coffe_maker', 'food_food', 'water', 'tray', 'kitchen_counter', 'shoes', 'sink', 'light', 'table']
Task:Drink
response:
{
    "thoughts": Feeling tired after hard work I opened the fridge and grabbed cool water and drank from the glass.,
    "actions": ['[WALK] <dining_room>', '[WALK] <freezer>', '[FIND] <freezer>', '[OPEN] <freezer>', '[FIND] <cup>', '[GRAB] <cup>', '[CLOSE] <freezer>', '[FIND] <water>', '[GRAB] <water>', '[FIND] <cup>', '[POUR] <water> <cup>', '[FIND] <cup>', '[DRINK] <cup>']
}

Input:
Scene_Objects:['cd_player', 'walllamp', 'needle', 'cpuscreen', 'music_stand', 'floor', 'phone', 'ceiling', 'bedroom', 'tea_bag', 'desk', 'toaster', 'mat', 'window', 'mousepad', 'closetdrawer', 'couch', 'food_peanut_butter', 'pillow', 'nightstand', 'bench', 'photoframe', 'check', 'food_food', 'curtain', 'mouse', 'kitchen_counter', 'door', 'table', 'light']
Task:Listen to music
response:

Walk to the living and turn to the music stand. Switch on the CD player to listen to music.

[WALK] <home_office>
[WALK] <music_stand>
[FIND] <music_stand>
[TURNTO] <music_stand>
[FIND] <cd_player>
[SWITCHON] <cd_player>


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

Here is an example plan to achieve a goal for reference:
Scene_Objects:['pot', 'filing_cabinet', 'food_carrot', 'drawing', 'floor', 'character', 'computer', 'ceilinglamp', 'shower', 'window', 'mousepad', 'couch', 'candle', 'wall', 'wall_clock', 'oven', 'cup', 'photoframe', 'bed', 'novel', 'check', 'toilet_paper', 'television', 'curtain', 'towel_rack', 'mouse', 'hairbrush', 'laundry_detergent', 'table', 'clothes_skirt']
Task:Read book
response:
{
    "thoughts": Walk to the couch in the living room, sit on ti and read the book,
    "actions": ['[WALK] <home_office>', '[WALK] <couch>', '[FIND] <couch>', '[SIT] <couch>', '[FIND] <novel>', '[GRAB] <novel>', '[READ] <novel>']
}

Input:
Scene_Objects:['filing_cabinet', 'food_salt', 'toilet', 'chair', 'walllamp', 'bathroom', 'trashcan', 'drawing', 'wallshelf', 'cpuscreen', 'floor', 'bedroom', 'bookshelf', 'computer', 'mat', 'shower', 'window', 'closetdrawer', 'couch', 'pillow', 'dining_room', 'nightstand', 'oven', 'coffe_maker', 'television', 'cards', 'towel_rack', 'cupboard', 'napkin', 'bathroom_cabinet']
Task:Wash dishes with dishwasher
response:

Walk to the sink. Take dishes out of sink. Open dishwasher and place dishes in dishwasher.

[WALK] <dining_room>
[WALK] <dishwasher>
[FIND] <dishwasher>
[OPEN] <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:['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', 'television', 'tray', 'doorjamb', 'towel_rack', 'mouse', 'pencil', 'dresser', 'door', 'light']
Task:Work
response:
{
    "thoughts": Walk to over to desk, sit down on chair and face the computer, turn the computer on, use arms to place hands on the keyboard, type work into the computer and use eyes to review.,
    "actions": ['[WALK] <home_office>', '[WALK] <desk>', '[FIND] <chair>', '[SIT] <chair>', '[FIND] <computer>', '[TURNTO] <computer>', '[LOOKAT] <computer>', '[SWITCHON] <computer>', '[FIND] <keyboard>', '[TYPE] <keyboard>']
}

Input:
Scene_Objects:['tablelamp', 'walllamp', 'trashcan', 'drawing', 'orchid', 'floor', 'bedroom', 'bookmark', 'mat', 'tvstand', 'ceilinglamp', 'floor_lamp', 'window', 'closetdrawer', 'couch', 'food_peanut_butter', 'pillow', 'wall', 'wall_clock', 'clothes_gloves', 'novel', 'television', 'curtain', 'towel_rack', 'mouse', 'comb', 'cupboard', 'sink', 'table', 'light']
Task:Read book
response:

First I walk into the living room, I find the lamp and switch it on. Then I find a book, grab it, sit in the sofa, open the book and read it. When I'm finished, I find a bookmark, grab it and put it in the book. Then I close the book, put it back, and switch off the lamp.

[WALK] <home_office>
[WALK] <floor_lamp>
[FIND] <floor_lamp>
[SWITCHON] <floor_lamp>
[FIND] <novel>
[GRAB] <novel>
[FIND] <couch>
[SIT] <couch>
[READ] <novel>
[FIND] <bookmark>
[GRAB] <bookmark>
[PUTBACK] <bookmark> <novel>
[PUTOBJBACK] <novel>
[SWITCHOFF] <floor_lamp>


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', 'dry_pasta', 'food_ice_cream', 'toilet', 'freezer', 'knifeblock', 'wallshelf', 'folder', 'desk', 'stamp', 'bedroom', 'computer', 'toaster', 'mat', 'floor_lamp', 'dustpan', 'pillow', 'dining_room', 'broom', 'wall', 'nightstand', 'check', 'curtain', 'console', 'dresser', 'door', 'sink', 'bathroom_cabinet', 'light', 'dishwasher']
Task:Turn on light
response:
{
    "thoughts": I go home and it's dark so I can not see anything,
    "actions": ['[WALK] <home_office>', '[WALK] <floor_lamp>', '[FIND] <floor_lamp>', '[SWITCHON] <floor_lamp>']
}

Input:
Scene_Objects:['dry_pasta', 'freezer', 'walllamp', 'bathroom', 'drawing', 'bathroom_counter', 'floor', 'ceiling', 'table_cloth', 'toaster', 'mat', 'tvstand', 'ceilinglamp', 'shower', 'window', 'couch', 'microphone', 'pillow', 'wall', 'wall_clock', 'nightstand', 'television', 'tray', 'curtain', 'towel_rack', 'mouse', 'kitchen_counter', 'home_office', 'table', 'soap']
Task:Relax on sofa
response:

go to the living room and sit on the couch, ease into the sofa and relax.

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


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

Here is an example plan to achieve a goal for reference:
Scene_Objects:['microwave', 'toilet', 'freezer', 'trashcan', 'drawing', 'cpuscreen', 'floor', 'stamp', 'bedroom', 'stovefan', 'toaster', 'plate', 'faucet', 'shower', 'dish_soap', 'food_jam', 'towel', 'wall', 'nightstand', 'oven', 'coffe_maker', 'food_food', 'ice', 'tray', 'curtain', 'kitchen_counter', 'cupboard', 'sink', 'bathtub', 'dishwasher']
Task:Wash dishes with dishwasher
response:
{
    "thoughts": I walk into the kitchen and go to the dishwasher. I open the dishwasher and grab the dishes. Iplace the dishes into the dishwasher then close it. I add soap then turn the dishwasher on.,
    "actions": ['[WALK] <dining_room>', '[WALK] <dishwasher>', '[OPEN] <dishwasher>', '[WALK] <kitchen_counter>', '[FIND] <plate>', '[GRAB] <plate>', '[PUTBACK] <plate> <dishwasher>', '[FIND] <dish_soap>', '[GRAB] <dish_soap>', '[PUTBACK] <dish_soap> <dishwasher>', '[CLOSE] <dishwasher>', '[SWITCHON] <dishwasher>']
}

Input:
Scene_Objects:['chair', 'walllamp', 'orchid', 'cpuscreen', 'floor', 'ceiling', 'desk', 'keyboard', 'bookshelf', 'thread', 'computer', 'toaster', 'ceilinglamp', 'tvstand', 'mousepad', 'closetdrawer', 'dining_room', 'wall', 'powersocket', 'bench', 'keys', 'television', 'doorjamb', 'diary', 'mouse', 'comb', 'cupboard', 'bathtub', 'home_office', 'table']
Task:Browse internet
response:

Browsing the world wide web for entertainment

[WALK] <home_office>
[WALK] <chair>
[FIND] <chair>
[SIT] <chair>
[FIND] <computer>
[SWITCHON] <computer>
[FIND] <mouse>
[TOUCH] <mouse>
[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:['chair', 'walllamp', 'bills', 'cpuscreen', 'wallshelf', 'hanger', 'floor', 'ceiling', 'shampoo', 'desk', 'keyboard', 'computer', 'ceilinglamp', 'mat', 'mousepad', 'closetdrawer', 'wall', 'powersocket', 'television', 'toothbrush_holder', 'wine', 'doorjamb', 'mouse', 'dresser', 'hairbrush', 'controller', 'clothes_dress', 'home_office', 'light', 'table']
Task:Turn on computer
response:
{
    "thoughts": Press the power button on the computer to turn it on,
    "actions": ['[WALK] <home_office>', '[WALK] <computer>', '[SWITCHON] <computer>']
}

Input:
Scene_Objects:['tablelamp', 'toilet', 'chair', 'drawing', 'cpuscreen', 'kitchen_cabinet', 'floor', 'bedroom', 'piano_bench', 'stovefan', 'toaster', 'plate', 'tvstand', 'faucet', 'shower', 'ceilinglamp', 'dish_soap', 'pillow', 'wall', 'bed', 'coffe_maker', 'television', 'tray', 'kettle', 'kitchen_counter', 'dishrack', 'sink', 'bathroom_cabinet', 'table', 'dishwasher']
Task:Wash dishes with dishwasher
response:

I went to the kitchen and collected the dishes and put them into the dish washer and wiped them with towel and put back into cabinet..

[WALK] <dining_room>
[WALK] <kitchen_cabinet>
[FIND] <kitchen_cabinet>
[OPEN] <kitchen_cabinet>
[FIND] <plate>
[GRAB] <plate>
[FIND] <dishwasher>
[OPEN] <dishwasher>
[PUTBACK] <plate> <dishwasher>
[FIND] <dish_soap>
[GRAB] <dish_soap>
[PUTBACK] <dish_soap> <dishwasher>
[CLOSE] <dishwasher>
[SWITCHON] <dishwasher>
[GRAB] <plate>
[WIPE] <plate>
[FIND] <dishrack>
[GRAB] <dishrack>
[PUTOBJBACK] <dishrack>


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

Here is an example plan to achieve a goal for reference:
Scene_Objects:['tablelamp', 'juice', 'walllamp', 'bathroom', 'ceilingfan', 'trashcan', 'drawing', 'floor', 'ceiling', 'food_bacon', 'ceilinglamp', 'tvstand', 'balanceball', 'mat', 'window', 'couch', 'wall', 'nightstand', 'wall_clock', 'bench', 'bed', 'food_food', 'television', 'coin', 'curtain', 'mouse', 'controller', 'table', 'vase', 'instrument_violin']
Task:Watch TV
response:
{
    "thoughts": Sitting on the couch watching my favorite television show.,
    "actions": ['[WALK] <home_office>', '[WALK] <couch>', '[FIND] <couch>', '[SIT] <couch>', '[FIND] <television>', '[TURNTO] <television>', '[WATCH] <television>']
}

Input:
Scene_Objects:['filing_cabinet', 'tablelamp', 'toilet', 'chair', 'ground_coffee', 'drawing', 'cpuscreen', 'wallshelf', 'floor', 'ceiling', 'stovefan', 'toaster', 'faucet', 'shower', 'window', 'closetdrawer', 'pillow', 'wall', 'oven', 'photoframe', 'coffe_maker', 'coffee_filter', 'water', 'tray', 'kitchen_counter', 'cupboard', 'door', 'sink', 'light', 'table']
Task:Make coffee
response:

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

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


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

Here is an example plan to achieve a goal for reference:
Scene_Objects:['pot', 'tablelamp', 'chair', 'freezer', 'walllamp', 'milk', 'floor', 'keyboard', 'table_cloth', 'stovefan', 'mat', 'tvstand', 'faucet', 'window', 'couch', 'clothes_hat', 'pillow', 'dining_room', 'toy', 'basket_for_clothes', 'coffe_maker', 'video_game_controller', 'tray', 'doorjamb', 'kettle', 'dresser', 'cupboard', 'clothes_dress', 'sink', 'table']
Task:Pick up toys
response:
{
    "thoughts": Bend down and pick up the toys off of the floor.,
    "actions": ['[WALK] <bedroom>', '[WALK] <toy>', '[FIND] <toy>', '[GRAB] <toy>', '[WALK] <dresser>', '[OPEN] <dresser>', '[PUTIN] <toy> <dresser>', '[FIND] <toy>', '[GRAB] <toy>', '[WALK] <dresser>', '[PUTIN] <toy> <dresser>', '[FIND] <toy>', '[WALK] <dresser>', '[GRAB] <toy>', '[PUTIN] <toy> <dresser>', '[CLOSE] <dresser>']
}

Input:
Scene_Objects:['microwave', 'chair', 'freezer', 'walllamp', 'drawing', 'orchid', 'cpuscreen', 'floor', 'keyboard', 'computer', 'mat', 'tvstand', 'ceilinglamp', 'stereo', 'window', 'couch', 'candle', 'clothes_hat', 'pillow', 'wall', 'oven', 'coffe_maker', 'television', 'curtain', 'diary', 'towel_rack', 'mouse', 'dishrack', 'home_office', 'table']
Task:Relax on sofa
response:

I walk to the living room. I see the couch.  I sit down on the couch, then lie down and put my feet up.

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


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

Here is an example plan to achieve a goal for reference:
Scene_Objects:['filing_cabinet', 'tea', 'microwave', 'cd_player', 'freezer', 'band-aids', 'bathroom', 'food_carrot', 'orchid', 'music_stand', 'phone', 'bookshelf', 'thread', 'mail', 'stereo', 'homework', 'mousepad', 'closetdrawer', 'clothes_hat', 'form', 'broom', 'newspaper', 'photoframe', 'check', 'food_rice', 'food_donut', 'dresser', 'sink', 'napkin', 'light']
Task:Listen to music
response:
{
    "thoughts": Walk to the living and turn to the music stand. Switch on the CD player to listen to music.,
    "actions": ['[WALK] <home_office>', '[WALK] <music_stand>', '[FIND] <music_stand>', '[TURNTO] <music_stand>', '[FIND] <cd_player>', '[SWITCHON] <cd_player>']
}

Input:
Scene_Objects:['chair', 'walllamp', 'trashcan', 'cpuscreen', 'hanger', 'floor', 'ceiling', 'phone', 'character', 'desk', 'keyboard', 'thread', 'computer', 'ceilinglamp', 'tvstand', 'mousepad', 'dining_room', 'wall', 'powersocket', 'bench', 'cup', 'light_bulb', 'coffe_maker', 'toilet_paper', 'television', 'doorjamb', 'towel_rack', 'mouse', 'kitchen_counter', 'table']
Task:Work
response:

[WALK] <home_office>
[WALK] <computer>
[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:['glue', 'food_ice_cream', 'tea', 'walllamp', 'orchid', 'knifeblock', 'wallshelf', 'drawing', 'floor', 'ceiling', 'bookshelf', 'remote_control', 'button', 'stovefan', 'mat', 'tvstand', 'ceilinglamp', 'shower', 'window', 'dining_room', 'wall', 'powersocket', 'bench', 'photoframe', 'television', 'curtain', 'doorjamb', 'cupboard', 'light', 'dishwasher']
Task:Change TV channel
response:
{
    "thoughts": Walk to the living room. Find the television. Switch on the television. Find the remote control. Grab the remote control. Point at television. Find the button. Push button.,
    "actions": ['[WALK] <home_office>', '[WALK] <television>', '[FIND] <television>', '[SWITCHON] <television>', '[FIND] <remote_control>', '[GRAB] <remote_control>', '[TURNTO] <television>', '[POINTAT] <television>', '[FIND] <button>', '[PUSH] <button>']
}

Input:
Scene_Objects:['pot', 'chair', 'walllamp', 'bathroom', 'cpuscreen', 'hanger', 'floor', 'ceiling', 'character', 'desk', 'keyboard', 'computer', 'ceilinglamp', 'tvstand', 'window', 'mousepad', 'wall', 'wall_clock', 'powersocket', 'oven', 'check', 'television', 'oven_mitts', 'doorjamb', 'mouse', 'kitchen_counter', 'sink', 'napkin', 'table', 'shoe_rack']
Task:Browse internet
response:

I will walk to the computer at the desk in my home office, sit in the chair, turn on the computer, open a web browser, type in the address, and view the computer.

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