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

Here is an example plan to achieve a goal for reference:
Scene_Objects:['filing_cabinet', 'tablelamp', 'microwave', 'detergent', 'knife', 'bills', 'bathroom_counter', 'phone', 'folder', 'bedroom', 'character', 'computer', 'toaster', 'stovefan', 'mat', 'window', 'mousepad', 'pillow', 'oven', 'check', 'coffe_maker', 'razor', 'after_shave', 'mouse', 'kitchen_counter', 'shoes', 'dresser', 'pajamas', 'sink', 'bag']
Task:Get dressed
response:
{
    "thoughts": I get dressed in my bedroom in the mornings.,
    "actions": ['[WALK] <bedroom>', '[WALK] <shoes>', '[FIND] <shoes>', '[GRAB] <shoes>', '[PUTON] <shoes>']
}

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

Find home office. Walk to home office. Find computer. Find chair at desk. Sit in chair. Switch on computer. Work on computer.

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


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

Here is an example plan to achieve a goal for reference:
Scene_Objects:['pot', 'food_bread', 'juice', 'microwave', 'chair', 'freezer', 'detergent', 'drawing', 'orchid', 'floor', 'ceiling', 'toaster', 'stovefan', 'plate', 'shower', 'mat', 'ceilinglamp', 'couch', 'pillow', 'wall', 'pasta', 'oven', 'cup', 'newspaper', 'coffe_maker', 'television', 'ice', 'wine', 'tray', 'towel_rack', 'kitchen_counter', 'headset', 'cupboard', 'table', 'dishwasher', 'creditcard']
Task:Grab some juice
response:
{
    "thoughts": I go to the fridge, and grab some juice out of it. I then get a glass, and pour the juice into the glass.,
    "actions": ['[WALK] <dining_room>', '[WALK] <cupboard>', '[FIND] <cupboard>', '[OPEN] <cupboard>', '[FIND] <cup>', '[GRAB] <cup>', '[CLOSE] <cupboard>', '[WALK] <freezer>', '[OPEN] <freezer>', '[FIND] <juice>', '[GRAB] <juice>', '[POUR] <juice> <cup>', '[PUTOBJBACK] <juice>', '[CLOSE] <freezer>', '[FIND] <table>', '[PUTBACK] <cup> <table>']
}

Input:
Scene_Objects:['pot', 'tablelamp', 'crayon', 'toilet', 'drawing', 'wallshelf', 'bathroom_counter', 'floor', 'phone', 'ceiling', 'bedroom', 'mail', 'food_bacon', 'clothes_jacket', 'table_cloth', 'faucet', 'mousepad', 'closetdrawer', 'food_jam', 'nightstand', 'powersocket', 'novel', 'food_food', 'centerpiece', 'diary', 'console', 'cupboard', 'bathroom_cabinet', 'table', 'light']
Task:Pick up phone
response:

[WALK] <home_office>
[WALK]

[FIND]

[TURNTO]

[POINTAT]

[FIND] <phone>
[GRAB] <phone>
[PUTOBJBACK] <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:['fork', 'microwave', 'chair', 'detergent', 'trashcan', 'knifeblock', 'floor', 'ceiling', 'character', 'bookshelf', 'purse', 'computer', 'toaster', 'mat', 'tvstand', 'clothes_socks', 'food_peanut_butter', 'microphone', 'food_jam', 'pillow', 'wall', 'powersocket', 'after_shave', 'doorjamb', 'cd', 'pajamas', 'laundry_detergent', 'door', 'light', 'tooth_paste']
Task:Turn on light
response:
{
    "thoughts": Coming home turning on lights.,
    "actions": ['[WALK] <home_office>', '[WALK] <light>', '[FIND] <light>', '[SWITCHON] <light>']
}

Input:
Scene_Objects:['filing_cabinet', 'toilet', 'drawing', 'wallshelf', 'bathroom_counter', 'floor', 'ceiling', 'desk', 'bookshelf', 'envelope', 'computer', 'table_cloth', 'mat', 'tvstand', 'iron', 'wall', 'powersocket', 'oven', 'bed', 'television', 'tray', 'after_shave', 'doorjamb', 'diary', 'kitchen_counter', 'dresser', 'door', 'home_office', 'light', 'dishwasher']
Task:Turn on light
response:

Walk to living room.  Find light switch.  Switch on light switch.

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


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

Here is an example plan to achieve a goal for reference:
Scene_Objects:['sponge', 'tablelamp', 'chair', 'detergent', 'toothbrush', 'floor', 'ceiling', 'food_cake', 'toaster', 'mat', 'plate', 'faucet', 'shower', 'ceilinglamp', 'dish_soap', 'closetdrawer', 'pillow', 'bowl', 'dining_room', 'wall', 'powersocket', 'cup', 'food_cheese', 'clothes_gloves', 'coffe_maker', 'after_shave', 'kitchen_counter', 'dishrack', 'cupboard', 'sink']
Task:Wash dishes
response:
{
    "thoughts": Turn water on and run over dishes while scrubbing with a soapy sponge.,
    "actions": ['[WALK] <dining_room>', '[WALK] <sink>', '[FIND] <faucet>', '[SWITCHON] <faucet>', '[FIND] <dish_soap>', '[GRAB] <dish_soap>', '[FIND] <sponge>', '[GRAB] <sponge>', '[POUR] <dish_soap> <sponge>', '[PUTOBJBACK] <dish_soap>', '[FIND] <plate>', '[GRAB] <plate>', '[SCRUB] <plate>', '[RINSE] <plate>', '[FIND] <dishrack>', '[PUTBACK] <plate> <dishrack>', '[FIND] <plate>', '[GRAB] <plate>', '[SCRUB] <plate>', '[RINSE] <plate>', '[PUTBACK] <plate> <dishrack>', '[RINSE] <sponge>', '[PUTOBJBACK] <sponge>', '[SWITCHOFF] <faucet>']
}

Input:
Scene_Objects:['tablelamp', 'microwave', 'chair', 'jelly', 'ground_coffee', 'nail_polish', 'detergent', 'orchid', 'needle', 'drawing', 'hanger', 'character', 'envelope', 'ceilinglamp', 'shower', 'electric_shaver', 'tooth_paste', 'mousepad', 'food_kiwi', 'powersocket', 'oven', 'tape', 'cup', 'photoframe', 'wooden_spoon', 'cards', 'kitchen_counter', 'cd', 'instrument_violin', 'laser_pointer']
Task:Wash dishes with dishwasher
response:

[WALK] <dining_room>
[WALK] <bowl>
[FIND] <bowl>
[GRAB] <bowl>
[WALK] <dining_room>
[WASH] <bowl>
[WALK] <detergent>
[FIND] <detergent>
[RINSE] <detergent>


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', 'mop', 'dog', 'freezer', 'drawing', 'bathroom_counter', 'floor', 'ceiling', 'keyboard', 'toaster', 'mat', 'closetdrawer', 'couch', 'food_jam', 'food_orange', 'pillow', 'dining_room', 'food_kiwi', 'wall', 'food_cheese', 'keys', 'food_food', 'video_game_controller', 'television', 'ice', 'curtain', 'kitchen_counter', 'cupboard', 'sink', 'dishwasher']
Task:Put groceries in Fridge
response:
{
    "thoughts": Walk to kitchen. Open fridge. Put groceries in fridge.,
    "actions": ['[WALK] <freezer>', '[OPEN] <freezer>', '[FIND] <food_food>', '[GRAB] <food_food>', '[PUTIN] <food_food> <freezer>', '[CLOSE] <freezer>']
}

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

I go to home office, sit in the desk, switch on the computer and write a message

[WALK] <home_office>
[WALK] <chair>
[FIND] <chair>
[SIT] <chair>
[FIND] <computer>
[SWITCHON] <computer>
[FIND] <keyboard>
[TYPE] <keyboard>
[FIND] <mail>
[OPEN] <mail>
[TYPE] <keyboard>
[CLOSE] <mail>
[SWITCHOFF] <computer>


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

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

Input:
Scene_Objects:['blender', 'chair', 'blow_dryer', 'bathroom', 'drawing', 'cpuscreen', 'hanger', 'floor', 'ceiling', 'phone', 'folder', 'desk', 'stamp', 'keyboard', 'computer', 'food_bacon', 'mousepad', 'closetdrawer', 'wall', 'powersocket', 'coffe_maker', 'wooden_spoon', 'towel_rack', 'mouse', 'kitchen_counter', 'vacuum_cleaner', 'dresser', 'controller', 'light', 'soap']
Task:Vacuum
response:

Plug in vacuum. Walk around with vacuum, covering all of the floor. Unplug vacuum.

[WALK] <bedroom>
[WALK] <dresser>
[OPEN] <dresser>
[FIND] <vacuum_cleaner>
[GRAB] <vacuum_cleaner>
[PULL] <vacuum_cleaner>
[PLUGIN] <vacuum_cleaner>
[SWITCHON] <vacuum_cleaner>
[PULL] <vacuum_cleaner>
[PUSH] <vacuum_cleaner>
[PULL] <vacuum_cleaner>
[PUSH] <vacuum_cleaner>
[PULL] <vacuum_cleaner>
[PUSH] <vacuum_cleaner>
[SWITCHOFF] <vacuum_cleaner>
[PLUGOUT] <vacuum_cleaner>
[WALK] <dresser>
[PUTIN] <vacuum_cleaner> <dresser>
[CLOSE] <dresser>


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

Here is an example plan to achieve a goal for reference:
Scene_Objects:['sheets', 'filing_cabinet', 'tablelamp', 'juice', 'microwave', 'toilet', 'walllamp', 'orchid', 'bathroom_counter', 'bookshelf', 'bookmark', 'toaster', 'ceilinglamp', 'tvstand', 'faucet', 'window', 'mousepad', 'wall_clock', 'food_food', 'coffe_maker', 'tray', 'curtain', 'doorjamb', 'diary', 'mouse', 'kitchen_counter', 'cupboard', 'bathtub', 'home_office', 'bathroom_cabinet']
Task:Drink
response:
{
    "thoughts": Walk to kitchen. Find water glass. Grab water glass. Find water. Pour water in water glass. Drink water from water glass.,
    "actions": ['[WALK] <dining_room>', '[WALK] <water_glass>', '[FIND] <water_glass>', '[GRAB] <water_glass>', '[WALK] <water>', '[FIND] <water>', '[GRAB] <water>', '[POUR] <water> <water_glass>', '[DRINK] <water_glass>']
}

