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

Here is an example plan to achieve a goal for reference:
Scene_Objects:['microwave', 'toilet', 'milk', 'toothbrush', 'drawing', 'orchid', 'cpuscreen', 'character', 'bedroom', 'stovefan', 'toaster', 'mousepad', 'clothes_pants', 'food_kiwi', 'wall_clock', 'bed', 'television', 'toothbrush_holder', 'water', 'tray', 'curtain', 'pencil', 'kitchen_counter', 'shoes', 'hairbrush', 'cupboard', 'bathroom_cabinet', 'home_office', 'tooth_paste', 'dirt']
Task:Brush teeth
response:
{
    "thoughts": today morning i went to bathroom and took my toothbrush and paste from tooth brush holder and brushed and cleaned my teeth well,
    "actions": ['[WALK] <bathroom>', '[WALK] <toothbrush_holder>', '[FIND] <toothbrush_holder>', '[FIND] <tooth_paste>', '[GRAB] <tooth_paste>', '[FIND] <toothbrush>', '[GRAB] <toothbrush>', '[PUTBACK] <tooth_paste> <toothbrush_holder>', '[WALK] <water>', '[FIND] <water>', '[GRAB] <water>', '[POUR] <water> <toothbrush>']
}

Input:
Scene_Objects:['cat', 'wallshelf', 'bathroom_counter', 'floor', 'ceiling', 'phone', 'character', 'stovefan', 'mat', 'ceilinglamp', 'faucet', 'iron', 'towel', 'wall', 'wall_clock', 'oven', 'nightstand', 'tape', 'novel', 'food_food', 'television', 'tray', 'mouse', 'sink', 'bathtub', 'bathroom_cabinet', 'light', 'vase', 'soap', 'hands_both']
Task:Wash hands
response:

I go into the bathroom, get my hands wet, add soap, suds up my hands, rinse the soap off, turn the faucet off, dry my hands.

[WALK] <bathroom>
[WALK] <faucet>
[FIND] <faucet>
[SWITCHON] <faucet>
[FIND] <hands_both>
[RINSE] <hands_both>
[FIND] <soap>
[GRAB] <soap>
[SCRUB] <soap>
[PUTOBJBACK] <soap>
[SCRUB] <hands_both>
[RINSE] <hands_both>
[SWITCHOFF] <faucet>
[FIND] <towel>
[GRAB] <towel>
[WIPE] <hands_both>
[PUTOBJBACK] <towel>


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

Here is an example plan to achieve a goal for reference:
Scene_Objects:['microwave', 'chair', 'freezer', 'walllamp', 'bathroom', 'knife', 'cpuscreen', 'hanger', 'floor', 'phone', 'desk', 'keyboard', 'thread', 'computer', 'piano_bench', 'toaster', 'laptop', 'ceilinglamp', 'mousepad', 'closetdrawer', 'pillow', 'wall', 'wall_clock', 'box', 'console', 'mouse', 'dresser', 'maindoor', 'hairdryer', 'board_game']
Task:Write an email
response:
{
    "thoughts": I open my laptop and then login to Windows. Then I open Google Chrome, and type gmail.com into the address bar. My email automatically logs in, then I click the Compose button, type in the address of the recipient, then the subject of the email, and then start typing my email,
    "actions": ['[WALK] <laptop>', '[SWITCHON] <laptop>', '[FIND] <keyboard>', '[TYPE] <keyboard>']
}

Input:
Scene_Objects:['chair', 'walllamp', 'cpuscreen', 'hanger', 'bathroom_counter', 'floor', 'desk', 'keyboard', 'computer', 'button', 'bookmark', 'mat', 'picture', 'window', 'mousepad', 'closetdrawer', 'couch', 'pillow', 'dining_room', 'wall', 'powersocket', 'novel', 'check', 'television', 'curtain', 'doorjamb', 'mouse', 'dresser', 'light', 'table']
Task:Read book
response:

Find book, grab book, fin bookmark, sit down somewhere comfortable, open book, read book, close book after reading.

[WALK] <desk>
[FIND] <novel>
[FIND] <bookmark>
[GRAB] <bookmark>
[FIND] <couch>
[SIT] <couch>
[GRAB] <novel>
[READ] <novel>
[PUTBACK] <bookmark> <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:['dry_pasta', 'scissors', 'chair', 'hanger', 'phone', 'keyboard', 'bookshelf', 'plate', 'faucet', 'window', 'mousepad', 'food_noodles', 'oil', 'food_peanut_butter', 'clothes_pants', 'dining_room', 'bench', 'oven', 'cutting_board', 'toy', 'basket_for_clothes', 'cup', 'photoframe', 'keys', 'food_food', 'laundry_detergent', 'bathroom_cabinet', 'instrument_violin', 'clothes_shirt', 'washing_machine']
Task:Wash clothes
response:
{
    "thoughts": 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.,
    "actions": ['[WALK] <bathroom>', '[WALK] <washing_machine>', '[FIND] <washing_machine>', '[OPEN] <washing_machine>', '[FIND] <basket_for_clothes>', '[GRAB] <basket_for_clothes>', '[FIND] <clothes_pants>', '[GRAB] <clothes_pants>', '[PUTBACK] <clothes_pants> <washing_machine>', '[FIND] <clothes_shirt>', '[GRAB] <clothes_shirt>', '[PUTBACK] <clothes_shirt> <washing_machine>', '[PUTOBJBACK] <basket_for_clothes>', '[WALK] <laundry_detergent>', '[FIND] <laundry_detergent>', '[GRAB] <laundry_detergent>', '[POUR] <laundry_detergent> <washing_machine>', '[CLOSE] <washing_machine>', '[SWITCHON] <washing_machine>']
}

Input:
Scene_Objects:['tablelamp', 'jelly', 'drawing', 'floor', 'bedroom', 'table_cloth', 'stovefan', 'mat', 'plate', 'window', 'couch', 'wall', 'nightstand', 'wall_clock', 'cutting_board', 'bed', 'novel', 'tray', 'curtain', 'doorjamb', 'diary', 'mouse', 'pencil', 'cd', 'clothes_dress', 'bathroom_cabinet', 'table', 'light', 'vase', 'laser_pointer']
Task:Read book
response:

I would go lie down in my bed and open the book and start reading.

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


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

Here is an example plan to achieve a goal for reference:
Scene_Objects:['sheets', 'filing_cabinet', 'crayon', 'dog', 'freezer', 'knife', 'orchid', 'bathroom_counter', 'character', 'bedroom', 'faucet', 'couch', 'food_orange', 'towel', 'nightstand', 'oven', 'powersocket', 'photoframe', 'check', 'video_game_controller', 'food_donut', 'food_rice', 'food_onion', 'diary', 'dresser', 'hairbrush', 'clothes_scarf', 'napkin', 'bathroom_cabinet', 'colander']
Task:Pet cat
response:
{
    "thoughts": Walk into the living room. Walk up to the cat. Pet the cat with your hand.,
    "actions": ['[WALK] <home_office>', '[WALK] <cat>', '[FIND] <cat>', '[TOUCH] <cat>']
}

Input:
Scene_Objects:['filing_cabinet', 'toilet', 'chair', 'dog', 'cat', 'dough', 'clothes_underwear', 'folder', 'closetdrawer', 'couch', 'food_orange', 'broom', 'oven', 'powersocket', 'toy', 'photoframe', 'bed', 'check', 'razor', 'curtain', 'lighter', 'mouse', 'pencil', 'kitchen_counter', 'dresser', 'door', 'sink', 'clothes_scarf', 'napkin', 'shoe_rack']
Task:Wash dishes with dishwasher
response:

I walk to the kitchen. I take plate. I open the dishwasher. I put plate in the dishwasher. I switch on the dishwasher.

[WALK] <dining_room>
[WALK] <plate>
[FIND] <plate>
[GRAB] <plate>
[WALK] <dishwasher>
[OPEN] <dishwasher>
[PUTBACK] <plate> <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:['food_salt', 'microwave', 'trashcan', 'hanger', 'floor', 'bedroom', 'computer', 'button', 'brush', 'mat', 'shower', 'faucet', 'window', 'clothes_hat', 'wall', 'child', 'oven', 'bed', 'newspaper', 'novel', 'curtain', 'centerpiece', 'doorjamb', 'mouse', 'cd', 'dresser', 'hairdryer', 'clothes_scarf', 'vase', 'board_game']
Task:Story reading time
response:
{
    "thoughts": Sit on bed with child, open mother goose, pick story, read book, point at the pretty pictures,
    "actions": ['[WALK] <bedroom>', '[WALK] <child>', '[FIND] <child>', '[GREET] <child>', '[FIND] <novel>', '[GRAB] <novel>', '[FIND] <bed>', '[SIT] <bed>', '[TURNTO] <child>', '[LOOKAT] <child>', '[TURNTO] <novel>', '[POINTAT] <novel>', '[READ] <novel>']
}

Input:
Scene_Objects:['glue', 'tablelamp', 'mop', 'toilet', 'chair', 'walllamp', 'bathroom', 'food_carrot', 'hanger', 'floor', 'shampoo', 'bookshelf', 'purse', 'computer', 'stovefan', 'toaster', 'shower', 'mousepad', 'dustpan', 'clothes_pants', 'wall', 'cutting_board', 'standingmirror', 'television', 'oven_mitts', 'curtain', 'doorjamb', 'hairbrush', 'door', 'bathtub']
Task:Go to toilet
response:

Walk to the bathroom. Pull down pants. Use the toilet.

[WALK] <bathroom>
[WALK] <clothes_pants>
[FIND] <clothes_pants>
[PULL] <clothes_pants>
[FIND] <toilet>
[SIT] <toilet>


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

Here is an example plan to achieve a goal for reference:
Scene_Objects:['microwave', 'chair', 'walllamp', 'drawing', 'cpuscreen', 'wallshelf', 'floor', 'ceiling', 'desk', 'bedroom', 'keyboard', 'computer', 'mop_bucket', 'stovefan', 'ceilinglamp', 'tvstand', 'homework', 'mousepad', 'couch', 'wall', 'wall_clock', 'powersocket', 'nightstand', 'television', 'doorjamb', 'mouse', 'headset', 'cupboard', 'table', 'shoe_rack']
Task:Write an email
response:
{
    "thoughts": I go to the home office to find the computer. I turn switch computer on , i open the email. i write the email and  send it.,
    "actions": ['[WALK] <home_office>', '[WALK] <computer>', '[FIND] <computer>', '[SWITCHON] <computer>']
}

