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

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

Input:
Scene_Objects:['pot', 'blender', 'microwave', 'detergent', 'trashcan', 'drawing', 'cpuscreen', 'longboard', 'floor', 'keyboard', 'toaster', 'laptop', 'stereo', 'window', 'food_peanut_butter', 'dining_room', 'broom', 'nightstand', 'oven', 'cup', 'photoframe', 'bed', 'television', 'after_shave', 'curtain', 'pencil', 'bathroom_cabinet', 'light', 'dishwasher', 'vase']
Task:Clean
response:

[WALK] <home_office>
[WALK] <vacuum_cleaner>
[FIND] <vacuum_cleaner>
[GRAB] <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:['dry_pasta', 'glue', 'measuring_cup', 'microwave', 'chair', 'blow_dryer', 'knifeblock', 'drawing', 'orchid', 'floor', 'phone', 'bookshelf', 'toaster', 'ceilinglamp', 'plate', 'faucet', 'wall', 'nightstand', 'photoframe', 'food_food', 'coffee_pot', 'pencil', 'kitchen_counter', 'cupboard', 'door', 'sink', 'instrument_violin', 'table', 'soap', 'tooth_paste']
Task:Bring dirty plate to sink
response:
{
    "thoughts": Stand up from the table.  Pick up dirty plate.  Walk to sink.  Put plate in sink.,
    "actions": ['[WALK] <dining_room>', '[WALK] <table>', '[FIND] <table>', '[TURNTO] <table>', '[FIND] <plate>', '[GRAB] <plate>', '[WALK] <dining_room>', '[WALK] <sink>', '[FIND] <sink>', '[PUTBACK] <plate> <sink>']
}

Input:
Scene_Objects:['pot', 'food_salt', 'beer', 'chair', 'freezer', 'knifeblock', 'bathroom_counter', 'longboard', 'phone', 'keyboard', 'computer', 'food_bacon', 'tvstand', 'balanceball', 'stereo', 'mousepad', 'clothes_pants', 'nightstand', 'bench', 'bed', 'photoframe', 'novel', 'television', 'pencil', 'kitchen_counter', 'vacuum_cleaner', 'food_steak', 'sink', 'hairdryer', 'vase']
Task:Read book
response:

Go to the book shelf, get a book, open the book and read the book.

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


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

Here is an example plan to achieve a goal for reference:
Scene_Objects:['glue', 'beer', 'measuring_cup', 'toilet', 'freezer', 'food_carrot', 'drawing', 'food_egg', 'hanger', 'floor', 'ceiling', 'bedroom', 'mat', 'laptop', 'shower', 'tvstand', 'closetdrawer', 'food_orange', 'nightstand', 'wall', 'powersocket', 'food_cheese', 'photoframe', 'bed', 'food_food', 'drinking_glass', 'wine', 'doorjamb', 'door', 'light']
Task:Drink
response:
{
    "thoughts": Robot Drinks the water,
    "actions": ['[WALK] <dining_room>', '[WALK] <freezer>', '[FIND] <freezer>', '[OPEN] <freezer>', '[FIND] <drinking_glass>', '[GRAB] <drinking_glass>', '[DRINK] <drinking_glass>', '[PUTOBJBACK] <drinking_glass>', '[CLOSE] <freezer>']
}

Input:
Scene_Objects:['glue', 'sheets', 'food_bread', 'food_pizza', 'tablelamp', 'scissors', 'toilet', 'walllamp', 'woman', 'knifeblock', 'hanger', 'bathroom_counter', 'man', 'tea_bag', 'keyboard', 'mail', 'stereo', 'window', 'couch', 'child', 'powersocket', 'photoframe', 'novel', 'coffe_maker', 'video_game_controller', 'ice', 'rag', 'headset', 'chessboard', 'maindoor']
Task:Greet guests
response:

Greet guests when they knock on the door and invite them to enter my home

[WALK] <home_office>
[WALK] <child>
[FIND] <child>
[GREET] <child>
[FIND] <man>
[GREET] <man>
[FIND] <woman>
[GREET] <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:['sheets', 'microwave', 'chair', 'bathroom', 'orchid', 'food_egg', 'cpuscreen', 'floor', 'phone', 'bedroom', 'desk', 'stovefan', 'toaster', 'ceilinglamp', 'shower', 'mat', 'food_peanut_butter', 'wall', 'pasta', 'powersocket', 'oven', 'cup', 'bed', 'after_shave', 'food_onion', 'chessboard', 'dresser', 'cupboard', 'clothes_scarf', 'home_office']
Task:Pet cat
response:
{
    "thoughts": I walk to my living room, find my cat, scrub it using my hand.,
    "actions": ['[WALK] <home_office>', '[WALK] <cat>', '[FIND] <cat>', '[SCRUB] <cat>']
}

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

[WALK] <home_office>
[WALK] <coffee_table>
[PUSH] <coffee_table>
[WALK] <couch>
[PUSH] <couch>
[WALK] <couch>
[PUSH] <couch>
[WALK] <filing_cabinet>
[PUSH] <filing_cabinet>


Instruction:
You serve as an AI task planner.
1. Your task is to create a plan to achieve a goal by converting it into a sequence of actions. Each action should follow the format "[verb] <target1> <target2>", where 'verb' represents the action, and 'target1' and 'target2' are optional arguments.
2. You must describe your plan in natural language at the beginning. After that, you should list all the actions together.
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', 'water_glass', 'microwave', 'toilet', 'chair', 'freezer', 'bathroom', 'wallshelf', 'bookshelf', 'clothes_jacket', 'toaster', 'ceilinglamp', 'faucet', 'window', 'closetdrawer', 'dining_room', 'nightstand', 'wall', 'wall_clock', 'powersocket', 'basket_for_clothes', 'novel', 'coffe_maker', 'tray', 'doorjamb', 'console', 'dishrack', 'hairdryer', 'door', 'bathtub']
Task:Drink
response:
{
    "thoughts": Drink water,
    "actions": ['[WALK] <dining_room>', '[WALK] <water_glass>', '[FIND] <water_glass>', '[GRAB] <water_glass>', '[DRINK] <water_glass>']
}

Input:
Scene_Objects:['food_pizza', 'nail_polish', 'food_carrot', 'drawing', 'knife', 'floor', 'ceiling', 'desk', 'mat', 'stereo', 'shower', 'clothes_socks', 'candle', 'pillow', 'dining_room', 'nightstand', 'bench', 'newspaper', 'check', 'video_game_controller', 'doorjamb', 'cards', 'chessboard', 'pajamas', 'clothes_dress', 'table', 'light', 'board_game', 'laser_pointer', 'coffee']
Task:Play games
response:

I either bring out monopoly, uno, chess, checkers or playing cards and lay them out on the dining room table. We then play the games for a couple of hours.

[WALK] <home_office>
[WALK] <board_game>
[FIND] <board_game>
[GRAB] <board_game>
[WALK] <dining_room>
[WALK] <table>
[PUTBACK] <board_game> <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:['microwave', 'chair', 'food_butter', 'food_carrot', 'drawing', 'orchid', 'knifeblock', 'knife', 'cpuscreen', 'floor', 'ceiling', 'bookshelf', 'toaster', 'mat', 'food_noodles', 'couch', 'pillow', 'wall', 'bed', 'photoframe', 'food_food', 'curtain', 'doorjamb', 'towel_rack', 'cupboard', 'door', 'bathroom_cabinet', 'table', 'light', 'dirt']
Task:Relax on sofa
response:
{
    "thoughts": Relax on the sofa in the living room.,
    "actions": ['[WALK] <home_office>', '[WALK] <couch>', '[FIND] <couch>', '[SIT] <couch>']
}

Input:
Scene_Objects:['glue', 'pot', 'freezer', 'walllamp', 'bathroom', 'trashcan', 'knifeblock', 'drawing', 'orchid', 'floor', 'ceiling', 'bedroom', 'keyboard', 'stovefan', 'ceilinglamp', 'toaster', 'form', 'wall', 'oven', 'food_vegetable', 'photoframe', 'tray', 'kitchen_counter', 'cupboard', 'maindoor', 'home_office', 'dishwasher', 'clothes_skirt', 'soap', 'creditcard']
Task:Cook some food
response:

I prepare meals and cook them on the stove.