Input:
Scene_Objects:['filing_cabinet', 'tablelamp', 'tea', 'milk', 'floor', 'desk', 'bedroom', 'food_cake', 'stovefan', 'tvstand', 'picture', 'window', 'clothes_socks', 'couch', 'microphone', 'oven', 'bench', 'toy', 'cutting_board', 'photoframe', 'coffe_maker', 'mouthwash', 'tray', 'pencil', 'controller', 'door', 'bathtub', 'home_office', 'light', 'bathroom_cabinet']
Task:Walk through
response:

[WALK] <home_office>
[WALK] <home_office>


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

Here is an example plan to achieve a goal for reference:
Scene_Objects:['microwave', 'freezer', 'bathroom', 'drawing', 'bathroom_counter', 'floor', 'ceiling', 'shampoo', 'alcohol', 'stovefan', 'mat', 'shoe-shine_kit', 'tvstand', 'closetdrawer', 'couch', 'food_orange', 'pillow', 'wall', 'powersocket', 'photoframe', 'food_food', 'check', 'television', 'coffe_maker', 'ice', 'kitchen_counter', 'cupboard', 'hair', 'table', 'scrabble']
Task:Put groceries in Fridge
response:
{
    "thoughts": I walk in to the kitchen. I open the fridge. I place the groceries in the fridge. I close the fridge.,
    "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:['sheets', 'juice', 'microwave', 'freezer', 'detergent', 'drawing', 'cpuscreen', 'bathroom_counter', 'floor', 'tea_bag', 'keyboard', 'computer', 'button', 'stovefan', 'mat', 'ceilinglamp', 'homework', 'closetdrawer', 'couch', 'wall', 'oven', 'cutting_board', 'toilet_paper', 'television', 'curtain', 'diary', 'pencil', 'shoes', 'dresser', 'table']
Task:Put out flowers
response:

Place a flower centrepiece on the entrance hall table.

[WALK] <home_office>
[WALK] <centerpiece>
[FIND] <centerpiece>
[GRAB] <centerpiece>
[WALK] <table>
[PUTBACK] <centerpiece> <table>


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

Here is an example plan to achieve a goal for reference:
Scene_Objects:['walllamp', 'orchid', 'drawing', 'wallshelf', 'floor', 'ceiling', 'bookshelf', 'remote_control', 'toaster', 'mat', 'tvstand', 'ceilinglamp', 'shower', 'window', 'oil', 'couch', 'pillow', 'wall', 'powersocket', 'photoframe', 'check', 'television', 'oven_mitts', 'curtain', 'doorjamb', 'towel_rack', 'dresser', 'door', 'light', 'table']
Task:Watch TV
response:
{
    "thoughts": Turn on the TV, sit on the couch, find a show, and watch it.,
    "actions": ['[WALK] <home_office>', '[WALK] <television>', '[FIND] <television>', '[FIND] <remote_control>', '[FIND] <couch>', '[SIT] <couch>', '[SWITCHON] <television>', '[TURNTO] <television>', '[LOOKAT] <television>']
}

Input:
Scene_Objects:['dry_pasta', 'blender', 'beer', 'mop', 'chair', 'freezer', 'bathroom', 'drawing', 'cpuscreen', 'ceiling', 'keyboard', 'alcohol', 'ceilinglamp', 'faucet', 'window', 'powersocket', 'toy', 'food_cheese', 'check', 'tray', 'console', 'mouse', 'pencil', 'kitchen_counter', 'hairbrush', 'hair', 'food_steak', 'bathtub', 'bathroom_cabinet', 'vase']
Task:Answer door
response:

Wait until doorbell rings, look to see who it is outside and open the door if you feel so inclined.

[WALK] <home_office>
[WALK] <man>
[FIND] <man>
[GREET] <man>


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

Here is an example plan to achieve a goal for reference:
Scene_Objects:['sponge', 'pot', 'food_bread', 'toilet', 'orchid', 'drawing', 'cpuscreen', 'bathroom_counter', 'floor', 'longboard', 'shampoo', 'desk', 'stamp', 'keyboard', 'toaster', 'mat', 'deck_of_cards', 'faucet', 'foundation', 'mousepad', 'form', 'wall', 'nightstand', 'photoframe', 'doorjamb', 'mouse', 'cupboard', 'door', 'bathroom_cabinet', 'light']
Task:Go to toilet
response:
{
    "thoughts": Travel through the house and locate the bathroom, and proceed to the toilet.,
    "actions": ['[WALK] <bathroom>', '[WALK] <toilet>', '[FIND] <toilet>']
}

Input:
Scene_Objects:['filing_cabinet', 'food_bread', 'dog', 'milk', 'floor', 'bedroom', 'computer', 'mail', 'alcohol', 'bookmark', 'mat', 'tvstand', 'window', 'couch', 'dustpan', 'pillow', 'dining_room', 'wall', 'wall_clock', 'coffee_table', 'novel', 'food_food', 'television', 'coin', 'curtain', 'doorjamb', 'towel_rack', 'kitchen_counter', 'maindoor', 'table']
Task:Read book
response:

Sit down in recliner.  Pick up novel off of coffee table.  Open novel to last read page.  Begin reading

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


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

Here is an example plan to achieve a goal for reference:
Scene_Objects:['tea', 'chair', 'freezer', 'cpuscreen', 'food_egg', 'hanger', 'floor', 'ceiling', 'phone', 'desk', 'bookshelf', 'keyboard', 'computer', 'clothes_jacket', 'stovefan', 'mousepad', 'wall', 'keys', 'check', 'oven_mitts', 'doorjamb', 'mouse', 'pencil', 'dresser', 'cupboard', 'door', 'clothes_scarf', 'napkin', 'home_office', 'light']
Task:Turn on light
response:
{
    "thoughts": turn on the light for room,
    "actions": ['[WALK] <home_office>', '[WALK] <light>', '[FIND] <light>', '[PLUGIN] <light>', '[SWITCHON] <light>', '[FIND] <chair>', '[SIT] <chair>']
}

Input:
Scene_Objects:['drawing', 'cpuscreen', 'hanger', 'floor', 'ceiling', 'bedroom', 'bookshelf', 'computer', 'mail', 'mat', 'ceilinglamp', 'faucet', 'shower', 'window', 'closetdrawer', 'couch', 'pillow', 'broom', 'wall', 'shelf', 'standingmirror', 'television', 'curtain', 'doorjamb', 'centerpiece', 'mouse', 'dresser', 'sink', 'table', 'clothes_shirt']
Task:Watch TV
response:

Turn TV on to TV channel and sit down on the couch and watch TV.

[WALK] <home_office>
[WALK] <television>
[SWITCHON] <television>
[WALK] <couch>
[SIT] <couch>
[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:['filing_cabinet', 'scissors', 'microwave', 'toilet', 'chair', 'walllamp', 'drawing', 'floor', 'ceiling', 'shampoo', 'computer', 'mat', 'food_orange', 'bowl', 'dining_room', 'wall', 'powersocket', 'oven', 'toy', 'shelf', 'cup', 'light_bulb', 'novel', 'coffe_maker', 'tray', 'doorjamb', 'maindoor', 'bathtub', 'light', 'vase']
Task:Turn on light
response:
{
    "thoughts": I walk into the kitchen, I find the light switch, and then i switch on the lights in the kitchen.,
    "actions": ['[WALK] <dining_room>', '[WALK] <light>', '[FIND] <light>', '[SWITCHON] <light>']
}

Input:
Scene_Objects:['sheets', 'filing_cabinet', 'walllamp', 'nail_polish', 'drawing', 'wallshelf', 'clothes_underwear', 'floor', 'computer', 'mat', 'couch', 'clothes_pants', 'form', 'wall', 'toy', 'box', 'basket_for_clothes', 'light_bulb', 'novel', 'food_food', 'check', 'television', 'coffee_filter', 'toothbrush_holder', 'tray', 'laundry_detergent', 'clothes_dress', 'table', 'clothes_shirt', 'washing_machine']
Task:Do laundry
response:

Collecting laundry from the children's hamper


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

Here is an example plan to achieve a goal for reference:
Scene_Objects:['tablelamp', 'microwave', 'toilet', 'chair', 'dog', 'walllamp', 'drawing', 'orchid', 'cpuscreen', 'floor', 'ceiling', 'desk', 'keyboard', 'computer', 'alcohol', 'mat', 'ceilinglamp', 'tvstand', 'mousepad', 'food_jam', 'pillow', 'wall', 'nightstand', 'cutting_board', 'novel', 'television', 'toothbrush_holder', 'mouse', 'door', 'dirt']
Task:Read book
response:
{
    "thoughts": I pick up a book. I sit in a chair. I open the book.,
    "actions": ['[WALK] <home_office>', '[WALK] <novel>', '[FIND] <novel>', '[GRAB] <novel>', '[FIND] <chair>', '[SIT] <chair>']
}

Input:
Scene_Objects:['food_bread', 'chair', 'freezer', 'blow_dryer', 'bathroom', 'detergent', 'nail_polish', 'orchid', 'drawing', 'cpuscreen', 'floor', 'ceiling', 'bedroom', 'piano_bench', 'shower', 'faucet', 'electric_shaver', 'closetdrawer', 'bowl', 'wall_clock', 'cutting_board', 'toilet_paper', 'check', 'tray', 'towel_rack', 'kettle', 'napkin', 'light', 'soap', 'creditcard']
Task:Greet guests
response:

[WALK] <home_office>
[WALK] <child>
[FIND] <child>
[GREET] <child>


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

Here is an example plan to achieve a goal for reference:
Scene_Objects:['pot', 'beer', 'microwave', 'jelly', 'freezer', 'cpuscreen', 'clothes_underwear', 'floor', 'ceiling', 'desk', 'tea_bag', 'keyboard', 'purse', 'computer', 'iron', 'window', 'mousepad', 'oil', 'wall', 'powersocket', 'bed', 'keys', 'mouthwash', 'wine', 'doorjamb', 'mouse', 'cupboard', 'door', 'sink', 'light']
Task:Turn on light
response:
{
    "thoughts": walk in kitchen. switch on light. walk in living room. switch on light.walk in entrance hall. switch on light.,
    "actions": ['[WALK] <dining_room>', '[WALK] <light>', '[FIND] <light>', '[SWITCHON] <light>', '[WALK] <home_office>', '[WALK] <home_office>']
}

Input:
Scene_Objects:['jelly', 'toothbrush', 'drawing', 'cpuscreen', 'hanger', 'bathroom_counter', 'floor', 'ceiling', 'bookshelf', 'computer', 'mat', 'ceilinglamp', 'faucet', 'window', 'closetdrawer', 'couch', 'pillow', 'wall', 'shelf', 'standingmirror', 'keys', 'television', 'curtain', 'doorjamb', 'cards', 'napkin', 'home_office', 'table', 'light', 'coffee']
Task:Watch TV
response:

We sit all around the television and watch a program.

[WALK] <home_office>
[WALK] <television>
[FIND] <television>
[SWITCHON] <television>
[FIND] <couch>
[SIT] <couch>
[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:['filing_cabinet', 'scissors', 'blender', 'food_salt', 'crayon', 'chair', 'band-aids', 'ceilingfan', 'needle', 'hanger', 'floor', 'ceiling', 'phone', 'keyboard', 'computer', 'brush', 'ceilinglamp', 'shower', 'dining_room', 'wall', 'oven', 'powersocket', 'coffe_maker', 'curtain', 'console', 'kitchen_counter', 'dresser', 'cupboard', 'maindoor', 'light']
Task:Dust
response:
{
    "thoughts": Using soft brush, carefully dust both Indonesian wedding doll statues.,
    "actions": ['[WALK] <home_office>', '[WALK] <dresser>', '[OPEN] <dresser>', '[FIND] <brush>', '[GRAB] <brush>', '[CLOSE] <dresser>']
}

Input:
Scene_Objects:['glue', 'filing_cabinet', 'microwave', 'freezer', 'detergent', 'drawing', 'floor', 'ceiling', 'table_cloth', 'stovefan', 'ceilinglamp', 'iron', 'faucet', 'window', 'homework', 'bowl', 'wall', 'wall_clock', 'bench', 'shelf', 'newspaper', 'mouthwash', 'food_donut', 'doorjamb', 'coffee_pot', 'door', 'sink', 'bathroom_cabinet', 'light', 'board_game']
Task:Turn light off
response:

Put the light switch into the down, or off, position.

[WALK] <bedroom>
[WALK] <light>
[SWITCHOFF] <light>


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

Here is an example plan to achieve a goal for reference:
Scene_Objects:['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:['sheets', 'cpuscreen', 'hanger', 'floor', 'ceiling', 'desk', 'keyboard', 'computer', 'clothes_socks', 'closetdrawer', 'mousepad', 'clothes_pants', 'wall', 'powersocket', 'oven', 'cup', 'newspaper', 'food_food', 'check', 'coffe_maker', 'shaving_cream', 'mouse', 'pencil', 'shoes', 'dresser', 'hair', 'conditioner', 'light', 'clothes_shirt', 'shoe_rack']
Task:Get dressed
response:

Open drawer. Pull out pants and put them on. Take a shirt out and put it on. Put on socks and shoes.

[WALK] <bedroom>
[WALK] <dresser>
[OPEN] <dresser>
[FIND] <clothes_pants>
[GRAB] <clothes_pants>
[PUTON] <clothes_pants>
[FIND] <clothes_shirt>
[GRAB] <clothes_shirt>
[PUTON] <clothes_shirt>
[FIND] <clothes_socks>
[GRAB] <clothes_socks>
[PUTON] <clothes_socks>
[CLOSE] <dresser>
[FIND] <shoes>
[GRAB] <shoes>
[PUTON] <shoes>


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', 'fork', 'filing_cabinet', 'toilet', 'detergent', 'food_butter', 'orchid', 'needle', 'bills', 'stereo', 'window', 'dining_room', 'bench', 'oven', 'bed', 'novel', 'check', 'coffee_filter', 'tray', 'wooden_spoon', 'centerpiece', 'headset', 'conditioner', 'food_steak', 'napkin', 'home_office', 'soap', 'scrabble', 'dirt', 'coffee']
Task:File documents
response:
{
    "thoughts": I file all of my paperwork (including bills, receipts, documents, device instructions, etc.) in my black paperwork case that has many different files in order to organize.  I place each piece of paper in its' corresponding subject (as indicated by printed words on each tab).,
    "actions": ['[WALK] <home_office>', '[WALK] <bills>', '[FIND] <bills>', '[GRAB] <bills>', '[WALK] <filing_cabinet>', '[OPEN] <filing_cabinet>', '[PUTIN] <bills> <filing_cabinet>', '[FIND] <check>', '[GRAB] <check>', '[WALK] <filing_cabinet>', '[PUTIN] <check> <filing_cabinet>', '[FIND] <check>', '[GRAB] <check>', '[WALK] <filing_cabinet>', '[PUTIN] <check> <filing_cabinet>']
}

Input:
Scene_Objects:['juice', 'microwave', 'jelly', 'freezer', 'walllamp', 'food_carrot', 'dough', 'orchid', 'drawing', 'kitchen_cabinet', 'floor', 'ceiling', 'food_bacon', 'stovefan', 'mat', 'plate', 'food_jam', 'wall', 'oven', 'bench', 'cutting_board', 'cup', 'food_vegetable', 'food_food', 'coffe_maker', 'ice', 'wine', 'tray', 'kitchen_counter', 'napkin', 'table']
Task:Fix snack
response:

Open fridge. Take out carrots and other vegetables. Put vegetables on a plate. Put away carrots and celery. Close fridge.

[WALK] <dining_room>
[WALK] <kitchen_cabinet>
[FIND] <kitchen_cabinet>
[OPEN] <kitchen_cabinet>
[FIND] <plate>
[GRAB] <plate>
[CLOSE] <kitchen_cabinet>
[WALK] <freezer>
[OPEN] <freezer>
[FIND] <food_carrot>
[GRAB] <food_carrot>
[PUTBACK] <food_carrot> <plate>
[FIND] <food_vegetable>
[GRAB] <food_vegetable>
[PUTBACK] <food_vegetable> <plate>
[CLOSE] <freezer>
[WALK] <table>
[PUTBACK] <plate> <table>


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

Here is an example plan to achieve a goal for reference:
Scene_Objects:['sponge', 'filing_cabinet', 'juice', 'microwave', 'knifeblock', 'wallshelf', 'bathroom_counter', 'floor', 'ceiling', 'computer', 'piano_bench', 'toaster', 'ceilinglamp', 'plate', 'faucet', 'stovefan', 'tvstand', 'dish_soap', 'wall', 'pasta', 'coffee_filter', 'tray', 'doorjamb', 'mouse', 'kitchen_counter', 'shoes', 'dishrack', 'cupboard', 'sink', 'scrabble']
Task:Wash dishes
response:
{
    "thoughts": Place all of the dirty dishes in a sink full of clean, soapy water.  Wash them.  Rinse them in fresh, running water.  Place them in the strainer to dry.,
    "actions": ['[WALK] <dining_room>', '[WALK] <sink>', '[FIND] <faucet>', '[SWITCHON] <faucet>', '[FIND] <plate>', '[GRAB] <plate>', '[RINSE] <plate>', '[PUTBACK] <plate> <sink>', '[FIND] <plate>', '[GRAB] <plate>', '[RINSE] <plate>', '[PUTBACK] <plate> <sink>', '[SWITCHOFF] <faucet>', '[FIND] <dish_soap>', '[GRAB] <dish_soap>', '[FIND] <sponge>', '[GRAB] <sponge>', '[POUR] <dish_soap> <sponge>', '[PUTOBJBACK] <dish_soap>', '[GRAB] <plate>', '[SCRUB] <plate>', '[PUTOBJBACK] <plate>', '[GRAB] <plate>', '[SCRUB] <plate>', '[PUTOBJBACK] <plate>', '[SWITCHON] <faucet>', '[RINSE] <sponge>', '[PUTOBJBACK] <sponge>', '[GRAB] <plate>', '[RINSE] <plate>', '[FIND] <dishrack>', '[PUTBACK] <plate> <dishrack>', '[GRAB] <plate>', '[RINSE] <plate>', '[PUTBACK] <plate> <dishrack>', '[SWITCHOFF] <faucet>']
}

Input:
Scene_Objects:['pot', 'food_bread', 'filing_cabinet', 'tablelamp', 'crayon', 'woman', 'wallshelf', 'shampoo', 'floor', 'phone', 'desk', 'man', 'bookshelf', 'closetdrawer', 'couch', 'dining_room', 'nightstand', 'child', 'bed', 'photoframe', 'standingmirror', 'toilet_paper', 'oven_mitts', 'towel_rack', 'kitchen_counter', 'dresser', 'sink', 'bathroom_cabinet', 'clothes_skirt', 'vase']
Task:Say goodbye to guests leaving
response:

[WALK] <home_office>
[WALK] <child>
[FIND] <child>
[TOUCH] <child>
[FIND] <man>
[TOUCH] <man>
[FIND] <woman>
[TOUCH] <woman>


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

Here is an example plan to achieve a goal for reference:
Scene_Objects:['filing_cabinet', 'crayon', 'walllamp', 'woman', 'knifeblock', 'hanger', 'ceiling', 'folder', 'character', 'man', 'mop_bucket', 'bookmark', 'shower', 'window', 'electric_shaver', 'pillow', 'dining_room', 'wall_clock', 'cutting_board', 'bed', 'television', 'wine', 'curtain', 'mouse', 'pencil', 'sink', 'home_office', 'light', 'dirt', 'shoe_rack']
Task:Greet people
response:
{
    "thoughts": Say HI to those that come in.,
    "actions": ['[WALK] <home_office>', '[WALK] <woman>', '[FIND] <woman>', '[GREET] <woman>', '[FIND] <woman>', '[GREET] <woman>', '[FIND] <man>', '[GREET] <man>', '[FIND] <man>', '[GREET] <man>']
}

Input:
Scene_Objects:['sheets', 'freezer', 'walllamp', 'detergent', 'cpuscreen', 'hanger', 'floor', 'ceiling', 'phone', 'desk', 'keyboard', 'envelope', 'computer', 'stereo', 'mousepad', 'closetdrawer', 'oil', 'clothes_pants', 'wall', 'wall_clock', 'powersocket', 'photoframe', 'coin', 'rag', 'kettle', 'mouse', 'chessboard', 'dresser', 'light', 'clothes_shirt']
Task:Get dressed
response:

Find dresser, grab pants, grab shirt, put on pants, put on shirt

[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>


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', 'detergent', 'cpuscreen', 'floor', 'ceiling', 'phone', 'desk', 'keyboard', 'computer', 'ceilinglamp', 'tvstand', 'mousepad', 'closetdrawer', 'dining_room', 'wall', 'nightstand', 'powersocket', 'photoframe', 'bed', 'coffe_maker', 'television', 'doorjamb', 'mouse', 'pencil', 'bathtub', 'home_office', 'table']
Task:Browse internet
response:
{
    "thoughts": For browsing internet walk to home office. Find Computer. Walk to Computer. Find Chair. Sit in a chair and switch on computer. Connect with internet and browse the net.,
    "actions": ['[WALK] <home_office>', '[WALK] <computer>', '[FIND] <computer>', '[WALK] <computer>', '[FIND] <chair>', '[SIT] <chair>', '[SWITCHON] <computer>']
}

Input:
Scene_Objects:['toilet', 'chair', 'food_carrot', 'toothbrush', 'orchid', 'needle', 'bathroom_counter', 'floor', 'ceiling', 'bookshelf', 'thread', 'stovefan', 'mat', 'toaster', 'shower', 'window', 'wall', 'powersocket', 'novel', 'food_food', 'check', 'television', 'rag', 'doorjamb', 'dresser', 'food_steak', 'spoon', 'bathroom_cabinet', 'light', 'table']
Task:Study
response:

Do homework or read books while sitting on the chair.

[WALK] <bedroom>
[WALK] <chair>
[FIND] <chair>
[SIT] <chair>
[FIND] <novel>
[GRAB] <novel>
[READ] <novel>
[PUTOBJBACK] <novel>
[FIND] <novel>
[GRAB] <novel>
[READ] <novel>
[PUTOBJBACK] <novel>


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

Here is an example plan to achieve a goal for reference:
Scene_Objects:['filing_cabinet', 'microwave', 'walllamp', 'trashcan', 'drawing', 'wallshelf', 'cpuscreen', 'hanger', 'floor', 'ceiling', 'bookshelf', 'mat', 'tvstand', 'ceilinglamp', 'shower', 'window', 'couch', 'pillow', 'wall', 'nightstand', 'oven', 'keys', 'television', 'curtain', 'doorjamb', 'towel_rack', 'mouse', 'door', 'light', 'table']
Task:Relax on sofa
response:
{
    "thoughts": I want to relax on the sofa to some relaxing music in the living room.,
    "actions": ['[WALK] <home_office>', '[WALK] <light>', '[FIND] <light>', '[SWITCHON] <light>', '[WALK] <stereo>', '[PLUGIN] <stereo>', '[SWITCHON] <stereo>', '[WALK] <couch>', '[SIT] <couch>', '[LIE] <couch>']
}

Input:
Scene_Objects:['dry_pasta', 'drawing', 'bills', 'hanger', 'floor', 'ceiling', 'video_game_console', 'computer', 'button', 'mat', 'ceilinglamp', 'shower', 'window', 'mousepad', 'closetdrawer', 'couch', 'pillow', 'wall', 'cutting_board', 'cup', 'standingmirror', 'video_game_controller', 'television', 'coffee_filter', 'curtain', 'doorjamb', 'bathroom_cabinet', 'table', 'soap', 'dirt']
Task:Play games
response:

Turn on the television. Turn on the video game system. Insert desired game into gaming system. Follow directions on game to and push needed buttons on video  game remote controller.

[WALK] <home_office>
[WALK] <television>
[FIND] <television>
[SWITCHON] <television>
[FIND] <video_game_console>
[SWITCHON] <video_game_console>
[FIND] <video_game_controller>
[GRAB] <video_game_controller>
[FIND] <button>
[PUSH] <button>
[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:['pot', 'tablelamp', 'chair', 'walllamp', 'knifeblock', 'cpuscreen', 'wallshelf', 'bathroom_counter', 'floor', 'ceiling', 'ceilinglamp', 'faucet', 'couch', 'dustpan', 'pillow', 'towel', 'wall', 'nightstand', 'oven', 'box', 'bed', 'keys', 'check', 'toilet_paper', 'television', 'kitchen_counter', 'dresser', 'instrument_guitar', 'soap', 'tooth_paste']
Task:Relax on sofa
response:
{
    "thoughts": Go to living room.  Find sofa.  Sit on sofa.,
    "actions": ['[WALK] <home_office>', '[WALK] <couch>', '[FIND] <couch>', '[SIT] <couch>']
}

Input:
Scene_Objects:['food_pizza', 'food_bread', 'microwave', 'freezer', 'walllamp', 'drawing', 'orchid', 'knife', 'kitchen_cabinet', 'floor', 'ceiling', 'bookshelf', 'stovefan', 'mat', 'shoe-shine_kit', 'wall', 'bench', 'oven', 'cutting_board', 'food_vegetable', 'food_food', 'coffe_maker', 'coffee_filter', 'wine', 'tray', 'food_onion', 'kitchen_counter', 'controller', 'food_steak', 'table']
Task:Chop vegetables
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:['sheets', 'filing_cabinet', 'chair', 'freezer', 'detergent', 'trashcan', 'drawing', 'longboard', 'floor', 'phone', 'purse', 'computer', 'bookmark', 'brush', 'window', 'wall', 'child', 'powersocket', 'bed', 'novel', 'food_food', 'after_shave', 'curtain', 'doorjamb', 'towel_rack', 'shoes', 'laundry_detergent', 'door', 'napkin', 'light']
Task:Read book
response:
{
    "thoughts": Read story to children,
    "actions": ['[WALK] <bedroom>', '[WALK] <child>', '[FIND] <child>', '[GREET] <child>', '[FIND] <child>', '[GREET] <child>', '[WALK] <filing_cabinet>', '[OPEN] <filing_cabinet>', '[FIND] <novel>', '[GRAB] <novel>', '[CLOSE] <filing_cabinet>', '[WALK] <bed>', '[SIT] <bed>', '[READ] <novel>']
}

Input:
Scene_Objects:['sheets', 'milk', 'knife', 'orchid', 'cpuscreen', 'hanger', 'floor', 'ceiling', 'desk', 'bedroom', 'keyboard', 'purse', 'computer', 'mat', 'tvstand', 'foundation', 'window', 'mousepad', 'closetdrawer', 'couch', 'bowl', 'wall', 'powersocket', 'keys', 'coffee_filter', 'mouse', 'dresser', 'home_office', 'light', 'coffee']
Task:Hang keys
response:

Remove keys from purse, pocket or hand.  Place in designated area (bowl, or on hook). Leave area

[WALK] <bedroom>
[WALK] <dresser>
[FIND] <purse>
[GRAB] <purse>
[OPEN] <purse>
[FIND] <keys>
[GRAB] <keys>
[FIND] <bowl>
[PUTBACK] <keys> <bowl>
[CLOSE] <purse>
[PUTOBJBACK] <purse>


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

Here is an example plan to achieve a goal for reference:
Scene_Objects:['pot', 'filing_cabinet', 'tablelamp', 'walllamp', 'food_carrot', 'orchid', 'cpuscreen', 'wallshelf', 'floor', 'ceiling', 'phone', 'bookshelf', 'remote_control', 'computer', 'button', 'tvstand', 'window', 'closetdrawer', 'couch', 'pillow', 'nightstand', 'wall', 'basket_for_clothes', 'food_food', 'television', 'curtain', 'dresser', 'clothes_dress', 'home_office', 'table']
Task:Change TV channel
response:
{
    "thoughts": Take TV remote to change TV Channel. Press channel/program +/- button on TV remote.,
    "actions": ['[WALK] <home_office>', '[WALK] <television>', '[FIND] <television>', '[SWITCHON] <television>', '[FIND] <remote_control>', '[GRAB] <remote_control>', '[FIND] <button>', '[TOUCH] <button>']
}

Input:
Scene_Objects:['microwave', 'toilet', 'band-aids', 'freezer', 'bathroom', 'dough', 'bathroom_counter', 'floor', 'ceiling', 'mail', 'stovefan', 'mat', 'tvstand', 'faucet', 'towel', 'wall', 'wall_clock', 'oven', 'coffe_maker', 'tray', 'cards', 'console', 'dresser', 'hair', 'sink', 'bathroom_cabinet', 'soap', 'instrument_violin', 'laser_pointer', 'hands_both']
Task:Wash hands
response:

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


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

Here is an example plan to achieve a goal for reference:
Scene_Objects:['pot', 'tablelamp', 'blender', 'crayon', 'walllamp', 'cat', 'drawing', 'orchid', 'cpuscreen', 'clothes_underwear', 'floor', 'ceiling', 'bookmark', 'ceilinglamp', 'plate', 'window', 'couch', 'pillow', 'wall', 'oven', 'cup', 'bed', 'clothes_gloves', 'newspaper', 'coffe_maker', 'curtain', 'hairbrush', 'food_steak', 'bag', 'table']
Task:Relax on sofa
response:
{
    "thoughts": walk to living room, find sofa, sit in sofa,
    "actions": ['[WALK] <home_office>', '[WALK] <couch>', '[FIND] <couch>', '[WALK] <couch>', '[SIT] <couch>']
}

Input:
Scene_Objects:['food_ice_cream', 'measuring_cup', 'toilet', 'chair', 'drawing', 'food_egg', 'clothes_underwear', 'hanger', 'bathroom_counter', 'floor', 'ceiling', 'stamp', 'bookshelf', 'button', 'shoe-shine_kit', 'shower', 'window', 'broom', 'wall', 'wall_clock', 'powersocket', 'bench', 'standingmirror', 'novel', 'coin', 'doorjamb', 'door', 'light', 'table', 'creditcard']
Task:Read
response:

We pick out a book from the bookshelf and read it.

[WALK] <novel>
[WALK] <bookshelf>
[FIND] <novel>
[GRAB] <novel>
[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:['pot', 'filing_cabinet', 'beer', 'freezer', 'walllamp', 'bathroom', 'bathroom_counter', 'character', 'bedroom', 'desk', 'ceilinglamp', 'tvstand', 'faucet', 'clothes_socks', 'clothes_pants', 'towel', 'bench', 'basket_for_clothes', 'bed', 'coin', 'food_donut', 'curtain', 'towel_rack', 'mouse', 'cd', 'comb', 'laundry_detergent', 'bathtub', 'bathroom_cabinet', 'washing_machine']
Task:Wash clothes
response:
{
    "thoughts": Go to kitchen, find washing machine, find laundry, put laundry in washing machine, find soap, put soap in washing machine, turn on.,
    "actions": ['[WALK] <dining_room>', '[WALK] <washing_machine>', '[FIND] <washing_machine>', '[FIND] <basket_for_clothes>', '[GRAB] <basket_for_clothes>', '[OPEN] <washing_machine>', '[PUTBACK] <basket_for_clothes> <washing_machine>', '[WALK] <laundry_detergent>', '[FIND] <laundry_detergent>', '[GRAB] <laundry_detergent>', '[POUR] <laundry_detergent> <washing_machine>', '[CLOSE] <washing_machine>', '[SWITCHON] <washing_machine>']
}

Input:
Scene_Objects:['microwave', 'bathroom', 'wallshelf', 'character', 'desk', 'mail', 'food_bacon', 'computer', 'mat', 'window', 'oil', 'closetdrawer', 'couch', 'dining_room', 'love_seat', 'cup', 'newspaper', 'standingmirror', 'coffe_maker', 'video_game_controller', 'television', 'centerpiece', 'cards', 'kitchen_counter', 'chessboard', 'maindoor', 'hairdryer', 'bathroom_cabinet', 'table', 'shoe_rack']
Task:Read
response:

[WALK] <home_office>
[WALK] <newspaper>
[FIND] <newspaper>
[GRAB] <newspaper>
[FIND] <love_seat>
[SIT] <love_seat>
[READ] <newspaper>


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

Here is an example plan to achieve a goal for reference:
Scene_Objects:['pot', 'filing_cabinet', 'freezer', 'walllamp', 'drawing', 'needle', 'orchid', 'floor', 'stamp', 'keyboard', 'plate', 'faucet', 'shower', 'dish_soap', 'oil', 'wall', 'keys', 'coffe_maker', 'coffee_filter', 'pencil', 'kitchen_counter', 'dishrack', 'dresser', 'cupboard', 'controller', 'pajamas', 'food_steak', 'spoon', 'light', 'dishwasher']
Task:Wash dishes with dishwasher
response:
{
    "thoughts": Walk to the kitchen. Find the dishwasher. Walk to the dishwasher. Open the dishwasher. Find plate no.1. Grab plate no.1. Put plate no.1 into the dishwasher. Find plate no.2. Grab plate no.2. Put plate no.2 into the dishwasher. Find the spoon. Grab the spoon. Put the spoon into the dishwasher. Find the dish soap. Put the dish soap into the dishwasher. Close the dishwasher. Switch on the dishwasher.,
    "actions": ['[WALK] <dining_room>', '[WALK] <dishwasher>', '[FIND] <dishwasher>', '[WALK] <dishwasher>', '[OPEN] <dishwasher>', '[FIND] <plate>', '[GRAB] <plate>', '[PUTBACK] <plate> <dishwasher>', '[FIND] <plate>', '[GRAB] <plate>', '[PUTBACK] <plate> <dishwasher>', '[FIND] <spoon>', '[GRAB] <spoon>', '[PUTBACK] <spoon> <dishwasher>', '[FIND] <dish_soap>', '[GRAB] <dish_soap>', '[PUTBACK] <dish_soap> <dishwasher>', '[CLOSE] <dishwasher>', '[SWITCHON] <dishwasher>']
}

Input:
Scene_Objects:['dry_pasta', 'microwave', 'bills', 'floor', 'computer', 'toaster', 'stovefan', 'shoe-shine_kit', 'faucet', 'ceilinglamp', 'dustpan', 'microphone', 'food_orange', 'dining_room', 'wall', 'cutting_board', 'toy', 'box', 'coffe_maker', 'food_donut', 'after_shave', 'mouse', 'kitchen_counter', 'shoes', 'hair', 'door', 'sink', 'light', 'soap', 'tooth_paste']
Task:Wipe down sink
response:

Use a cloth to wipe the edge of the sink. Then wipe the bowl of the sink as well.

[WALK] <dining_room>
[WALK] <rag>
[FIND] <rag>
[GRAB] <rag>
[WALK] <sink>
[WIPE] <sink>
[PUTOBJBACK] <rag>


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

Here is an example plan to achieve a goal for reference:
Scene_Objects:['food_bread', 'filing_cabinet', 'tablelamp', 'food_salt', 'toilet', 'chair', 'bathroom', 'trashcan', 'drawing', 'floor', 'character', 'desk', 'purse', 'computer', 'table_cloth', 'stovefan', 'ceilinglamp', 'tvstand', 'shower', 'foundation', 'couch', 'pillow', 'nightstand', 'powersocket', 'novel', 'tray', 'mouse', 'bathroom_cabinet', 'soap', 'teeth']
Task:Pet cat
response:
{
    "thoughts": First I need to find the cat in the living room. Then I walk over to the cat and pet it gently.,
    "actions": ['[WALK] <home_office>', '[WALK] <cat>', '[FIND] <cat>', '[WALK] <cat>', '[TOUCH] <cat>']
}

Input:
Scene_Objects:['sheets', 'scissors', 'walllamp', 'needle', 'wallshelf', 'cpuscreen', 'hanger', 'bedroom', 'keyboard', 'bookmark', 'stovefan', 'shower', 'oil', 'dining_room', 'wall', 'powersocket', 'bench', 'love_seat', 'standingmirror', 'novel', 'coffe_maker', 'check', 'after_shave', 'towel_rack', 'mouse', 'pencil', 'kitchen_counter', 'maindoor', 'bathtub', 'soap']
Task:Read book
response:

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

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


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

Here is an example plan to achieve a goal for reference:
Scene_Objects:['dry_pasta', 'tablelamp', 'scissors', 'food_salt', 'toilet', 'chair', 'detergent', 'drawing', 'cpuscreen', 'bathroom_counter', 'floor', 'desk', 'keyboard', 'mail', 'toaster', 'homework', 'mousepad', 'clothes_pants', 'wall', 'powersocket', 'photoframe', 'coffe_maker', 'food_food', 'coffee_pot', 'mouse', 'home_office', 'table', 'dishwasher', 'vase', 'tooth_paste']
Task:Go to toilet
response:
{
    "thoughts": Walk to the bathroom. Pull down pants. Use the toilet.,
    "actions": ['[WALK] <bathroom>', '[WALK] <clothes_pants>', '[FIND] <clothes_pants>', '[PULL] <clothes_pants>', '[FIND] <toilet>', '[SIT] <toilet>']
}

Input:
Scene_Objects:['pot', 'filing_cabinet', 'toilet', 'walllamp', 'hanger', 'floor', 'ceiling', 'keyboard', 'computer', 'stovefan', 'stereo', 'shower', 'window', 'mousepad', 'wall', 'nightstand', 'wall_clock', 'toy', 'photoframe', 'coffe_maker', 'curtain', 'lighter', 'towel_rack', 'kitchen_counter', 'controller', 'bathtub', 'bathroom_cabinet', 'table', 'instrument_violin', 'creditcard']
Task:Open bathroom window
response:

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

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


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

Here is an example plan to achieve a goal for reference:
Scene_Objects:['tablelamp', 'food_salt', 'microwave', 'freezer', 'walllamp', 'bathroom', 'cpuscreen', 'bathroom_counter', 'ceiling', 'keyboard', 'computer', 'food_bacon', 'table_cloth', 'ceilinglamp', 'faucet', 'picture', 'clothes_socks', 'towel', 'dining_room', 'wall', 'pasta', 'bed', 'centerpiece', 'kitchen_counter', 'door', 'bathtub', 'home_office', 'light', 'table', 'colander']
Task:Clean screen
response:
{
    "thoughts": Use a soft rag to wipe the screen until there are no marks on it.,
    "actions": ['[WALK] <home_office>', '[WALK] <rag>', '[FIND] <rag>', '[GRAB] <rag>', '[WALK] <computer>', '[WIPE] <computer>', '[PUTOBJBACK] <rag>']
}

Input:
Scene_Objects:['sheets', 'pot', 'filing_cabinet', 'fork', 'tablelamp', 'toilet', 'walllamp', 'orchid', 'character', 'alcohol', 'faucet', 'mousepad', 'dustpan', 'wall', 'nightstand', 'oven', 'cup', 'photoframe', 'coffe_maker', 'razor', 'after_shave', 'cards', 'dishrack', 'sink', 'spoon', 'bathroom_cabinet', 'clothes_skirt', 'vase', 'clothes_shirt', 'dirt']
Task:Shut off alarm
response:

[WALK] <bedroom>
[WALK] <alarm_clock>
[FIND] <alarm_clock>
[GRAB] <alarm_clock>
[SWITCHOFF] <alarm_clock>
[PUTOBJBACK] <alarm_clock>


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', 'walllamp', 'bathroom', 'trashcan', 'dough', 'drawing', 'wallshelf', 'bathroom_counter', 'floor', 'ceiling', 'bookshelf', 'faucet', 'window', 'food_noodles', 'mousepad', 'pillow', 'dining_room', 'wall', 'bed', 'food_food', 'razor', 'rag', 'console', 'mouse', 'towel_rack', 'kitchen_counter', 'door', 'sink', 'bathtub', 'bathroom_cabinet']
Task:Clean sink
response:
{
    "thoughts": Take a premoistened cleaning wipe and wipe down top of sink and faucet.  Next clean the sink bowl.  Let air dry.,
    "actions": ['[WALK] <bathroom>', '[WALK] <rag>', '[FIND] <rag>', '[GRAB] <rag>', '[WALK] <sink>', '[FIND] <faucet>', '[WIPE] <faucet>', '[WIPE] <sink>', '[PUTOBJBACK] <rag>']
}

Input:
Scene_Objects:['chair', 'walllamp', 'bills', 'cpuscreen', 'wallshelf', 'hanger', 'floor', 'ceiling', 'shampoo', 'desk', 'keyboard', 'computer', 'ceilinglamp', 'mat', 'mousepad', 'closetdrawer', 'wall', 'powersocket', 'television', 'toothbrush_holder', 'wine', 'doorjamb', 'mouse', 'dresser', 'hairbrush', 'controller', 'clothes_dress', 'home_office', 'light', 'table']
Task:Turn on computer
response:

Press the power button on the computer to turn it on

[WALK] <home_office>
[WALK] <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:['filing_cabinet', 'scissors', 'tablelamp', 'crayon', 'microwave', 'freezer', 'bathroom', 'trashcan', 'ceilingfan', 'knifeblock', 'clothes_underwear', 'longboard', 'shampoo', 'dvd_player', 'folder', 'mail', 'bookmark', 'toaster', 'shower', 'homework', 'couch', 'bed', 'clothes_gloves', 'towel_rack', 'mouse', 'pencil', 'cupboard', 'maindoor', 'table', 'laser_pointer']
Task:Pet cat
response:
{
    "thoughts": I walk into the living room and I pet the cat,
    "actions": ['[WALK] <home_office>', '[WALK] <cat>', '[TOUCH] <cat>']
}

Input:
Scene_Objects:['pot', 'jelly', 'chair', 'phone', 'ceiling', 'desk', 'bedroom', 'table_cloth', 'bookmark', 'stovefan', 'mat', 'tvstand', 'stereo', 'shoe-shine_kit', 'faucet', 'toaster', 'mousepad', 'powersocket', 'cutting_board', 'shelf', 'food_cheese', 'television', 'wooden_spoon', 'after_shave', 'food_onion', 'doorjamb', 'shoes', 'dishrack', 'vase', 'electrical_outlet']
Task:Turn on radio
response:

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

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


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

Here is an example plan to achieve a goal for reference:
Scene_Objects:['chair', 'walllamp', 'cat', 'food_carrot', 'toothbrush', 'drawing', 'orchid', 'floor', 'mail', 'stovefan', 'ceilinglamp', 'window', 'mousepad', 'couch', 'food_jam', 'pillow', 'dining_room', 'wall', 'photoframe', 'mouthwash', 'tray', 'curtain', 'coffee_pot', 'pajamas', 'door', 'sink', 'bathroom_cabinet', 'table', 'light', 'tooth_paste']
Task:Relax
response:
{
    "thoughts": Lie down on the couch.,
    "actions": ['[WALK] <home_office>', '[WALK] <couch>', '[LIE] <couch>']
}

Input:
Scene_Objects:['toilet', 'walllamp', 'bathroom', 'drawing', 'knife', 'laptop', 'tvstand', 'faucet', 'shower', 'window', 'mat', 'clothes_socks', 'closetdrawer', 'pillow', 'photoframe', 'standingmirror', 'newspaper', 'toothbrush_holder', 'lighter', 'centerpiece', 'kitchen_counter', 'shoes', 'cd', 'hair', 'conditioner', 'maindoor', 'bathtub', 'sink', 'table', 'vase']
Task:Leave home
response:

Put on shoes. Put on coat. Open door and exit through it. Lock door behind you.

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


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

Here is an example plan to achieve a goal for reference:
Scene_Objects:['pot', 'tablelamp', 'walllamp', 'bathroom', 'trashcan', 'knifeblock', 'drawing', 'cpuscreen', 'floor', 'ceiling', 'folder', 'bookshelf', 'computer', 'stovefan', 'toaster', 'food_noodles', 'wall', 'oven', 'toy', 'food_vegetable', 'food_food', 'video_game_controller', 'water', 'tray', 'kitchen_counter', 'cupboard', 'sink', 'home_office', 'dishwasher', 'scrabble']
Task:Cook some food
response:
{
    "thoughts": walk to kicthen , find stove , find cooking pot , find vegetables , find water  ,put vegetables in cooking pot, pour water to cooking pot,put cooking pot on stove, switch on stove,
    "actions": ['[WALK] <dining_room>', '[WALK] <oven>', '[FIND] <oven>', '[FIND] <pot>', '[FIND] <food_vegetable>', '[FIND] <water>', '[GRAB] <water>', '[WASH] <food_vegetable>', '[POUR] <water> <pot>', '[FIND] <pot>', '[GRAB] <pot>', '[PUTBACK] <pot> <oven>', '[SWITCHON] <oven>']
}

Input:
Scene_Objects:['pot', 'food_pizza', 'filing_cabinet', 'microwave', 'chair', 'bathroom', 'orchid', 'character', 'desk', 'bedroom', 'thread', 'computer', 'brush', 'ceilinglamp', 'faucet', 'stereo', 'closetdrawer', 'dining_room', 'wall', 'pasta', 'toy', 'cup', 'standingmirror', 'television', 'wine', 'doorjamb', 'kitchen_counter', 'conditioner', 'bathroom_cabinet', 'clothes_shirt']
Task:Open door
response:

Open the door when leaving or coming in.


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', 'drawing', 'wallshelf', 'hanger', 'bathroom_counter', 'floor', 'ceiling', 'phone', 'character', 'desk', 'tea_bag', 'mat', 'closetdrawer', 'couch', 'pillow', 'wall', 'powersocket', 'toy', 'photoframe', 'check', 'mouthwash', 'food_food', 'food_donut', 'wine', 'curtain', 'doorjamb', 'console', 'dresser', 'door', 'light']
Task:Pick up toys
response:
{
    "thoughts": Bend down and pick up the toys off of the floor.,
    "actions": ['[WALK] <bedroom>', '[WALK] <toy>', '[FIND] <toy>', '[GRAB] <toy>', '[WALK] <dresser>', '[OPEN] <dresser>', '[PUTIN] <toy> <dresser>', '[FIND] <toy>', '[GRAB] <toy>', '[WALK] <dresser>', '[PUTIN] <toy> <dresser>', '[FIND] <toy>', '[WALK] <dresser>', '[GRAB] <toy>', '[PUTIN] <toy> <dresser>', '[CLOSE] <dresser>']
}

Input:
Scene_Objects:['drawing', 'hanger', 'floor', 'ceiling', 'computer', 'brush', 'mat', 'ceilinglamp', 'faucet', 'stovefan', 'window', 'mousepad', 'closetdrawer', 'couch', 'pillow', 'dining_room', 'wall', 'cutting_board', 'shelf', 'toy', 'standingmirror', 'television', 'curtain', 'doorjamb', 'towel_rack', 'controller', 'home_office', 'table', 'soap', 'shoe_rack']
Task:Turn off TV
response:

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


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

Here is an example plan to achieve a goal for reference:
Scene_Objects:['tablelamp', 'toilet', 'chair', 'walllamp', 'orchid', 'drawing', 'cpuscreen', 'wallshelf', 'hanger', 'floor', 'ceiling', 'phone', 'desk', 'keyboard', 'computer', 'ceilinglamp', 'tvstand', 'mat', 'mousepad', 'closetdrawer', 'couch', 'pillow', 'wall', 'nightstand', 'oven', 'television', 'doorjamb', 'mouse', 'dresser', 'door']
Task:Browse internet
response:
{
    "thoughts": I go to the living room, where my computer is. I locate it, switch it on and type desired URL adress in the web browser.,
    "actions": ['[WALK] <home_office>', '[WALK] <computer>', '[FIND] <computer>', '[SWITCHON] <computer>', '[FIND] <keyboard>', '[TYPE] <keyboard>']
}

Input:
Scene_Objects:['food_bread', 'microwave', 'freezer', 'walllamp', 'drawing', 'floor', 'ceiling', 'alcohol', 'piano_bench', 'stovefan', 'toaster', 'ceilinglamp', 'faucet', 'shower', 'oil', 'food_peanut_butter', 'creditcard', 'form', 'wall', 'nightstand', 'oven', 'cutting_board', 'toy', 'newspaper', 'coffe_maker', 'tray', 'kitchen_counter', 'dresser', 'sink', 'electrical_outlet']
Task:Toast bread
response:

Place two slices of bread in the toaster. Select medium toast on toaster.  Push down button to begin toasting.

[WALK] <dining_room>
[WALK] <freezer>
[FIND] <freezer>
[OPEN] <freezer>
[FIND] <food_bread>
[GRAB] <food_bread>
[CLOSE] <freezer>
[WALK] <electrical_outlet>
[FIND] <toaster>
[PLUGIN] <toaster>
[PUTBACK] <food_bread> <toaster>
[SWITCHON] <electrical_outlet>
[TURNTO] <toaster>
[LOOKAT] <toaster>
[SWITCHON] <toaster>


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

Here is an example plan to achieve a goal for reference:
Scene_Objects:['food_pizza', 'tablelamp', 'juice', 'scissors', 'beer', 'chair', 'freezer', 'bathroom', 'ceilingfan', 'hanger', 'floor', 'computer', 'food_bacon', 'mat', 'couch', 'creditcard', 'dining_room', 'oven', 'tape', 'bed', 'light_bulb', 'novel', 'food_food', 'mouse', 'cupboard', 'conditioner', 'home_office', 'table', 'scrabble', 'shoe_rack']
Task:Pet dog
response:
{
    "thoughts": Pet my dog in hall,
    "actions": ['[WALK] <home_office>', '[WALK] <dog>', '[TURNTO] <dog>', '[LOOKAT] <dog>', '[TOUCH] <dog>']
}

Input:
Scene_Objects:['filing_cabinet', 'walllamp', 'drawing', 'hanger', 'floor', 'ceiling', 'bookshelf', 'ceilinglamp', 'laptop', 'faucet', 'mat', 'closetdrawer', 'teeth', 'dining_room', 'wall', 'pasta', 'toy', 'shelf', 'standingmirror', 'novel', 'check', 'television', 'curtain', 'console', 'dresser', 'napkin', 'table', 'light', 'scrabble', 'coffee']
Task:Look at painting
response:

Walk to the painting.  Look up at the painting.  Admire it on the wall.

[WALK] <home_office>
[WALK] <drawing>
[FIND] <drawing>
[TURNTO] <drawing>
[LOOKAT] <drawing>


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

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

Input:
Scene_Objects:['spectacles', 'measuring_cup', 'blow_dryer', 'ground_coffee', 'bathroom', 'cat', 'phone', 'ceiling', 'character', 'man', 'keyboard', 'computer', 'mat', 'window', 'mousepad', 'clothes_pants', 'powersocket', 'cutting_board', 'cup', 'standingmirror', 'bed', 'coffe_maker', 'television', 'food_rice', 'wine', 'controller', 'sink', 'napkin', 'laser_pointer', 'shoe_rack']
Task:Answer door
response:

Walk up to the door.  Open the door and greet whomever is out side

[WALK] <home_office>
[WALK] <man>
[FIND] <man>
[GREET] <man>


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

Here is an example plan to achieve a goal for reference:
Scene_Objects:['dry_pasta', 'filing_cabinet', 'beer', 'chair', 'bills', 'knife', 'hanger', 'bathroom_counter', 'floor', 'computer', 'stovefan', 'mat', 'tvstand', 'window', 'couch', 'pillow', 'towel', 'dining_room', 'food_kiwi', 'wall', 'toy', 'photoframe', 'novel', 'coffe_maker', 'television', 'curtain', 'doorjamb', 'coffee_pot', 'bag', 'table']
Task:Read book
response:
{
    "thoughts": Sit on couch. Grab book. Open book. Read book.,
    "actions": ['[WALK] <couch>', '[SIT] <couch>', '[FIND] <novel>', '[GRAB] <novel>', '[READ] <novel>']
}

Input:
Scene_Objects:['fork', 'beer', 'microwave', 'freezer', 'walllamp', 'dough', 'floor', 'ceiling', 'phone', 'stovefan', 'mat', 'ceilinglamp', 'window', 'couch', 'pillow', 'wall', 'oven', 'cutting_board', 'shelf', 'coffe_maker', 'food_food', 'television', 'tray', 'curtain', 'doorjamb', 'cards', 'kitchen_counter', 'maindoor', 'bathtub', 'table']
Task:Drink
response:

Get a can of beer, open it, sit on couch, relax

[WALK] <dining_room>
[WALK] <freezer>
[FIND] <freezer>
[OPEN] <freezer>
[FIND] <beer>
[GRAB] <beer>
[CLOSE] <freezer>
[WALK] <home_office>
[WALK] <couch>
[FIND] <couch>
[SIT] <couch>
[DRINK] <beer>


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', 'toilet', 'freezer', 'walllamp', 'orchid', 'hanger', 'phone', 'computer', 'piano_bench', 'nightstand', 'pasta', 'wall_clock', 'powersocket', 'toy', 'food_cheese', 'clothes_gloves', 'check', 'toilet_paper', 'television', 'after_shave', 'doorjamb', 'door', 'hairdryer', 'sink', 'home_office', 'light', 'table', 'clothes_scarf', 'soap']
Task:Read book
response:
{
    "thoughts": go to bedroom, sit down, pick up book, read,
    "actions": ['[WALK] <home_office>', '[WALK] <novel>', '[FIND] <novel>', '[GRAB] <novel>', '[READ] <novel>']
}

Input:
Scene_Objects:['sponge', 'scissors', 'tablelamp', 'measuring_cup', 'microwave', 'chair', 'band-aids', 'bathroom', 'milk', 'wallshelf', 'phone', 'character', 'computer', 'mail', 'button', 'mousepad', 'couch', 'pillow', 'wall', 'powersocket', 'photoframe', 'standingmirror', 'centerpiece', 'kitchen_counter', 'shoes', 'maindoor', 'sink', 'bathtub', 'bathroom_cabinet', 'table']
Task:Turn off light
response:

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

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


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

Here is an example plan to achieve a goal for reference:
Scene_Objects:['chair', 'band-aids', 'walllamp', 'detergent', 'drawing', 'wallshelf', 'hanger', 'floor', 'ceiling', 'character', 'desk', 'computer', 'mat', 'tvstand', 'ceilinglamp', 'picture', 'homework', 'faucet', 'closetdrawer', 'couch', 'pillow', 'wall', 'photoframe', 'keys', 'television', 'doorjamb', 'kitchen_counter', 'dresser', 'light', 'soap']
Task:Change TV channels
response:
{
    "thoughts": Take remote. Change to desired channel by you.,
    "actions": ['[WALK] <home_office>', '[WALK] <remote_control>', '[FIND] <remote_control>', '[GRAB] <remote_control>', '[WALK] <couch>', '[SIT] <couch>', '[TOUCH] <remote_control>', '[TOUCH] <remote_control>', '[TOUCH] <remote_control>', '[FIND] <television>', '[TURNTO] <television>', '[LOOKAT] <television>', '[WATCH] <television>', '[WATCH] <television>', '[WATCH] <television>']
}

Input:
Scene_Objects:['food_bread', 'tablelamp', 'chair', 'freezer', 'drawing', 'orchid', 'needle', 'floor', 'phone', 'mail', 'mat', 'plate', 'faucet', 'stereo', 'couch', 'dustpan', 'dining_room', 'wall', 'bench', 'oven', 'toy', 'cup', 'newspaper', 'standingmirror', 'food_food', 'razor', 'console', 'towel_rack', 'bathtub', 'table']
Task:Set up table
response:

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

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

[PUTBACK] <plate>

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

[PUTBACK] <plate>

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

[PUTBACK] <plate>

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

[PUTBACK] <food_food>

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

[PUTBACK] <food_food>


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

Here is an example plan to achieve a goal for reference:
Scene_Objects:['pot', 'tablelamp', 'microwave', 'walllamp', 'knifeblock', 'cpuscreen', 'floor', 'ceiling', 'desk', 'toaster', 'plate', 'faucet', 'stereo', 'mousepad', 'couch', 'pillow', 'dining_room', 'wall', 'coffe_maker', 'check', 'doorjamb', 'mouse', 'kitchen_counter', 'dishrack', 'cupboard', 'sink', 'bathtub', 'dishwasher', 'clothes_skirt', 'laser_pointer']
Task:Wash dishes with dishwasher
response:
{
    "thoughts": Take a dish and put it in the dishwasher to be washed,
    "actions": ['[WALK] <dining_room>', '[WALK] <sink>', '[FIND] <plate>', '[GRAB] <plate>', '[FIND] <dishwasher>', '[OPEN] <dishwasher>', '[PUTBACK] <plate> <dishwasher>', '[FIND] <dishwasher>', '[CLOSE] <dishwasher>', '[SWITCHON] <dishwasher>']
}

Input:
Scene_Objects:['blow_dryer', 'bathroom', 'food_carrot', 'toothbrush', 'cpuscreen', 'hanger', 'floor', 'ceiling', 'desk', 'keyboard', 'bookshelf', 'computer', 'clothes_jacket', 'mousepad', 'closetdrawer', 'clothes_pants', 'wall', 'powersocket', 'bench', 'cutting_board', 'bed', 'photoframe', 'television', 'food_onion', 'mouse', 'dresser', 'hairbrush', 'controller', 'light', 'clothes_shirt']
Task:Organize closet
response:

Organize the hanging clothes in my closet by color and type and get rid of clothes I don't wear.


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', '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:
{
    "thoughts": walk into living room, walk to light, turn on light switch.,
    "actions": ['[WALK] <home_office>', '[WALK] <light>', '[SWITCHON] <light>']
}

Input:
Scene_Objects:['tablelamp', 'microwave', 'freezer', 'walllamp', 'kitchen_cabinet', 'floor', 'ceiling', 'bathroom_counter', 'mail', 'stovefan', 'laptop', 'window', 'towel', 'dining_room', 'food_kiwi', 'wall', 'oven', 'cutting_board', 'bed', 'coffe_maker', 'food_food', 'check', 'tray', 'kitchen_counter', 'dishrack', 'conditioner', 'food_steak', 'bathtub', 'table', 'vase']
Task:Look in refrigerator
response:

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

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


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

Here is an example plan to achieve a goal for reference:
Scene_Objects:['pot', 'microwave', 'chair', 'freezer', 'walllamp', 'detergent', 'milk', 'knifeblock', 'drawing', 'cpuscreen', 'kitchen_cabinet', 'floor', 'ceiling', 'computer', 'stovefan', 'toaster', 'tvstand', 'faucet', 'iron', 'couch', 'wall', 'oven', 'food_food', 'television', 'tray', 'kitchen_counter', 'cupboard', 'sink', 'laser_pointer', 'scrabble']
Task:Cook some food
response:
{
    "thoughts": Cooking a meal,
    "actions": ['[WALK] <dining_room>', '[WALK] <kitchen_cabinet>', '[FIND] <kitchen_cabinet>', '[OPEN] <kitchen_cabinet>', '[FIND] <pot>', '[GRAB] <pot>', '[CLOSE] <kitchen_cabinet>', '[WALK] <sink>', '[FIND] <faucet>', '[SWITCHON] <faucet>', '[PUTBACK] <pot> <sink>', '[GRAB] <pot>', '[SWITCHOFF] <faucet>', '[WALK] <oven>', '[PUTBACK] <pot> <oven>', '[WALK] <freezer>', '[OPEN] <freezer>', '[FIND] <food_food>', '[GRAB] <food_food>', '[CLOSE] <freezer>', '[WALK] <oven>', '[PUTBACK] <food_food> <pot>', '[SWITCHON] <oven>']
}

Input:
Scene_Objects:['pot', 'crayon', 'chair', 'bathroom', 'food_butter', 'phone', 'ceiling', 'bedroom', 'tea_bag', 'laptop', 'ceilinglamp', 'shower', 'iron', 'clothes_socks', 'closetdrawer', 'clothes_pants', 'pillow', 'wall', 'powersocket', 'standingmirror', 'photoframe', 'toothbrush_holder', 'food_donut', 'curtain', 'doorjamb', 'towel_rack', 'pencil', 'controller', 'door', 'table']
Task:Switch on lamp
response:

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


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

Here is an example plan to achieve a goal for reference:
Scene_Objects:['glue', 'filing_cabinet', 'mop', 'microwave', 'dog', 'walllamp', 'drawing', 'wallshelf', 'floor', 'ceiling', 'bedroom', 'bookshelf', 'computer', 'mat', 'tvstand', 'ceilinglamp', 'couch', 'form', 'pillow', 'wall', 'nightstand', 'powersocket', 'photoframe', 'television', 'tray', 'curtain', 'doorjamb', 'centerpiece', 'sink', 'scrabble']
Task:Relax on sofa
response:
{
    "thoughts": I walk into the living room. I bend down. I sit on the sofa.,
    "actions": ['[WALK] <home_office>', '[WALK] <couch>', '[FIND] <couch>', '[SIT] <couch>']
}

Input:
Scene_Objects:['pot', 'microwave', 'freezer', 'walllamp', 'drawing', 'bathroom_counter', 'floor', 'ceiling', 'phone', 'stovefan', 'mat', 'ceilinglamp', 'faucet', 'window', 'clothes_pants', 'pillow', 'wall', 'wall_clock', 'oven', 'nightstand', 'cutting_board', 'shelf', 'clothes_gloves', 'food_food', 'coffe_maker', 'wooden_spoon', 'tray', 'kitchen_counter', 'sink', 'bathroom_cabinet']
Task:Keep an eye on stove as something is cooking
response:

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

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


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

Here is an example plan to achieve a goal for reference:
Scene_Objects:['blender', 'chair', 'walllamp', 'bathroom', 'drawing', 'bathroom_counter', 'shampoo', 'floor', 'ceiling', 'toaster', 'mat', 'ceilinglamp', 'plate', 'stovefan', 'dish_soap', 'broom', 'wall', 'bench', 'food_food', 'coffe_maker', 'tray', 'wooden_spoon', 'towel_rack', 'kitchen_counter', 'cupboard', 'hair', 'sink', 'table', 'dishwasher', 'instrument_violin']
Task:Wash dishes with dishwasher
response:
{
    "thoughts": I go the in kitchen then grab the plate on the table. I put the plate and dish soap in the dishwasher. Finally, I turn on the dishwasher.,
    "actions": ['[WALK] <dining_room>', '[WALK] <table>', '[FIND] <plate>', '[GRAB] <plate>', '[WALK] <dishwasher>', '[OPEN] <dishwasher>', '[PUTBACK] <plate> <dishwasher>', '[FIND] <dish_soap>', '[GRAB] <dish_soap>', '[PUTBACK] <dish_soap> <dishwasher>', '[CLOSE] <dishwasher>', '[SWITCHON] <dishwasher>']
}

Input:
Scene_Objects:['filing_cabinet', 'microwave', 'chair', 'freezer', 'blow_dryer', 'walllamp', 'nail_polish', 'bathroom', 'toothbrush', 'drawing', 'hanger', 'floor', 'shampoo', 'character', 'desk', 'bookshelf', 'purse', 'envelope', 'mat', 'ceilinglamp', 'window', 'towel', 'wall', 'powersocket', 'toy', 'cup', 'food_food', 'coffe_maker', 'sink', 'duster']
Task:Dust
response:

Apply duster to shelves and clean them until dust is gone

[WALK] <home_office>
[WALK] <duster>
[FIND] <duster>
[GRAB] <duster>
[FIND] <filing_cabinet>
[WIPE] <filing_cabinet>
[PUTOBJBACK] <duster>


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:['dry_pasta', 'glue', 'blender', 'food_salt', 'character', 'bedroom', 'mat', 'tvstand', 'food_noodles', 'garbage_can', 'couch', 'nightstand', 'wall_clock', 'bench', 'powersocket', 'toy', 'cutting_board', 'tape', 'food_vegetable', 'food_food', 'food_donut', 'tray', 'mouse', 'pencil', 'door', 'bathtub', 'home_office', 'table', 'colander', 'pantry']
Task:Organize pantry
response:

Remove all perishable foods from the pantry, check dates and throw away any old food. Decide on an efficient ad neat arrangement for the food and replace it in the pantry accordingly.


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_ice_cream', 'freezer', 'walllamp', 'milk', 'knifeblock', 'cpuscreen', 'floor', 'ceiling', 'desk', 'keyboard', 'alcohol', 'computer', 'stovefan', 'ceilinglamp', 'faucet', 'mousepad', 'wall', 'oven', 'powersocket', 'cup', 'ice', 'tray', 'doorjamb', 'mouse', 'kitchen_counter', 'cupboard', 'door', 'sink', 'light']
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:['measuring_cup', 'dog', 'chair', 'dough', 'wallshelf', 'hanger', 'cleaning_solution', 'keyboard', 'computer', 'ceilinglamp', 'plate', 'shower', 'faucet', 'window', 'homework', 'clothes_hat', 'nightstand', 'wall_clock', 'cup', 'photoframe', 'novel', 'check', 'oven_mitts', 'curtain', 'rag', 'towel_rack', 'shoes', 'hairbrush', 'maindoor', 'spoon']
Task:Clean mirror
response:

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

[WALK] <bathroom>
[WALK] <cleaning_solution>
[FIND] <cleaning_solution>
[GRAB] <cleaning_solution>
[FIND] <rag>
[GRAB] <rag>
[POUR] <cleaning_solution> <rag>
[PUTOBJBACK] <cleaning_solution>
[WALK] <mirror>
[WIPE] <mirror>
[PUTOBJBACK] <rag>


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

Here is an example plan to achieve a goal for reference:
Scene_Objects:['sheets', 'tablelamp', 'food_salt', 'milk', 'floor', 'phone', 'desk', 'keyboard', 'computer', 'clothes_jacket', 'mat', 'shower', 'window', 'couch', 'clothes_hat', 'pillow', 'wall', 'photoframe', 'check', 'mouthwash', 'razor', 'television', 'coin', 'coffe_maker', 'curtain', 'doorjamb', 'mouse', 'kitchen_counter', 'vacuum_cleaner', 'table']
Task:Relax on sofa
response:
{
    "thoughts": I walk into the living room and I lie down on the sofa.,
    "actions": ['[WALK] <home_office>', '[WALK] <couch>', '[FIND] <couch>', '[LIE] <couch>']
}

Input:
Scene_Objects:['microwave', 'chair', 'jelly', 'orchid', 'cpuscreen', 'hanger', 'bathroom_counter', 'floor', 'desk', 'keyboard', 'computer', 'toaster', 'mat', 'laptop', 'stovefan', 'tvstand', 'window', 'mousepad', 'closetdrawer', 'couch', 'pillow', 'wall', 'powersocket', 'television', 'curtain', 'doorjamb', 'towel_rack', 'mouse', 'dresser', 'table']
Task:Use laptop
response:

Sit down on a couch and perform tasks such as navigating the internet on a laptop

[WALK] <home_office>
[WALK] <couch>
[FIND] <couch>
[SIT] <couch>
[FIND] <laptop>
[SWITCHON] <laptop>
[TURNTO] <laptop>
[LOOKAT] <laptop>
[FIND] <keyboard>
[TYPE] <keyboard>
[TURNTO] <keyboard>
[LOOKAT] <keyboard>
[TYPE] <keyboard>
[TURNTO] <laptop>
[LOOKAT] <laptop>


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', 'bathroom', 'trashcan', 'milk', 'drawing', 'orchid', 'floor', 'ceiling', 'bedroom', 'bookshelf', 'computer', 'clothes_jacket', 'toaster', 'stovefan', 'tvstand', 'picture', 'window', 'dustpan', 'pillow', 'dining_room', 'wall', 'box', 'bed', 'wine', 'curtain', 'kettle', 'home_office', 'light', 'dishwasher']
Task:Look out window
response:
{
    "thoughts": I head into my child's room and look out the window to view the neighborhood from a different area in the house.,
    "actions": ['[WALK] <bedroom>', '[WALK] <window>', '[TURNTO] <window>', '[LOOKAT] <window>']
}

Input:
Scene_Objects:['pot', 'toilet', 'chair', 'walllamp', 'ground_coffee', 'dough', 'cpuscreen', 'hanger', 'floor', 'ceiling', 'desk', 'keyboard', 'computer', 'ceilinglamp', 'mousepad', 'closetdrawer', 'oil', 'wall', 'powersocket', 'shelf', 'toilet_paper', 'television', 'doorjamb', 'mouse', 'kitchen_counter', 'vacuum_cleaner', 'dresser', 'light', 'table', 'vase']
Task:Vacuum
response:

Keep my keyboard vacuumed and free of debris.

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


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

Here is an example plan to achieve a goal for reference:
Scene_Objects:['tablelamp', 'chair', 'walllamp', 'orchid', 'drawing', 'cpuscreen', 'wallshelf', 'hanger', 'floor', 'ceiling', 'phone', 'character', 'desk', 'keyboard', 'computer', 'ceilinglamp', 'tvstand', 'mat', 'mousepad', 'couch', 'pillow', 'wall', 'nightstand', 'oven', 'bed', 'television', 'doorjamb', 'mouse', 'dresser', 'door']
Task:Work
response:
{
    "thoughts": Type on a computer in the home office.,
    "actions": ['[WALK] <home_office>', '[WALK] <computer>', '[FIND] <computer>', '[SWITCHON] <computer>', '[FIND] <keyboard>', '[TYPE] <keyboard>']
}

Input:
Scene_Objects:['microwave', 'chair', 'dog', 'walllamp', 'detergent', 'orchid', 'cpuscreen', 'floor', 'ceiling', 'character', 'desk', 'keyboard', 'computer', 'ceilinglamp', 'mousepad', 'closetdrawer', 'towel', 'wall', 'wall_clock', 'powersocket', 'box', 'television', 'doorjamb', 'centerpiece', 'mouse', 'dresser', 'door', 'bathtub', 'light', 'table']
Task:Clean screen
response:

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

[WALK] <home_office>
[WALK] <rag>
[FIND] <rag>
[GRAB] <rag>
[WALK] <computer>
[WIPE] <computer>
[PUTOBJBACK] <rag>


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

Here is an example plan to achieve a goal for reference:
Scene_Objects:['tablelamp', 'measuring_cup', 'toilet', 'drawing', 'bathroom_counter', 'floor', 'ceiling', 'longboard', 'button', 'ceilinglamp', 'faucet', 'oil', 'teeth', 'clothes_hat', 'towel', 'wall', 'photoframe', 'bed', 'doorjamb', 'diary', 'kitchen_counter', 'dishrack', 'coffee', 'hairbrush', 'maindoor', 'sink', 'bathroom_cabinet', 'vase', 'soap', 'hands_both']
Task:Wash hands
response:
{
    "thoughts": Go to the bathroom. Turn on the sink. Rinse hands. Apply soap and scrub your hands together. Rinse hands again. Turn off faucet. Dry hands on a towel.,
    "actions": ['[WALK] <bathroom>', '[WALK] <faucet>', '[FIND] <faucet>', '[SWITCHON] <faucet>', '[FIND] <hands_both>', '[RINSE] <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:['glue', 'pot', 'filing_cabinet', 'food_bread', 'microwave', 'walllamp', 'dough', 'woman', 'toothbrush', 'wallshelf', 'ceiling', 'character', 'man', 'toaster', 'stereo', 'window', 'couch', 'dustpan', 'pillow', 'nightstand', 'bench', 'newspaper', 'keys', 'standingmirror', 'television', 'curtain', 'sink', 'instrument_guitar', 'table', 'light']
Task:Greet guests
response:

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

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


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

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

Input:
Scene_Objects:['food_butter', 'drawing', 'cpuscreen', 'hanger', 'floor', 'ceiling', 'desk', 'keyboard', 'computer', 'food_bacon', 'toaster', 'stereo', 'mousepad', 'closetdrawer', 'wall', 'powersocket', 'bench', 'cutting_board', 'cup', 'check', 'food_donut', 'food_rice', 'curtain', 'centerpiece', 'mouse', 'vacuum_cleaner', 'shoes', 'dresser', 'light', 'teeth']
Task:Vacuum
response:

Run the vacuum cleaner across the floor, back and forth a couple of times until clean.

[WALK] <bedroom>
[WALK] <dresser>
[OPEN] <dresser>
[FIND] <vacuum_cleaner>
[GRAB] <vacuum_cleaner>
[PULL] <vacuum_cleaner>
[PLUGIN] <vacuum_cleaner>
[SWITCHON] <vacuum_cleaner>
[PULL] <vacuum_cleaner>
[PUSH] <vacuum_cleaner>
[PULL] <vacuum_cleaner>
[PUSH] <vacuum_cleaner>
[PULL] <vacuum_cleaner>
[PUSH] <vacuum_cleaner>
[SWITCHOFF] <vacuum_cleaner>
[PLUGOUT] <vacuum_cleaner>
[WALK] <dresser>
[PUTIN] <vacuum_cleaner> <dresser>
[CLOSE] <dresser>