Input:
Scene_Objects:['tablelamp', 'food_ice_cream', 'toilet', 'chair', 'walllamp', 'floor', 'ceiling', 'phone', 'desk', 'bookshelf', 'shower', 'mousepad', 'food_peanut_butter', 'food_jam', 'wall', 'bench', 'powersocket', 'toy', 'box', 'standingmirror', 'coffe_maker', 'water', 'doorjamb', 'cards', 'kitchen_counter', 'sink', 'bathroom_cabinet', 'light', 'soap', 'board_game']
Task:Take shower
response:

go to a bathroom, open the shower, let water wash your body

[WALK] <bathroom>
[WALK] <shower>
[FIND] <soap>
[SCRUB] <soap>
[FIND] <water>
[RINSE] <water>


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

Here is an example plan to achieve a goal for reference:
Scene_Objects:['glue', 'tablelamp', 'toilet', 'walllamp', 'cat', 'orchid', 'floor', 'ceiling', 'remote_control', 'computer', 'food_bacon', 'tvstand', 'window', 'mousepad', 'closetdrawer', 'couch', 'pillow', 'nightstand', 'wall', 'mouthwash', 'television', 'coin', 'food_rice', 'tray', 'curtain', 'doorjamb', 'kitchen_counter', 'dresser', 'table', 'soap']
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:['food_ice_cream', 'band-aids', 'dough', 'food_carrot', 'drawing', 'bookshelf', 'stovefan', 'shower', 'oil', 'towel', 'dining_room', 'wall', 'bench', 'toy', 'shelf', 'box', 'cup', 'bed', 'photoframe', 'check', 'coffe_maker', 'food_food', 'food_rice', 'kettle', 'shoes', 'door', 'bathtub', 'home_office', 'vase', 'soap']
Task:Wash hands
response:

[WALK] <bathroom>
[WALK] <soap>
[FIND] <soap>
[GRAB] <soap>
[FIND] <towel>
[WIPE] <towel>


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

