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

Here is an example plan to achieve a goal for reference:
Scene_Objects:['tablelamp', 'drawing', 'hanger', 'longboard', 'floor', 'ceiling', 'bathroom_counter', 'bookshelf', 'keyboard', 'computer', 'button', 'ceilinglamp', 'tvstand', 'faucet', 'picture', 'mousepad', 'pillow', 'wall', 'basket_for_clothes', 'photoframe', 'curtain', 'shoes', 'cd', 'vacuum_cleaner', 'dresser', 'cupboard', 'clothes_dress', 'home_office', 'table', 'shoe_rack']
Task:Take off shoes
response:
{
    "thoughts": Bend down to reach your feet. Shift balance to one leg. Grab the shoe of the foot of the other leg, it is best to use one hand to grip near the front, and one towards the heel. Pull the shoe down toward the ground while also pushing on the heel away from the body. Repeat with other shoe. Place shoes in a designated area.,
    "actions": ['[WALK] <bedroom>', '[WALK] <shoes>', '[FIND] <shoes>', '[GRAB] <shoes>', '[PULL] <shoes>', '[WALK] <dresser>', '[OPEN] <dresser>', '[PUTIN] <shoes> <dresser>', '[FIND] <shoes>', '[GRAB] <shoes>', '[PULL] <shoes>', '[WALK] <dresser>', '[PUTIN] <shoes> <dresser>', '[CLOSE] <dresser>']
}

Input:
Scene_Objects:['pot', 'juice', 'tea', 'microwave', 'chair', 'drawing', 'floor', 'character', 'toaster', 'laptop', 'plate', 'shower', 'tvstand', 'dish_soap', 'tooth_paste', 'dustpan', 'candle', 'bowl', 'wall', 'cup', 'coffe_maker', 'check', 'pencil', 'kitchen_counter', 'vacuum_cleaner', 'cupboard', 'sink', 'instrument_guitar', 'dishwasher', 'instrument_violin']
Task:Wash dishes with dishwasher
response:

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


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

Here is an example plan to achieve a goal for reference:
Scene_Objects:['tablelamp', 'mop', 'walllamp', 'drawing', 'wallshelf', 'floor', 'ceiling', 'phone', 'desk', 'bookshelf', 'computer', 'toaster', 'mat', 'tvstand', 'ceilinglamp', 'couch', 'candle', 'pillow', 'wall', 'powersocket', 'photoframe', 'light_bulb', 'check', 'television', 'rag', 'doorjamb', 'kitchen_counter', 'door', 'bathroom_cabinet', 'light']
Task:Relax on sofa
response:
{
    "thoughts": I go to the living room, switch off the light, sit in the sofa and do nothing.,
    "actions": ['[WALK] <home_office>', '[WALK] <light>', '[FIND] <light>', '[SWITCHOFF] <light>', '[FIND] <couch>', '[SIT] <couch>', '[LIE] <couch>']
}

Input:
Scene_Objects:['food_salt', 'cat', 'drawing', 'cpuscreen', 'wallshelf', 'bathroom_counter', 'floor', 'ceiling', 'desk', 'bookshelf', 'computer', 'mat', 'oil', 'closetdrawer', 'food_orange', 'form', 'pillow', 'wall', 'nightstand', 'powersocket', 'tape', 'photoframe', 'doorjamb', 'console', 'kitchen_counter', 'door', 'light', 'dishwasher', 'clothes_skirt', 'table']
Task:Turn on light
response:

approach the light switch, raise hand to the switch, flip the switch