[WALK] <dining_room>
[WALK] <freezer>
[OPEN] <freezer>
[FIND] <food_vegetable>
[GRAB] <food_vegetable>
[CLOSE] <freezer>
[FIND] <oven>
[SWITCHON] <oven>
[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:['sponge', 'toilet', 'chair', 'freezer', 'band-aids', 'walllamp', 'cat', 'drawing', 'orchid', 'floor', 'ceiling', 'phone', 'bedroom', 'ceilinglamp', 'tvstand', 'clothes_socks', 'couch', 'pillow', 'dining_room', 'wall', 'bench', 'clothes_gloves', 'novel', 'tray', 'doorjamb', 'kitchen_counter', 'door', 'table', 'light', 'dishwasher']
Task:Pet cat
response:
{
    "thoughts": walk to entrance hall, look at the sofa, sit on the sofa, look at the cat, allow cat to near with you, touch the cat smoothly on it head, now pet the cat smoothly,
    "actions": ['[WALK] <home_office>', '[WALK] <couch>', '[FIND] <couch>', '[TURNTO] <couch>', '[LOOKAT] <couch>', '[SIT] <couch>', '[FIND] <cat>', '[TURNTO] <cat>', '[LOOKAT] <cat>', '[TOUCH] <cat>']
}

Input:
Scene_Objects:['toilet', 'nail_polish', 'ceilingfan', 'drawing', 'cpuscreen', 'floor', 'ceiling', 'phone', 'character', 'remote_control', 'stovefan', 'ceilinglamp', 'tvstand', 'balanceball', 'toaster', 'window', 'couch', 'pillow', 'wall', 'powersocket', 'bench', 'cup', 'check', 'television', 'curtain', 'shoes', 'vacuum_cleaner', 'hairdryer', 'spoon', 'table']
Task:Change TV channel
response:

I go to the living room, I settle on the sofa, I turn on the television, change the channel

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


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

Here is an example plan to achieve a goal for reference:
Scene_Objects:['measuring_cup', 'microwave', 'chair', 'freezer', 'nail_polish', 'bathroom', 'food_butter', 'knifeblock', 'cpuscreen', 'hanger', 'ceiling', 'dvd_player', 'stamp', 'bookshelf', 'keyboard', 'computer', 'stovefan', 'mat', 'tvstand', 'iron', 'nightstand', 'oven', 'cutting_board', 'check', 'television', 'coin', 'tray', 'doorjamb', 'bathroom_cabinet', 'teeth']
Task:Answer door
response:
{
    "thoughts": Walk up to the door.  Open the door and greet whomever is out side,
    "actions": ['[WALK] <home_office>', '[WALK] <man>', '[FIND] <man>', '[GREET] <man>']
}

Input:
Scene_Objects:['crayon', 'cd_player', 'chair', 'toilet', 'walllamp', 'cat', 'hanger', 'floor', 'phone', 'remote_control', 'purse', 'alcohol', 'tvstand', 'iron', 'picture', 'window', 'wall', 'nightstand', 'powersocket', 'bench', 'cutting_board', 'basket_for_clothes', 'after_shave', 'doorjamb', 'kitchen_counter', 'comb', 'dresser', 'cupboard', 'door', 'light']
Task:Listen to music
response:

Walk to CD player and turn it on then go and sit in a chair and turn the remote control on and then listen to some music.

[WALK] <cd_player>
[SWITCHON] <cd_player>
[FIND] <chair>
[SIT] <chair>
[FIND] <remote_control>
[TOUCH] <remote_control>


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

Here is an example plan to achieve a goal for reference:
Scene_Objects:['sponge', 'filing_cabinet', 'tablelamp', 'bathroom', 'trashcan', 'food_butter', 'cpuscreen', 'desk', 'bookshelf', 'computer', 'mop_bucket', 'mat', 'closetdrawer', 'form', 'dining_room', 'nightstand', 'bench', 'oven', 'powersocket', 'toy', 'photoframe', 'coffe_maker', 'television', 'towel_rack', 'mouse', 'kitchen_counter', 'dresser', 'bathtub', 'sink', 'home_office']
Task:Pick up toys
response:
{
    "thoughts": Grab toys off floor.  Put it in a container.,
    "actions": ['[WALK] <bedroom>', '[WALK] <toy>', '[FIND] <toy>', '[GRAB] <toy>', '[WALK] <filing_cabinet>', '[OPEN] <filing_cabinet>', '[PUTBACK] <toy> <filing_cabinet>', '[FIND] <toy>', '[GRAB] <toy>', '[WALK] <filing_cabinet>', '[PUTBACK] <toy> <filing_cabinet>', '[FIND] <toy>', '[GRAB] <toy>', '[WALK] <filing_cabinet>', '[PUTBACK] <toy> <filing_cabinet>', '[CLOSE] <filing_cabinet>']
}

Input:
Scene_Objects:['tablelamp', 'microwave', 'toilet', 'chair', 'trashcan', 'ceilingfan', 'drawing', 'cpuscreen', 'floor', 'ceiling', 'phone', 'desk', 'keyboard', 'bookshelf', 'computer', 'piano_bench', 'bookmark', 'ceilinglamp', 'balanceball', 'mousepad', 'wall', 'nightstand', 'powersocket', 'doorjamb', 'mouse', 'dresser', 'maindoor', 'light', 'instrument_violin', 'shoe_rack']
Task:Write an email
response:

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


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

Here is an example plan to achieve a goal for reference:
Scene_Objects:['pot', 'tablelamp', 'blender', 'crayon', 'microwave', 'toilet', 'walllamp', 'milk', 'drawing', 'bathroom_counter', 'phone', 'desk', 'envelope', 'table_cloth', 'ceilinglamp', 'plate', 'faucet', 'picture', 'couch', 'clothes_pants', 'powersocket', 'bench', 'newspaper', 'tray', 'rag', 'kitchen_counter', 'laundry_detergent', 'soap', 'scrabble', 'washing_machine']
Task:Wash clothes
response:
{
    "thoughts": Walk to bathroom. Open washing maschine. Grab pants and put it into washing maschine. Pour laundry detergent into washing machine and close the washing maschine. Plug in washing machine.,
    "actions": ['[WALK] <bathroom>', '[WALK] <washing_machine>', '[FIND] <washing_machine>', '[OPEN] <washing_machine>', '[FIND] <clothes_pants>', '[GRAB] <clothes_pants>', '[PUTBACK] <clothes_pants> <washing_machine>', '[WALK] <laundry_detergent>', '[FIND] <laundry_detergent>', '[GRAB] <laundry_detergent>', '[POUR] <laundry_detergent> <washing_machine>', '[CLOSE] <washing_machine>', '[PLUGIN] <washing_machine>']
}

Input:
Scene_Objects:['filing_cabinet', 'tablelamp', 'crayon', 'freezer', 'bathroom', 'food_carrot', 'drawing', 'knifeblock', 'floor', 'desk', 'ceilinglamp', 'stereo', 'window', 'couch', 'food_orange', 'pillow', 'form', 'dining_room', 'wall', 'bench', 'coffe_maker', 'television', 'rag', 'pencil', 'comb', 'table', 'tooth_paste', 'clothes_shirt', 'scrabble', 'creditcard']
Task:Relax on sofa
response:

I walk to the living room and stand in front of the sofa. Then I turn and sit on the sofa and lean my back against the pillow and my feet on the floor.

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


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

Here is an example plan to achieve a goal for reference:
Scene_Objects:['sponge', 'water_glass', 'pot', 'glue', 'walllamp', 'trashcan', 'knifeblock', 'ceiling', 'clothes_jacket', 'stovefan', 'toaster', 'mat', 'faucet', 'microphone', 'wall', 'cup', 'bed', 'food_food', 'check', 'water', 'food_donut', 'curtain', 'kitchen_counter', 'chessboard', 'cupboard', 'laundry_detergent', 'sink', 'spoon', 'bathroom_cabinet', 'dirt']
Task:Drink
response:
{
    "thoughts": I walk to the kitchen. open the cupboard. Find the water glass, grab it. Fill the glass with water and drink water.,
    "actions": ['[WALK] <dining_room>', '[WALK] <cupboard>', '[FIND] <cupboard>', '[OPEN] <cupboard>', '[FIND] <water_glass>', '[GRAB] <water_glass>', '[WALK] <water>', '[FIND] <water>', '[GRAB] <water>', '[POUR] <water> <water_glass>', '[DRINK] <water_glass>']
}

Input:
Scene_Objects:['fork', 'tablelamp', 'crayon', 'microwave', 'drawing', 'bills', 'cpuscreen', 'longboard', 'floor', 'bookshelf', 'computer', 'button', 'table_cloth', 'toaster', 'ceilinglamp', 'faucet', 'window', 'oil', 'couch', 'food_jam', 'food_orange', 'wall', 'bench', 'mouthwash', 'television', 'cupboard', 'table', 'clothes_skirt', 'light', 'tooth_paste']
Task:Relax on sofa
response:

walk into living room, look at the sofa which one is available, sit on the sofa, now take relax on the sofa

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


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

Here is an example plan to achieve a goal for reference:
Scene_Objects:['juice', 'food_ice_cream', 'blow_dryer', 'detergent', 'ceilingfan', 'drawing', 'hanger', 'longboard', 'floor', 'ceiling', 'phone', 'bedroom', 'keyboard', 'remote_control', 'ceilinglamp', 'tvstand', 'balanceball', 'faucet', 'window', 'shoe-shine_kit', 'couch', 'food_orange', 'wall', 'tape', 'television', 'curtain', 'kitchen_counter', 'conditioner', 'bathroom_cabinet', 'table']
Task:Relax on sofa
response:
{
    "thoughts": For relaxing walk to living room. Find the sofa to relax. Arrange the sofa to relax. Sit on the sofa to relaxing.,
    "actions": ['[WALK] <home_office>', '[WALK] <couch>', '[FIND] <couch>', '[FIND] <conditioner>', '[FIND] <remote_control>', '[FIND] <television>', '[SWITCHON] <television>', '[LIE] <couch>']
}

Input:
Scene_Objects:['pot', 'scissors', 'tea', 'chair', 'freezer', 'walllamp', 'trashcan', 'knifeblock', 'hanger', 'kitchen_cabinet', 'floor', 'ceiling', 'phone', 'food_chicken', 'button', 'stovefan', 'toaster', 'ceilinglamp', 'wall', 'oven', 'bed', 'food_food', 'tray', 'doorjamb', 'kitchen_counter', 'dresser', 'cupboard', 'door', 'light', 'dishwasher']
Task:Cook some food
response:

I walk into the kitchen and walk over the cabinent. I pull out a pan and walk to the stove. I put the pan on the stove and walk over to the fridge. I pull out out meat from the fridge and walk back over the stove. Then I put the meat in the pan.

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


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

Here is an example plan to achieve a goal for reference:
Scene_Objects:['filing_cabinet', 'microwave', 'chair', 'walllamp', 'orchid', 'cpuscreen', 'wallshelf', 'bathroom_counter', 'floor', 'ceiling', 'phone', 'desk', 'keyboard', 'computer', 'ceilinglamp', 'tvstand', 'mat', 'mousepad', 'pillow', 'dining_room', 'wall', 'nightstand', 'powersocket', 'cutting_board', 'television', 'curtain', 'doorjamb', 'mouse', 'door', 'table']
Task:Watch youtube
response:
{
    "thoughts": Go to youtube.Com watch videos,
    "actions": ['[WALK] <home_office>', '[WALK] <chair>', '[FIND] <chair>', '[SIT] <chair>', '[FIND] <computer>', '[SWITCHON] <computer>', '[TURNTO] <computer>', '[LOOKAT] <computer>']
}

Input:
Scene_Objects:['tablelamp', 'beer', 'toilet', 'dough', 'toothbrush', 'drawing', 'floor', 'ceiling', 'computer', 'ceilinglamp', 'tvstand', 'stereo', 'shower', 'window', 'oil', 'couch', 'bowl', 'wall', 'oven', 'toy', 'cup', 'bed', 'food_food', 'television', 'wooden_spoon', 'towel_rack', 'comb', 'cupboard', 'table', 'dishwasher']
Task:Relax on sofa
response:

Walk to living room. Find couch. Sit on couch

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


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

Here is an example plan to achieve a goal for reference:
Scene_Objects:['fork', 'pot', 'filing_cabinet', 'tablelamp', 'microwave', 'chair', 'bathroom', 'drawing', 'cpuscreen', 'floor', 'phone', 'desk', 'bedroom', 'ceilinglamp', 'shoe-shine_kit', 'faucet', 'clothes_pants', 'dining_room', 'wall', 'tape', 'basket_for_clothes', 'bed', 'coffe_maker', 'chessboard', 'clothes_dress', 'door', 'home_office', 'light', 'soap', 'washing_machine']
Task:Wash clothes
response:
{
    "thoughts": Walk to Bathroom. Find basket for clothes. Lift clothes dress from basket. Find washing machine. Walk to washing machine. Put clothes in washing machine. Put soap in washing machine. Switch on washing machine.,
    "actions": ['[WALK] <bathroom>', '[WALK] <basket_for_clothes>', '[FIND] <basket_for_clothes>', '[FIND] <clothes_dress>', '[GRAB] <clothes_dress>', '[FIND] <washing_machine>', '[WALK] <washing_machine>', '[OPEN] <washing_machine>', '[PUTBACK] <clothes_dress> <washing_machine>', '[FIND] <soap>', '[GRAB] <soap>', '[PUTBACK] <soap> <washing_machine>', '[CLOSE] <washing_machine>', '[SWITCHON] <washing_machine>']
}

Input:
Scene_Objects:['dry_pasta', 'toilet', 'ceilingfan', 'milk', 'knife', 'drawing', 'cpuscreen', 'bathroom_counter', 'floor', 'character', 'desk', 'keyboard', 'food_cake', 'computer', 'stovefan', 'deck_of_cards', 'mousepad', 'wall', 'wall_clock', 'photoframe', 'bed', 'video_game_controller', 'coffee_pot', 'mouse', 'door', 'bathroom_cabinet', 'light', 'soap', 'scrabble', 'coffee']
Task:Go to toilet
response:

I go to the bathroom. I locate the toilet. I walk to the toilet.

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


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

Here is an example plan to achieve a goal for reference:
Scene_Objects:['chair', 'detergent', 'food_butter', 'clothes_underwear', 'hanger', 'floor', 'stamp', 'bookshelf', 'computer', 'clothes_jacket', 'table_cloth', 'mat', 'shoe-shine_kit', 'clothes_socks', 'closetdrawer', 'couch', 'clothes_pants', 'basket_for_clothes', 'check', 'mouthwash', 'food_rice', 'vacuum_cleaner', 'laundry_detergent', 'clothes_dress', 'bathroom_cabinet', 'light', 'dishwasher', 'clothes_shirt', 'washing_machine', 'creditcard']
Task:Wash clothes
response:
{
    "thoughts": I grab the basket for clothes from the bedroom. I carry it and walk to the washing machine. I open the washing machine. I grab the dirty clothes. I put the clothes in the washing machine. I grab the laundry detergent and put it in the washing machine. I close the washing machine. I switch on the washing machine.,
    "actions": ['[WALK] <bedroom>', '[WALK] <basket_for_clothes>', '[FIND] <basket_for_clothes>', '[GRAB] <basket_for_clothes>', '[WALK] <washing_machine>', '[DROP] <basket_for_clothes>', '[OPEN] <washing_machine>', '[FIND] <clothes_pants>', '[GRAB] <clothes_pants>', '[PUTBACK] <clothes_pants> <washing_machine>', '[FIND] <clothes_shirt>', '[GRAB] <clothes_shirt>', '[PUTBACK] <clothes_shirt> <washing_machine>', '[FIND] <clothes_underwear>', '[GRAB] <clothes_underwear>', '[PUTBACK] <clothes_underwear> <washing_machine>', '[FIND] <clothes_socks>', '[GRAB] <clothes_socks>', '[PUTBACK] <clothes_socks> <washing_machine>', '[FIND] <laundry_detergent>', '[GRAB] <laundry_detergent>', '[PUTBACK] <laundry_detergent> <washing_machine>', '[GRAB] <laundry_detergent>', '[PUTOBJBACK] <laundry_detergent>', '[CLOSE] <washing_machine>', '[SWITCHON] <washing_machine>']
}

Input:
Scene_Objects:['filing_cabinet', 'tablelamp', 'beer', 'microwave', 'toilet', 'nail_polish', 'knifeblock', 'hanger', 'bedroom', 'keyboard', 'mail', 'button', 'mat', 'stereo', 'iron', 'shower', 'mousepad', 'dustpan', 'photoframe', 'newspaper', 'food_food', 'video_game_controller', 'coffe_maker', 'coin', 'curtain', 'kettle', 'napkin', 'home_office', 'light', 'teeth']
Task:Listen to music
response:

I go into the living room and turn on the radio.  Then, I select the station I want, which is usually a preset.

[WALK] <home_office>
[WALK] <stereo>
[FIND] <stereo>
[FIND] <button>
[PUSH] <button>
[FIND] <button>
[PUSH] <button>


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

Here is an example plan to achieve a goal for reference:
Scene_Objects:['sheets', 'food_pizza', 'chair', 'cat', 'drawing', 'floor', 'tea_bag', 'bookshelf', 'thread', 'toaster', 'ceilinglamp', 'stovefan', 'window', 'couch', 'food_orange', 'wall', 'food_food', 'television', 'oven_mitts', 'food_onion', 'curtain', 'after_shave', 'comb', 'napkin', 'home_office', 'table', 'dishwasher', 'bathroom_cabinet', 'laser_pointer', 'scrabble']
Task:Relax on sofa
response:
{
    "thoughts": go to the living room,find the sofa,sat down in the sofa,take some relaxation.,
    "actions": ['[WALK] <home_office>', '[WALK] <couch>', '[FIND] <couch>', '[SIT] <couch>']
}

Input:
Scene_Objects:['blender', 'food_ice_cream', 'bathroom', 'cat', 'drawing', 'bills', 'bathroom_counter', 'floor', 'stovefan', 'ceilinglamp', 'mat', 'toaster', 'window', 'mousepad', 'couch', 'towel', 'wall', 'powersocket', 'tape', 'food_cheese', 'novel', 'television', 'wooden_spoon', 'curtain', 'shaving_cream', 'chessboard', 'shoes', 'food_steak', 'table', 'light']
Task:Relax on sofa
response:

move to living room, locate sofa, move to sofa, sit on sofa, lie on sofa

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


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

Here is an example plan to achieve a goal for reference:
Scene_Objects:['spectacles', 'blender', 'crayon', 'microwave', 'walllamp', 'drawing', 'hanger', 'floor', 'ceiling', 'character', 'bedroom', 'envelope', 'stovefan', 'window', 'oil', 'wall', 'powersocket', 'bench', 'toy', 'keys', 'food_donut', 'wooden_spoon', 'curtain', 'doorjamb', 'maindoor', 'bathtub', 'bathroom_cabinet', 'light', 'dirt', 'teeth']
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:['pot', 'crayon', 'microwave', 'chair', 'freezer', 'detergent', 'food_egg', 'hanger', 'floor', 'ceiling', 'toaster', 'plate', 'shower', 'mousepad', 'broom', 'wall', 'pasta', 'keys', 'novel', 'coffe_maker', 'toothbrush_holder', 'coffee_filter', 'wooden_spoon', 'towel_rack', 'controller', 'maindoor', 'sink', 'dishwasher', 'coffee', 'creditcard']
Task:Make coffee
response:

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

[WALK] <dining_room>
[WALK] <coffe_maker>
[FIND] <coffe_maker>
[OPEN] <coffe_maker>
[FIND] <coffee_filter>
[GRAB] <coffee_filter>
[PUTBACK] <coffee_filter> <coffe_maker>
[FIND] <coffee>
[GRAB] <coffee>
[PUTBACK] <coffee> <coffe_maker>


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

Here is an example plan to achieve a goal for reference:
Scene_Objects:['pot', 'filing_cabinet', 'tablelamp', 'tea', 'knifeblock', 'cpuscreen', 'folder', 'bedroom', 'table_cloth', 'toaster', 'plate', 'homework', 'oil', 'closetdrawer', 'powersocket', 'tape', 'bed', 'novel', 'coffe_maker', 'television', 'razor', 'wine', 'doorjamb', 'shoes', 'dishrack', 'headset', 'cupboard', 'hairdryer', 'light', 'shoe_rack']
Task:Listen to music
response:
{
    "thoughts": walk into living room, walk to stereo, turn on stereo, listen to music,
    "actions": ['[WALK] <home_office>', '[WALK] <stereo>', '[FIND] <stereo>', '[SWITCHON] <stereo>']
}

Input:
Scene_Objects:['pot', 'filing_cabinet', 'tablelamp', 'food_ice_cream', 'walllamp', 'ceilingfan', 'drawing', 'floor', 'ceiling', 'dvd_player', 'character', 'remote_control', 'toaster', 'ceilinglamp', 'tvstand', 'balanceball', 'window', 'electric_shaver', 'mousepad', 'couch', 'form', 'wall', 'nightstand', 'clothes_gloves', 'television', 'curtain', 'headset', 'maindoor', 'table', 'clothes_shirt']
Task:Watch TV
response:

Walk to Living room. Find Television. Walk to sofa. Sit on sofa. Find Remote. Grab remote. Turn to television. Look at television. Switch on Television.

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


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

Here is an example plan to achieve a goal for reference:
Scene_Objects:['sponge', 'food_pizza', 'filing_cabinet', 'microwave', 'chair', 'walllamp', 'orchid', 'knifeblock', 'bathroom_counter', 'ceiling', 'phone', 'stamp', 'keyboard', 'thread', 'computer', 'stovefan', 'toaster', 'plate', 'shower', 'mousepad', 'form', 'wall', 'food_cheese', 'bed', 'console', 'headset', 'dresser', 'spoon', 'bathroom_cabinet', 'bag']
Task:Walk to room
response:
{
    "thoughts": Leave the living room and enter the hall,
    "actions": ['[WALK] <home_office>', '[WALK] <home_office>']
}

Input:
Scene_Objects:['dry_pasta', 'filing_cabinet', 'toilet', 'detergent', 'ceilingfan', 'drawing', 'knifeblock', 'hanger', 'bathroom_counter', 'floor', 'ceiling', 'phone', 'remote_control', 'thread', 'toaster', 'ceilinglamp', 'tvstand', 'balanceball', 'faucet', 'window', 'shower', 'couch', 'pillow', 'wall', 'food_cheese', 'television', 'curtain', 'centerpiece', 'home_office', 'table']
Task:Watch TV
response:

I go in my living room, find the remote, sit on my couch,  turn on the TV and watch TV.

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


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

Here is an example plan to achieve a goal for reference:
Scene_Objects:['food_pizza', 'tablelamp', 'chair', 'freezer', 'detergent', 'bathroom_counter', 'desk', 'bedroom', 'keyboard', 'button', 'stovefan', 'ceilinglamp', 'stereo', 'shower', 'window', 'clothes_socks', 'dining_room', 'nightstand', 'wall', 'bench', 'oven', 'powersocket', 'bed', 'television', 'curtain', 'doorjamb', 'dresser', 'napkin', 'bathroom_cabinet', 'soap']
Task:Listen to music
response:
{
    "thoughts": Walk into living room, look for radio, grab on button,
    "actions": ['[WALK] <home_office>', '[WALK] <stereo>', '[FIND] <stereo>', '[TURNTO] <stereo>', '[LOOKAT] <stereo>', '[FIND] <button>', '[GRAB] <button>']
}

Input:
Scene_Objects:['sheets', 'glue', 'chair', 'walllamp', 'ceilingfan', 'knife', 'orchid', 'cpuscreen', 'longboard', 'floor', 'ceiling', 'phone', 'character', 'desk', 'bookshelf', 'keyboard', 'computer', 'balanceball', 'mousepad', 'clothes_socks', 'bowl', 'wall', 'check', 'television', 'mouse', 'kitchen_counter', 'cd', 'door', 'light', 'soap']
Task:Pick up phone
response:

When the phone rings, I pick up the call and give response to the call.

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


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

Here is an example plan to achieve a goal for reference:
Scene_Objects:['scissors', 'tablelamp', 'chair', 'freezer', 'walllamp', 'drawing', 'wallshelf', 'hanger', 'floor', 'ceiling', 'desk', 'keyboard', 'computer', 'mat', 'tvstand', 'ceilinglamp', 'faucet', 'shower', 'closetdrawer', 'couch', 'pillow', 'wall', 'nightstand', 'photoframe', 'newspaper', 'television', 'doorjamb', 'dresser', 'soap', 'instrument_violin']
Task:Watch TV
response:
{
    "thoughts": I sit on my couch and watch TV in my living room,
    "actions": ['[WALK] <home_office>', '[WALK] <television>', '[SWITCHON] <television>', '[TURNTO] <television>', '[LOOKAT] <television>', '[TOUCH] <television>', '[TURNTO] <television>', '[LOOKAT] <television>', '[TOUCH] <television>', '[TURNTO] <television>', '[LOOKAT] <television>', '[WALK] <couch>', '[SIT] <couch>', '[TURNTO] <television>', '[LOOKAT] <television>', '[WATCH] <television>', '[WATCH] <television>', '[WATCH] <television>']
}

Input:
Scene_Objects:['glue', 'shoe_rack', 'food_salt', 'beer', 'measuring_cup', 'microwave', 'trashcan', 'food_carrot', 'orchid', 'drawing', 'bookshelf', 'envelope', 'alcohol', 'ceilinglamp', 'plate', 'food_jam', 'pillow', 'oven', 'newspaper', 'photoframe', 'coffe_maker', 'food_food', 'tray', 'lighter', 'doorjamb', 'coffee_pot', 'towel_rack', 'cupboard', 'hairdryer', 'creditcard']
Task:Pet cat
response:

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


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

Here is an example plan to achieve a goal for reference:
Scene_Objects:['glue', 'sheets', 'food_bread', 'food_pizza', 'tablelamp', 'scissors', 'toilet', 'walllamp', 'woman', 'knifeblock', 'hanger', 'bathroom_counter', 'man', 'tea_bag', 'keyboard', 'mail', 'stereo', 'window', 'couch', 'child', 'powersocket', 'photoframe', 'novel', 'coffe_maker', 'video_game_controller', 'ice', 'rag', 'headset', 'chessboard', 'maindoor']
Task:Greet guests
response:
{
    "thoughts": Greet guests when they knock on the door and invite them to enter my home,
    "actions": ['[WALK] <home_office>', '[WALK] <child>', '[FIND] <child>', '[GREET] <child>', '[FIND] <man>', '[GREET] <man>', '[FIND] <woman>', '[GREET] <woman>']
}

Input:
Scene_Objects:['bathroom', 'ceilingfan', 'drawing', 'floor', 'ceiling', 'folder', 'character', 'remote_control', 'food_cake', 'toaster', 'ceilinglamp', 'tvstand', 'balanceball', 'picture', 'window', 'couch', 'wall', 'oven', 'bench', 'photoframe', 'coffee_table', 'food_food', 'television', 'curtain', 'lighter', 'towel_rack', 'controller', 'maindoor', 'table', 'light']
Task:Change TV channel
response:

Walk to the living room and look at the coffee table. Grab the remote control and turn to the television and point the remote control. Put back the remote control.

[WALK] <home_office>
[WALK] <coffee_table>
[FIND] <coffee_table>
[TURNTO] <coffee_table>
[LOOKAT] <coffee_table>
[FIND] <remote_control>
[GRAB] <remote_control>
[FIND] <television>
[TURNTO] <television>
[POINTAT] <television>
[PUTOBJBACK] <remote_control>


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

Here is an example plan to achieve a goal for reference:
Scene_Objects:['pot', 'food_salt', 'beer', 'chair', 'freezer', 'knifeblock', 'bathroom_counter', 'longboard', 'phone', 'keyboard', 'computer', 'food_bacon', 'tvstand', 'balanceball', 'stereo', 'mousepad', 'clothes_pants', 'nightstand', 'bench', 'bed', 'photoframe', 'novel', 'television', 'pencil', 'kitchen_counter', 'vacuum_cleaner', 'food_steak', 'sink', 'hairdryer', 'vase']
Task:Read book
response:
{
    "thoughts": Go to the book shelf, get a book, open the book and read the book.,
    "actions": ['[WALK] <home_office>', '[WALK] <novel>', '[FIND] <novel>', '[GRAB] <novel>', '[READ] <novel>']
}

Input:
Scene_Objects:['beer', 'toilet', 'walllamp', 'detergent', 'dough', 'drawing', 'needle', 'bathroom_counter', 'floor', 'ceiling', 'dvd_player', 'desk', 'table_cloth', 'faucet', 'window', 'mousepad', 'couch', 'dining_room', 'wall', 'pasta', 'photoframe', 'food_food', 'check', 'food_donut', 'dishrack', 'cupboard', 'sink', 'clothes_scarf', 'bathroom_cabinet', 'soap']
Task:Wash hands
response:

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

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


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

Here is an example plan to achieve a goal for reference:
Scene_Objects:['sheets', 'crayon', 'microwave', 'toilet', 'chair', 'dough', 'drawing', 'knifeblock', 'clothes_underwear', 'floor', 'folder', 'bedroom', 'toaster', 'ceilinglamp', 'plate', 'faucet', 'candle', 'clothes_hat', 'wall', 'food_food', 'food_onion', 'cards', 'mouse', 'kitchen_counter', 'cupboard', 'conditioner', 'laundry_detergent', 'sink', 'bathroom_cabinet', 'dirt']
Task:Wash dishes by hand
response:
{
    "thoughts": I walk into the kitchen to the sink. I put dishes in sink and wash them with my hands,
    "actions": ['[WALK] <dining_room>', '[WALK] <plate>', '[FIND] <plate>', '[GRAB] <plate>', '[FIND] <sink>', '[PUTBACK] <plate> <sink>', '[WASH] <plate>']
}

Input:
Scene_Objects:['glue', 'food_pizza', 'tea', 'freezer', 'walllamp', 'knifeblock', 'food_egg', 'cpuscreen', 'bathroom_counter', 'phone', 'computer', 'toaster', 'brush', 'ceilinglamp', 'mat', 'window', 'mousepad', 'pillow', 'wall', 'clothes_gloves', 'novel', 'check', 'food_onion', 'console', 'kitchen_counter', 'vacuum_cleaner', 'hair', 'controller', 'bathroom_cabinet', 'instrument_violin']
Task:Read book
response:

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

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


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

Here is an example plan to achieve a goal for reference:
Scene_Objects:['water_glass', 'tablelamp', 'microwave', 'toilet', 'freezer', 'walllamp', 'trashcan', 'drawing', 'wallshelf', 'floor', 'ceiling', 'phone', 'toaster', 'stovefan', 'mat', 'faucet', 'shower', 'window', 'wall', 'wall_clock', 'oven', 'coffe_maker', 'water', 'tray', 'doorjamb', 'towel_rack', 'kitchen_counter', 'cupboard', 'door', 'sink']
Task:Drink
response:
{
    "thoughts": I need to go to Kitchen.  Get a cup.  Fill cup.  Drink,
    "actions": ['[WALK] <dining_room>', '[WALK] <cupboard>', '[FIND] <cupboard>', '[OPEN] <cupboard>', '[FIND] <water_glass>', '[GRAB] <water_glass>', '[WALK] <freezer>', '[WALK] <water>', '[FIND] <water>', '[GRAB] <water>', '[POUR] <water> <water_glass>', '[DRINK] <water_glass>']
}

Input:
Scene_Objects:['tablelamp', 'toilet', 'chair', 'walllamp', 'trashcan', 'ceilingfan', 'drawing', 'cpuscreen', 'floor', 'ceiling', 'phone', 'desk', 'bookshelf', 'keyboard', 'computer', 'bookmark', 'ceilinglamp', 'balanceball', 'shower', 'mousepad', 'pillow', 'wall', 'nightstand', 'photoframe', 'doorjamb', 'cards', 'mouse', 'bathroom_cabinet', 'light', 'soap']
Task:Work
response:

Walk to the home office and turn to the desk. Switch on the computer. Grab the mouse and keyboard to start working.

[WALK] <home_office>
[WALK] <desk>
[FIND] <desk>
[TURNTO] <desk>
[FIND] <computer>
[TURNTO] <computer>
[LOOKAT] <computer>
[SWITCHON] <computer>
[FIND] <keyboard>
[GRAB] <keyboard>
[FIND] <mouse>
[GRAB] <mouse>


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

Here is an example plan to achieve a goal for reference:
Scene_Objects:['filing_cabinet', 'juice', 'dog', 'orchid', 'floor', 'desk', 'button', 'clothes_jacket', 'mat', 'stereo', 'shower', 'window', 'couch', 'pillow', 'wall', 'wall_clock', 'bench', 'cutting_board', 'toilet_paper', 'mouthwash', 'television', 'curtain', 'after_shave', 'doorjamb', 'hair', 'food_steak', 'napkin', 'home_office', 'table', 'vase']
Task:Listen to music
response:
{
    "thoughts": sitting down to listen to music on the radio,
    "actions": ['[WALK] <home_office>', '[WALK] <stereo>', '[FIND] <stereo>', '[SWITCHON] <stereo>', '[FIND] <couch>', '[SIT] <couch>']
}

Input:
Scene_Objects:['pot', 'filing_cabinet', 'beer', 'crayon', 'detergent', 'drawing', 'food_egg', 'floor', 'ceiling', 'bedroom', 'brush', 'mat', 'ceilinglamp', 'shower', 'balanceball', 'window', 'couch', 'towel', 'wall', 'bench', 'light_bulb', 'television', 'water', 'curtain', 'mouse', 'kitchen_counter', 'door', 'home_office', 'soap', 'laser_pointer']
Task:Take shower
response:

Walk into bathroom. Turn on shower. Take off clothing. Climb into shower. Rinse with water. Soap up body. Rinse off with water. Turn off shower. Climb out of shower. Dry off with towel.

[WALK] <bathroom>
[WALK] <shower>
[FIND] <shower>
[TURNTO] <shower>
[FIND] <water>
[RINSE] <water>
[FIND] <soap>
[WASH] <soap>
[RINSE] <water>
[FIND] <towel>
[GRAB] <towel>
[SCRUB] <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', 'walllamp', 'cat', 'drawing', 'wallshelf', 'cpuscreen', 'floor', 'phone', 'desk', 'bookshelf', 'stovefan', 'mat', 'tvstand', 'ceilinglamp', 'toaster', 'window', 'oil', 'closetdrawer', 'couch', 'form', 'pillow', 'wall', 'wall_clock', 'coffe_maker', 'television', 'curtain', 'mouse', 'home_office', 'table', 'coffee']
Task:Pet cat
response:
{
    "thoughts": I walk into the living room. I see my cat on the couch. I go sit next to the cat on the couch. I pet the cat on the back.,
    "actions": ['[WALK] <home_office>', '[WALK] <cat>', '[FIND] <cat>', '[TURNTO] <cat>', '[LOOKAT] <cat>', '[FIND] <couch>', '[SIT] <couch>', '[TOUCH] <cat>']
}

Input:
Scene_Objects:['sheets', 'scissors', 'toilet', 'jelly', 'ground_coffee', 'ceilingfan', 'drawing', 'bathroom_counter', 'floor', 'ceiling', 'bookshelf', 'clothes_jacket', 'faucet', 'mousepad', 'wall', 'oven', 'cup', 'photoframe', 'video_game_controller', 'television', 'tray', 'doorjamb', 'mouse', 'conditioner', 'sink', 'bathroom_cabinet', 'home_office', 'vase', 'soap', 'hands_both']
Task:Wash hands
response:

[RUN] <bathroom>
[WALK] <sink>
[FIND] <faucet>
[SWITCHON] <faucet>
[FIND] <soap>
[GRAB] <soap>
[PUTBACK] <soap> <sink>
[FIND] <hands_both>
[WASH] <hands_both>
[GRAB] <soap>
[PUTOBJBACK] <soap>
[RINSE] <hands_both>
[SWITCHOFF] <faucet>


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

Here is an example plan to achieve a goal for reference:
Scene_Objects:['tea', 'toilet', 'walllamp', 'bathroom', 'detergent', 'drawing', 'bills', 'floor', 'character', 'bookshelf', 'computer', 'stovefan', 'ceilinglamp', 'tvstand', 'stereo', 'closetdrawer', 'form', 'dining_room', 'nightstand', 'powersocket', 'cup', 'bed', 'tray', 'mouse', 'kitchen_counter', 'cupboard', 'bathroom_cabinet', 'home_office', 'dirt', 'electrical_outlet']
Task:Turn on radio
response:
{
    "thoughts": Go to the radio.  Switch on the power button.  Tune the station.  Set the volume.  Listen to the music.,
    "actions": ['[WALK] <home_office>', '[WALK] <stereo>', '[FIND] <stereo>', '[FIND] <electrical_outlet>', '[TURNTO] <electrical_outlet>', '[PLUGIN] <stereo>', '[SWITCHON] <electrical_outlet>', '[SWITCHON] <stereo>']
}

Input:
Scene_Objects:['microwave', 'toilet', 'chair', 'freezer', 'ceilingfan', 'drawing', 'cpuscreen', 'floor', 'ceiling', 'desk', 'bookshelf', 'keyboard', 'computer', 'ceilinglamp', 'tvstand', 'balanceball', 'faucet', 'window', 'mousepad', 'couch', 'dining_room', 'wall', 'television', 'toothbrush_holder', 'curtain', 'kettle', 'mouse', 'bag', 'table', 'vase']
Task:Watch TV
response:

Go to entrance hall, switch on TV, sit back in a chair and using remote watch your favorite program.

[WALK] <home_office>
[WALK] <television>
[FIND] <television>
[SWITCHON] <television>
[WALK] <chair>
[SIT] <chair>
[TURNTO] <television>
[WATCH] <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:['pot', 'water_glass', 'microwave', 'toilet', 'drawing', 'wallshelf', 'ceiling', 'desk', 'bookmark', 'toaster', 'stovefan', 'mat', 'shower', 'couch', 'wall', 'oven', 'coffe_maker', 'coin', 'water', 'tray', 'towel_rack', 'kitchen_counter', 'shoes', 'vacuum_cleaner', 'cupboard', 'controller', 'hairdryer', 'spoon', 'dishwasher', 'creditcard']
Task:Drink
response:
{
    "thoughts": I go to the kitchen, take a glass from the cupboard, fill with water and drink,
    "actions": ['[WALK] <dining_room>', '[WALK] <cupboard>', '[FIND] <cupboard>', '[OPEN] <cupboard>', '[FIND] <water_glass>', '[GRAB] <water_glass>', '[WALK] <water>', '[FIND] <water>', '[GRAB] <water>', '[POUR] <water> <water_glass>', '[DRINK] <water_glass>', '[RINSE] <water_glass>', '[PUTBACK] <water_glass> <cupboard>']
}

Input:
Scene_Objects:['glue', 'pot', 'food_ice_cream', 'walllamp', 'nail_polish', 'detergent', 'knife', 'needle', 'cpuscreen', 'bathroom_counter', 'character', 'bedroom', 'remote_control', 'envelope', 'alcohol', 'button', 'deck_of_cards', 'iron', 'nightstand', 'pasta', 'television', 'wine', 'towel_rack', 'mouse', 'dresser', 'cupboard', 'door', 'bathroom_cabinet', 'dishwasher', 'vase']
Task:Change TV channel
response:

Take the Tv Remote Control  in the Living Room table And Press the Channel Change Button to change the channel

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


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

Here is an example plan to achieve a goal for reference:
Scene_Objects:['pot', 'toilet', 'chair', 'freezer', 'walllamp', 'blow_dryer', 'toothbrush', 'drawing', 'kitchen_cabinet', 'floor', 'ceiling', 'character', 'bedroom', 'keyboard', 'ceilinglamp', 'stereo', 'shower', 'foundation', 'food_peanut_butter', 'towel', 'wall', 'clothes_gloves', 'food_food', 'toilet_paper', 'tray', 'after_shave', 'dresser', 'cupboard', 'door', 'light']
Task:Look in refrigerator
response:
{
    "thoughts": 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.,
    "actions": ['[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>']
}

Input:
Scene_Objects:['juice', 'bathroom', 'ceilingfan', 'drawing', 'bills', 'knife', 'orchid', 'floor', 'ceiling', 'bookshelf', 'remote_control', 'button', 'bookmark', 'ceilinglamp', 'tvstand', 'balanceball', 'mat', 'window', 'couch', 'pillow', 'wall', 'oven', 'keys', 'television', 'coffee_filter', 'curtain', 'centerpiece', 'cupboard', 'bathroom_cabinet', 'table']
Task:Change TV channel
response:

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


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

Here is an example plan to achieve a goal for reference:
Scene_Objects:['pot', 'microwave', 'toilet', 'food_carrot', 'drawing', 'orchid', 'wallshelf', 'floor', 'ceiling', 'folder', 'tea_bag', 'mat', 'shower', 'window', 'mousepad', 'couch', 'pillow', 'wall', 'pasta', 'nightstand', 'photoframe', 'novel', 'food_food', 'tray', 'curtain', 'doorjamb', 'door', 'table', 'light', 'board_game']
Task:Read book
response:
{
    "thoughts": Bring book, lie on the sofa, read book,
    "actions": ['[WALK] <home_office>', '[WALK] <novel>', '[GRAB] <novel>', '[WALK] <couch>', '[LIE] <couch>', '[READ] <novel>']
}

Input:
Scene_Objects:['sponge', 'fork', 'sheets', 'tablelamp', 'mop', 'detergent', 'ceilingfan', 'milk', 'hanger', 'ceiling', 'desk', 'window', 'mousepad', 'clothes_socks', 'clothes_pants', 'pillow', 'dining_room', 'bench', 'cutting_board', 'bed', 'novel', 'check', 'television', 'curtain', 'cards', 'towel_rack', 'cd', 'shoes', 'napkin', 'table']
Task:Pick up phone
response:

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


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

Here is an example plan to achieve a goal for reference:
Scene_Objects:['spectacles', 'filing_cabinet', 'tea', 'microwave', 'dog', 'freezer', 'walllamp', 'drawing', 'orchid', 'hanger', 'keyboard', 'button', 'ceilinglamp', 'stereo', 'homework', 'mousepad', 'closetdrawer', 'food_peanut_butter', 'food_jam', 'wall', 'oven', 'food_cheese', 'keys', 'tray', 'lighter', 'mouse', 'kitchen_counter', 'cd', 'clothes_dress', 'bathroom_cabinet']
Task:Pet cat
response:
{
    "thoughts": Petting the cat,
    "actions": ['[WALK] <home_office>', '[WALK] <cat>', '[FIND] <cat>', '[TOUCH] <cat>']
}

Input:
Scene_Objects:['sponge', 'juice', 'freezer', 'ceilingfan', 'drawing', 'knifeblock', 'bathroom_counter', 'floor', 'ceiling', 'longboard', 'desk', 'mop_bucket', 'stovefan', 'toaster', 'faucet', 'food_jam', 'wall', 'photoframe', 'novel', 'coffe_maker', 'video_game_controller', 'shaving_cream', 'towel_rack', 'hairbrush', 'sink', 'bathroom_cabinet', 'home_office', 'vase', 'soap', 'hands_both']
Task:Wash hands
response:

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


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

Here is an example plan to achieve a goal for reference:
Scene_Objects:['tablelamp', 'dog', 'bathroom', 'drawing', 'cpuscreen', 'floor', 'ceiling', 'desk', 'piano_bench', 'stovefan', 'toaster', 'mat', 'faucet', 'shower', 'pillow', 'towel', 'wall', 'oven', 'coffe_maker', 'television', 'coffee_filter', 'tray', 'doorjamb', 'towel_rack', 'kitchen_counter', 'cupboard', 'door', 'sink', 'bathtub', 'coffee']
Task:Make coffee
response:
{
    "thoughts": Open coffee maker. Put filter in main basket, put ground coffee in filter, fill reservoir with water, turn on coffee maker.,
    "actions": ['[WALK] <dining_room>', '[WALK] <coffe_maker>', '[FIND] <coffe_maker>', '[OPEN] <coffe_maker>', '[FIND] <coffee_filter>', '[GRAB] <coffee_filter>', '[PUTBACK] <coffee_filter> <coffe_maker>', '[FIND] <coffee>', '[GRAB] <coffee>', '[PUTBACK] <coffee> <coffe_maker>']
}

Input:
Scene_Objects:['filing_cabinet', 'microwave', 'toilet', 'freezer', 'cat', 'orchid', 'drawing', 'hanger', 'ceiling', 'dvd_player', 'desk', 'mail', 'piano_bench', 'toaster', 'mat', 'tvstand', 'ceilinglamp', 'mousepad', 'food_orange', 'pillow', 'bench', 'bed', 'check', 'doorjamb', 'cd', 'controller', 'laundry_detergent', 'sink', 'home_office', 'dishwasher']
Task:Pet cat
response:

I go to the living room then go to the cat and touch it.

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


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

Here is an example plan to achieve a goal for reference:
Scene_Objects:['sheets', 'walllamp', 'drawing', 'needle', 'wallshelf', 'floor', 'ceiling', 'shampoo', 'character', 'computer', 'toaster', 'mat', 'tvstand', 'deck_of_cards', 'stovefan', 'ceilinglamp', 'couch', 'pillow', 'wall', 'nightstand', 'photoframe', 'coffe_maker', 'television', 'tray', 'doorjamb', 'pencil', 'conditioner', 'door', 'table', 'dishwasher']
Task:Relax on sofa
response:
{
    "thoughts": Walk to living room. Find couch. Sit on couch,
    "actions": ['[WALK] <home_office>', '[WALK] <couch>', '[FIND] <couch>', '[SIT] <couch>']
}

Input:
Scene_Objects:['fork', 'food_bread', 'filing_cabinet', 'tablelamp', 'freezer', 'walllamp', 'trashcan', 'milk', 'knifeblock', 'bills', 'floor', 'ceiling', 'character', 'food_cake', 'piano_bench', 'brush', 'ceilinglamp', 'mousepad', 'towel', 'wall', 'bed', 'food_food', 'food_donut', 'ice', 'curtain', 'kettle', 'dresser', 'light', 'soap', 'coffee']
Task:Put groceries in Fridge
response:

Open the fridge, put the groceries in the fridge and close it.

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


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

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

Input:
Scene_Objects:['dry_pasta', 'pot', 'ceilingfan', 'toothbrush', 'knifeblock', 'drawing', 'bathroom_counter', 'floor', 'ceiling', 'phone', 'piano_bench', 'toaster', 'faucet', 'window', 'mousepad', 'clothes_pants', 'wall', 'nightstand', 'pasta', 'photoframe', 'toothbrush_holder', 'shoes', 'dresser', 'clothes_dress', 'door', 'sink', 'bathroom_cabinet', 'clothes_skirt', 'tooth_paste', 'laser_pointer']
Task:Brush teeth
response:

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


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

Here is an example plan to achieve a goal for reference:
Scene_Objects:['dry_pasta', 'glue', 'measuring_cup', 'microwave', 'chair', 'blow_dryer', 'knifeblock', 'drawing', 'orchid', 'floor', 'phone', 'bookshelf', 'toaster', 'ceilinglamp', 'plate', 'faucet', 'wall', 'nightstand', 'photoframe', 'food_food', 'coffee_pot', 'pencil', 'kitchen_counter', 'cupboard', 'door', 'sink', 'instrument_violin', 'table', 'soap', 'tooth_paste']
Task:Bring dirty plate to sink
response:
{
    "thoughts": Stand up from the table.  Pick up dirty plate.  Walk to sink.  Put plate in sink.,
    "actions": ['[WALK] <dining_room>', '[WALK] <table>', '[FIND] <table>', '[TURNTO] <table>', '[FIND] <plate>', '[GRAB] <plate>', '[WALK] <dining_room>', '[WALK] <sink>', '[FIND] <sink>', '[PUTBACK] <plate> <sink>']
}

Input:
Scene_Objects:['sheets', 'food_pizza', 'filing_cabinet', 'freezer', 'drawing', 'hanger', 'kitchen_cabinet', 'floor', 'phone', 'bathroom_counter', 'folder', 'stamp', 'keyboard', 'computer', 'food_bacon', 'table_cloth', 'brush', 'mat', 'plate', 'clothes_socks', 'couch', 'bowl', 'bench', 'toy', 'bed', 'check', 'cupboard', 'door', 'table', 'light']
Task:Set up table
response:

Walk to the kitchen. Open the kitchen cabinet. Grab the plate and put it on the table.

[WALK] <dining_room>
[WALK] <kitchen_cabinet>
[FIND] <kitchen_cabinet>
[OPEN] <kitchen_cabinet>
[FIND] <plate>
[GRAB] <plate>
[FIND] <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:['sheets', 'glue', 'measuring_cup', 'dog', 'walllamp', 'bathroom', 'floor', 'phone', 'bedroom', 'mat', 'stereo', 'faucet', 'window', 'closetdrawer', 'dining_room', 'food_cheese', 'standingmirror', 'bed', 'check', 'television', 'coffee_filter', 'food_rice', 'ice', 'curtain', 'doorjamb', 'pencil', 'conditioner', 'bathtub', 'napkin', 'vase']
Task:Listen to music
response:
{
    "thoughts": Listen to music,
    "actions": ['[WALK] <home_office>', '[WALK] <stereo>', '[FIND] <stereo>', '[SWITCHON] <stereo>']
}

Input:
Scene_Objects:['scissors', 'tea', 'chair', 'trashcan', 'cpuscreen', 'hanger', 'floor', 'ceiling', 'phone', 'character', 'desk', 'tea_bag', 'bookshelf', 'keyboard', 'computer', 'picture', 'mousepad', 'food_jam', 'wall', 'cutting_board', 'cup', 'novel', 'tray', 'doorjamb', 'mouse', 'dresser', 'cupboard', 'door', 'light', 'dishwasher']
Task:Read book
response:

Walk to home office, turn on light, grab a book, sit in chair, start to read the book

[WALK] <home_office>
[WALK] <light>
[FIND] <light>
[SWITCHON] <light>
[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:['sponge', 'crayon', 'chair', 'walllamp', 'hanger', 'floor', 'ceiling', 'phone', 'tea_bag', 'clothes_jacket', 'toaster', 'mat', 'ceilinglamp', 'faucet', 'dish_soap', 'mousepad', 'dustpan', 'clothes_hat', 'wall', 'cup', 'coffe_maker', 'coffee_filter', 'curtain', 'coffee_pot', 'mouse', 'kitchen_counter', 'dishrack', 'cupboard', 'sink', 'napkin']
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>', '[SWITCHOFF] <faucet>', '[FIND] <dish_soap>', '[GRAB] <dish_soap>', '[POUR] <dish_soap> <sink>', '[PUTOBJBACK] <dish_soap>', '[FIND] <sponge>', '[GRAB] <sponge>', '[FIND] <cup>', '[GRAB] <cup>', '[SCRUB] <cup>', '[PUTOBJBACK] <cup>', '[FIND] <cup>', '[GRAB] <cup>', '[SCRUB] <cup>', '[PUTOBJBACK] <cup>', '[PUTBACK] <sponge> <sink>', '[SWITCHON] <faucet>', '[RINSE] <cup>', '[GRAB] <cup>', '[FIND] <dishrack>', '[PUTBACK] <cup> <dishrack>', '[RINSE] <cup>', '[GRAB] <cup>', '[PUTBACK] <cup> <dishrack>', '[RINSE] <sponge>', '[SWITCHOFF] <faucet>', '[GRAB] <sponge>', '[PUTOBJBACK] <sponge>']
}

Input:
Scene_Objects:['sheets', 'crayon', 'chair', 'band-aids', 'bathroom', 'food_butter', 'ceilingfan', 'hanger', 'bathroom_counter', 'floor', 'ceiling', 'phone', 'longboard', 'folder', 'bookshelf', 'brush', 'shoe-shine_kit', 'stereo', 'food_jam', 'wall', 'powersocket', 'coffe_maker', 'food_food', 'television', 'wooden_spoon', 'doorjamb', 'dresser', 'cupboard', 'door', 'light']
Task:Turn on light
response:

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

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


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

Here is an example plan to achieve a goal for reference:
Scene_Objects:['fork', 'chair', 'milk', 'drawing', 'cpuscreen', 'shampoo', 'folder', 'bookshelf', 'computer', 'table_cloth', 'ceilinglamp', 'mat', 'oil', 'mousepad', 'couch', 'towel', 'nightstand', 'wall', 'cutting_board', 'cup', 'photoframe', 'bed', 'food_donut', 'mouse', 'kitchen_counter', 'pajamas', 'sink', 'napkin', 'home_office', 'tooth_paste']
Task:Open front door
response:
{
    "thoughts": Walk over to the front door, turn the knob, and open the door.,
    "actions": ['[WALK] <home_office>']
}

Input:
Scene_Objects:['food_pizza', 'mop', 'walllamp', 'drawing', 'bathroom_counter', 'floor', 'ceiling', 'bedroom', 'bookshelf', 'envelope', 'faucet', 'picture', 'homework', 'window', 'mousepad', 'clothes_hat', 'towel', 'wall', 'photoframe', 'hands_both', 'food_food', 'doorjamb', 'kettle', 'dresser', 'door', 'sink', 'bathroom_cabinet', 'light', 'vase', 'teeth']
Task:Wash teeth
response:

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

[WALK] <bathroom>
[WALK] <light>
[FIND] <light>
[SWITCHON] <light>
[WALK] <sink>
[FIND] <faucet>
[SWITCHON] <faucet>
[FIND] <teeth>
[GRAB] <teeth>
[WASH] <teeth>
[PUTOBJBACK] <teeth>
[SWITCHOFF] <faucet>
[FIND] <towel>
[GRAB] <towel>
[FIND] <hands_both>
[SCRUB] <hands_both>
[PUTOBJBACK] <towel>
[SWITCHOFF] <light>


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

Here is an example plan to achieve a goal for reference:
Scene_Objects:['sponge', 'microwave', 'chair', 'jelly', 'knifeblock', 'floor', 'ceiling', 'character', 'alcohol', 'toaster', 'plate', 'faucet', 'drying_rack', 'window', 'tvstand', 'dish_soap', 'closetdrawer', 'couch', 'towel', 'pillow', 'food_kiwi', 'wall', 'toy', 'novel', 'curtain', 'kitchen_counter', 'cupboard', 'sink', 'instrument_guitar', 'shoe_rack']
Task:Do dishes
response:
{
    "thoughts": Wash dirty dishes, dry them and then put them away,
    "actions": ['[WALK] <dining_room>', '[WALK] <sink>', '[FIND] <faucet>', '[SWITCHON] <faucet>', '[FIND] <dish_soap>', '[GRAB] <dish_soap>', '[POUR] <dish_soap> <sink>', '[PUTOBJBACK] <dish_soap>', '[FIND] <sponge>', '[GRAB] <sponge>', '[FIND] <plate>', '[GRAB] <plate>', '[SCRUB] <plate>', '[RINSE] <plate>', '[FIND] <drying_rack>', '[PUTBACK] <plate> <drying_rack>', '[FIND] <plate>', '[GRAB] <plate>', '[SCRUB] <plate>', '[RINSE] <plate>', '[PUTBACK] <plate> <drying_rack>', '[PUTOBJBACK] <sponge>', '[SWITCHOFF] <faucet>']
}

Input:
Scene_Objects:['sponge', 'tea', 'toilet', 'walllamp', 'bathroom', 'trashcan', 'drawing', 'ceiling', 'bookshelf', 'computer', 'button', 'mail', 'stovefan', 'ceilinglamp', 'window', 'couch', 'wall', 'bench', 'tape', 'cup', 'coffe_maker', 'tray', 'headset', 'comb', 'cupboard', 'sink', 'home_office', 'table', 'bathroom_cabinet', 'vase']
Task:Read book
response:

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


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

Here is an example plan to achieve a goal for reference:
Scene_Objects:['food_salt', 'toilet', 'drawing', 'cpuscreen', 'bathroom_counter', 'floor', 'desk', 'bedroom', 'keyboard', 'tvstand', 'stereo', 'balanceball', 'picture', 'mousepad', 'couch', 'clothes_hat', 'pillow', 'dining_room', 'wall', 'nightstand', 'bench', 'photoframe', 'bed', 'toilet_paper', 'coffe_maker', 'cards', 'mouse', 'kitchen_counter', 'cd', 'vase']
Task:Go to toilet
response:
{
    "thoughts": Walk to the bathroom.  Find the toilet.  Lift the top of the toilet.  Sit on the toilet.,
    "actions": ['[WALK] <bathroom>', '[WALK] <toilet>', '[FIND] <toilet>', '[OPEN] <toilet>', '[SIT] <toilet>']
}

Input:
Scene_Objects:['food_bread', 'freezer', 'cat', 'food_carrot', 'dough', 'orchid', 'needle', 'hanger', 'longboard', 'floor', 'ceiling', 'bathroom_counter', 'ceilinglamp', 'mat', 'stereo', 'couch', 'dustpan', 'pillow', 'wall', 'powersocket', 'light_bulb', 'food_food', 'coffe_maker', 'video_game_controller', 'oven_mitts', 'food_rice', 'vacuum_cleaner', 'dresser', 'door', 'hairdryer']
Task:Put groceries in Fridge
response:

I leave the bags with groceries near the fridge, open the door and put the groceries in the shelves.

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


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

Here is an example plan to achieve a goal for reference:
Scene_Objects:['microwave', 'toilet', 'freezer', 'walllamp', 'bathroom', 'trashcan', 'orchid', 'floor', 'toaster', 'mat', 'faucet', 'shower', 'pillow', 'wall', 'nightstand', 'bench', 'toy', 'coffe_maker', 'television', 'curtain', 'after_shave', 'doorjamb', 'towel_rack', 'kitchen_counter', 'chessboard', 'sink', 'home_office', 'bathroom_cabinet', 'table', 'instrument_violin']
Task:Go to toilet
response:
{
    "thoughts": Walk to the bathroom.  Find the toilet.  Lift the top of the toilet.  Sit on the toilet.,
    "actions": ['[WALK] <bathroom>', '[WALK] <toilet>', '[FIND] <toilet>', '[OPEN] <toilet>', '[SIT] <toilet>']
}

Input:
Scene_Objects:['food_pizza', 'food_ice_cream', 'mop', 'chair', 'freezer', 'walllamp', 'cat', 'trashcan', 'toothbrush', 'hanger', 'bathroom_counter', 'floor', 'keyboard', 'dining_room', 'bench', 'powersocket', 'cup', 'photoframe', 'novel', 'toothbrush_holder', 'curtain', 'mouse', 'headset', 'pajamas', 'door', 'dishwasher', 'vase', 'tooth_paste', 'clothes_shirt', 'teeth']
Task:Wash teeth
response:

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

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


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

Here is an example plan to achieve a goal for reference:
Scene_Objects:['filing_cabinet', 'microwave', 'toilet', 'detergent', 'cat', 'food_butter', 'knife', 'phone', 'character', 'table_cloth', 'mat', 'deck_of_cards', 'stereo', 'form', 'pillow', 'dining_room', 'nightstand', 'wall', 'basket_for_clothes', 'photoframe', 'tray', 'doorjamb', 'kitchen_counter', 'chessboard', 'dresser', 'clothes_dress', 'table', 'soap', 'washing_machine', 'creditcard']
Task:Wash clothes
response:
{
    "thoughts": Walk to Bathroom. Find basket for clothes. Lift clothes dress from basket. Find washing machine. Walk to washing machine. Put clothes in washing machine. Put soap in washing machine. Switch on washing machine.,
    "actions": ['[WALK] <bathroom>', '[WALK] <basket_for_clothes>', '[FIND] <basket_for_clothes>', '[FIND] <clothes_dress>', '[GRAB] <clothes_dress>', '[FIND] <washing_machine>', '[WALK] <washing_machine>', '[OPEN] <washing_machine>', '[PUTBACK] <clothes_dress> <washing_machine>', '[FIND] <soap>', '[GRAB] <soap>', '[PUTBACK] <soap> <washing_machine>', '[CLOSE] <washing_machine>', '[SWITCHON] <washing_machine>']
}

Input:
Scene_Objects:['sheets', 'pot', 'mop', 'dog', 'jelly', 'drawing', 'knife', 'bathroom_counter', 'floor', 'ceiling', 'longboard', 'character', 'computer', 'stovefan', 'faucet', 'oil', 'dining_room', 'wall', 'nightstand', 'oven', 'cutting_board', 'photoframe', 'check', 'tray', 'sink', 'napkin', 'bathroom_cabinet', 'soap', 'dirt', 'hands_both']
Task:Wash hands
response:

[WALK] <bathroom>
[WALK] <sink>
[FIND] <faucet>
[SWITCHON] <faucet>
[FIND] <soap>
[SQUEEZE] <soap>
[FIND] <hands_both>
[WASH] <hands_both>


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

Here is an example plan to achieve a goal for reference:
Scene_Objects:['sheets', 'spectacles', 'scissors', 'knife', 'hanger', 'bathroom_counter', 'floor', 'bedroom', 'desk', 'keyboard', 'piano_bench', 'stovefan', 'stereo', 'window', 'wall', 'powersocket', 'cutting_board', 'cup', 'bed', 'console', 'pencil', 'shoes', 'door', 'bathtub', 'bag', 'instrument_guitar', 'table', 'home_office', 'light', 'board_game']
Task:Listen to music
response:
{
    "thoughts": I walk into my room and turn the radio on so that I can listen to music.,
    "actions": ['[WALK] <bedroom>', '[WALK] <stereo>', '[FIND] <stereo>', '[SWITCHON] <stereo>']
}

Input:
Scene_Objects:['food_bread', 'microwave', 'freezer', 'walllamp', 'bathroom', 'toothbrush', 'orchid', 'hanger', 'longboard', 'phone', 'desk', 'computer', 'food_bacon', 'table_cloth', 'clothes_jacket', 'brush', 'ceilinglamp', 'faucet', 'foundation', 'mousepad', 'clothes_pants', 'pasta', 'light_bulb', 'toothbrush_holder', 'coin', 'coffee_filter', 'towel_rack', 'hair', 'vase', 'tooth_paste']
Task:Wash teeth
response:

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

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


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

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

Input:
Scene_Objects:['water_glass', 'scissors', 'tablelamp', 'bathroom', 'drawing', 'floor', 'desk', 'computer', 'food_bacon', 'stovefan', 'ceilinglamp', 'shower', 'window', 'couch', 'clothes_hat', 'towel', 'wall', 'oven', 'photoframe', 'check', 'food_food', 'television', 'coffe_maker', 'tray', 'centerpiece', 'pencil', 'chessboard', 'hair', 'table', 'vase']
Task:Relax on sofa
response:

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


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

Here is an example plan to achieve a goal for reference:
Scene_Objects:['tablelamp', 'tea', 'microwave', 'chair', 'walllamp', 'blow_dryer', 'bathroom', 'knifeblock', 'wallshelf', 'floor', 'ceiling', 'ceilinglamp', 'plate', 'mousepad', 'food_noodles', 'couch', 'closetdrawer', 'food_jam', 'form', 'pillow', 'wall', 'nightstand', 'razor', 'television', 'shaving_cream', 'kitchen_counter', 'bathroom_cabinet', 'dishwasher', 'soap', 'teeth']
Task:Text friends while sitting on couch
response:
{
    "thoughts": Text while sitting,
    "actions": ['[WALK] <home_office>', '[WALK] <phone>', '[FIND] <phone>', '[GRAB] <phone>', '[WALK] <couch>', '[SIT] <couch>', '[TURNTO] <phone>', '[LOOKAT] <phone>', '[TOUCH] <phone>']
}

Input:
Scene_Objects:['fork', 'blow_dryer', 'bathroom', 'ceilingfan', 'drawing', 'hanger', 'kitchen_cabinet', 'floor', 'phone', 'desk', 'computer', 'laptop', 'plate', 'stereo', 'oil', 'clothes_hat', 'wall', 'bench', 'oven', 'powersocket', 'newspaper', 'coffe_maker', 'curtain', 'rag', 'kitchen_counter', 'maindoor', 'home_office', 'table', 'light', 'soap']
Task:Set up table
response:

Walk into kitchen. Grab plates and forks. Walk into dining room. Put plates and forks on table.

[WALK] <dining_room>
[WALK] <kitchen_cabinet>
[FIND] <kitchen_cabinet>
[OPEN] <kitchen_cabinet>
[FIND] <fork>
[GRAB] <fork>
[FIND] <plate>
[GRAB] <plate>
[WALK] <dining_room>
[WALK]

[FIND]

[PUTBACK] <fork>

[PUTBACK] <plate>


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

Here is an example plan to achieve a goal for reference:
Scene_Objects:['fork', 'filing_cabinet', 'chair', 'drawing', 'bills', 'knife', 'floor', 'ceilinglamp', 'stereo', 'window', 'couch', 'food_jam', 'form', 'towel', 'dining_room', 'wall', 'basket_for_clothes', 'photoframe', 'novel', 'food_food', 'check', 'television', 'oven_mitts', 'razor', 'tray', 'pencil', 'dresser', 'pajamas', 'table', 'soap']
Task:Read book
response:
{
    "thoughts": Sit and read,
    "actions": ['[WALK] <home_office>', '[WALK] <filing_cabinet>', '[OPEN] <filing_cabinet>', '[FIND] <novel>', '[GRAB] <novel>', '[CLOSE] <filing_cabinet>', '[WALK] <couch>', '[SIT] <couch>', '[READ] <novel>']
}

Input:
Scene_Objects:['chair', 'bathroom', 'ceilingfan', 'drawing', 'floor', 'ceiling', 'tea_bag', 'keyboard', 'remote_control', 'toaster', 'ceilinglamp', 'tvstand', 'balanceball', 'stovefan', 'window', 'mat', 'plate', 'couch', 'candle', 'microphone', 'dining_room', 'wall', 'powersocket', 'box', 'photoframe', 'coffe_maker', 'television', 'curtain', 'table', 'dishwasher']
Task:Watch TV
response:

Turn on the TV, sit on the couch, find a show, and watch it.

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


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

Here is an example plan to achieve a goal for reference:
Scene_Objects:['ironing_board', 'sheets', 'tablelamp', 'detergent', 'knifeblock', 'bathroom_counter', 'phone', 'desk', 'keyboard', 'computer', 'ceilinglamp', 'tvstand', 'iron', 'window', 'couch', 'pillow', 'bowl', 'nightstand', 'food_cheese', 'video_game_controller', 'tray', 'curtain', 'doorjamb', 'towel_rack', 'kitchen_counter', 'pajamas', 'bag', 'dishwasher', 'board_game', 'clothes_shirt']
Task:Iron shirt
response:
{
    "thoughts": Set up an ironing board and an iron.  Lay a shirt on board.  Run iron over shirt until it is free of wrinkles.,
    "actions": ['[WALK] <bedroom>', '[WALK] <ironing_board>', '[FIND] <ironing_board>', '[FIND] <clothes_shirt>', '[GRAB] <clothes_shirt>', '[PUTBACK] <clothes_shirt> <ironing_board>', '[FIND] <iron>', '[GRAB] <iron>', '[PLUGIN] <iron>', '[PLUGOUT] <iron>', '[PUTOBJBACK] <iron>']
}

Input:
Scene_Objects:['sheets', 'food_pizza', 'tablelamp', 'blender', 'scissors', 'freezer', 'walllamp', 'ground_coffee', 'orchid', 'character', 'bedroom', 'bookshelf', 'alcohol', 'button', 'toaster', 'stereo', 'homework', 'electric_shaver', 'mousepad', 'couch', 'bowl', 'toy', 'clothes_gloves', 'coffe_maker', 'kitchen_counter', 'conditioner', 'napkin', 'table', 'light', 'dishwasher']
Task:Listen to music
response:

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

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


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

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

Input:
Scene_Objects:['pot', 'ground_coffee', 'walllamp', 'detergent', 'knifeblock', 'longboard', 'floor', 'ceiling', 'toaster', 'stovefan', 'plate', 'faucet', 'candle', 'wall', 'box', 'coffe_maker', 'food_food', 'television', 'coffee_filter', 'water', 'towel_rack', 'kitchen_counter', 'chessboard', 'cupboard', 'hair', 'maindoor', 'sink', 'napkin', 'dishwasher', 'tooth_paste']
Task:Make coffee
response:

I walk to the kitchen and find the coffee machine. I open the coffee machine and pour a filter in it. I open the cupboard and grab ground coffee. I put ground coffee in the filter and water in the coffee machine. I close the coffee machine. I switch on the coffee machine and wait

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


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

Here is an example plan to achieve a goal for reference:
Scene_Objects:['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:
{
    "thoughts": Open drawer. Pull out pants and put them on. Take a shirt out and put it on. Put on socks and shoes.,
    "actions": ['[WALK] <bedroom>', '[WALK] <dresser>', '[OPEN] <dresser>', '[FIND] <clothes_pants>', '[GRAB] <clothes_pants>', '[PUTON] <clothes_pants>', '[FIND] <clothes_shirt>', '[GRAB] <clothes_shirt>', '[PUTON] <clothes_shirt>', '[FIND] <clothes_socks>', '[GRAB] <clothes_socks>', '[PUTON] <clothes_socks>', '[CLOSE] <dresser>', '[FIND] <shoes>', '[GRAB] <shoes>', '[PUTON] <shoes>']
}

Input:
Scene_Objects:['microwave', 'walllamp', 'bathroom', 'food_carrot', 'toothbrush', 'orchid', 'knife', 'longboard', 'character', 'bedroom', 'computer', 'faucet', 'homework', 'clothes_socks', 'food_noodles', 'dining_room', 'photoframe', 'check', 'television', 'after_shave', 'rag', 'lighter', 'towel_rack', 'kitchen_counter', 'dresser', 'clothes_dress', 'home_office', 'light', 'laser_pointer', 'scrabble']
Task:Pick up phone
response:

I walk to the home office. I find the telephone. I pick up the telephone handset.

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


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

Here is an example plan to achieve a goal for reference:
Scene_Objects:['sponge', 'pot', 'mop', 'band-aids', 'walllamp', 'trashcan', 'ceilingfan', 'knifeblock', 'kitchen_cabinet', 'floor', 'ceiling', 'bathroom_counter', 'desk', 'computer', 'stovefan', 'toaster', 'deck_of_cards', 'shower', 'wall', 'pasta', 'oven', 'cup', 'water', 'tray', 'doorjamb', 'shaving_cream', 'kitchen_counter', 'sauce_pan', 'cupboard', 'dishwasher']
Task:Cook some food
response:
{
    "thoughts": Cook some pasta on the stove,
    "actions": ['[WALK] <dining_room>', '[WALK] <kitchen_cabinet>', '[FIND] <kitchen_cabinet>', '[OPEN] <kitchen_cabinet>', '[FIND] <pasta>', '[GRAB] <pasta>', '[FIND] <water>', '[GRAB] <water>', '[FIND] <sauce_pan>', '[POUR] <water> <sauce_pan>', '[FIND] <oven>', '[SWITCHON] <oven>', '[PUTBACK] <pasta> <sauce_pan>', '[FIND] <sauce_pan>', '[GRAB] <sauce_pan>', '[PUTBACK] <sauce_pan> <oven>']
}

Input:
Scene_Objects:['tablelamp', 'food_ice_cream', 'freezer', 'cat', 'knifeblock', 'longboard', 'floor', 'ceiling', 'keyboard', 'clothes_jacket', 'stovefan', 'ceilinglamp', 'mat', 'stereo', 'tvstand', 'electric_shaver', 'mousepad', 'couch', 'wall', 'oven', 'bench', 'cup', 'food_food', 'doorjamb', 'conditioner', 'clothes_scarf', 'home_office', 'table', 'light', 'vase']
Task:Put groceries in Fridge
response:

I get my groceries and go to the fridge. I open the fridge and put the groceries there.

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


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

Here is an example plan to achieve a goal for reference:
Scene_Objects:['fork', 'crayon', 'dog', 'toothbrush', 'drawing', 'knifeblock', 'hanger', 'bathroom_counter', 'floor', 'ceiling', 'character', 'faucet', 'shower', 'balanceball', 'mousepad', 'wall', 'pasta', 'powersocket', 'oven', 'nightstand', 'photoframe', 'video_game_controller', 'coffee_filter', 'wooden_spoon', 'console', 'shoes', 'sink', 'bathroom_cabinet', 'tooth_paste', 'teeth']
Task:Brush teeth
response:
{
    "thoughts": Put toothpaste on toothbrush, brush teeth, rinse mouth,
    "actions": ['[WALK] <bathroom>', '[WALK] <toothbrush>', '[FIND] <toothbrush>', '[GRAB] <toothbrush>', '[FIND] <tooth_paste>', '[GRAB] <tooth_paste>', '[POUR] <tooth_paste> <toothbrush>', '[PUTOBJBACK] <tooth_paste>', '[WALK] <sink>', '[FIND] <teeth>', '[SCRUB] <teeth>', '[SCRUB] <teeth>', '[SCRUB] <teeth>', '[PUTBACK] <toothbrush> <sink>', '[FIND] <faucet>', '[SWITCHON] <faucet>', '[RINSE] <toothbrush>', '[RINSE] <teeth>', '[SWITCHOFF] <faucet>', '[GRAB] <toothbrush>', '[PUTOBJBACK] <toothbrush>']
}

Input:
Scene_Objects:['sponge', 'microwave', 'chair', 'trashcan', 'ceilingfan', 'bills', 'hanger', 'floor', 'ceiling', 'phone', 'character', 'stamp', 'bookshelf', 'envelope', 'computer', 'stovefan', 'pillow', 'wall', 'powersocket', 'coffe_maker', 'television', 'oven_mitts', 'ice', 'doorjamb', 'towel_rack', 'dresser', 'cupboard', 'door', 'light', 'table']
Task:Turn on light
response:

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