Here is an example plan to achieve a goal for reference:
Scene_Objects:['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:
{
    "thoughts": I go to the kitchen. I get a glass. I fill it with water. I take a drink from the glass.,
    "actions": ['[WALK] <dining_room>', '[WALK] <cup>', '[FIND] <cup>', '[GRAB] <cup>', '[WALK] <water>', '[FIND] <water>', '[GRAB] <water>', '[POUR] <water> <cup>', '[DRINK] <cup>']
}

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


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', 'toilet', 'trashcan', 'ceilingfan', 'drawing', 'hanger', 'floor', 'ceiling', 'bookshelf', 'thread', 'computer', 'piano_bench', 'ceilinglamp', 'tvstand', 'balanceball', 'window', 'foundation', 'clothes_pants', 'pillow', 'dining_room', 'wall', 'oven', 'bed', 'novel', 'check', 'television', 'curtain', 'towel_rack', 'dresser', 'vase']
Task:Read book
response:
{
    "thoughts": Put child in bed, sit down,read book.,
    "actions": ['[WALK] <bedroom>', '[WALK] <dresser>', '[OPEN] <dresser>', '[FIND] <novel>', '[GRAB] <novel>', '[FIND] <bed>', '[SIT] <bed>', '[READ] <novel>']
}

Input:
Scene_Objects:['fork', 'glue', 'food_ice_cream', 'food_salt', 'tea', 'drawing', 'knife', 'cpuscreen', 'phone', 'desk', 'computer', 'button', 'plate', 'iron', 'dish_soap', 'mousepad', 'nightstand', 'powersocket', 'curtain', 'kitchen_counter', 'dishrack', 'dresser', 'spoon', 'napkin', 'table', 'dishwasher', 'home_office', 'vase', 'bathroom_cabinet', 'coffee']
Task:Wash dishes with dishwasher
response:

put forks, spoons, plates, knife in dishwasher, add dish soap, turn diswaser on

[WALK] <dining_room>
[WALK] <dishwasher>
[FIND] <dishwasher>
[OPEN] <dishwasher>
[FIND] <dish_soap>
[GRAB] <dish_soap>
[PUTBACK] <dish_soap> <dishwasher>
[FIND] <fork>
[GRAB] <fork>
[FIND] <dishrack>
[PUTBACK] <fork> <dishrack>
[FIND] <plate>
[GRAB] <plate>
[PUTBACK] <plate> <dishrack>
[FIND] <spoon>
[GRAB] <spoon>
[PUTBACK] <spoon> <dishrack>
[FIND] <knife>
[GRAB] <knife>
[PUTBACK] <knife> <dishrack>
[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', 'microwave', 'toilet', 'jelly', 'ceilingfan', 'food_carrot', 'drawing', 'knife', 'clothes_underwear', 'floor', 'phone', 'ceilinglamp', 'tvstand', 'stereo', 'window', 'mousepad', 'couch', 'food_jam', 'wall', 'nightstand', 'cup', 'television', 'ice', 'mouse', 'kitchen_counter', 'home_office', 'table', 'soap', 'board_game', 'shoe_rack']
Task:Listen to music
response:
{
    "thoughts": sitting down to listen to music on the radio,
    "actions": ['[WALK] <home_office>', '[WALK] <stereo>', '[FIND] <stereo>', '[SWITCHON] <stereo>', '[FIND] <couch>', '[SIT] <couch>']
}

Input:
Scene_Objects:['drawing', 'orchid', 'wallshelf', 'hanger', 'floor', 'ceiling', 'bookshelf', 'remote_control', 'computer', 'mat', 'ceilinglamp', 'deck_of_cards', 'window', 'homework', 'closetdrawer', 'couch', 'pillow', 'wall', 'standingmirror', 'newspaper', 'photoframe', 'food_food', 'television', 'food_donut', 'curtain', 'doorjamb', 'towel_rack', 'bag', 'table', 'light']
Task:Change TV channel
response:

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


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

Here is an example plan to achieve a goal for reference:
Scene_Objects:['sheets', 'microwave', 'toilet', 'chair', 'freezer', 'walllamp', 'detergent', 'hanger', 'floor', 'ceiling', 'phone', 'keyboard', 'computer', 'food_bacon', 'alcohol', 'ceilinglamp', 'pillow', 'wall', 'powersocket', 'bed', 'curtain', 'doorjamb', 'kettle', 'mouse', 'dresser', 'cupboard', 'door', 'maindoor', 'light', 'creditcard']
Task:Turn on light
response:
{
    "thoughts": I open the room door and press the light button on,
    "actions": ['[WALK] <home_office>', '[WALK] <light>', '[FIND] <light>', '[SWITCHON] <light>']
}

Input:
Scene_Objects:['bathroom', 'detergent', 'milk', 'floor', 'folder', 'bedroom', 'tea_bag', 'remote_control', 'button', 'mat', 'plate', 'shower', 'closetdrawer', 'pillow', 'nightstand', 'toy', 'standingmirror', 'clothes_gloves', 'keys', 'food_food', 'tray', 'after_shave', 'towel_rack', 'shoes', 'maindoor', 'bathtub', 'sink', 'light', 'table', 'scrabble']
Task:Change TV channel
response:

Walk into living room. Find television remote control. Pick up remote control. Press button.

[WALK] <home_office>
[WALK] <remote_control>
[FIND] <remote_control>
[GRAB] <remote_control>
[FIND] <button>
[PUSH] <button>


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

Here is an example plan to achieve a goal for reference:
Scene_Objects:['fork', 'pot', 'blender', 'crayon', 'microwave', 'cat', 'drawing', 'orchid', 'needle', 'phone', 'stovefan', 'ceilinglamp', 'tvstand', 'shower', 'food_jam', 'dining_room', 'powersocket', 'bed', 'photoframe', 'coffe_maker', 'television', 'diary', 'shoes', 'comb', 'controller', 'food_steak', 'instrument_violin', 'sink', 'dishwasher', 'board_game']
Task:Pet cat
response:
{
    "thoughts": I walk to the living room. I find the cat. I pet the cat.,
    "actions": ['[WALK] <home_office>', '[WALK] <cat>', '[FIND] <cat>', '[TOUCH] <cat>']
}

Input:
Scene_Objects:['filing_cabinet', 'band-aids', 'freezer', 'orchid', 'drawing', 'cpuscreen', 'bills', 'floor', 'ceiling', 'character', 'bookshelf', 'mop_bucket', 'mat', 'deck_of_cards', 'faucet', 'window', 'electric_shaver', 'couch', 'pillow', 'wall', 'nightstand', 'cup', 'television', 'coffee_filter', 'curtain', 'doorjamb', 'mouse', 'conditioner', 'bathroom_cabinet', 'table']
Task:Relax on sofa
response:

walk to living room ,find sofa ,sit on sofa

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


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

Here is an example plan to achieve a goal for reference:
Scene_Objects:['pot', 'toilet', 'jelly', 'band-aids', 'chair', 'drawing', 'cpuscreen', 'bathroom_counter', 'floor', 'shampoo', 'ceiling', 'desk', 'keyboard', 'purse', 'brush', 'toaster', 'shoe-shine_kit', 'plate', 'faucet', 'mousepad', 'towel', 'dining_room', 'wall', 'photoframe', 'newspaper', 'coffe_maker', 'toothbrush_holder', 'mouse', 'door', 'home_office']
Task:Go to toilet
response:
{
    "thoughts": I walk into the bathroom. I walk over to the toilet. I sit on the toilet.,
    "actions": ['[WALK] <bathroom>', '[WALK] <toilet>', '[SIT] <toilet>']
}

Input:
Scene_Objects:['beer', 'tea', 'chair', 'walllamp', 'ground_coffee', 'bills', 'orchid', 'bathroom_counter', 'floor', 'phone', 'ceiling', 'mail', 'ceilinglamp', 'mat', 'iron', 'stereo', 'faucet', 'clothes_socks', 'clothes_hat', 'basket_for_clothes', 'food_rice', 'curtain', 'lighter', 'doorjamb', 'towel_rack', 'vacuum_cleaner', 'dishrack', 'cd', 'napkin', 'home_office']
Task:Turn on light
response:

I go to bedroom and locate a lamp. This lamp can be turned on by touch, as it has capacitive sensing. So I do it.

[WALK] <bedroom>
[WALK] <floor_lamp>
[FIND] <floor_lamp>
[TOUCH] <floor_lamp>
[SWITCHON] <floor_lamp>


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

Here is an example plan to achieve a goal for reference:
Scene_Objects:['knife', 'cpuscreen', 'hanger', 'floor', 'ceiling', 'folder', 'desk', 'keyboard', 'computer', 'mat', 'stereo', 'mousepad', 'closetdrawer', 'clothes_pants', 'wall', 'powersocket', 'cup', 'newspaper', 'novel', 'tray', 'mouse', 'kitchen_counter', 'dresser', 'bathtub', 'spoon', 'light', 'soap', 'board_game', 'clothes_shirt', 'scrabble']
Task:Get dressed
response:
{
    "thoughts": Pick out the clothes you are going to wear and put them on your body,
    "actions": ['[WALK] <bedroom>', '[WALK] <dresser>', '[OPEN] <dresser>', '[FIND] <clothes_pants>', '[GRAB] <clothes_pants>', '[PUTON] <clothes_pants>', '[FIND] <clothes_shirt>', '[GRAB] <clothes_shirt>', '[PUTON] <clothes_shirt>', '[CLOSE] <dresser>']
}

Input:
Scene_Objects:['microwave', 'freezer', 'walllamp', 'blow_dryer', 'milk', 'bills', 'orchid', 'floor', 'ceiling', 'character', 'food_cake', 'alcohol', 'stovefan', 'homework', 'closetdrawer', 'pillow', 'broom', 'wall', 'oven', 'cutting_board', 'cup', 'coffe_maker', 'food_food', 'water', 'tray', 'kitchen_counter', 'shoes', 'sink', 'light', 'table']
Task:Drink
response:

Feeling tired after hard work I opened the fridge and grabbed cool water and drank from the glass.

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


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

Here is an example plan to achieve a goal for reference:
Scene_Objects:['food_pizza', 'mop', 'chair', 'bathroom', 'drawing', 'wallshelf', 'character', 'bedroom', 'keyboard', 'computer', 'mat', 'ceilinglamp', 'shower', 'faucet', 'floor_lamp', 'mousepad', 'closetdrawer', 'nightstand', 'wall', 'oven', 'bench', 'photoframe', 'bed', 'coffe_maker', 'food_food', 'check', 'conditioner', 'light', 'table', 'tooth_paste']
Task:Turn on light
response:
{
    "thoughts": walk to living room, find lamp, switch on.,
    "actions": ['[WALK] <home_office>', '[WALK] <floor_lamp>', '[FIND] <floor_lamp>']
}

Input:
Scene_Objects:['jelly', 'freezer', 'dog', 'chair', 'nail_polish', 'bathroom', 'orchid', 'bills', 'food_egg', 'hanger', 'character', 'bedroom', 'thread', 'toaster', 'faucet', 'mousepad', 'oil', 'nightstand', 'cup', 'photoframe', 'standingmirror', 'bed', 'video_game_controller', 'wine', 'doorjamb', 'maindoor', 'bathtub', 'vase', 'clothes_shirt', 'coffee']
Task:Read book
response:

pick up  the book open the book and read

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


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

Here is an example plan to achieve a goal for reference:
Scene_Objects:['pot', 'filing_cabinet', 'toilet', 'chair', 'walllamp', 'ground_coffee', 'orchid', 'bathroom_counter', 'floor', 'ceiling', 'phone', 'bookshelf', 'stovefan', 'tvstand', 'faucet', 'shower', 'electric_shaver', 'towel', 'wall', 'wall_clock', 'oven', 'television', 'tray', 'rag', 'doorjamb', 'dresser', 'sink', 'bathroom_cabinet', 'clothes_skirt', 'laser_pointer']
Task:Take shower
response:
{
    "thoughts": Walk to Bathroom. Open the Bathroom Cabinet. Grab a Towel. Close the Bathroom Cabinet. Rinse the Shower.,
    "actions": ['[WALK] <bathroom>', '[WALK] <bathroom_cabinet>', '[FIND] <bathroom_cabinet>', '[OPEN] <bathroom_cabinet>', '[FIND] <towel>', '[GRAB] <towel>', '[CLOSE] <bathroom_cabinet>', '[FIND] <shower>', '[RINSE] <shower>']
}

Input:
Scene_Objects:['scissors', 'toilet', 'freezer', 'bathroom', 'cpuscreen', 'bathroom_counter', 'floor', 'ceiling', 'bedroom', 'thread', 'stovefan', 'mat', 'faucet', 'towel', 'dining_room', 'wall', 'wall_clock', 'oven', 'bench', 'nightstand', 'check', 'coffee_filter', 'tray', 'shaving_cream', 'towel_rack', 'pencil', 'mouse', 'sink', 'bathroom_cabinet', 'soap']
Task:Wash hands
response:

I walk into the bathroom. Walk to the sink. Turn on tap. Get soap. Wash and rinse hands. Turn off tap. Dry hands.

[WALK] <bathroom>
[WALK] <sink>
[FIND] <sink>
[TURNTO] <sink>
[LOOKAT] <sink>
[WALK] <sink>
[FIND] <faucet>
[SWITCHON] <faucet>
[FIND] <soap>
[GRAB] <soap>
[RINSE] <soap>
[SWITCHOFF] <faucet>
[FIND] <towel>
[GRAB] <towel>


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

Here is an example plan to achieve a goal for reference:
Scene_Objects:['sponge', 'toilet', 'freezer', 'drawing', 'bathroom_counter', 'floor', 'ceiling', 'keyboard', 'ceilinglamp', 'mat', 'shower', 'food_noodles', 'couch', 'towel', 'wall', 'powersocket', 'oven', 'cutting_board', 'photoframe', 'newspaper', 'water', 'food_donut', 'curtain', 'doorjamb', 'headset', 'door', 'bathroom_cabinet', 'light', 'soap', 'tooth_paste']
Task:Take shower
response:
{
    "thoughts": Walk into bathroom. Turn on shower. Take off clothing. Climb into shower. Rinse with water. Soap up body. Rinse off with water. Turn off shower. Climb out of shower. Dry off with towel.,
    "actions": ['[WALK] <bathroom>', '[WALK] <shower>', '[FIND] <shower>', '[TURNTO] <shower>', '[FIND] <water>', '[RINSE] <water>', '[FIND] <soap>', '[WASH] <soap>', '[RINSE] <water>', '[FIND] <towel>', '[GRAB] <towel>', '[SCRUB] <towel>']
}

Input:
Scene_Objects:['scissors', 'dog', 'walllamp', 'drawing', 'hanger', 'floor', 'ceiling', 'remote_control', 'envelope', 'computer', 'table_cloth', 'mat', 'ceilinglamp', 'window', 'food_noodles', 'closetdrawer', 'couch', 'pillow', 'wall', 'bench', 'standingmirror', 'television', 'tray', 'curtain', 'doorjamb', 'console', 'cd', 'napkin', 'table', 'clothes_shirt']
Task:Watch TV
response:

Walk to the living room. Find the television. Walk to the television. Switch on the television. Find the sofa. Walk to the sofa. Sit on the sofa. Find the remote control. Grab the remote control. Look at the television.

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


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:['microwave', 'chair', 'freezer', 'walllamp', 'bathroom', 'floor', 'ceiling', 'keyboard', 'stovefan', 'electric_shaver', 'clothes_socks', 'form', 'wall', 'nightstand', 'oven', 'cutting_board', 'coffe_maker', 'food_food', 'oven_mitts', 'food_donut', 'tray', 'doorjamb', 'kettle', 'mouse', 'kitchen_counter', 'laundry_detergent', 'home_office', 'table', 'bathroom_cabinet', 'instrument_guitar']
Task:Put groceries in Fridge
response:

go to the kitchen and put the groceries in the fridge

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


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

Here is an example plan to achieve a goal for reference:
Scene_Objects:['dry_pasta', 'food_pizza', 'filing_cabinet', 'scissors', 'chair', 'ceilingfan', 'dough', 'drawing', 'orchid', 'floor', 'ceiling', 'phone', 'bookshelf', 'remote_control', 'stovefan', 'ceilinglamp', 'tvstand', 'balanceball', 'window', 'couch', 'food_orange', 'wall', 'powersocket', 'coffee_table', 'television', 'coin', 'wooden_spoon', 'curtain', 'maindoor', 'table']
Task:Watch TV
response:
{
    "thoughts": I walk into the living room and sit on the couch. I pick up the remote to turn on the television. I put down the remote on the coffee table and look at the television.,
    "actions": ['[WALK] <home_office>', '[WALK] <couch>', '[FIND] <couch>', '[SIT] <couch>', '[FIND] <remote_control>', '[GRAB] <remote_control>', '[FIND] <television>', '[SWITCHON] <television>', '[FIND] <coffee_table>', '[PUTBACK] <remote_control> <coffee_table>', '[TURNTO] <television>', '[LOOKAT] <television>']
}

Input:
Scene_Objects:['toilet', 'chair', 'walllamp', 'bathroom', 'wallshelf', 'cpuscreen', 'hanger', 'floor', 'ceiling', 'phone', 'desk', 'keyboard', 'envelope', 'computer', 'mop_bucket', 'stovefan', 'mat', 'tvstand', 'toaster', 'foundation', 'mousepad', 'pillow', 'wall', 'standingmirror', 'photoframe', 'toilet_paper', 'oven_mitts', 'tray', 'mouse', 'sink']
Task:Read book
response:

go to living room,find the text book on the self ,sat on the chair ,open and read the book

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


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

Here is an example plan to achieve a goal for reference:
Scene_Objects:['microwave', 'walllamp', 'drawing', 'orchid', 'wallshelf', 'floor', 'ceiling', 'shampoo', 'computer', 'mail', 'table_cloth', 'mat', 'tvstand', 'plate', 'couch', 'pillow', 'dining_room', 'food_kiwi', 'wall', 'nightstand', 'photoframe', 'check', 'television', 'curtain', 'after_shave', 'doorjamb', 'cards', 'mouse', 'shoes', 'sink']
Task:Relax on sofa
response:
{
    "thoughts": I walk to the living room. I sit in the sofa and I relax.,
    "actions": ['[WALK] <home_office>', '[WALK] <couch>', '[FIND] <couch>', '[SIT] <couch>']
}

Input:
Scene_Objects:['crayon', 'walllamp', 'blow_dryer', 'detergent', 'orchid', 'bathroom_counter', 'ceiling', 'phone', 'computer', 'clothes_jacket', 'table_cloth', 'stovefan', 'faucet', 'shower', 'couch', 'clothes_pants', 'wall', 'wall_clock', 'oven', 'bench', 'bed', 'toothbrush_holder', 'tray', 'curtain', 'dresser', 'clothes_dress', 'sink', 'spoon', 'bathroom_cabinet', 'washing_machine']
Task:Wash clothes
response:

Walk to bathroom, open cabinet and collect clothes and put them into washing machine and wash clothes


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', 'orchid', 'cpuscreen', 'wallshelf', 'bathroom_counter', 'floor', 'ceiling', 'phone', 'desk', 'keyboard', 'computer', 'ceilinglamp', 'tvstand', 'mat', 'mousepad', 'pillow', 'dining_room', 'wall', 'nightstand', 'powersocket', 'cutting_board', 'television', 'curtain', 'doorjamb', 'mouse', 'door', 'table']
Task:Watch youtube
response:
{
    "thoughts": Go to youtube.Com watch videos,
    "actions": ['[WALK] <home_office>', '[WALK] <chair>', '[FIND] <chair>', '[SIT] <chair>', '[FIND] <computer>', '[SWITCHON] <computer>', '[TURNTO] <computer>', '[LOOKAT] <computer>']
}

Input:
Scene_Objects:['dog', 'food_carrot', 'toothbrush', 'orchid', 'knife', 'hanger', 'floor', 'ceiling', 'bedroom', 'bookshelf', 'computer', 'ceilinglamp', 'tvstand', 'faucet', 'stereo', 'mousepad', 'pillow', 'towel', 'wall', 'nightstand', 'bench', 'cutting_board', 'cup', 'food_food', 'coffe_maker', 'television', 'food_donut', 'coffee_pot', 'towel_rack', 'soap']
Task:Listen to music
response:

walk into living room, walk to stereo, turn on stereo, listen to music

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


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

Here is an example plan to achieve a goal for reference:
Scene_Objects:['microwave', 'dog', 'freezer', 'walllamp', 'cat', 'knifeblock', 'bills', 'desk', 'bookshelf', 'keyboard', 'computer', 'ceilinglamp', 'faucet', 'clothes_hat', 'broom', 'powersocket', 'bench', 'coffe_maker', 'food_food', 'television', 'mirror', 'rag', 'lighter', 'towel_rack', 'mouse', 'dresser', 'sink', 'table', 'clothes_skirt', 'shoe_rack']
Task:Clean mirror
response:
{
    "thoughts": Spray glass cleaner on mirror. Wipe with a clean cloth.,
    "actions": ['[WALK] <bathroom>', '[WALK] <cleaning_solution>', '[FIND] <cleaning_solution>', '[GRAB] <cleaning_solution>', '[WALK] <mirror>', '[PUTOBJBACK] <cleaning_solution>', '[FIND] <rag>', '[GRAB] <rag>', '[WALK] <mirror>', '[WIPE] <mirror>', '[WIPE] <mirror>', '[WIPE] <mirror>', '[PUTOBJBACK] <rag>']
}

Input:
Scene_Objects:['food_pizza', 'blender', 'beer', 'toilet', 'detergent', 'food_butter', 'phone', 'bookshelf', 'remote_control', 'alcohol', 'button', 'table_cloth', 'piano_bench', 'toaster', 'tvstand', 'pillow', 'nightstand', 'pasta', 'wall_clock', 'tape', 'coffe_maker', 'doorjamb', 'cards', 'pencil', 'controller', 'clothes_dress', 'maindoor', 'sink', 'home_office', 'light']
Task:Change TV channel
response:

I pick up the remote. I press button on remote.

[WALK] <bedroom>
[WALK] <remote_control>
[FIND] <remote_control>
[GRAB] <remote_control>
[FIND] <button>
[PUSH] <button>


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

Here is an example plan to achieve a goal for reference:
Scene_Objects:['fork', 'scissors', 'tea', 'freezer', 'walllamp', 'knifeblock', 'knife', 'bills', 'floor', 'toaster', 'mat', 'plate', 'stereo', 'picture', 'tvstand', 'dish_soap', 'microphone', 'wall', 'oven', 'cup', 'light_bulb', 'coffe_maker', 'drinking_glass', 'tray', 'mouse', 'cupboard', 'controller', 'maindoor', 'spoon', 'dishwasher']
Task:Wash dishes with dishwasher
response:
{
    "thoughts": Walk to the kitchen and turn to the dishwasher, put the knife, glass, fork and plate into the dishwasher. Turn on the dishwasher.,
    "actions": ['[WALK] <dining_room>', '[WALK] <dishwasher>', '[FIND] <dishwasher>', '[TURNTO] <dishwasher>', '[FIND] <dish_soap>', '[GRAB] <dish_soap>', '[OPEN] <dishwasher>', '[PUTBACK] <dish_soap> <dishwasher>', '[FIND] <drinking_glass>', '[GRAB] <drinking_glass>', '[PUTBACK] <drinking_glass> <dishwasher>', '[FIND] <fork>', '[GRAB] <fork>', '[PUTBACK] <fork> <dishwasher>', '[FIND] <knife>', '[GRAB] <knife>', '[PUTBACK] <knife> <dishwasher>', '[FIND] <plate>', '[GRAB] <plate>', '[PUTBACK] <plate> <dishwasher>', '[CLOSE] <dishwasher>', '[SWITCHON] <dishwasher>']
}

Input:
Scene_Objects:['tablelamp', 'food_salt', 'microwave', 'freezer', 'band-aids', 'walllamp', 'food_carrot', 'drawing', 'floor', 'ceiling', 'stovefan', 'ceilinglamp', 'tvstand', 'faucet', 'wall', 'nightstand', 'oven', 'cutting_board', 'cup', 'food_cheese', 'coffe_maker', 'coffee_filter', 'drinking_glass', 'tray', 'shaving_cream', 'kitchen_counter', 'dresser', 'sink', 'light', 'table']
Task:Drink
response:

[WALK] <dining_room>
[WALK] <freezer>
[FIND] <freezer>
[OPEN] <freezer>
[FIND] <drinking_glass>
[GRAB] <drinking_glass>
[DRINK] <drinking_glass>
[PUTOBJBACK] <drinking_glass>
[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:['cd_player', 'freezer', 'ground_coffee', 'bathroom', 'milk', 'orchid', 'cpuscreen', 'hanger', 'dvd_player', 'character', 'ceilinglamp', 'stereo', 'faucet', 'dustpan', 'clothes_hat', 'nightstand', 'wall', 'newspaper', 'check', 'mouthwash', 'video_game_controller', 'food_food', 'tray', 'doorjamb', 'pencil', 'cupboard', 'door', 'sink', 'home_office', 'dishwasher']
Task:Listen to music
response:
{
    "thoughts": I walk in the living room, then I go the the stereo and the cd player and turn them on.,
    "actions": ['[WALK] <home_office>', '[WALK] <stereo>', '[FIND] <stereo>', '[SWITCHON] <stereo>', '[FIND] <cd_player>', '[SWITCHON] <cd_player>']
}

Input:
Scene_Objects:['tablelamp', 'juice', 'toilet', 'chair', 'food_egg', 'cpuscreen', 'hanger', 'bathroom_counter', 'floor', 'character', 'desk', 'bookshelf', 'piano_bench', 'shower', 'faucet', 'stereo', 'electric_shaver', 'food_jam', 'wall', 'nightstand', 'wall_clock', 'shelf', 'bed', 'photoframe', 'novel', 'light_bulb', 'coffee_filter', 'board_game', 'laser_pointer', 'shoe_rack']
Task:Go to toilet
response:

Travel through the house and locate the bathroom, and proceed to the toilet.

[WALK] <bathroom>
[WALK] <toilet>
[FIND] <toilet>


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

Here is an example plan to achieve a goal for reference:
Scene_Objects:['microwave', 'walllamp', 'orchid', 'ceiling', 'desk', 'computer', 'food_bacon', 'stovefan', 'ceilinglamp', 'plate', 'shower', 'faucet', 'window', 'form', 'dining_room', 'oven', 'basket_for_clothes', 'keys', 'novel', 'food_food', 'coffe_maker', 'food_rice', 'tray', 'doorjamb', 'cards', 'mouse', 'pajamas', 'home_office', 'light', 'bathroom_cabinet']
Task:Listen to music
response:
{
    "thoughts": Find the playback device you want to listen to. turn on. press play. enjoyu music.,
    "actions": ['[WALK] <bedroom>', '[WALK] <cd_player>', '[FIND] <cd_player>', '[SWITCHON] <cd_player>']
}

Input:
Scene_Objects:['fork', 'food_salt', 'food_butter', 'food_carrot', 'drawing', 'food_egg', 'floor', 'phone', 'ceiling', 'character', 'purse', 'mat', 'plate', 'window', 'mousepad', 'closetdrawer', 'couch', 'food_orange', 'bed', 'photoframe', 'tray', 'coffee_pot', 'kitchen_counter', 'shoes', 'pajamas', 'sink', 'spoon', 'bathtub', 'table', 'vase']
Task:Set up table
response:

Place your plate on the placemat. The forks will be placed on the left side of the plate and the knife and spoon on the right and place the spoon to the right of the knife. If you want to set out food, place them above the plate.

[WALK] <table>
[FIND] <plate>
[GRAB] <plate>
[DROP] <plate>
[FIND] <fork>
[GRAB] <fork>
[DROP] <fork>
[FIND] <spoon>
[GRAB] <spoon>
[DROP] <spoon>


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

Here is an example plan to achieve a goal for reference:
Scene_Objects:['filing_cabinet', 'chair', 'freezer', 'walllamp', 'knifeblock', 'orchid', 'cpuscreen', 'hanger', 'floor', 'ceiling', 'desk', 'bookshelf', 'bookmark', 'ceilinglamp', 'tvstand', 'balanceball', 'picture', 'mousepad', 'couch', 'wall', 'bed', 'food_food', 'tray', 'after_shave', 'rag', 'doorjamb', 'maindoor', 'bathroom_cabinet', 'dishwasher', 'vase']
Task:Put away groceries
response:
{
    "thoughts": Place groceries in refrigerator from shopping at the grocery store.,
    "actions": ['[WALK] <dining_room>', '[WALK] <freezer>', '[FIND] <freezer>', '[OPEN] <freezer>', '[FIND] <food_food>', '[GRAB] <food_food>', '[PUTIN] <food_food> <freezer>', '[CLOSE] <freezer>']
}

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

Walk to kitchen. Open fridge. Put groceries in fridge.

[WALK] <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:['pot', 'chair', 'freezer', 'walllamp', 'bathroom', 'food_butter', 'knifeblock', 'floor', 'ceiling', 'character', 'desk', 'food_cake', 'computer', 'bookmark', 'toaster', 'stovefan', 'mat', 'faucet', 'food_kiwi', 'wall', 'oven', 'powersocket', 'food_vegetable', 'bed', 'food_food', 'oven_mitts', 'tray', 'towel_rack', 'kitchen_counter', 'cupboard']
Task:Cook some food
response:
{
    "thoughts": I prepare meals and cook them on the stove.,
    "actions": ['[WALK] <dining_room>', '[WALK] <freezer>', '[OPEN] <freezer>', '[FIND] <food_vegetable>', '[GRAB] <food_vegetable>', '[CLOSE] <freezer>', '[FIND] <oven>', '[SWITCHON] <oven>', '[SWITCHOFF] <oven>']
}

Input:
Scene_Objects:['filing_cabinet', 'tablelamp', 'toilet', 'freezer', 'bathroom_counter', 'floor', 'ceiling', 'desk', 'stovefan', 'mat', 'tvstand', 'faucet', 'toaster', 'teeth', 'towel', 'wall', 'wall_clock', 'oven', 'powersocket', 'food_food', 'tray', 'headset', 'comb', 'sink', 'clothes_scarf', 'bathroom_cabinet', 'instrument_guitar', 'soap', 'hands_both', 'creditcard']
Task:Wash hands
response:

Go to bathroom, turn on faucet, wet hands, apply soap, rub hands, rinse hands, turn off faucet, dry hands

[WALK] <bathroom>
[WALK] <faucet>
[FIND] <faucet>
[SWITCHON] <faucet>
[FIND] <hands_both>
[RINSE] <hands_both>
[FIND] <soap>
[GRAB] <soap>
[SCRUB] <hands_both>
[RINSE] <hands_both>
[SWITCHOFF] <faucet>
[FIND] <towel>
[GRAB] <towel>
[WIPE] <hands_both>
[PUTOBJBACK] <towel>


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

Here is an example plan to achieve a goal for reference:
Scene_Objects:['glue', 'filing_cabinet', 'tablelamp', 'microwave', 'toilet', 'dog', 'walllamp', 'bathroom', 'knifeblock', 'food_egg', 'food_bacon', 'brush', 'mat', 'deck_of_cards', 'balanceball', 'tvstand', 'ceilinglamp', 'picture', 'couch', 'wall', 'tape', 'cup', 'toilet_paper', 'food_food', 'video_game_controller', 'water', 'cupboard', 'bathroom_cabinet', 'table', 'vase']
Task:Drink
response:
{
    "thoughts": I go to the kitchen. I get a glass. I fill it with water. I take a drink from the glass.,
    "actions": ['[WALK] <dining_room>', '[WALK] <cup>', '[FIND] <cup>', '[GRAB] <cup>', '[WALK] <water>', '[FIND] <water>', '[GRAB] <water>', '[POUR] <water> <cup>', '[DRINK] <cup>']
}

Input:
Scene_Objects:['food_pizza', 'food_salt', 'microwave', 'freezer', 'walllamp', 'floor', 'ceiling', 'bedroom', 'food_cake', 'mail', 'table_cloth', 'stovefan', 'mat', 'shower', 'closetdrawer', 'food_jam', 'wall', 'nightstand', 'oven', 'cutting_board', 'shelf', 'bed', 'photoframe', 'standingmirror', 'coffe_maker', 'food_food', 'tray', 'kitchen_counter', 'dresser', 'instrument_violin']
Task:Put groceries in Fridge
response:

[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:['food_ice_cream', 'toilet', 'walllamp', 'nail_polish', 'dough', 'orchid', 'wallshelf', 'floor', 'ceiling', 'bookshelf', 'remote_control', 'keyboard', 'computer', 'stovefan', 'mat', 'tvstand', 'ceilinglamp', 'shower', 'window', 'wall', 'nightstand', 'powersocket', 'photoframe', 'television', 'curtain', 'doorjamb', 'cards', 'dishrack', 'door', 'light']
Task:Change TV channel
response:
{
    "thoughts": first i will go to living room and then take the remote and swtitch on television after that il change the channel,
    "actions": ['[WALK] <home_office>', '[WALK] <television>', '[FIND] <television>', '[SWITCHON] <television>', '[FIND] <remote_control>', '[TURNTO] <remote_control>', '[POINTAT] <remote_control>', '[TOUCH] <remote_control>', '[TURNTO] <television>', '[WATCH] <television>']
}

Input:
Scene_Objects:['sheets', 'food_pizza', 'food_ice_cream', 'crayon', 'toilet', 'chair', 'freezer', 'jelly', 'detergent', 'floor', 'ceiling', 'bookshelf', 'table_cloth', 'deck_of_cards', 'shower', 'picture', 'couch', 'wall', 'shelf', 'newspaper', 'wooden_spoon', 'centerpiece', 'kettle', 'shoes', 'comb', 'conditioner', 'door', 'napkin', 'bathroom_cabinet', 'table']
Task:Go to toilet
response:

[WALK] <bathroom>
[WALK] <toilet>
[FIND] <toilet>


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', 'blow_dryer', 'cat', 'trashcan', 'toothbrush', 'drawing', 'floor', 'character', 'desk', 'wine_glass', 'ceilinglamp', 'plate', 'shower', 'window', 'couch', 'pillow', 'dining_room', 'wall', 'nightstand', 'food_cheese', 'bed', 'food_food', 'check', 'television', 'coffee_filter', 'curtain', 'door', 'spoon', 'table']
Task:Entertain
response:
{
    "thoughts": Give guests wine, cheese, crackers and sit and talk,
    "actions": ['[WALK] <home_office>', '[WALK] <food_cheese>', '[FIND] <food_cheese>', '[FIND] <food_food>', '[FIND] <couch>', '[SIT] <couch>', '[FIND] <wine_glass>', '[GRAB] <wine_glass>', '[DRINK] <wine_glass>']
}

Input:
Scene_Objects:['mop', 'toilet', 'freezer', 'food_carrot', 'cpuscreen', 'bathroom_counter', 'floor', 'ceiling', 'piano_bench', 'stovefan', 'mat', 'faucet', 'wall', 'wall_clock', 'oven', 'cutting_board', 'toilet_paper', 'video_game_controller', 'television', 'tray', 'doorjamb', 'towel_rack', 'coffee_pot', 'kitchen_counter', 'dresser', 'conditioner', 'sink', 'bathroom_cabinet', 'light', 'teeth']
Task:Wash teeth
response:

Walk to bathroom.  Find mouthwash or turn on water.  Put mouthwash or water in mouth.  Swish around for 30 seconds.  Spit mouthwash out.

[WALK] <bathroom>
[WALK] <faucet>
[FIND] <faucet>
[SWITCHON] <faucet>
[FIND] <teeth>
[RINSE] <teeth>


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

Here is an example plan to achieve a goal for reference:
Scene_Objects:['glue', 'pot', 'blow_dryer', 'ceilingfan', 'drawing', 'bathroom_counter', 'floor', 'stovefan', 'ceilinglamp', 'balanceball', 'stereo', 'window', 'shower', 'clothes_socks', 'couch', 'candle', 'broom', 'wall', 'wall_clock', 'bed', 'television', 'curtain', 'pencil', 'kitchen_counter', 'dresser', 'napkin', 'spoon', 'table', 'dirt', 'creditcard']
Task:Relax on sofa
response:
{
    "thoughts": Find the sofa and sit on it.,
    "actions": ['[WALK] <home_office>', '[WALK] <couch>', '[FIND] <couch>', '[SIT] <couch>']
}

Input:
Scene_Objects:['filing_cabinet', 'mop', 'microwave', 'toilet', 'chair', 'dog', 'walllamp', 'floor', 'desk', 'bookshelf', 'keyboard', 'mat', 'plate', 'shower', 'window', 'bowl', 'wall', 'nightstand', 'powersocket', 'cutting_board', 'shelf', 'check', 'food_food', 'cards', 'towel_rack', 'kitchen_counter', 'maindoor', 'table', 'vase', 'dirt']
Task:Go to toilet
response:

Walk to the bathroom.  Find the toilet.  Lift the top of the toilet.  Sit on the toilet.

[WALK] <bathroom>
[WALK] <toilet>
[FIND] <toilet>
[OPEN] <toilet>
[SIT] <toilet>


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

Here is an example plan to achieve a goal for reference:
Scene_Objects:['food_bread', 'scissors', 'mop', 'chair', 'ceilingfan', 'milk', 'toothbrush', 'knifeblock', 'phone', 'bookshelf', 'stovefan', 'toaster', 'tvstand', 'shower', 'couch', 'food_peanut_butter', 'dustpan', 'oven', 'photoframe', 'clothes_gloves', 'bed', 'video_game_controller', 'tray', 'towel_rack', 'clothes_scarf', 'table', 'light', 'soap', 'tooth_paste', 'scrabble']
Task:Wash teeth
response:
{
    "thoughts": before going to bed or when wake up earily morning brush teeth,
    "actions": ['[WALK] <bathroom>', '[WALK] <tooth_paste>', '[FIND] <tooth_paste>', '[GRAB] <tooth_paste>', '[FIND] <toothbrush>', '[GRAB] <toothbrush>']
}

Input:
Scene_Objects:['chair', 'walllamp', 'bills', 'drawing', 'cpuscreen', 'floor', 'ceiling', 'character', 'desk', 'keyboard', 'bookshelf', 'computer', 'ceilinglamp', 'mousepad', 'closetdrawer', 'wall', 'powersocket', 'shelf', 'cup', 'television', 'doorjamb', 'mouse', 'address_book', 'dresser', 'conditioner', 'bathtub', 'spoon', 'light', 'table', 'soap']
Task:Work
response:

Walk to home office. Walk to computer. Switch on computer. Open the address book.

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


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

Here is an example plan to achieve a goal for reference:
Scene_Objects:['dry_pasta', 'food_pizza', 'mop', 'cat', 'knife', 'drawing', 'bathroom_counter', 'floor', 'ceiling', 'shampoo', 'dvd_player', 'keyboard', 'computer', 'mat', 'ceilinglamp', 'faucet', 'stereo', 'window', 'couch', 'towel', 'wall', 'novel', 'tray', 'doorjamb', 'hairbrush', 'sink', 'bathroom_cabinet', 'soap', 'hands_both', 'shoe_rack']
Task:Wash hands
response:
{
    "thoughts": I go to the sink, turn on the water,  put soap on my hands, rub them together, then rinse them off and turn off the water. I then towel off my hands.,
    "actions": ['[WALK] <bathroom>', '[WALK] <sink>', '[FIND] <faucet>', '[SWITCHON] <faucet>', '[FIND] <soap>', '[GRAB] <soap>', '[FIND] <hands_both>', '[WASH] <hands_both>', '[RINSE] <hands_both>', '[SWITCHOFF] <faucet>', '[FIND] <towel>', '[GRAB] <towel>', '[FIND] <hands_both>', '[WIPE] <hands_both>']
}

Input:
Scene_Objects:['filing_cabinet', 'tablelamp', 'food_salt', 'freezer', 'orchid', 'drawing', 'wallshelf', 'clothes_underwear', 'floor', 'phone', 'bookshelf', 'stovefan', 'pillow', 'wall', 'wall_clock', 'cutting_board', 'box', 'shelf', 'newspaper', 'bed', 'novel', 'coffe_maker', 'toilet_paper', 'wooden_spoon', 'hairbrush', 'door', 'home_office', 'table', 'light', 'vase']
Task:Read book
response:

Pick up the book, open to current page, read the words.

[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:['pot', 'microwave', 'freezer', 'dough', 'milk', 'drawing', 'floor', 'ceiling', 'keyboard', 'food_bacon', 'toaster', 'stovefan', 'mat', 'shower', 'couch', 'pillow', 'bowl', 'wall', 'oven', 'cup', 'coffe_maker', 'check', 'television', 'tray', 'curtain', 'towel_rack', 'kitchen_counter', 'cupboard', 'light', 'dishwasher']
Task:Get something to drink
response:
{
    "thoughts": Walk into the kitchen and to the cupboard to get a cup, walk to the fridge to look for a beverage to enjoy, open the freezer and get ice, pour beverage and enjoy,
    "actions": ['[WALK] <dining_room>', '[WALK] <cupboard>', '[FIND] <cupboard>', '[OPEN] <cupboard>', '[FIND] <cup>', '[GRAB] <cup>', '[CLOSE] <cupboard>', '[WALK] <freezer>', '[OPEN] <freezer>', '[FIND] <milk>', '[GRAB] <milk>', '[CLOSE] <freezer>', '[POUR] <milk> <cup>', '[DRINK] <cup>']
}

Input:
Scene_Objects:['pot', 'chair', 'freezer', 'drawing', 'needle', 'cpuscreen', 'hanger', 'floor', 'ceiling', 'desk', 'bookshelf', 'envelope', 'computer', 'ceilinglamp', 'mousepad', 'closetdrawer', 'couch', 'dustpan', 'dining_room', 'wall', 'nightstand', 'powersocket', 'food_food', 'toilet_paper', 'doorjamb', 'coffee_pot', 'mouse', 'kettle', 'dresser', 'light']
Task:Turn on light
response:

walk into living room, walk to light, turn on light switch.

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


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

Here is an example plan to achieve a goal for reference:
Scene_Objects:['pot', 'chair', 'ground_coffee', 'food_butter', 'toothbrush', 'knifeblock', 'drawing', 'phone', 'keyboard', 'bookshelf', 'table_cloth', 'mat', 'plate', 'electric_shaver', 'window', 'pillow', 'nightstand', 'oven', 'newspaper', 'clothes_gloves', 'photoframe', 'toilet_paper', 'water', 'centerpiece', 'towel_rack', 'kettle', 'pencil', 'clothes_scarf', 'tooth_paste', 'teeth']
Task:Wash teeth
response:
{
    "thoughts": Walk to bathroom. Find tooth paste, tooth brush and water. Squeeze tooth paste on tooth brush. Wash teeth.,
    "actions": ['[WALK] <bathroom>', '[WALK] <tooth_paste>', '[FIND] <tooth_paste>', '[FIND] <toothbrush>', '[FIND] <water>', '[SQUEEZE] <tooth_paste>', '[FIND] <teeth>', '[WASH] <teeth>']
}

Input:
Scene_Objects:['glue', 'microwave', 'freezer', 'ground_coffee', 'hanger', 'floor', 'ceiling', 'stamp', 'keyboard', 'toaster', 'plate', 'faucet', 'shower', 'mousepad', 'food_kiwi', 'wall', 'wall_clock', 'oven', 'cutting_board', 'standingmirror', 'photoframe', 'coffe_maker', 'video_game_controller', 'razor', 'coffee_filter', 'water', 'coffee_pot', 'kitchen_counter', 'sink', 'home_office']
Task:Make coffee
response:

Walk to Kitchen and find coffee maker, find coffee filter and place it in coffee maker. Find ground coffee and water. put both in coffee maker. Close the coffee maker and switch it on.

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


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

Here is an example plan to achieve a goal for reference:
Scene_Objects:['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:['tablelamp', 'chair', 'bathroom', 'cat', 'milk', 'orchid', 'floor', 'dvd_player', 'desk', 'keyboard', 'purse', 'table_cloth', 'mat', 'shower', 'window', 'clothes_socks', 'couch', 'clothes_pants', 'pillow', 'wall', 'powersocket', 'mouthwash', 'television', 'curtain', 'food_onion', 'doorjamb', 'kitchen_counter', 'bathtub', 'napkin', 'table']
Task:Pet cat
response:

I walk into the living room. I see my cat on the couch. I go sit next to the cat on the couch. I pet the cat on the back.

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


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

Here is an example plan to achieve a goal for reference:
Scene_Objects:['pot', 'toilet', 'freezer', 'walllamp', 'drawing', 'hanger', 'floor', 'mat', 'tvstand', 'window', 'couch', 'food_peanut_butter', 'pillow', 'wall', 'cutting_board', 'cup', 'novel', 'food_food', 'television', 'wine', 'curtain', 'doorjamb', 'towel_rack', 'pencil', 'shoes', 'bathtub', 'bathroom_cabinet', 'table', 'soap', 'board_game']
Task:Relax on sofa
response:
{
    "thoughts": lie in the sofa, relax,
    "actions": ['[WALK] <home_office>', '[WALK] <couch>', '[FIND] <couch>', '[LIE] <couch>']
}

Input:
Scene_Objects:['glue', 'filing_cabinet', 'toilet', 'walllamp', 'nail_polish', 'food_butter', 'drawing', 'orchid', 'bathroom_counter', 'floor', 'ceiling', 'phone', 'character', 'ceilinglamp', 'tvstand', 'shower', 'closetdrawer', 'couch', 'form', 'dining_room', 'wall', 'wall_clock', 'bed', 'toothbrush_holder', 'doorjamb', 'chessboard', 'door', 'napkin', 'bathroom_cabinet', 'shoe_rack']
Task:Pick up phone
response:

I walk over to the phone and pick it up.


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

Here is an example plan to achieve a goal for reference:
Scene_Objects:['pot', 'food_bread', 'microwave', 'detergent', 'knifeblock', 'floor', 'ceiling', 'character', 'computer', 'toaster', 'ceilinglamp', 'faucet', 'shower', 'wall', 'cup', 'check', 'mouthwash', 'water', 'wine', 'after_shave', 'curtain', 'food_onion', 'mouse', 'kitchen_counter', 'vacuum_cleaner', 'cupboard', 'conditioner', 'sink', 'napkin', 'bathroom_cabinet']
Task:Drink
response:
{
    "thoughts": I go in the kitchen and get the glass near the sink. I open the faucet, then I pour water in it, turn off the faucet and drink it.,
    "actions": ['[WALK] <dining_room>', '[WALK] <sink>', '[FIND] <cup>', '[GRAB] <cup>', '[FIND] <faucet>', '[SWITCHON] <faucet>', '[FIND] <water>', '[PUTBACK] <cup> <sink>', '[GRAB] <cup>', '[SWITCHOFF] <faucet>', '[DRINK] <cup>']
}

Input:
Scene_Objects:['chair', 'walllamp', 'bathroom', 'orchid', 'knife', 'cpuscreen', 'floor', 'ceiling', 'phone', 'desk', 'keyboard', 'computer', 'button', 'table_cloth', 'ceilinglamp', 'mousepad', 'closetdrawer', 'dining_room', 'wall', 'powersocket', 'shelf', 'television', 'doorjamb', 'mouse', 'dresser', 'door', 'home_office', 'light', 'table', 'laser_pointer']
Task:Write an email
response:

Find the computer.  Turn on the computer.  Open the e-mail program.  Create a new message.  Write the message.

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


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

Here is an example plan to achieve a goal for reference:
Scene_Objects:['sheets', 'pot', 'scissors', 'juice', 'drawing', 'bills', 'bathroom_counter', 'floor', 'ceiling', 'character', 'desk', 'faucet', 'towel', 'dining_room', 'wall', 'photoframe', 'food_food', 'razor', 'television', 'food_rice', 'wooden_spoon', 'after_shave', 'headset', 'laundry_detergent', 'conditioner', 'sink', 'bathroom_cabinet', 'table', 'soap', 'hands_both']
Task:Wash hands
response:
{
    "thoughts": Turn on the water faucet. Wet my hands and turn off the faucet. Put soap on my hands. Rub hands together, making sure the soap covers all areas of the hands. Scrub hands for about 20 seconds. Turn on the water water faucet. Rinse hands under the running water. Turn off the water faucet. Dry hands with a towel.,
    "actions": ['[WALK] <bathroom>', '[WALK] <sink>', '[FIND] <sink>', '[TURNTO] <sink>', '[FIND] <faucet>', '[SWITCHON] <faucet>', '[FIND] <hands_both>', '[WASH] <hands_both>', '[FIND] <soap>', '[GRAB] <soap>', '[SCRUB] <hands_both>', '[PUTOBJBACK] <soap>', '[RINSE] <hands_both>', '[SWITCHOFF] <faucet>', '[FIND] <towel>', '[GRAB] <towel>', '[WIPE] <hands_both>', '[PUTOBJBACK] <towel>']
}

Input:
Scene_Objects:['sheets', 'pot', 'microwave', 'chair', 'freezer', 'nail_polish', 'detergent', 'wallshelf', 'floor', 'ceiling', 'bedroom', 'bookshelf', 'food_cake', 'keyboard', 'toaster', 'stovefan', 'window', 'tooth_paste', 'cup', 'check', 'toothbrush_holder', 'doorjamb', 'coffee_pot', 'mouse', 'pencil', 'bathtub', 'light', 'table', 'board_game', 'teeth']
Task:Pet cat
response:

I go looking for the cat in the living room where he usually sleeps. Once I find the cat I just pet him for a few minutes.

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


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

Here is an example plan to achieve a goal for reference:
Scene_Objects:['food_ice_cream', 'chair', 'walllamp', 'bathroom', 'orchid', 'knifeblock', 'cpuscreen', 'needle', 'floor', 'ceiling', 'desk', 'keyboard', 'bookshelf', 'computer', 'mat', 'ceilinglamp', 'mousepad', 'couch', 'dining_room', 'wall', 'basket_for_clothes', 'light_bulb', 'food_food', 'check', 'toothbrush_holder', 'mouse', 'comb', 'door', 'clothes_scarf', 'table']
Task:Work
response:
{
    "thoughts": I walk to the home office. I open the door of the office room and sit on the chair and in front of me is my desktop computer,  and I switch on the computer.,
    "actions": ['[WALK] <home_office>', '[WALK] <chair>', '[FIND] <chair>', '[SIT] <chair>', '[FIND] <computer>', '[SWITCHON] <computer>']
}

Input:
Scene_Objects:['sheets', 'pot', 'filing_cabinet', 'cat', 'floor', 'phone', 'dvd_player', 'bedroom', 'stovefan', 'mat', 'window', 'electric_shaver', 'couch', 'pillow', 'towel', 'wall', 'powersocket', 'toy', 'food_cheese', 'photoframe', 'newspaper', 'television', 'curtain', 'doorjamb', 'pencil', 'shoes', 'maindoor', 'bathtub', 'spoon', 'table']
Task:Pet cat
response:

I walk to the living room.  I locate the cat.  I walk to the couch and sit down beside the cat.  I pet the cat.

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


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

Here is an example plan to achieve a goal for reference:
Scene_Objects:['fork', 'pot', 'microwave', 'toilet', 'cat', 'wallshelf', 'bathroom_counter', 'floor', 'dvd_player', 'bookshelf', 'stovefan', 'ceilinglamp', 'toaster', 'mat', 'shower', 'faucet', 'tvstand', 'couch', 'towel', 'wall', 'bench', 'cutting_board', 'bed', 'razor', 'television', 'curtain', 'kitchen_counter', 'dresser', 'home_office', 'light']
Task:Pet cat
response:
{
    "thoughts": Pet Cat,
    "actions": ['[WALK] <home_office>', '[WALK] <cat>', '[FIND] <cat>', '[WALK] <cat>', '[TURNTO] <cat>', '[LOOKAT] <cat>', '[TOUCH] <cat>']
}

Input:
Scene_Objects:['filing_cabinet', 'mop', 'microwave', 'freezer', 'walllamp', 'detergent', 'toothbrush', 'orchid', 'drawing', 'clothes_underwear', 'floor', 'thread', 'mat', 'closetdrawer', 'wall', 'nightstand', 'toy', 'standingmirror', 'light_bulb', 'novel', 'check', 'tray', 'cards', 'mouse', 'pencil', 'vacuum_cleaner', 'headset', 'maindoor', 'napkin', 'light']
Task:Read book
response:

Walk to the Living Room. Look at the Cabinet. Find a Textbook. Grab the textbook. Open the Textbook. Read the textbook.

[WALK] <home_office>
[WALK] <filing_cabinet>
[FIND] <filing_cabinet>
[TURNTO] <filing_cabinet>
[LOOKAT] <filing_cabinet>
[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:['filing_cabinet', 'trashcan', 'food_carrot', 'knifeblock', 'drawing', 'cpuscreen', 'clothes_underwear', 'floor', 'bedroom', 'alcohol', 'laptop', 'tvstand', 'stereo', 'faucet', 'mat', 'couch', 'clothes_hat', 'nightstand', 'bench', 'oven', 'toy', 'coffe_maker', 'television', 'coin', 'kitchen_counter', 'cupboard', 'home_office', 'bathroom_cabinet', 'dishwasher', 'board_game']
Task:Listen to music
response:
{
    "thoughts": go to radio. run on radio.,
    "actions": ['[WALK] <stereo>', '[SWITCHON] <stereo>']
}

Input:
Scene_Objects:['scissors', 'detergent', 'orchid', 'wallshelf', 'bedroom', 'tea_bag', 'bookshelf', 'ceilinglamp', 'laptop', 'faucet', 'window', 'couch', 'broom', 'wall', 'oven', 'cutting_board', 'toy', 'cup', 'standingmirror', 'razor', 'television', 'tray', 'after_shave', 'towel_rack', 'mouse', 'kitchen_counter', 'controller', 'bathtub', 'vase', 'soap']
Task:Pick up phone
response:

walk to living room, walk to the phone reach for the phone and pick up the phone.

[WALK] <home_office>
[WALK] <phone>
[FIND] <phone>
[TOUCH] <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', 'food_salt', 'microwave', 'freezer', 'drawing', 'floor', 'ceiling', 'desk', 'alcohol', 'stovefan', 'mat', 'plate', 'shower', 'couch', 'food_orange', 'pillow', 'wall', 'oven', 'food_food', 'television', 'tray', 'towel_rack', 'kitchen_counter', 'sauce_pan', 'cupboard', 'spoon', 'napkin', 'light', 'dishwasher']
Task:Cook some food
response:
{
    "thoughts": I pull a sauce pan from the cupboard. I turn the stove on. I take my ingredients from the pantry and fridge. I put the ingredients in the pan and I mix them with a spoon. I cook until the food is finished and transfer my food to a plate.,
    "actions": ['[WALK] <dining_room>', '[WALK] <food_food>', '[FIND] <food_food>', '[FIND] <pot>', '[GRAB] <pot>', '[FIND] <spoon>', '[GRAB] <spoon>', '[FIND] <sauce_pan>', '[PUTBACK] <spoon> <sauce_pan>', '[FIND] <freezer>', '[OPEN] <freezer>', '[FIND] <plate>', '[PUTBACK] <pot> <plate>']
}

Input:
Scene_Objects:['spectacles', 'fork', 'tablelamp', 'tea', 'band-aids', 'bathroom', 'drawing', 'hanger', 'floor', 'ceiling', 'dvd_player', 'desk', 'remote_control', 'computer', 'food_bacon', 'mat', 'ceilinglamp', 'window', 'mousepad', 'closetdrawer', 'couch', 'clothes_pants', 'pillow', 'wall', 'standingmirror', 'television', 'curtain', 'doorjamb', 'table', 'soap']
Task:Change TV channel
response:

I push my body to be near to the table in front of me, without stand up. I move my right hand to near the TV remote control on the table. I take the TV remote control. I look the number on the remote control. I touch number 3 button. I put back the remote control to the table. I put my body back to the sofa

[WALK] <home_office>
[WALK] <television>
[FIND] <television>
[PLUGIN] <television>
[FIND] <couch>
[SIT] <couch>
[FIND] <remote_control>
[TURNTO] <remote_control>
[LOOKAT] <remote_control>
[GRAB] <remote_control>
[TOUCH] <remote_control>
[PUTOBJBACK] <remote_control>
[TURNTO] <television>
[WATCH] <television>


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

Here is an example plan to achieve a goal for reference:
Scene_Objects:['microwave', 'chair', 'freezer', 'detergent', 'food_carrot', 'orchid', 'floor', 'wine_glass', 'food_cake', 'mat', 'picture', 'window', 'mousepad', 'couch', 'clothes_hat', 'pillow', 'wall', 'pasta', 'shelf', 'food_cheese', 'newspaper', 'food_food', 'television', 'curtain', 'doorjamb', 'kitchen_counter', 'dresser', 'bathtub', 'table', 'vase']
Task:Entertain
response:
{
    "thoughts": Give guests wine, cheese, crackers and sit and talk,
    "actions": ['[WALK] <home_office>', '[WALK] <food_cheese>', '[FIND] <food_cheese>', '[FIND] <food_food>', '[FIND] <couch>', '[SIT] <couch>', '[FIND] <wine_glass>', '[GRAB] <wine_glass>', '[DRINK] <wine_glass>']
}

Input:
Scene_Objects:['blow_dryer', 'drawing', 'knife', 'hanger', 'floor', 'ceiling', 'shampoo', 'desk', 'keyboard', 'remote_control', 'thread', 'computer', 'alcohol', 'bookmark', 'mat', 'ceilinglamp', 'window', 'closetdrawer', 'couch', 'pillow', 'wall', 'wall_clock', 'tape', 'standingmirror', 'bed', 'television', 'curtain', 'doorjamb', 'instrument_guitar', 'table']
Task:Change TV channel
response:

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


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

Here is an example plan to achieve a goal for reference:
Scene_Objects:['measuring_cup', 'microwave', 'chair', 'walllamp', 'cat', 'wallshelf', 'floor', 'character', 'desk', 'tea_bag', 'toaster', 'plate', 'couch', 'dining_room', 'box', 'newspaper', 'bed', 'toilet_paper', 'curtain', 'coffee_pot', 'mouse', 'kettle', 'cupboard', 'controller', 'clothes_dress', 'sink', 'bathroom_cabinet', 'table', 'dishwasher', 'soap']
Task:Pet cat
response:
{
    "thoughts": Find Cat in living room.  Walk to cat.  Pet cat.,
    "actions": ['[WALK] <home_office>', '[WALK] <cat>', '[FIND] <cat>', '[TURNTO] <cat>', '[LOOKAT] <cat>', '[TOUCH] <cat>']
}

Input:
Scene_Objects:['freezer', 'bathroom', 'detergent', 'orchid', 'cpuscreen', 'floor', 'phone', 'desk', 'bedroom', 'purse', 'computer', 'table_cloth', 'bookmark', 'stovefan', 'stereo', 'oil', 'closetdrawer', 'coffe_maker', 'television', 'food_donut', 'food_rice', 'tray', 'centerpiece', 'doorjamb', 'pencil', 'maindoor', 'sink', 'home_office', 'table', 'clothes_skirt']
Task:Read book
response:

Walk to living room. Find book. Grab book. Open book. Read 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:['fork', 'toilet', 'trashcan', 'ceilingfan', 'drawing', 'hanger', 'floor', 'ceiling', 'bookshelf', 'thread', 'computer', 'piano_bench', 'ceilinglamp', 'tvstand', 'balanceball', 'window', 'foundation', 'clothes_pants', 'pillow', 'dining_room', 'wall', 'oven', 'bed', 'novel', 'check', 'television', 'curtain', 'towel_rack', 'dresser', 'vase']
Task:Read book
response:
{
    "thoughts": Put child in bed, sit down,read book.,
    "actions": ['[WALK] <bedroom>', '[WALK] <dresser>', '[OPEN] <dresser>', '[FIND] <novel>', '[GRAB] <novel>', '[FIND] <bed>', '[SIT] <bed>', '[READ] <novel>']
}

Input:
Scene_Objects:['sponge', 'toilet', 'jelly', 'freezer', 'walllamp', 'bathroom', 'hanger', 'folder', 'bedroom', 'desk', 'tvstand', 'window', 'food_jam', 'microphone', 'dining_room', 'wall_clock', 'powersocket', 'bench', 'shelf', 'bed', 'video_game_controller', 'food_donut', 'water', 'doorjamb', 'cards', 'towel_rack', 'mouse', 'sink', 'colander', 'hands_both']
Task:Wash hands
response:

walk to bathroom, look at the water, wash hands

[WALK] <bathroom>
[WALK] <water>
[FIND] <water>
[TURNTO] <water>
[LOOKAT] <water>
[FIND] <hands_both>
[WASH] <hands_both>


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

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

Input:
Scene_Objects:['microwave', 'walllamp', 'detergent', 'toothbrush', 'drawing', 'cpuscreen', 'food_egg', 'phone', 'character', 'computer', 'piano_bench', 'shoe-shine_kit', 'faucet', 'food_noodles', 'mousepad', 'clothes_hat', 'towel', 'broom', 'cutting_board', 'shelf', 'keys', 'novel', 'food_food', 'check', 'wooden_spoon', 'towel_rack', 'sink', 'table', 'light', 'coffee']
Task:Change TV channel
response:

I pull up my online classes on the computer to look at what the assigned reading is. I get my textbook, notebook, and mechanical pencil. As I'm reading, I take notes over important points. I then use those notes to complete the assignment for the week. Frequently that involves writing a post on an online discussion board that answers a question related to things from the reading.

[WALK] <home_office>
[WALK] <remote_control>
[GRAB] <remote_control>
[TURNTO] <remote_control>
[POINTAT] <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:['spectacles', 'food_ice_cream', 'cd_player', 'orchid', 'bedroom', 'purse', 'computer', 'stovefan', 'mat', 'ceilinglamp', 'stereo', 'tvstand', 'balanceball', 'clothes_socks', 'couch', 'food_jam', 'powersocket', 'oven', 'cutting_board', 'photoframe', 'novel', 'check', 'television', 'wine', 'food_onion', 'pencil', 'vacuum_cleaner', 'door', 'sink', 'instrument_violin']
Task:Listen to music
response:
{
    "thoughts": I walk in the living room, then I go the the stereo and the cd player and turn them on.,
    "actions": ['[WALK] <home_office>', '[WALK] <stereo>', '[FIND] <stereo>', '[SWITCHON] <stereo>', '[FIND] <cd_player>', '[SWITCHON] <cd_player>']
}

Input:
Scene_Objects:['filing_cabinet', 'scissors', 'freezer', 'nail_polish', 'food_carrot', 'orchid', 'bedroom', 'computer', 'food_bacon', 'toaster', 'plate', 'window', 'clothes_socks', 'closetdrawer', 'oil', 'nightstand', 'basket_for_clothes', 'photoframe', 'check', 'doorjamb', 'towel_rack', 'console', 'dresser', 'door', 'sink', 'table', 'clothes_skirt', 'soap', 'clothes_shirt', 'washing_machine']
Task:Wash clothes
response:

walk to the bathroom, grab the basket for clothes, find soap, put in washing machine, turn on


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

Here is an example plan to achieve a goal for reference:
Scene_Objects:['sheets', 'glue', 'microwave', 'bathroom', 'trashcan', 'toothbrush', 'drawing', 'knifeblock', 'food_egg', 'floor', 'ceiling', 'desk', 'purse', 'food_bacon', 'ceilinglamp', 'plate', 'laptop', 'deck_of_cards', 'window', 'couch', 'food_orange', 'wall', 'powersocket', 'photoframe', 'check', 'television', 'spoon', 'home_office', 'table', 'teeth']
Task:Relax on sofa
response:
{
    "thoughts": I walk to the sofa, and lie down on the sofa.,
    "actions": ['[WALK] <couch>', '[LIE] <couch>']
}

Input:
Scene_Objects:['freezer', 'walllamp', 'bathroom', 'cpuscreen', 'clothes_underwear', 'bathroom_counter', 'shampoo', 'tvstand', 'faucet', 'stereo', 'clothes_socks', 'couch', 'clothes_pants', 'cutting_board', 'basket_for_clothes', 'photoframe', 'food_food', 'video_game_controller', 'coffe_maker', 'coffee_filter', 'television', 'tray', 'curtain', 'shaving_cream', 'laundry_detergent', 'maindoor', 'spoon', 'home_office', 'clothes_shirt', 'washing_machine']
Task:Wash clothes
response:

I go to the bathroom and open the washing machine there. I take my laundry basket and put each item of laundry into the machine. Then I take the laundry detergent and pour some into the machine. Finally I close the machine and switch it on.


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

Here is an example plan to achieve a goal for reference:
Scene_Objects:['sheets', 'pot', 'scissors', 'juice', 'drawing', 'bills', 'bathroom_counter', 'floor', 'ceiling', 'character', 'desk', 'faucet', 'towel', 'dining_room', 'wall', 'photoframe', 'food_food', 'razor', 'television', 'food_rice', 'wooden_spoon', 'after_shave', 'headset', 'laundry_detergent', 'conditioner', 'sink', 'bathroom_cabinet', 'table', 'soap', 'hands_both']
Task:Wash hands
response:
{
    "thoughts": Turn on the water faucet. Wet my hands and turn off the faucet. Put soap on my hands. Rub hands together, making sure the soap covers all areas of the hands. Scrub hands for about 20 seconds. Turn on the water water faucet. Rinse hands under the running water. Turn off the water faucet. Dry hands with a towel.,
    "actions": ['[WALK] <bathroom>', '[WALK] <sink>', '[FIND] <sink>', '[TURNTO] <sink>', '[FIND] <faucet>', '[SWITCHON] <faucet>', '[FIND] <hands_both>', '[WASH] <hands_both>', '[FIND] <soap>', '[GRAB] <soap>', '[SCRUB] <hands_both>', '[PUTOBJBACK] <soap>', '[RINSE] <hands_both>', '[SWITCHOFF] <faucet>', '[FIND] <towel>', '[GRAB] <towel>', '[WIPE] <hands_both>', '[PUTOBJBACK] <towel>']
}

Input:
Scene_Objects:['fork', 'pot', 'food_pizza', 'juice', 'board_game', 'dog', 'food_butter', 'orchid', 'drawing', 'bathroom_counter', 'bookshelf', 'stovefan', 'mat', 'laptop', 'tvstand', 'picture', 'window', 'couch', 'nightstand', 'wall_clock', 'toy', 'clothes_gloves', 'toilet_paper', 'television', 'ice', 'bathroom_cabinet', 'table', 'light', 'vase', 'instrument_violin']
Task:Set up table
response:

Walk into kitchen, find plate, drop plate on table in living room, walk into kitchen, find cup, bring cup to table in living room, walk into kitchen find fork, bring fork to table in living room

[WALK] <dining_room>
[WALK] <plate>
[FIND] <plate>
[GRAB] <plate>
[WALK] <home_office>
[DROP] <plate>
[WALK] <dining_room>
[WALK] <cup>
[FIND] <cup>
[GRAB] <cup>
[WALK] <home_office>
[DROP] <cup>
[WALK] <dining_room>
[WALK] <fork>
[FIND] <fork>
[GRAB] <fork>
[WALK] <home_office>
[DROP] <fork>


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

Here is an example plan to achieve a goal for reference:
Scene_Objects:['pot', 'food_pizza', 'food_salt', 'microwave', 'freezer', 'orchid', 'drawing', 'hanger', 'button', 'table_cloth', 'tvstand', 'homework', 'couch', 'dining_room', 'nightstand', 'keys', 'coffe_maker', 'television', 'oven_mitts', 'curtain', 'doorjamb', 'diary', 'cards', 'kitchen_counter', 'comb', 'dresser', 'food_steak', 'home_office', 'light', 'clothes_skirt']
Task:Pet cat
response:
{
    "thoughts": I go to the living room then go to the cat and touch it.,
    "actions": ['[WALK] <home_office>', '[WALK] <cat>', '[FIND] <cat>', '[TOUCH] <cat>']
}

Input:
Scene_Objects:['microwave', 'toilet', 'freezer', 'ground_coffee', 'walllamp', 'blow_dryer', 'dough', 'floor', 'ceiling', 'bookshelf', 'toaster', 'faucet', 'wall', 'wall_clock', 'pasta', 'bench', 'powersocket', 'cutting_board', 'box', 'bed', 'coffe_maker', 'coffee_filter', 'water', 'tray', 'doorjamb', 'mouse', 'kitchen_counter', 'sink', 'table', 'clothes_skirt']
Task:Make coffee
response:

I walk into the kitchen. I find the coffee maker and open it. I find the coffee filter, grab it and put it into the coffee maker. I find ground coffee, grab it and put it into the coffee maker. I find some water, then I pour it into the coffee maker. I close the coffee maker, I plug it in and I 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>
[PUTBACK] <ground_coffee> <coffe_maker>
[WALK] <water>
[FIND] <water>
[GRAB] <water>
[POUR] <water> <coffe_maker>
[CLOSE] <coffe_maker>
[PLUGIN] <coffe_maker>
[SWITCHON] <coffe_maker>