[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:['tablelamp', 'toilet', 'chair', 'walllamp', 'trashcan', 'ceilingfan', 'drawing', 'cpuscreen', 'floor', 'ceiling', 'phone', 'character', 'desk', 'bookshelf', 'keyboard', 'computer', 'ceilinglamp', 'balanceball', 'mousepad', 'pillow', 'wall', 'nightstand', 'photoframe', 'wine', 'doorjamb', 'mouse', 'dresser', 'napkin', 'bathroom_cabinet', 'light']
Task:Clean
response:
{
    "thoughts": Wipe down computer desk and monitor,
    "actions": ['[WALK] <home_office>', '[WALK] <rag>', '[FIND] <rag>', '[GRAB] <rag>', '[WALK] <desk>', '[FIND] <computer>', '[WIPE] <computer>', '[WIPE] <desk>', '[PUTOBJBACK] <rag>']
}

Input:
Scene_Objects:['filing_cabinet', 'beer', 'chair', 'freezer', 'drawing', 'wallshelf', 'hanger', 'phone', 'dvd_player', 'purse', 'clothes_jacket', 'mat', 'stereo', 'oil', 'pillow', 'nightstand', 'cup', 'newspaper', 'keys', 'bed', 'check', 'video_game_controller', 'television', 'lighter', 'chessboard', 'dresser', 'napkin', 'spoon', 'table', 'scrabble']
Task:Pick up phone
response:

Walk to Living Room. Find table. Walk to table. Find telephone. Lift telephone.

[WALK] <home_office>
[WALK]

[FIND]

[WALK]

[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:['pot', 'filing_cabinet', 'measuring_cup', 'microwave', 'orchid', 'knifeblock', 'wallshelf', 'character', 'keyboard', 'stovefan', 'mat', 'closetdrawer', 'dining_room', 'food_kiwi', 'box', 'cup', 'bed', 'coffe_maker', 'television', 'water', 'colander', 'tray', 'curtain', 'kitchen_counter', 'cd', 'cupboard', 'door', 'bag', 'soap', 'creditcard']
Task:Wash hands
response:
{
    "thoughts": put soap on hands, scrub it and rinse with water,
    "actions": ['[WALK] <bathroom>', '[WALK] <soap>', '[FIND] <soap>', '[SCRUB] <soap>', '[FIND] <water>', '[RINSE] <water>']
}

Input:
Scene_Objects:['tablelamp', 'chair', 'walllamp', 'drawing', 'orchid', 'cpuscreen', 'wallshelf', 'hanger', 'floor', 'ceiling', 'desk', 'keyboard', 'remote_control', 'computer', 'mat', 'ceilinglamp', 'tvstand', 'mousepad', 'closetdrawer', 'couch', 'pillow', 'wall', 'nightstand', 'photoframe', 'television', 'doorjamb', 'mouse', 'dresser', 'door', 'shoe_rack']
Task:Watch TV
response:

I walk to the living room. I find the chair. I find the television remote control. I turn it on. I find the television. I look at the television. I watched television.

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


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

Here is an example plan to achieve a goal for reference:
Scene_Objects:['filing_cabinet', 'freezer', 'walllamp', 'trashcan', 'drawing', 'orchid', 'bathroom_counter', 'floor', 'ceiling', 'desk', 'keyboard', 'computer', 'mat', 'tvstand', 'window', 'mousepad', 'couch', 'pillow', 'wall', 'powersocket', 'bench', 'bed', 'coin', 'curtain', 'dresser', 'cupboard', 'door', 'bathtub', 'sink', 'light']
Task:Wipe down baseboards please
response:
{
    "thoughts": Use a rag to get all the dust off the baseboards please.,
    "actions": ['[WALK] <home_office>', '[WALK] <rag>', '[FIND] <rag>', '[GRAB] <rag>', '[WALK] <wall>', '[PUTOBJBACK] <rag>']
}

Input:
Scene_Objects:['sheets', 'glue', 'food_pizza', 'pot', 'microwave', 'toilet', 'nail_polish', 'orchid', 'stamp', 'desk', 'food_cake', 'toaster', 'oil', 'candle', 'broom', 'nightstand', 'powersocket', 'cup', 'food_cheese', 'photoframe', 'novel', 'coffe_maker', 'mouse', 'kitchen_counter', 'cd', 'shoes', 'food_steak', 'clothes_scarf', 'home_office', 'clothes_skirt']
Task:Pick up phone
response:

walk into living room, look at the phone when it ringing, grab the phone or pickup the phone

[WALK] <home_office>
[WALK] <phone>
[FIND] <phone>
[TURNTO] <phone>
[LOOKAT] <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:['filing_cabinet', 'tablelamp', 'microwave', 'walllamp', 'drawing', 'orchid', 'wallshelf', 'floor', 'ceiling', 'bookshelf', 'computer', 'mat', 'tvstand', 'ceilinglamp', 'clothes_socks', 'couch', 'pillow', 'wall', 'powersocket', 'box', 'cup', 'photoframe', 'television', 'food_rice', 'doorjamb', 'towel_rack', 'kitchen_counter', 'door', 'home_office', 'soap']
Task:Relax on sofa
response:
{
    "thoughts": I walk to the living room and stand in front of the sofa. Then I turn and sit on the sofa and lean my back against the pillow and my feet on the floor.,
    "actions": ['[WALK] <home_office>', '[WALK] <couch>', '[FIND] <couch>', '[TURNTO] <couch>', '[SIT] <couch>']
}

Input:
Scene_Objects:['filing_cabinet', 'chair', 'ground_coffee', 'detergent', 'cpuscreen', 'hanger', 'floor', 'ceiling', 'folder', 'purse', 'computer', 'toaster', 'laptop', 'shower', 'picture', 'couch', 'wall', 'pasta', 'nightstand', 'box', 'photoframe', 'coffe_maker', 'television', 'coffee_filter', 'tray', 'kitchen_counter', 'cupboard', 'sink', 'dishwasher', 'instrument_violin']
Task:Make coffee
response:

Open the coffee maker and put a filer, grab ground coffee and put it in the coffee maker, then close the coffee maker and switch it on

[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>
[FIND] <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:['spectacles', 'filing_cabinet', 'juice', 'toilet', 'chair', 'nail_polish', 'needle', 'clothes_underwear', 'phone', 'keyboard', 'bookmark', 'stovefan', 'ceilinglamp', 'toaster', 'shower', 'foundation', 'clothes_hat', 'pillow', 'oven', 'powersocket', 'tape', 'bed', 'coffe_maker', 'television', 'curtain', 'towel_rack', 'mouse', 'cupboard', 'bathroom_cabinet', 'table']
Task:Listen to music
response:
{
    "thoughts": Walk into the living room. Walk up to the radio. Turn on the radio. Listen to the radio.,
    "actions": ['[WALK] <home_office>', '[WALK] <stereo>', '[SWITCHON] <stereo>']
}

Input:
Scene_Objects:['filing_cabinet', 'tablelamp', 'measuring_cup', 'mop', 'freezer', 'walllamp', 'bathroom', 'drawing', 'cpuscreen', 'floor', 'phone', 'bedroom', 'purse', 'mat', 'plate', 'stereo', 'closetdrawer', 'pillow', 'wall', 'nightstand', 'powersocket', 'bed', 'mouse', 'kitchen_counter', 'cd', 'dresser', 'light', 'dishwasher', 'soap', 'board_game']
Task:Listen to music
response:

I go into my bedroom and see my stereo. I decide to play music. I walk over to the stereo and turn it on. I sit down on the bed to listen to the music.

[WALK] <bedroom>
[WALK] <stereo>
[FIND] <stereo>
[TURNTO] <stereo>
[LOOKAT] <stereo>
[SWITCHON] <stereo>
[FIND] <bed>
[SIT] <bed>


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

Here is an example plan to achieve a goal for reference:
Scene_Objects:['toilet', 'ceilingfan', 'drawing', 'floor', 'ceiling', 'bedroom', 'remote_control', 'toaster', 'ceilinglamp', 'tvstand', 'balanceball', 'window', 'mousepad', 'couch', 'dining_room', 'wall', 'wall_clock', 'powersocket', 'oven', 'television', 'toothbrush_holder', 'curtain', 'doorjamb', 'console', 'dresser', 'cupboard', 'home_office', 'table', 'clothes_skirt', 'vase']
Task:Watch TV
response:
{
    "thoughts": Watch the television,
    "actions": ['[WALK] <home_office>', '[WALK] <television>', '[TURNTO] <television>', '[LOOKAT] <television>', '[FIND] <remote_control>', '[GRAB] <remote_control>', '[SWITCHON] <television>', '[FIND] <couch>', '[TURNTO] <couch>', '[SIT] <couch>', '[TURNTO] <television>', '[WATCH] <television>']
}

Input:
Scene_Objects:['tablelamp', 'blender', 'bathroom', 'detergent', 'food_carrot', 'cpuscreen', 'wallshelf', 'phone', 'bedroom', 'desk', 'remote_control', 'envelope', 'computer', 'mail', 'tvstand', 'shower', 'iron', 'mousepad', 'closetdrawer', 'oven', 'powersocket', 'newspaper', 'novel', 'food_food', 'curtain', 'dresser', 'food_steak', 'sink', 'table', 'shoe_rack']
Task:Watch TV
response:

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.

[WALK] <home_office>
[WALK] <remote_control>
[FIND] <remote_control>
[GRAB] <remote_control>
[PUSH] <remote_control>
[FIND] <remote_control>
[PUSH] <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:['sheets', 'glue', 'tablelamp', 'cpuscreen', 'hanger', 'floor', 'ceiling', 'phone', 'desk', 'keyboard', 'purse', 'computer', 'clothes_jacket', 'toaster', 'stereo', 'mousepad', 'closetdrawer', 'couch', 'wall', 'wall_clock', 'powersocket', 'nightstand', 'bed', 'novel', 'mouse', 'shoes', 'dresser', 'clothes_dress', 'light', 'table']
Task:Get ready for day
response:
{
    "thoughts": Grab shoes, purse etc and head out the door!,
    "actions": ['[WALK] <bedroom>', '[WALK] <dresser>', '[FIND] <dresser>', '[OPEN] <dresser>', '[FIND] <clothes_dress>', '[GRAB] <clothes_dress>', '[PUTON] <clothes_dress>', '[FIND] <shoes>', '[GRAB] <shoes>', '[PUTON] <shoes>', '[FIND] <purse>', '[GRAB] <purse>', '[CLOSE] <dresser>', '[WALK] <home_office>']
}

Input:
Scene_Objects:['dry_pasta', 'tablelamp', 'chair', 'walllamp', 'orchid', 'drawing', 'cpuscreen', 'wallshelf', 'hanger', 'floor', 'ceiling', 'phone', 'desk', 'keyboard', 'computer', 'ceilinglamp', 'tvstand', 'mat', 'mousepad', 'couch', 'pillow', 'wall', 'nightstand', 'oven', 'television', 'doorjamb', 'mouse', 'dresser', 'hair', 'door']
Task:Work
response:

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


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

Here is an example plan to achieve a goal for reference:
Scene_Objects:['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:['blow_dryer', 'bathroom', 'food_carrot', 'bathroom_counter', 'floor', 'ceiling', 'desk', 'stamp', 'bedroom', 'food_cake', 'computer', 'shower', 'picture', 'oven', 'basket_for_clothes', 'photoframe', 'food_food', 'check', 'towel_rack', 'mouse', 'pencil', 'shoes', 'comb', 'hairbrush', 'cupboard', 'laundry_detergent', 'sink', 'napkin', 'light', 'washing_machine']
Task:Wash clothes
response:

Pick up my dirty clothes, load the washer, add detergent, turn on washer


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', 'orchid', 'wallshelf', 'floor', 'ceiling', 'phone', 'bookshelf', 'computer', 'clothes_jacket', 'table_cloth', 'ceilinglamp', 'shower', 'window', 'homework', 'mousepad', 'pillow', 'powersocket', 'photoframe', 'coffe_maker', 'doorjamb', 'kettle', 'shoes', 'dresser', 'cupboard', 'laundry_detergent', 'clothes_dress', 'door', 'bag', 'light', 'washing_machine']
Task:Wash clothes
response:
{
    "thoughts": Go to bedroom and grab dirty pants and take to the washing machine in entrance hall. Put clothes in washing machine and then put in laundry detergent.,
    "actions": ['[WALK] <bedroom>', '[WALK] <clothes_pants>', '[FIND] <clothes_pants>', '[GRAB] <clothes_pants>', '[WALK] <home_office>', '[WALK] <washing_machine>', '[FIND] <washing_machine>', '[OPEN] <washing_machine>', '[PUTBACK] <clothes_pants> <washing_machine>', '[FIND] <laundry_detergent>', '[GRAB] <laundry_detergent>', '[PUTBACK] <laundry_detergent> <washing_machine>', '[CLOSE] <washing_machine>']
}

Input:
Scene_Objects:['sheets', 'spectacles', 'measuring_cup', 'chair', 'freezer', 'walllamp', 'drawing', 'wallshelf', 'hanger', 'floor', 'ceiling', 'character', 'desk', 'bookshelf', 'remote_control', 'computer', 'mat', 'tvstand', 'ceilinglamp', 'closetdrawer', 'couch', 'pillow', 'wall', 'photoframe', 'coffe_maker', 'television', 'tray', 'doorjamb', 'dresser', 'coffee']
Task:Change TV channel
response:

walk to living room ,find television ,find remote control ,switch on remote control and change the channel

[WALK] <home_office>
[WALK] <television>
[FIND] <television>
[FIND] <remote_control>
[TURNTO] <remote_control>
[SWITCHON] <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:['food_bread', 'filing_cabinet', 'tablelamp', 'chair', 'freezer', 'food_butter', 'drawing', 'bills', 'desk', 'tea_bag', 'keyboard', 'purse', 'food_cake', 'envelope', 'plate', 'dish_soap', 'mousepad', 'pillow', 'wall_clock', 'powersocket', 'shelf', 'standingmirror', 'check', 'coffe_maker', 'doorjamb', 'towel_rack', 'shaving_cream', 'kitchen_counter', 'dresser', 'sink']
Task:Wash dishes by hand
response:
{
    "thoughts": Pick up dish.  Put in soapy water.  Wash dish.,
    "actions": ['[WALK] <dining_room>', '[WALK] <dish_soap>', '[FIND] <dish_soap>', '[GRAB] <dish_soap>', '[FIND] <plate>', '[GRAB] <plate>', '[PUTBACK] <dish_soap> <plate>', '[SCRUB] <plate>', '[RINSE] <plate>', '[WIPE] <plate>']
}

Input:
Scene_Objects:['tablelamp', 'measuring_cup', 'toilet', 'chair', 'ground_coffee', 'bathroom', 'dough', 'wallshelf', 'phone', 'character', 'keyboard', 'computer', 'ceilinglamp', 'deck_of_cards', 'stereo', 'mousepad', 'couch', 'powersocket', 'cutting_board', 'bed', 'food_food', 'food_rice', 'tray', 'wooden_spoon', 'pencil', 'headset', 'cupboard', 'laundry_detergent', 'sink', 'dishwasher']
Task:Pet cat
response:

find the cat, go near the cat and pet the cat

[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:['sponge', 'food_salt', 'beer', 'walllamp', 'knifeblock', 'cpuscreen', 'floor', 'bookshelf', 'mail', 'computer', 'button', 'toaster', 'plate', 'shower', 'dish_soap', 'mousepad', 'pillow', 'wall', 'oven', 'photoframe', 'clothes_gloves', 'coffe_maker', 'tray', 'food_onion', 'doorjamb', 'dresser', 'hairdryer', 'sink', 'dishwasher', 'clothes_shirt']
Task:Wash dishes with dishwasher
response:
{
    "thoughts": Put dishes in the dishwasher and start the dishwasher.,
    "actions": ['[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>']
}

Input:
Scene_Objects:['spectacles', 'filing_cabinet', 'tablelamp', 'blender', 'tea', 'toothbrush', 'cpuscreen', 'hanger', 'bedroom', 'computer', 'laptop', 'plate', 'faucet', 'candle', 'food_jam', 'wall_clock', 'bed', 'food_food', 'check', 'television', 'food_donut', 'after_shave', 'lighter', 'cards', 'mouse', 'kitchen_counter', 'dresser', 'pajamas', 'laundry_detergent', 'home_office']
Task:Pet cat
response:

Go to the living room where the cat sleeps. Find cat. Proceed to petting cat.

[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:['filing_cabinet', 'toilet', 'chair', 'trashcan', 'food_carrot', 'drawing', 'knifeblock', 'hanger', 'floor', 'tea_bag', 'ceilinglamp', 'tvstand', 'shower', 'window', 'homework', 'couch', 'dustpan', 'food_orange', 'dining_room', 'wall', 'nightstand', 'photoframe', 'clothes_gloves', 'coffe_maker', 'check', 'television', 'mouse', 'pencil', 'table', 'laser_pointer']
Task:Relax on sofa
response:
{
    "thoughts": Walk to the living room, turn to the sofa. Sit on the sofa and relax.,
    "actions": ['[WALK] <home_office>', '[WALK] <couch>', '[FIND] <couch>', '[TURNTO] <couch>', '[SIT] <couch>']
}

Input:
Scene_Objects:['sponge', 'pot', 'microwave', 'freezer', 'drawing', 'floor', 'ceiling', 'dvd_player', 'keyboard', 'stovefan', 'mat', 'laptop', 'stereo', 'oil', 'mousepad', 'couch', 'pillow', 'wall', 'food_food', 'television', 'drinking_glass', 'water', 'curtain', 'diary', 'pencil', 'kitchen_counter', 'cupboard', 'sink', 'light', 'instrument_violin']
Task:Drink
response:

[WALK] <dining_room>
[WALK] <freezer>
[FIND] <freezer>
[OPEN] <freezer>
[FIND] <drinking_glass>
[GRAB] <drinking_glass>
[FIND] <water>
[DRINK] <drinking_glass>


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

Here is an example plan to achieve a goal for reference:
Scene_Objects:['pot', 'filing_cabinet', 'food_salt', 'chair', 'bathroom', 'drawing', 'food_egg', 'floor', 'desk', 'bookshelf', 'computer', 'mat', 'stereo', 'shower', 'couch', 'food_peanut_butter', 'wall', 'powersocket', 'oven', 'cup', 'doorjamb', 'mouse', 'kitchen_counter', 'pajamas', 'controller', 'door', 'clothes_scarf', 'light', 'dishwasher', 'board_game']
Task:Pull up carpet
response:
{
    "thoughts": Pry up a corner of your old dirty carpet.  Tug as hard as you can until it comes off the tacs. Pull up the pad. Try not to be sick at all the dirt.,
    "actions": ['[WALK] <home_office>', '[WALK] <mat>', '[FIND] <mat>', '[TOUCH] <mat>', '[PULL] <mat>']
}

Input:
Scene_Objects:['sponge', 'pot', 'toilet', 'dog', 'freezer', 'walllamp', 'bathroom', 'food_carrot', 'drawing', 'hanger', 'phone', 'ceiling', 'desk', 'computer', 'toaster', 'mat', 'mousepad', 'closetdrawer', 'food_peanut_butter', 'towel', 'cup', 'food_cheese', 'keys', 'tray', 'after_shave', 'towel_rack', 'mouse', 'cupboard', 'sink', 'coffee']
Task:Pet cat
response:

I walk into the living room and I pet the cat

[WALK] <home_office>
[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:['chair', 'ground_coffee', 'nail_polish', 'orchid', 'hanger', 'floor', 'ceiling', 'dvd_player', 'character', 'keyboard', 'food_cake', 'bookshelf', 'mail', 'toaster', 'plate', 'homework', 'pillow', 'dining_room', 'wall', 'bed', 'coffe_maker', 'coffee_filter', 'water', 'tray', 'curtain', 'kitchen_counter', 'cupboard', 'bathroom_cabinet', 'light', 'dishwasher']
Task:Make coffee
response:
{
    "thoughts": Open coffee maker. Put filter in main basket, put ground coffee in filter, fill reservoir with water, turn on coffee maker.,
    "actions": ['[WALK] <dining_room>', '[WALK] <coffe_maker>', '[FIND] <coffe_maker>', '[OPEN] <coffe_maker>', '[FIND] <coffee_filter>', '[GRAB] <coffee_filter>', '[PUTBACK] <coffee_filter> <coffe_maker>', '[FIND] <ground_coffee>', '[GRAB] <ground_coffee>', '[PUTBACK] <ground_coffee> <coffe_maker>', '[GRAB] <ground_coffee>', '[PUTOBJBACK] <ground_coffee>', '[WALK] <water>', '[FIND] <water>', '[GRAB] <water>', '[POUR] <water> <coffe_maker>', '[CLOSE] <coffe_maker>', '[SWITCHON] <coffe_maker>']
}

Input:
Scene_Objects:['filing_cabinet', 'tablelamp', 'freezer', 'bathroom', 'cat', 'milk', 'ceiling', 'desk', 'bedroom', 'computer', 'ceilinglamp', 'tvstand', 'faucet', 'oil', 'closetdrawer', 'clothes_pants', 'food_jam', 'broom', 'wall', 'basket_for_clothes', 'food_food', 'razor', 'tray', 'curtain', 'kitchen_counter', 'cupboard', 'laundry_detergent', 'soap', 'clothes_shirt', 'washing_machine']
Task:Wash clothes
response:

Walk to bathroom, open wash-machine, lift laundry basket, grab cloth and put into wash-machine one by one, put down laundry basket, pour detergent, close wash-machine, turn on wash-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:['pot', 'toilet', 'freezer', 'walllamp', 'drawing', 'knifeblock', 'floor', 'ceiling', 'food_chicken', 'food_cake', 'stovefan', 'mat', 'toaster', 'shower', 'food_noodles', 'oil', 'nightstand', 'wall', 'powersocket', 'oven', 'cup', 'photoframe', 'food_food', 'tray', 'doorjamb', 'kitchen_counter', 'cupboard', 'door', 'light', 'dishwasher']
Task:Cook some food
response:
{
    "thoughts": I walk in the kitchen, I open the fridge and remove the Chicken. I grab frying fan and put it on stove. I put chicken in the frying pan and I cook food.,
    "actions": ['[WALK] <dining_room>', '[WALK] <freezer>', '[FIND] <freezer>', '[OPEN] <freezer>', '[FIND] <food_chicken>', '[GRAB] <food_chicken>', '[FIND] <pot>', '[GRAB] <pot>', '[FIND] <oven>', '[PUTBACK] <pot> <oven>', '[PUTBACK] <food_chicken> <oven>']
}

Input:
Scene_Objects:['pot', 'tablelamp', 'chair', 'drawing', 'orchid', 'cpuscreen', 'floor', 'phone', 'ceiling', 'desk', 'keyboard', 'computer', 'mat', 'laptop', 'ceilinglamp', 'tvstand', 'mousepad', 'wall', 'nightstand', 'oven', 'powersocket', 'novel', 'check', 'television', 'tray', 'doorjamb', 'towel_rack', 'mouse', 'door', 'light']
Task:Read book
response:

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


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

Here is an example plan to achieve a goal for reference:
Scene_Objects:['blender', 'food_ice_cream', 'microwave', 'toilet', 'freezer', 'ceilingfan', 'knife', 'character', 'desk', 'bookshelf', 'table_cloth', 'stovefan', 'mat', 'tvstand', 'couch', 'candle', 'clothes_pants', 'food_orange', 'wall', 'nightstand', 'bench', 'tape', 'check', 'curtain', 'doorjamb', 'dishrack', 'clothes_dress', 'food_steak', 'scrabble', 'coffee']
Task:Read book
response:
{
    "thoughts": Pick up the book, open to current page, read the words.,
    "actions": ['[WALK] <home_office>', '[WALK] <novel>', '[FIND] <novel>', '[GRAB] <novel>', '[READ] <novel>']
}

Input:
Scene_Objects:['walllamp', 'drawing', 'orchid', 'wallshelf', 'cpuscreen', 'floor', 'ceiling', 'character', 'tea_bag', 'computer', 'mat', 'tvstand', 'mousepad', 'couch', 'candle', 'pillow', 'bowl', 'wall', 'oven', 'toy', 'cup', 'photoframe', 'television', 'wooden_spoon', 'curtain', 'doorjamb', 'dresser', 'laundry_detergent', 'sink', 'tooth_paste']
Task:Relax on sofa
response:

Walk to the living room, find the sofa and sit in the sofa and find pillow. lie down in sofa.

[WALK] <home_office>
[WALK] <couch>
[FIND] <couch>
[SIT] <couch>
[FIND] <pillow>
[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:['mop', 'freezer', 'trashcan', 'milk', 'knifeblock', 'orchid', 'clothes_underwear', 'bookshelf', 'purse', 'thread', 'computer', 'ceilinglamp', 'tvstand', 'iron', 'couch', 'microphone', 'wall', 'cutting_board', 'basket_for_clothes', 'keys', 'toothbrush_holder', 'oven_mitts', 'curtain', 'doorjamb', 'diary', 'chessboard', 'home_office', 'bathroom_cabinet', 'clothes_skirt', 'light']
Task:Hang up car keys
response:
{
    "thoughts": Open the front door. Enter the entrance hall. Take out car keys from purse. Hang car keys up on hook on the wall.,
    "actions": ['[WALK] <home_office>', '[WALK] <purse>', '[FIND] <purse>', '[OPEN] <purse>', '[FIND] <keys>', '[GRAB] <keys>', '[CLOSE] <purse>']
}

Input:
Scene_Objects:['filing_cabinet', 'tablelamp', 'band-aids', 'nail_polish', 'toothbrush', 'drawing', 'bathroom_counter', 'phone', 'food_cake', 'ceilinglamp', 'shoe-shine_kit', 'mousepad', 'closetdrawer', 'dining_room', 'wall_clock', 'food_cheese', 'newspaper', 'novel', 'television', 'coffee_filter', 'tray', 'after_shave', 'rag', 'centerpiece', 'curtain', 'console', 'kitchen_counter', 'clothes_dress', 'bathroom_cabinet', 'dishwasher']
Task:Read book
response:

walk to living room ,find a book ,open the book ,read the book

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


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

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

Input:
Scene_Objects:['tablelamp', 'chair', 'walllamp', 'detergent', 'drawing', 'orchid', 'cpuscreen', 'wallshelf', 'hanger', 'floor', 'ceiling', 'phone', 'desk', 'keyboard', 'computer', 'mat', 'ceilinglamp', 'tvstand', 'mousepad', 'couch', 'pillow', 'wall', 'nightstand', 'television', 'razor', 'food_onion', 'doorjamb', 'mouse', 'dresser', 'door']
Task:Browse internet
response:

I walk in the living room, find the computer and sit down on a chair. I turn on the computer. I grab the computer mouse.

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


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', 'food_salt', 'bathroom', 'ceilingfan', 'drawing', 'floor', 'ceiling', 'desk', 'brush', 'ceilinglamp', 'tvstand', 'balanceball', 'faucet', 'window', 'couch', 'clothes_pants', 'dining_room', 'wall', 'toy', 'basket_for_clothes', 'bed', 'television', 'coin', 'coffee_filter', 'food_rice', 'curtain', 'cupboard', 'controller', 'table', 'dishwasher']
Task:Watch TV
response:
{
    "thoughts": Watch TV in the living room.,
    "actions": ['[WALK] <home_office>', '[WALK] <television>', '[FIND] <television>', '[SWITCHON] <television>', '[TURNTO] <television>', '[WATCH] <television>']
}

Input:
Scene_Objects:['filing_cabinet', 'toilet', 'dog', 'cat', 'drawing', 'wallshelf', 'ceiling', 'folder', 'character', 'cleaning_solution', 'envelope', 'computer', 'brush', 'toaster', 'iron', 'mousepad', 'closetdrawer', 'couch', 'bed', 'photoframe', 'novel', 'coffe_maker', 'centerpiece', 'hair', 'cupboard', 'sink', 'home_office', 'light', 'dirt', 'hands_both']
Task:Wash hands
response:

walk to bathroom , find cleaning solution , squeeze cleaning solution , wash hands

[WALK] <bathroom>
[WALK] <cleaning_solution>
[FIND] <cleaning_solution>
[SQUEEZE] <cleaning_solution>
[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:['filing_cabinet', 'microwave', 'chair', 'walllamp', 'nail_polish', 'knifeblock', 'drawing', 'cpuscreen', 'wallshelf', 'bathroom_counter', 'desk', 'cleaning_solution', 'bookshelf', 'stovefan', 'mat', 'tvstand', 'shower', 'faucet', 'ceilinglamp', 'pillow', 'bench', 'cup', 'mouse', 'controller', 'laundry_detergent', 'door', 'napkin', 'light', 'dirt', 'hands_both']
Task:Wash hands
response:
{
    "thoughts": walk to bathroom , find cleaning solution , squeeze cleaning solution , wash hands,
    "actions": ['[WALK] <bathroom>', '[WALK] <cleaning_solution>', '[FIND] <cleaning_solution>', '[SQUEEZE] <cleaning_solution>', '[FIND] <hands_both>', '[WASH] <hands_both>']
}

Input:
Scene_Objects:['filing_cabinet', 'detergent', 'cat', 'drawing', 'bills', 'wallshelf', 'cpuscreen', 'phone', 'character', 'shower', 'food_orange', 'form', 'pillow', 'nightstand', 'photoframe', 'food_food', 'tray', 'lighter', 'shaving_cream', 'mouse', 'towel_rack', 'dishrack', 'laundry_detergent', 'spoon', 'bathroom_cabinet', 'light', 'home_office', 'soap', 'instrument_violin', 'shoe_rack']
Task:Pet cat
response:

[WALK] <home_office>
[WALK] <cat>
[FIND] <cat>
[WALK] <cat>
[TURNTO] <cat>
[LOOKAT] <cat>
[TOUCH] <cat>
[TOUCH] <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:['pot', 'filing_cabinet', 'tablelamp', 'chair', 'cpuscreen', 'wallshelf', 'hanger', 'floor', 'phone', 'bedroom', 'button', 'plate', 'dish_soap', 'wall', 'nightstand', 'food_cheese', 'photoframe', 'newspaper', 'coffe_maker', 'check', 'tray', 'kettle', 'pencil', 'kitchen_counter', 'comb', 'cupboard', 'door', 'table', 'dishwasher', 'light']
Task:Wash dishes with dishwasher
response:
{
    "thoughts": Go to kitchen to put dirty dishs into dishwasher with soap to clean the dirty dishes,
    "actions": ['[WALK] <dining_room>', '[WALK] <dishwasher>', '[FIND] <dishwasher>', '[OPEN] <dishwasher>', '[FIND] <plate>', '[GRAB] <plate>', '[PUTBACK] <plate> <dishwasher>', '[FIND] <plate>', '[GRAB] <plate>', '[PUTBACK] <plate> <dishwasher>', '[FIND] <plate>', '[GRAB] <plate>', '[PUTBACK] <plate> <dishwasher>', '[FIND] <plate>', '[GRAB] <plate>', '[PUTBACK] <plate> <dishwasher>', '[FIND] <plate>', '[GRAB] <plate>', '[PUTBACK] <plate> <dishwasher>', '[FIND] <dish_soap>', '[GRAB] <dish_soap>', '[PUTBACK] <dish_soap> <dishwasher>', '[CLOSE] <dishwasher>', '[SWITCHON] <dishwasher>']
}

Input:
Scene_Objects:['filing_cabinet', 'blender', 'food_salt', 'chair', 'walllamp', 'drawing', 'orchid', 'wallshelf', 'hanger', 'floor', 'ceiling', 'desk', 'remote_control', 'envelope', 'computer', 'mat', 'tvstand', 'ceilinglamp', 'shower', 'closetdrawer', 'couch', 'pillow', 'wall', 'photoframe', 'mouthwash', 'television', 'doorjamb', 'centerpiece', 'dresser', 'soap']
Task:Watch TV
response:

Walk to living room. Sit on the sofa. Grab the remote control and plug in TV.

[WALK] <home_office>
[WALK] <couch>
[FIND] <couch>
[SIT] <couch>
[FIND] <remote_control>
[GRAB] <remote_control>
[FIND] <television>
[PLUGIN] <television>


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

Here is an example plan to achieve a goal for reference:
Scene_Objects:['fork', 'dry_pasta', 'filing_cabinet', 'scissors', 'kitchen_cabinet', 'envelope', 'faucet', 'dish_soap', 'mousepad', 'couch', 'pillow', 'dining_room', 'wall_clock', 'bench', 'toy', 'cutting_board', 'razor', 'food_onion', 'doorjamb', 'towel_rack', 'kitchen_counter', 'pajamas', 'clothes_dress', 'bathtub', 'sink', 'bathroom_cabinet', 'table', 'dishwasher', 'vase', 'light']
Task:Wash dishes with dishwasher
response:
{
    "thoughts": I walk to the kitchen. I open the dishwasher. I open the kitchen cabinet. I reach inside the cabinet and grab the box of dish soap. I add some soap to the open dishwasher. I put the box of dish soap back in the kitchen cabinet. I close the kitchen cabinet and then I close the dishwasher. I turn the dishwasher on and wait.,
    "actions": ['[WALK] <dining_room>', '[WALK] <dishwasher>', '[FIND] <dishwasher>', '[OPEN] <dishwasher>', '[FIND] <kitchen_cabinet>', '[OPEN] <kitchen_cabinet>', '[FIND] <dish_soap>', '[GRAB] <dish_soap>', '[PUTBACK] <dish_soap> <dishwasher>', '[GRAB] <dish_soap>', '[PUTIN] <dish_soap> <kitchen_cabinet>', '[CLOSE] <kitchen_cabinet>', '[CLOSE] <dishwasher>', '[SWITCHON] <dishwasher>']
}

Input:
Scene_Objects:['walllamp', 'drawing', 'orchid', 'wallshelf', 'floor', 'ceiling', 'bedroom', 'computer', 'stovefan', 'mat', 'tvstand', 'iron', 'ceilinglamp', 'oil', 'couch', 'dustpan', 'pillow', 'wall', 'photoframe', 'food_food', 'television', 'wooden_spoon', 'curtain', 'doorjamb', 'dresser', 'pajamas', 'hairdryer', 'light', 'soap', 'dirt']
Task:Relax on sofa
response:

Walk into the living room. Walk to the sofa and sit on it. Put your feet up on the sofa and lay down.

[WALK] <home_office>
[WALK] <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:['spectacles', 'sponge', 'food_bread', 'blender', 'chair', 'walllamp', 'orchid', 'knife', 'cpuscreen', 'floor', 'ceiling', 'desk', 'keyboard', 'bookshelf', 'computer', 'ceilinglamp', 'mat', 'tvstand', 'window', 'mousepad', 'clothes_socks', 'wall', 'oven', 'cup', 'television', 'mouse', 'cupboard', 'door', 'home_office', 'table']
Task:Browse internet
response:
{
    "thoughts": go to the office, turn computer on, open an browser or any application to open any website.,
    "actions": ['[WALK] <home_office>', '[WALK] <computer>', '[FIND] <computer>', '[SWITCHON] <computer>', '[FIND] <computer>']
}

Input:
Scene_Objects:['spectacles', 'pot', 'filing_cabinet', 'tablelamp', 'food_salt', 'microwave', 'chair', 'bathroom', 'detergent', 'tea_bag', 'keyboard', 'ceilinglamp', 'plate', 'dining_room', 'food_kiwi', 'nightstand', 'powersocket', 'basket_for_clothes', 'check', 'mouthwash', 'doorjamb', 'towel_rack', 'hairbrush', 'pajamas', 'door', 'home_office', 'table', 'soap', 'washing_machine', 'shoe_rack']
Task:Wash clothes
response:

put clothes and soap in the washing machine, turn it on

[WALK] <dining_room>
[WALK] <washing_machine>
[FIND] <washing_machine>
[FIND] <basket_for_clothes>
[OPEN] <basket_for_clothes>
[FIND] <soap>
[GRAB] <soap>
[OPEN] <washing_machine>
[PUTBACK] <soap> <washing_machine>
[CLOSE] <washing_machine>
[SWITCHON] <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:['tablelamp', 'freezer', 'walllamp', 'bills', 'drawing', 'cpuscreen', 'bathroom_counter', 'floor', 'character', 'bookshelf', 'ceilinglamp', 'tvstand', 'shower', 'mat', 'closetdrawer', 'dining_room', 'wall', 'powersocket', 'oven', 'coffe_maker', 'tray', 'curtain', 'coffee_pot', 'towel_rack', 'mouse', 'kitchen_counter', 'dresser', 'door', 'bathtub', 'hairdryer']
Task:Answer door
response:
{
    "thoughts": Walk up to the door.  Open the door and greet whomever is out side,
    "actions": ['[WALK] <home_office>', '[WALK] <man>', '[FIND] <man>', '[GREET] <man>']
}

Input:
Scene_Objects:['sponge', 'scissors', 'chair', 'clothes_underwear', 'floor', 'ceiling', 'phone', 'mail', 'bookmark', 'toaster', 'mat', 'plate', 'faucet', 'shower', 'dish_soap', 'bowl', 'wall', 'basket_for_clothes', 'coffe_maker', 'food_food', 'curtain', 'doorjamb', 'kettle', 'kitchen_counter', 'dishrack', 'dresser', 'cupboard', 'sink', 'spoon', 'table']
Task:Wash dishes by hand
response:

I enter the kitchen, walk to the sink, turn on the faucet, grab the sponge and get it wet, then apply dish soap to the sponge. I take a dish, scrub it with the sponge, rinse it, and place it on the dish rack to dry, and repeat until all the dishes are clean. I rinse the sponge, put it down, and turn off the faucet.

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


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

Here is an example plan to achieve a goal for reference:
Scene_Objects:['food_bread', 'tablelamp', 'food_ice_cream', 'freezer', 'bathroom', 'orchid', 'bills', 'cpuscreen', 'bathroom_counter', 'floor', 'phone', 'stereo', 'closetdrawer', 'nightstand', 'oven', 'photoframe', 'clothes_gloves', 'toilet_paper', 'video_game_controller', 'television', 'doorjamb', 'mouse', 'cupboard', 'controller', 'door', 'spoon', 'bathroom_cabinet', 'light', 'dishwasher', 'instrument_violin']
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:['pot', 'walllamp', 'blow_dryer', 'drawing', 'wallshelf', 'floor', 'ceiling', 'bookshelf', 'keyboard', 'computer', 'clothes_jacket', 'mat', 'tvstand', 'shower', 'mousepad', 'couch', 'pillow', 'wall', 'photoframe', 'novel', 'food_food', 'television', 'doorjamb', 'towel_rack', 'kitchen_counter', 'cupboard', 'sink', 'coffee_cup', 'table', 'board_game']
Task:Relax on sofa
response:

you walk to the living room, open the door, find a comfy sofa, sit on it, read a book or sip a cup of coffee and relax.

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


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

Here is an example plan to achieve a goal for reference:
Scene_Objects:['beer', 'microwave', 'drawing', 'floor', 'purse', 'computer', 'plate', 'balanceball', 'shower', 'stereo', 'dustpan', 'clothes_hat', 'microphone', 'bench', 'basket_for_clothes', 'cup', 'bed', 'check', 'coffe_maker', 'food_onion', 'after_shave', 'cards', 'pencil', 'chessboard', 'maindoor', 'napkin', 'table', 'board_game', 'clothes_shirt', 'coffee']
Task:Set up table
response:
{
    "thoughts": Get dishes. Place dishes neatly around table. Get food. Place food on middle of table.,
    "actions": ['[WALK] <dining_room>', '[WALK] <plate>', '[FIND] <plate>', '[GRAB] <plate>', '[WALK] <dining_room>', '[WALK] <table>', '[PUTBACK] <plate> <table>', '[WALK] <dining_room>', '[WALK] <plate>', '[FIND] <plate>', '[GRAB] <plate>', '[WALK] <dining_room>', '[WALK] <table>', '[PUTBACK] <plate> <table>', '[WALK] <dining_room>', '[WALK] <plate>', '[FIND] <plate>', '[GRAB] <plate>', '[WALK] <dining_room>', '[WALK] <table>', '[PUTBACK] <plate> <table>', '[WALK] <dining_room>', '[WALK] <food_food>', '[FIND] <food_food>', '[GRAB] <food_food>', '[WALK] <dining_room>', '[WALK] <table>', '[PUTBACK] <food_food> <table>', '[WALK] <dining_room>', '[WALK] <food_food>', '[FIND] <food_food>', '[GRAB] <food_food>', '[WALK] <dining_room>', '[WALK] <table>', '[PUTBACK] <food_food> <table>']
}

Input:
Scene_Objects:['chair', 'walllamp', 'drawing', 'wallshelf', 'hanger', 'floor', 'ceiling', 'phone', 'desk', 'remote_control', 'computer', 'clothes_jacket', 'mat', 'tvstand', 'ceilinglamp', 'picture', 'mousepad', 'closetdrawer', 'couch', 'pillow', 'wall', 'photoframe', 'check', 'television', 'ice', 'doorjamb', 'towel_rack', 'mouse', 'dresser', 'table']
Task:Change TV channel
response:

walk to living room.grab remote control. look at television. switch on television. lift remote control. push remote control. watch television. switch off television. put back remote control.

[WALK] <home_office>
[WALK] <remote_control>
[FIND] <remote_control>
[GRAB] <remote_control>
[FIND] <television>
[TURNTO] <television>
[LOOKAT] <television>
[SWITCHON] <television>
[PUSH] <remote_control>
[WATCH] <television>
[SWITCHOFF] <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', 'juice', 'microwave', 'freezer', 'blow_dryer', 'ground_coffee', 'cat', 'floor', 'legs_both', 'face', 'toaster', 'laptop', 'homework', 'closetdrawer', 'towel', 'feet_both', 'arms_both', 'basket_for_clothes', 'newspaper', 'photoframe', 'coffe_maker', 'mouthwash', 'centerpiece', 'doorjamb', 'headset', 'dresser', 'cupboard', 'napkin', 'soap', 'clothes_shirt']
Task:Try yourself off
response:
{
    "thoughts": After your shower, go into your bedroom and use a towel to dry water off of yourself before dressing.,
    "actions": ['[WALK] <bedroom>', '[WALK] <dresser>', '[FIND] <dresser>', '[OPEN] <dresser>', '[FIND] <towel>', '[GRAB] <towel>', '[CLOSE] <dresser>', '[FIND] <face>', '[WIPE] <face>', '[FIND] <arms_both>', '[WIPE] <arms_both>', '[FIND] <legs_both>', '[WIPE] <legs_both>', '[FIND] <feet_both>', '[WIPE] <feet_both>', '[FIND] <basket_for_clothes>', '[PUTBACK] <towel> <basket_for_clothes>']
}

Input:
Scene_Objects:['filing_cabinet', 'tablelamp', 'chair', 'dough', 'wallshelf', 'hanger', 'floor', 'phone', 'folder', 'desk', 'tea_bag', 'mousepad', 'closetdrawer', 'couch', 'dustpan', 'pillow', 'bed', 'television', 'toothbrush_holder', 'food_onion', 'curtain', 'lighter', 'diary', 'cd', 'dresser', 'controller', 'sink', 'table', 'light', 'dishwasher']
Task:Pick up phone
response:

Walk to home office 1. Walk over to phone 1 on table 1.  Grab phone 1.  lift phone 1.

[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:['walllamp', 'toothbrush', 'wallshelf', 'cpuscreen', 'bathroom_counter', 'floor', 'phone', 'bedroom', 'thread', 'stovefan', 'mat', 'ceilinglamp', 'faucet', 'plate', 'dining_room', 'wall', 'wall_clock', 'oven', 'toothbrush_holder', 'tray', 'doorjamb', 'towel_rack', 'chessboard', 'dresser', 'door', 'sink', 'bathroom_cabinet', 'clothes_skirt', 'tooth_paste', 'teeth']
Task:Brush teeth
response:
{
    "thoughts": getting ready for bed,
    "actions": ['[WALK] <bathroom_counter>', '[FIND] <toothbrush>', '[GRAB] <toothbrush>', '[PUTBACK] <toothbrush> <bathroom_counter>', '[FIND] <tooth_paste>', '[SQUEEZE] <tooth_paste>', '[GRAB] <toothbrush>', '[SCRUB] <toothbrush>', '[RINSE] <toothbrush>', '[FIND] <toothbrush_holder>', '[PUTBACK] <toothbrush> <toothbrush_holder>']
}

Input:
Scene_Objects:['fork', 'chair', 'walllamp', 'drawing', 'wallshelf', 'hanger', 'floor', 'ceiling', 'desk', 'remote_control', 'envelope', 'computer', 'button', 'food_bacon', 'table_cloth', 'mat', 'tvstand', 'ceilinglamp', 'shoe-shine_kit', 'closetdrawer', 'couch', 'pillow', 'dining_room', 'wall', 'cup', 'photoframe', 'television', 'doorjamb', 'dresser', 'dirt']
Task:Change TV channel
response:

Pickup remote control for the living room TV and push the change channel button

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


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

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

Input:
Scene_Objects:['sponge', 'pot', 'microwave', 'dog', 'detergent', 'knife', 'bathroom_counter', 'floor', 'toaster', 'tvstand', 'shower', 'faucet', 'dish_soap', 'mousepad', 'closetdrawer', 'couch', 'wall', 'nightstand', 'photoframe', 'coffe_maker', 'oven_mitts', 'wine', 'tray', 'centerpiece', 'kitchen_counter', 'dresser', 'cupboard', 'clothes_dress', 'door', 'dishwasher']
Task:Wash dishes with dishwasher
response:

walk to kitchen, find the dishwasher, apply dish soap into vessels or dishwasher, wash the dishes with a dishwasher

[WALK] <dining_room>
[WALK] <dishwasher>
[FIND] <dishwasher>
[FIND] <dish_soap>
[GRAB] <dish_soap>
[OPEN] <dishwasher>
[PUTBACK] <dish_soap> <dishwasher>
[WASH] <dishwasher>


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

Here is an example plan to achieve a goal for reference:
Scene_Objects:['food_salt', 'chair', 'ground_coffee', 'drawing', 'orchid', 'cpuscreen', 'phone', 'bedroom', 'stamp', 'desk', 'bookshelf', 'computer', 'stovefan', 'ceilinglamp', 'tvstand', 'mat', 'nightstand', 'wall', 'oven', 'wall_clock', 'photoframe', 'coffe_maker', 'mouse', 'dresser', 'cupboard', 'bathtub', 'sink', 'home_office', 'table', 'light']
Task:Pet cat
response:
{
    "thoughts": You walk to the living room and find the cat. You look at the cat and touch it to pet it.,
    "actions": ['[WALK] <home_office>', '[WALK] <cat>', '[FIND] <cat>', '[TURNTO] <cat>', '[LOOKAT] <cat>', '[TOUCH] <cat>']
}

Input:
Scene_Objects:['tablelamp', 'chair', 'walllamp', 'drawing', 'wallshelf', 'hanger', 'floor', 'ceiling', 'desk', 'remote_control', 'computer', 'mat', 'tvstand', 'ceilinglamp', 'shower', 'closetdrawer', 'couch', 'food_orange', 'pillow', 'food_kiwi', 'wall', 'photoframe', 'newspaper', 'television', 'food_donut', 'food_rice', 'doorjamb', 'mouse', 'cd', 'dresser']
Task:Watch TV
response:

[WALK] <home_office>
[WALK] <television>
[FIND] <television>
[SWITCHON] <television>
[FIND] <remote_control>
[TOUCH] <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:['sheets', 'tablelamp', 'microwave', 'chair', 'bathroom', 'orchid', 'drawing', 'bathroom_counter', 'floor', 'phone', 'character', 'computer', 'toaster', 'mat', 'tvstand', 'couch', 'clothes_hat', 'pillow', 'wall', 'wall_clock', 'bench', 'powersocket', 'cup', 'bed', 'food_food', 'television', 'mouse', 'pencil', 'bathroom_cabinet', 'table']
Task:Set up table
response:
{
    "thoughts": walk to entrance hall. find a table. pull table. walk to living rook. push table.,
    "actions": ['[WALK] <home_office>', '[WALK] <table>', '[FIND] <table>', '[PULL] <table>', '[WALK] <home_office>', '[WALK] <table>', '[PUSH] <table>']
}

Input:
Scene_Objects:['fork', 'chair', 'walllamp', 'drawing', 'wallshelf', 'hanger', 'floor', 'ceiling', 'desk', 'remote_control', 'computer', 'mat', 'tvstand', 'ceilinglamp', 'closetdrawer', 'couch', 'form', 'pillow', 'wall', 'pasta', 'powersocket', 'photoframe', 'television', 'food_donut', 'curtain', 'doorjamb', 'chessboard', 'dresser', 'laundry_detergent', 'table']
Task:Watch TV
response:

walk to living room, find couch, sit on couch, find remote control , turn on tv by pressing button

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


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

Here is an example plan to achieve a goal for reference:
Scene_Objects:['pot', 'microwave', 'freezer', 'walllamp', 'orchid', 'wallshelf', 'floor', 'ceiling', 'character', 'bedroom', 'mail', 'stovefan', 'faucet', 'stereo', 'couch', 'wall', 'oven', 'cutting_board', 'bed', 'newspaper', 'coffe_maker', 'food_food', 'tray', 'lighter', 'doorjamb', 'kitchen_counter', 'home_office', 'bathroom_cabinet', 'vase', 'soap']
Task:Put groceries in Fridge
response:
{
    "thoughts": Walk to kitchen. Open fridge. Put groceries in fridge.,
    "actions": ['[WALK] <freezer>', '[OPEN] <freezer>', '[FIND] <food_food>', '[GRAB] <food_food>', '[PUTIN] <food_food> <freezer>', '[CLOSE] <freezer>']
}

Input:
Scene_Objects:['tablelamp', 'crayon', 'jelly', 'freezer', 'bathroom', 'drawing', 'bathroom_counter', 'floor', 'ceiling', 'phone', 'food_cake', 'mop_bucket', 'stovefan', 'mat', 'ceilinglamp', 'closetdrawer', 'couch', 'pillow', 'broom', 'wall', 'food_food', 'television', 'wine', 'tray', 'kitchen_counter', 'cupboard', 'home_office', 'table', 'light', 'clothes_skirt']
Task:Put groceries in Fridge
response:

Go to kitchen, open fridge, get groceries, put groceries in fridge, close 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:['spectacles', 'pot', 'walllamp', 'nail_polish', 'knifeblock', 'kitchen_cabinet', 'floor', 'ceiling', 'bookshelf', 'computer', 'faucet', 'oil', 'dining_room', 'wall', 'nightstand', 'oven', 'powersocket', 'toy', 'cup', 'coffee_filter', 'shaving_cream', 'kitchen_counter', 'dresser', 'cupboard', 'door', 'sink', 'home_office', 'table', 'dishwasher', 'bathroom_cabinet']
Task:Get glass of water
response:
{
    "thoughts": Get a glass from a cabinet. Hold it under the sink and turn the cold water on. Fill the glass. Turn off the water.,
    "actions": ['[WALK] <dining_room>', '[WALK] <kitchen_cabinet>', '[FIND] <kitchen_cabinet>', '[OPEN] <kitchen_cabinet>', '[FIND] <cup>', '[GRAB] <cup>', '[CLOSE] <kitchen_cabinet>', '[WALK] <sink>', '[FIND] <faucet>', '[SWITCHON] <faucet>', '[PUTBACK] <cup> <sink>', '[GRAB] <cup>', '[SWITCHOFF] <faucet>']
}

Input:
Scene_Objects:['filing_cabinet', 'freezer', 'walllamp', 'drawing', 'orchid', 'wallshelf', 'floor', 'ceiling', 'bedroom', 'computer', 'mop_bucket', 'toaster', 'mat', 'tvstand', 'stereo', 'shower', 'deck_of_cards', 'homework', 'electric_shaver', 'closetdrawer', 'couch', 'pillow', 'wall', 'photoframe', 'newspaper', 'television', 'doorjamb', 'cd', 'bathroom_cabinet', 'teeth']
Task:Listen to music
response:

Walk to living room. Walk to radio. Switch on the radio. Walk to sofa and sit on it.

[WALK] <home_office>
[WALK] <stereo>
[SWITCHON] <stereo>
[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:['dry_pasta', 'filing_cabinet', 'beer', 'chair', 'bills', 'knife', 'hanger', 'bathroom_counter', 'floor', 'computer', 'stovefan', 'mat', 'tvstand', 'window', 'couch', 'pillow', 'towel', 'dining_room', 'food_kiwi', 'wall', 'toy', 'photoframe', 'novel', 'coffe_maker', 'television', 'curtain', 'doorjamb', 'coffee_pot', 'bag', 'table']
Task:Read book
response:
{
    "thoughts": Sit on couch. Grab book. Open book. Read book.,
    "actions": ['[WALK] <couch>', '[SIT] <couch>', '[FIND] <novel>', '[GRAB] <novel>', '[READ] <novel>']
}

Input:
Scene_Objects:['fork', 'pot', 'spectacles', 'tablelamp', 'chair', 'walllamp', 'bills', 'drawing', 'wallshelf', 'cpuscreen', 'orchid', 'hanger', 'floor', 'ceiling', 'phone', 'desk', 'bookshelf', 'keyboard', 'computer', 'mat', 'ceilinglamp', 'tvstand', 'mousepad', 'couch', 'pillow', 'wall', 'nightstand', 'powersocket', 'oven', 'check', 'television', 'tray', 'doorjamb', 'towel_rack', 'mouse', 'kitchen_counter', 'dresser', 'door', 'light']
Task:Write an email
response:

I walk into my office and go to the computer desk. I sit at my desk and turn the computer on. Then I write an email.

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


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

Here is an example plan to achieve a goal for reference:
Scene_Objects:['pot', 'chair', 'walllamp', 'trashcan', 'knifeblock', 'floor', 'character', 'computer', 'table_cloth', 'toaster', 'plate', 'faucet', 'dish_soap', 'wall', 'oven', 'bench', 'cup', 'coffe_maker', 'food_food', 'television', 'wine', 'tray', 'pencil', 'kitchen_counter', 'dresser', 'cupboard', 'sink', 'home_office', 'dishwasher', 'vase']
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:['fork', 'water_glass', 'pot', 'tablelamp', 'microwave', 'drawing', 'knife', 'food_egg', 'bathroom_counter', 'floor', 'ceiling', 'desk', 'toaster', 'stovefan', 'plate', 'shower', 'dish_soap', 'mousepad', 'wall', 'oven', 'photoframe', 'coffe_maker', 'tray', 'towel_rack', 'kitchen_counter', 'cupboard', 'spoon', 'coffee_cup', 'dishwasher', 'light']
Task:Wash dishes with dishwasher
response:

I go to the kitchen and put plates, cutlery and glasses into the dishwasher, put the soap, close the machine and switch it on.

[WALK] <dining_room>
[WALK] <dishwasher>
[FIND] <dishwasher>
[OPEN] <dishwasher>
[FIND] <coffee_cup>
[GRAB] <coffee_cup>
[PUTBACK] <coffee_cup> <dishwasher>
[FIND] <coffee_cup>
[GRAB] <coffee_cup>
[PUTBACK] <coffee_cup> <dishwasher>
[FIND] <pot>
[GRAB] <pot>
[PUTBACK] <pot> <dishwasher>
[FIND] <pot>
[GRAB] <pot>
[PUTBACK] <pot> <dishwasher>
[FIND] <fork>
[GRAB] <fork>
[PUTBACK] <fork> <dishwasher>
[FIND] <fork>
[GRAB] <fork>
[PUTBACK] <fork> <dishwasher>
[FIND] <knife>
[GRAB] <knife>
[PUTBACK] <knife> <dishwasher>
[FIND] <knife>
[GRAB] <knife>
[PUTBACK] <knife> <dishwasher>
[FIND] <plate>
[GRAB] <plate>
[PUTBACK] <plate> <dishwasher>
[FIND] <plate>
[GRAB] <plate>
[PUTBACK] <plate> <dishwasher>
[FIND] <spoon>
[GRAB] <spoon>
[PUTBACK] <spoon> <dishwasher>
[FIND] <spoon>
[GRAB] <spoon>
[PUTBACK] <spoon> <dishwasher>
[FIND] <water_glass>
[GRAB] <water_glass>
[PUTBACK] <water_glass> <dishwasher>
[FIND] <water_glass>
[GRAB] <water_glass>
[PUTBACK] <water_glass> <dishwasher>
[FIND] <dish_soap>
[GRAB] <dish_soap>
[PUTBACK] <dish_soap> <dishwasher>
[CLOSE] <dishwasher>
[SWITCHON] <dishwasher>


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

Here is an example plan to achieve a goal for reference:
Scene_Objects:['toilet', 'walllamp', 'drawing', 'orchid', 'knifeblock', 'bathroom_counter', 'floor', 'ceiling', 'table_cloth', 'mat', 'ceilinglamp', 'shower', 'plate', 'wall', 'nightstand', 'powersocket', 'food_cheese', 'bed', 'coffe_maker', 'tray', 'curtain', 'towel_rack', 'dresser', 'controller', 'clothes_scarf', 'home_office', 'bathroom_cabinet', 'board_game', 'scrabble', 'teeth']
Task:Take shower
response:
{
    "thoughts": walk to bathroom , find shower , take a shower,
    "actions": ['[WALK] <bathroom>', '[WALK] <shower>', '[FIND] <shower>']
}

Input:
Scene_Objects:['water_glass', 'pot', 'tablelamp', 'food_carrot', 'toothbrush', 'drawing', 'wallshelf', 'kitchen_cabinet', 'floor', 'keyboard', 'alcohol', 'stovefan', 'tvstand', 'closetdrawer', 'couch', 'pillow', 'dining_room', 'nightstand', 'wall', 'powersocket', 'box', 'keys', 'coffe_maker', 'water', 'tray', 'kitchen_counter', 'clothes_dress', 'sink', 'bathroom_cabinet', 'board_game']
Task:Drink
response:

Go to kitchen. Open the the cabinet. Locate the water glass. Pour water into glass. Drag the bottle close to mouth. Drink water.

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


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

Here is an example plan to achieve a goal for reference:
Scene_Objects:['sheets', 'sponge', 'crayon', 'microwave', 'walllamp', 'bathroom', 'drawing', 'clothes_underwear', 'floor', 'bookshelf', 'button', 'stovefan', 'mat', 'stereo', 'mousepad', 'clothes_hat', 'bowl', 'nightstand', 'wall', 'bed', 'photoframe', 'light_bulb', 'food_food', 'television', 'kitchen_counter', 'dresser', 'door', 'sink', 'clothes_skirt', 'scrabble']
Task:Breakfast
response:
{
    "thoughts": I have breakfast in bed, watching tv.,
    "actions": ['[WALK] <dining_room>', '[WALK] <food_food>', '[GRAB] <food_food>', '[WALK] <bedroom>', '[WALK] <television>', '[SWITCHON] <television>', '[WALK] <bed>', '[LIE] <bed>', '[TURNTO] <television>', '[WATCH] <television>', '[EAT] <food_food>']
}

Input:
Scene_Objects:['fork', 'pot', 'filing_cabinet', 'microwave', 'chair', 'jelly', 'bathroom', 'detergent', 'knife', 'floor', 'toaster', 'mat', 'plate', 'shower', 'faucet', 'dish_soap', 'bowl', 'wall', 'cup', 'coffe_maker', 'food_food', 'after_shave', 'kitchen_counter', 'cupboard', 'hair', 'sink', 'spoon', 'home_office', 'table', 'dishwasher']
Task:Wash dishes with dishwasher
response:

I walk to the kitchen and find the dishwasher. I open it. I find the sink and grab the dirty plates, cups, bowls, and utensils. I rinse off the dirty dishes under the faucet. I then place the dirty dishes into the dishwasher. I add soap to the dishwasher and close the lid. I turn it on and wait.

[WALK] <dining_room>
[WALK] <dishwasher>
[FIND] <dishwasher>
[OPEN] <dishwasher>
[FIND] <sink>
[FIND] <bowl>
[GRAB] <bowl>
[RINSE] <bowl>
[PUTBACK] <bowl> <dishwasher>
[FIND] <cup>
[GRAB] <cup>
[RINSE] <cup>
[PUTBACK] <cup> <dishwasher>
[FIND] <fork>
[GRAB] <fork>
[RINSE] <fork>
[PUTBACK] <fork> <dishwasher>
[FIND] <knife>
[GRAB] <knife>
[RINSE] <knife>
[PUTBACK] <knife> <dishwasher>
[FIND] <plate>
[GRAB] <plate>
[RINSE] <plate>
[PUTBACK] <plate> <dishwasher>
[FIND] <spoon>
[GRAB] <spoon>
[RINSE] <spoon>
[PUTBACK] <spoon> <dishwasher>
[FIND] <dish_soap>
[GRAB] <dish_soap>
[PUTBACK] <dish_soap> <dishwasher>
[CLOSE] <dishwasher>
[TURNTO] <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:['sponge', 'tablelamp', 'microwave', 'chair', 'walllamp', 'trashcan', 'food_butter', 'orchid', 'floor', 'dvd_player', 'desk', 'toaster', 'tvstand', 'oil', 'wall', 'bench', 'basket_for_clothes', 'photoframe', 'coffe_maker', 'razor', 'wooden_spoon', 'curtain', 'coffee_pot', 'mouse', 'pencil', 'kitchen_counter', 'dishrack', 'cupboard', 'spoon', 'dishwasher']
Task:Wash dishes by hand
response:
{
    "thoughts": walk to kitchen , find dish washer , wash the dishe rack , put dishes in dish washer , switch on dish washer,
    "actions": ['[WALK] <dining_room>', '[WALK] <dishwasher>', '[FIND] <dishwasher>', '[FIND] <dishrack>', '[FIND] <dishrack>', '[GRAB] <dishrack>', '[FIND] <dishwasher>', '[OPEN] <dishwasher>', '[PUTBACK] <dishrack> <dishwasher>', '[SWITCHON] <dishwasher>']
}

Input:
Scene_Objects:['sheets', 'microwave', 'chair', 'cat', 'dough', 'bathroom_counter', 'phone', 'bookshelf', 'ceilinglamp', 'tvstand', 'stereo', 'candle', 'bowl', 'dining_room', 'wall', 'newspaper', 'coffe_maker', 'food_food', 'coffee_filter', 'tray', 'curtain', 'diary', 'towel_rack', 'pencil', 'dresser', 'food_steak', 'sink', 'napkin', 'door', 'dishwasher']
Task:Pick up phone
response:

I'll enter the location containing the phone. Once there, I'll locate the phone, and move close to it. I'll then use my hand to pick up the phone such that I can then use it.

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


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

Here is an example plan to achieve a goal for reference:
Scene_Objects:['pot', 'tablelamp', 'chair', 'walllamp', 'drawing', 'orchid', 'cpuscreen', 'wallshelf', 'hanger', 'floor', 'ceiling', 'phone', 'desk', 'keyboard', 'computer', 'mat', 'ceilinglamp', 'tvstand', 'mousepad', 'couch', 'pillow', 'wall', 'nightstand', 'oven', 'powersocket', 'check', 'television', 'tray', 'doorjamb', 'towel_rack', 'mouse', 'dresser', 'door', 'light']
Task:Work
response:
{
    "thoughts": I have my desktop computer set up on my desk and complete the paperwork I brought home with me from work.,
    "actions": ['[WALK] <home_office>', '[WALK] <chair>', '[FIND] <chair>', '[SIT] <chair>', '[FIND] <computer>', '[SWITCHON] <computer>', '[FIND] <check>', '[GRAB] <check>', '[READ] <check>', '[FIND] <desk>', '[OPEN] <desk>', '[PUTBACK] <check> <desk>', '[FIND] <keyboard>', '[TYPE] <keyboard>']
}

Input:
Scene_Objects:['pot', 'food_pizza', 'filing_cabinet', 'blender', 'toilet', 'drawing', 'needle', 'food_egg', 'clothes_underwear', 'bathroom_counter', 'phone', 'keyboard', 'computer', 'table_cloth', 'closetdrawer', 'clothes_hat', 'nightstand', 'oven', 'basket_for_clothes', 'photoframe', 'check', 'television', 'coin', 'food_donut', 'diary', 'towel_rack', 'headset', 'comb', 'hairdryer', 'napkin']
Task:Drink
response:

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


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

Here is an example plan to achieve a goal for reference:
Scene_Objects:['glue', 'freezer', 'ceilingfan', 'drawing', 'knifeblock', 'needle', 'floor', 'ceiling', 'phone', 'remote_control', 'toaster', 'ceilinglamp', 'tvstand', 'balanceball', 'shower', 'window', 'stereo', 'iron', 'stovefan', 'couch', 'pillow', 'wall', 'television', 'food_rice', 'curtain', 'doorjamb', 'bag', 'bathroom_cabinet', 'table', 'laser_pointer']
Task:Watch TV
response:
{
    "thoughts": Walk into the living room/den. Turn on the television. Switch channels to find a program with remote. I find a program and look at the screen.,
    "actions": ['[WALK] <home_office>', '[WALK] <television>', '[FIND] <television>', '[SWITCHON] <television>', '[FIND] <remote_control>', '[TURNTO] <remote_control>', '[TURNTO] <television>', '[LOOKAT] <television>']
}

Input:
Scene_Objects:['tablelamp', 'chair', 'walllamp', 'orchid', 'drawing', 'cpuscreen', 'wallshelf', 'hanger', 'floor', 'ceiling', 'phone', 'shampoo', 'desk', 'keyboard', 'computer', 'ceilinglamp', 'tvstand', 'mat', 'mousepad', 'couch', 'pillow', 'wall', 'nightstand', 'oven', 'food_food', 'television', 'doorjamb', 'mouse', 'dresser', 'door']
Task:Work
response:

I go to my office. I switch the computer on and sit on the office chair. I look at the computer screen to see what needs to be done. I use my mouse to navigate to the relevant directory, then release it. I type code with my keyboard. When I'm done, I look at the computer again to evaluate what I've done. Then I switch off the computer using the mouse and put back the mouse.

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


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

Here is an example plan to achieve a goal for reference:
Scene_Objects:['tablelamp', 'food_salt', 'orchid', 'hanger', 'floor', 'phone', 'ceiling', 'character', 'toaster', 'mat', 'plate', 'faucet', 'shower', 'window', 'closetdrawer', 'powersocket', 'oven', 'cup', 'curtain', 'doorjamb', 'mouse', 'comb', 'cupboard', 'clothes_dress', 'door', 'bathtub', 'home_office', 'table', 'dishwasher', 'dirt']
Task:Wash dishes with dishwasher
response:
{
    "thoughts": Walk to Kitchen, find dishwasher. Find vessels to be washed. Open dishwasher, put vessels in dish washer, close dish washer and switch it on.,
    "actions": ['[WALK] <dining_room>', '[WALK] <dishwasher>', '[FIND] <dishwasher>', '[OPEN] <dishwasher>', '[FIND] <cup>', '[GRAB] <cup>', '[PUTBACK] <cup> <dishwasher>', '[FIND] <plate>', '[GRAB] <plate>', '[GRAB] <cup>', '[PUTBACK] <cup> <plate>', '[GRAB] <cup>', '[PUTBACK] <cup> <dishwasher>', '[CLOSE] <dishwasher>', '[SWITCHON] <dishwasher>']
}

Input:
Scene_Objects:['sheets', 'tablelamp', 'food_salt', 'crayon', 'drawing', 'orchid', 'hanger', 'floor', 'ceiling', 'bedroom', 'bookshelf', 'ceilinglamp', 'clothes_socks', 'closetdrawer', 'couch', 'pillow', 'wall', 'nightstand', 'powersocket', 'bed', 'food_food', 'video_game_controller', 'doorjamb', 'diary', 'chessboard', 'dresser', 'door', 'light', 'table', 'dishwasher']
Task:Turn on light
response:


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

Here is an example plan to achieve a goal for reference:
Scene_Objects:['chair', 'bathroom', 'wallshelf', 'hanger', 'floor', 'ceiling', 'bookshelf', 'food_bacon', 'button', 'toaster', 'tvstand', 'shower', 'plate', 'food_noodles', 'clothes_socks', 'dustpan', 'pillow', 'nightstand', 'pasta', 'wall_clock', 'bed', 'novel', 'food_donut', 'towel_rack', 'kitchen_counter', 'comb', 'cupboard', 'door', 'table', 'light']
Task:Listen to music
response:
{
    "thoughts": go to radio. run on radio.,
    "actions": ['[WALK] <stereo>', '[SWITCHON] <stereo>']
}

Input:
Scene_Objects:['pot', 'microwave', 'chair', 'milk', 'bathroom_counter', 'floor', 'bookshelf', 'table_cloth', 'toaster', 'tvstand', 'shower', 'foundation', 'pillow', 'wall', 'nightstand', 'powersocket', 'cutting_board', 'cup', 'coffe_maker', 'food_onion', 'kitchen_counter', 'dishrack', 'cupboard', 'clothes_dress', 'sink', 'bag', 'table', 'dishwasher', 'dirt', 'shoe_rack']
Task:Wash dishes by hand
response:

walk to kitchen , find dish washer , wash the dishe rack , put dishes in dish washer , switch on dish washer

[WALK] <dining_room>
[WALK] <dishwasher>
[FIND] <dishwasher>
[FIND] <dishrack>
[FIND] <dishrack>
[GRAB] <dishrack>
[FIND] <dishwasher>
[OPEN] <dishwasher>
[PUTBACK] <dishrack> <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', 'measuring_cup', 'toilet', 'chair', 'ground_coffee', 'bathroom', 'dough', 'wallshelf', 'phone', 'character', 'keyboard', 'computer', 'ceilinglamp', 'deck_of_cards', 'stereo', 'mousepad', 'couch', 'powersocket', 'cutting_board', 'bed', 'food_food', 'food_rice', 'tray', 'wooden_spoon', 'pencil', 'headset', 'cupboard', 'laundry_detergent', 'sink', 'dishwasher']
Task:Pet cat
response:
{
    "thoughts": find the cat, go near the cat and pet the cat,
    "actions": ['[WALK] <home_office>', '[WALK] <cat>', '[FIND] <cat>', '[TOUCH] <cat>']
}

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

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.

[WALK] <home_office>
[WALK] <desk>
[FIND] <chair>
[SIT] <chair>
[FIND] <computer>
[TURNTO] <computer>
[LOOKAT] <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:['pot', 'food_salt', 'microwave', 'ceilingfan', 'orchid', 'bathroom_counter', 'bookshelf', 'purse', 'stovefan', 'mat', 'iron', 'electric_shaver', 'food_noodles', 'mousepad', 'couch', 'clothes_pants', 'pillow', 'powersocket', 'keys', 'coffe_maker', 'oven_mitts', 'wine', 'shaving_cream', 'pencil', 'kitchen_counter', 'vacuum_cleaner', 'dresser', 'home_office', 'light', 'tooth_paste']
Task:Hang up car keys
response:
{
    "thoughts": Open the front door. Enter the entrance hall. Take out car keys from purse. Hang car keys up on hook on the wall.,
    "actions": ['[WALK] <home_office>', '[WALK] <purse>', '[FIND] <purse>', '[OPEN] <purse>', '[FIND] <keys>', '[GRAB] <keys>', '[CLOSE] <purse>']
}

Input:
Scene_Objects:['filing_cabinet', 'juice', 'walllamp', 'food_carrot', 'knife', 'orchid', 'cpuscreen', 'phone', 'dvd_player', 'desk', 'mop_bucket', 'toaster', 'laptop', 'tvstand', 'closetdrawer', 'food_jam', 'pillow', 'dining_room', 'food_food', 'television', 'oven_mitts', 'water', 'after_shave', 'pencil', 'hairbrush', 'clothes_dress', 'door', 'table', 'dishwasher', 'light']
Task:Drink
response:

I go to the kitchen. I get a glass. I fill it with water. I take a drink from the glass.

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


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

Here is an example plan to achieve a goal for reference:
Scene_Objects:['dog', 'freezer', 'chair', 'walllamp', 'bathroom', 'drawing', 'cpuscreen', 'bathroom_counter', 'floor', 'ceiling', 'character', 'desk', 'bedroom', 'computer', 'stovefan', 'tvstand', 'faucet', 'couch', 'pillow', 'wall', 'nightstand', 'oven', 'curtain', 'rag', 'doorjamb', 'towel_rack', 'sink', 'bathroom_cabinet', 'table', 'light']
Task:Wipe down sink
response:
{
    "thoughts": Use a cloth to wipe the edge of the sink. Then wipe the bowl of the sink as well.,
    "actions": ['[WALK] <bathroom>', '[WALK] <bathroom_cabinet>', '[OPEN] <bathroom_cabinet>', '[FIND] <rag>', '[GRAB] <rag>', '[WALK] <sink>', '[WIPE] <sink>', '[PUTOBJBACK] <rag>', '[CLOSE] <bathroom_cabinet>']
}

Input:
Scene_Objects:['chair', 'bathroom', 'wallshelf', 'hanger', 'floor', 'ceiling', 'bookshelf', 'food_bacon', 'button', 'toaster', 'tvstand', 'shower', 'plate', 'food_noodles', 'clothes_socks', 'dustpan', 'pillow', 'nightstand', 'pasta', 'wall_clock', 'bed', 'novel', 'food_donut', 'towel_rack', 'kitchen_counter', 'comb', 'cupboard', 'door', 'table', 'light']
Task:Listen to music
response:


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

Here is an example plan to achieve a goal for reference:
Scene_Objects:['blow_dryer', 'trashcan', 'hanger', 'floor', 'ceiling', 'bedroom', 'bookmark', 'toaster', 'stovefan', 'tvstand', 'food_jam', 'pillow', 'dining_room', 'bowl', 'wall', 'powersocket', 'clothes_gloves', 'novel', 'coffe_maker', 'coffee_filter', 'tray', 'after_shave', 'curtain', 'cd', 'chessboard', 'cupboard', 'sink', 'dishwasher', 'scrabble', 'coffee']
Task:Make coffee
response:
{
    "thoughts": Enter kitchen, find coffee maker, find coffee filter, pick up coffee filter, put it in coffee maker, find coffee, pour coffee into filter, turn on.,
    "actions": ['[WALK] <dining_room>', '[WALK] <coffe_maker>', '[FIND] <coffe_maker>', '[FIND] <coffee_filter>', '[GRAB] <coffee_filter>', '[OPEN] <coffe_maker>', '[PUTBACK] <coffee_filter> <coffe_maker>', '[WALK] <coffee>', '[FIND] <coffee>', '[GRAB] <coffee>', '[POUR] <coffee> <coffe_maker>', '[SWITCHON] <coffe_maker>']
}

Input:
Scene_Objects:['tablelamp', 'chair', 'walllamp', 'drawing', 'orchid', 'cpuscreen', 'wallshelf', 'hanger', 'floor', 'ceiling', 'phone', 'desk', 'keyboard', 'purse', 'computer', 'mat', 'ceilinglamp', 'tvstand', 'electric_shaver', 'mousepad', 'couch', 'pillow', 'wall', 'nightstand', 'oven', 'television', 'doorjamb', 'mouse', 'dresser', 'door']
Task:Work
response:

Walk to home office. Sit on chair. Switch on computer. type in keyboard.

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


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

Here is an example plan to achieve a goal for reference:
Scene_Objects:['pot', 'filing_cabinet', 'measuring_cup', 'microwave', 'walllamp', 'bathroom', 'trashcan', 'knifeblock', 'cpuscreen', 'floor', 'desk', 'toaster', 'stovefan', 'plate', 'faucet', 'iron', 'dish_soap', 'wall', 'oven', 'coffe_maker', 'food_food', 'wooden_spoon', 'tray', 'kitchen_counter', 'dishrack', 'cupboard', 'door', 'sink', 'bathroom_cabinet', '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:['tablelamp', 'chair', 'walllamp', 'drawing', 'orchid', 'cpuscreen', 'wallshelf', 'hanger', 'floor', 'ceiling', 'phone', 'desk', 'keyboard', 'bookshelf', 'computer', 'toaster', 'mat', 'ceilinglamp', 'tvstand', 'mousepad', 'couch', 'pillow', 'wall', 'nightstand', 'television', 'doorjamb', 'mouse', 'headset', 'dresser', 'door']
Task:Browse internet
response:

[WALK] <home_office>
[WALK] <chair>
[FIND] <chair>
[SIT] <chair>
[FIND] <computer>
[SWITCHON] <computer>
[TURNTO] <chair>
[LOOKAT] <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:['dry_pasta', 'toilet', 'chair', 'freezer', 'detergent', 'food_butter', 'wallshelf', 'hanger', 'phone', 'character', 'desk', 'remote_control', 'button', 'piano_bench', 'toaster', 'mat', 'tvstand', 'picture', 'oil', 'couch', 'clothes_pants', 'pillow', 'towel', 'wall', 'novel', 'razor', 'diary', 'conditioner', 'table', 'coffee']
Task:Change TV channel
response:
{
    "thoughts": Take the Tv Remote Control  in the Living Room table And Press the Channel Change Button to change the channel,
    "actions": ['[WALK] <home_office>', '[WALK] <remote_control>', '[FIND] <remote_control>', '[GRAB] <remote_control>', '[FIND] <button>', '[PUSH] <button>', '[PUTOBJBACK] <remote_control>']
}

Input:
Scene_Objects:['tablelamp', 'chair', 'walllamp', 'bathroom', 'orchid', 'cpuscreen', 'wallshelf', 'hanger', 'floor', 'ceiling', 'phone', 'desk', 'keyboard', 'computer', 'ceilinglamp', 'tvstand', 'mat', 'shower', 'mousepad', 'couch', 'pillow', 'wall', 'nightstand', 'photoframe', 'keys', 'television', 'doorjamb', 'mouse', 'dresser', 'door']
Task:Browse internet
response:

go to the office, turn computer on, open an browser or any application to open any website.

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