Input: You serve as an AI task planner.   1. Your task is to create a plan to achieve a goal by converting it into a sequence of actions. Each action should follow the format  [verb] <target1> <target2> , where 'verb' represents the action, and 'target1' and 'target2' are optional arguments.  2. You must describe your plan in natural language at the beginning. After that, you should list all the actions together.   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', 'crayon', 'tea', 'beer', 'microwave', 'toilet', 'trashcan', 'food_carrot', 'knifeblock', 'cpuscreen', 'bathroom_counter', 'floor', 'character', 'bedroom', 'desk', 'keyboard', 'bookshelf', 'computer', 'ceilinglamp', 'window', 'dining_room', 'food_kiwi', 'nightstand', 'bed', 'photoframe', 'doorjamb', 'dishrack', 'cupboard', 'sink', 'home_office']  Task:Open bathroom window  response:  {       thoughts : Make sure bathroom window is unlocked. Lift up bathroom window so it is open.,       actions : ['[WALK] <bathroom>', '[WALK] <window>', '[FIND] <window>', '[OPEN] <window>']  }     Scene_Objects:['blender', 'toilet', 'freezer', 'walllamp', 'drawing', 'bathroom_counter', 'floor', 'ceiling', 'ceilinglamp', 'shoe-shine_kit', 'shower', 'faucet', 'mat', 'oil', 'food_peanut_butter', 'towel', 'wall', 'nightstand', 'powersocket', 'photoframe', 'bed', 'toilet_paper', 'curtain', 'doorjamb', 'kitchen_counter', 'door', 'sink', 'bathroom_cabinet', 'light', 'colander']  Task:Take shower  response:

{  Walk to Bathroom. Open the Bathroom Cabinet. Grab a Towel. Close the Bathroom Cabinet. Rinse the Shower. }


Input: You serve as an AI task planner.   1. Your task is to create a plan to achieve a goal by converting it into a sequence of actions. Each action should follow the format  [verb] <target1> <target2> , where 'verb' represents the action, and 'target1' and 'target2' are optional arguments.  2. You must describe your plan in natural language at the beginning. After that, you should list all the actions together.   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', 'freezer', 'band-aids', 'knifeblock', 'food_egg', 'shampoo', 'phone', 'bookshelf', 'purse', 'thread', 'deck_of_cards', 'shower', 'picture', 'clothes_socks', 'oven', 'food_cheese', 'novel', 'food_food', 'check', 'coffe_maker', 'tray', 'after_shave', 'curtain', 'doorjamb', 'cupboard', 'controller', 'bag', 'table', 'scrabble']  Task:Drink  response:  {       thoughts : Pour water into a glass and drink from the glass.,       actions : ['[WALK] <dining_room>', '[WALK] <water_glass>', '[FIND] <water_glass>', '[GRAB] <water_glass>', '[WALK] <water>', '[FIND] <water>', '[GRAB] <water>', '[POUR] <water> <water_glass>', '[DRINK] <water_glass>']  }     Scene_Objects:['pot', 'filing_cabinet', 'freezer', 'walllamp', 'drawing', 'needle', 'orchid', 'floor', 'stamp', 'keyboard', 'plate', 'faucet', 'shower', 'dish_soap', 'oil', 'wall', 'keys', 'coffe_maker', 'coffee_filter', 'pencil', 'kitchen_counter', 'dishrack', 'dresser', 'cupboard', 'controller', 'pajamas', 'food_steak', 'spoon', 'light', 'dishwasher']  Task:Wash dishes with dishwasher  response:

{  Walk to the kitchen. Find the dishwasher. Walk to the dishwasher. Open the dishwasher. Find plate no.1. Grab plate no.1. Put plate no.1 into the dishwasher. Find plate no.2. Grab plate no.2. Put plate no.2 into the dishwasher. Find the spoon. Grab the spoon. Put the spoon into the dishwasher. Find the dish soap. Put the dish soap into the dishwasher. Close the dishwasher. Switch on the dishwasher. }


Input: You serve as an AI task planner.   1. Your task is to create a plan to achieve a goal by converting it into a sequence of actions. Each action should follow the format  [verb] <target1> <target2> , where 'verb' represents the action, and 'target1' and 'target2' are optional arguments.  2. You must describe your plan in natural language at the beginning. After that, you should list all the actions together.   Ensure that you response can be parsed by Python json.loads.      Here is an example plan to achieve a goal for reference:   Scene_Objects:['food_bread', 'filing_cabinet', 'toilet', 'freezer', 'dough', 'drawing', 'hanger', 'floor', 'ceiling', 'mat', 'shoe-shine_kit', 'shower', 'clothes_hat', 'bowl', 'nightstand', 'wall', 'powersocket', 'wall_clock', 'photoframe', 'light_bulb', 'food_food', 'coffe_maker', 'razor', 'coffee_filter', 'doorjamb', 'hairbrush', 'door', 'home_office', 'light', 'soap']  Task:Put away groceries  response:  {       thoughts : Place groceries in refrigerator from shopping at the grocery store.,       actions : ['[WALK] <dining_room>', '[WALK] <freezer>', '[FIND] <freezer>', '[OPEN] <freezer>', '[FIND] <food_food>', '[GRAB] <food_food>', '[PUTIN] <food_food> <freezer>', '[CLOSE] <freezer>']  }     Scene_Objects:['beer', 'walllamp', 'blow_dryer', 'knifeblock', 'hanger', 'floor', 'ceiling', 'piano_bench', 'ceilinglamp', 'faucet', 'stereo', 'oil', 'food_peanut_butter', 'pillow', 'dining_room', 'wall', 'coffe_maker', 'toilet_paper', 'coffee_filter', 'water', 'wine', 'tray', 'curtain', 'kitchen_counter', 'dresser', 'cupboard', 'sink', 'dishwasher', 'laser_pointer', 'coffee']  Task:Make coffee  response:


Input: You serve as an AI task planner.   1. Your task is to create a plan to achieve a goal by converting it into a sequence of actions. Each action should follow the format  [verb] <target1> <target2> , where 'verb' represents the action, and 'target1' and 'target2' are optional arguments.  2. You must describe your plan in natural language at the beginning. After that, you should list all the actions together.   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', 'chair', 'walllamp', 'orchid', 'cpuscreen', 'floor', 'ceiling', 'shampoo', 'desk', 'keyboard', 'computer', 'table_cloth', 'stovefan', 'ceilinglamp', 'mat', 'plate', 'stereo', 'mousepad', 'wall', 'bench', 'television', 'wine', 'rag', 'lighter', 'shaving_cream', 'mouse', 'hairbrush', 'door', 'table']  Task:Write an email  response:  {       thoughts : walk to living room, look at computer, find chair, sit in chair, grab keyboard, grab mouse, type using keyboard and mouse,       actions : ['[WALK] <home_office>', '[WALK] <computer>', '[FIND] <computer>', '[TURNTO] <computer>', '[LOOKAT] <computer>', '[WALK] <computer>', '[FIND] <chair>', '[SIT] <chair>', '[FIND] <keyboard>', '[GRAB] <keyboard>', '[FIND] <mouse>', '[GRAB] <mouse>', '[TYPE] <keyboard>']  }     Scene_Objects:['beer', 'toilet', 'freezer', 'bathroom', 'knifeblock', 'drawing', 'wallshelf', 'floor', 'ceiling', 'phone', 'bedroom', 'keyboard', 'clothes_jacket', 'mat', 'shower', 'candle', 'creditcard', 'food_jam', 'food_orange', 'wall', 'nightstand', 'powersocket', 'photoframe', 'food_rice', 'doorjamb', 'door', 'spoon', 'light', 'board_game', 'shoe_rack']  Task:Put groceries in Fridge  response:

{  Walk to kitchen. Grab groceries and walk to the fridge. Open fridge and put groceries in the fridge. Close the fridge. }


Input: You serve as an AI task planner.   1. Your task is to create a plan to achieve a goal by converting it into a sequence of actions. Each action should follow the format  [verb] <target1> <target2> , where 'verb' represents the action, and 'target1' and 'target2' are optional arguments.  2. You must describe your plan in natural language at the beginning. After that, you should list all the actions together.   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', 'cat', 'drawing', 'hanger', 'longboard', 'floor', 'phone', 'character', 'desk', 'purse', 'stovefan', 'ceilinglamp', 'iron', 'stereo', 'window', 'oil', 'couch', 'wall', 'bench', 'toy', 'food_food', 'television', 'food_rice', 'towel_rack', 'console', 'hairbrush', 'napkin', 'table', 'vase', 'dirt']  Task:Pet cat  response:  {       thoughts : I would walk into the living room. Then sit on the couch and pet the cat.,       actions : ['[WALK] <home_office>', '[WALK] <couch>', '[SIT] <couch>', '[FIND] <cat>', '[TOUCH] <cat>']  }     Scene_Objects:['sponge', 'fork', 'microwave', 'toilet', 'walllamp', 'detergent', 'knifeblock', 'cpuscreen', 'hanger', 'floor', 'ceiling', 'bedroom', 'keyboard', 'table_cloth', 'toaster', 'laptop', 'plate', 'faucet', 'stereo', 'shower', 'food_noodles', 'wall', 'nightstand', 'novel', 'check', 'food_food', 'coin', 'kitchen_counter', 'cupboard', 'sink']  Task:Wash dishes by hand  response:

{  Walk into the kitchen. Walk up to the sink. Turn on the faucet. Pick up the plate. Wash the plate. Rinse the plate. }


Input: You serve as an AI task planner.   1. Your task is to create a plan to achieve a goal by converting it into a sequence of actions. Each action should follow the format  [verb] <target1> <target2> , where 'verb' represents the action, and 'target1' and 'target2' are optional arguments.  2. You must describe your plan in natural language at the beginning. After that, you should list all the actions together.   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', 'freezer', 'detergent', 'hanger', 'floor', 'ceiling', 'phone', 'dvd_player', 'character', 'bedroom', 'keyboard', 'computer', 'stereo', 'shower', 'towel', 'wall', 'wall_clock', 'pasta', 'nightstand', 'bed', 'doorjamb', 'dresser', 'cupboard', 'conditioner', 'door', 'clothes_scarf', 'light', 'clothes_shirt']  Task:Turn on light  response:  {       thoughts : approach the light switch, raise hand to the switch, flip the switch,       actions : ['[WALK] <home_office>', '[WALK] <light>', '[FIND] <light>', '[SWITCHON] <light>']  }     Scene_Objects:['pot', 'food_ice_cream', 'microwave', 'freezer', 'walllamp', 'blow_dryer', 'detergent', 'knifeblock', 'bathroom_counter', 'floor', 'ceiling', 'table_cloth', 'stovefan', 'toaster', 'faucet', 'mousepad', 'wall', 'wall_clock', 'oven', 'cup', 'coffe_maker', 'food_food', 'water', 'tray', 'cards', 'kitchen_counter', 'cupboard', 'sink', 'light', 'dishwasher']  Task:Drink  response:

{  Walk to kitchen, grab a cup, fill with water and then drink it. }


Input: You serve as an AI task planner.   1. Your task is to create a plan to achieve a goal by converting it into a sequence of actions. Each action should follow the format  [verb] <target1> <target2> , where 'verb' represents the action, and 'target1' and 'target2' are optional arguments.  2. You must describe your plan in natural language at the beginning. After that, you should list all the actions together.   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', 'crayon', 'tea', 'mop', 'microwave', 'toilet', 'toothbrush', 'drawing', 'knifeblock', 'orchid', 'phone', 'ceiling', 'computer', 'stovefan', 'toaster', 'tvstand', 'window', 'floor_lamp', 'couch', 'clothes_hat', 'photoframe', 'after_shave', 'food_onion', 'headset', 'chessboard', 'cupboard', 'controller', 'door', 'bathroom_cabinet', 'clothes_skirt']  Task:Switch on lamp  response:  {       thoughts : Press the button so the light comes on.,       actions : ['[WALK] <bedroom>', '[WALK] <floor_lamp>', '[FIND] <floor_lamp>', '[SWITCHON] <floor_lamp>']  }     Scene_Objects:['sheets', 'food_salt', 'beer', 'chair', 'bathroom', 'cpuscreen', 'hanger', 'ceiling', 'desk', 'ceilinglamp', 'mat', 'shower', 'stereo', 'window', 'oil', 'dustpan', 'microphone', 'dining_room', 'novel', 'check', 'food_food', 'razor', 'ice', 'curtain', 'rag', 'after_shave', 'coffee_pot', 'shoes', 'instrument_guitar', 'tooth_paste']  Task:Listen to music  response:

{  I find a radio. I turn on the radio. I listen to music. }


Input: You serve as an AI task planner.   1. Your task is to create a plan to achieve a goal by converting it into a sequence of actions. Each action should follow the format  [verb] <target1> <target2> , where 'verb' represents the action, and 'target1' and 'target2' are optional arguments.  2. You must describe your plan in natural language at the beginning. After that, you should list all the actions together.   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', 'toilet', 'chair', 'detergent', 'bathroom_counter', 'ceiling', 'character', 'desk', 'laptop', 'tvstand', 'faucet', 'electric_shaver', 'mousepad', 'couch', 'food_orange', 'bench', 'powersocket', 'cup', 'bed', 'novel', 'razor', 'oven_mitts', 'curtain', 'after_shave', 'cd', 'headset', 'dresser', 'pajamas', 'bathroom_cabinet', 'tooth_paste']  Task:Pick up phone  response:  {       thoughts : I'll enter the location containing the phone. Once there, I'll locate the phone, and move close to it. I'll then use my hand to pick up the phone such that I can then use it.,       actions : ['[WALK] <home_office>', '[WALK] <phone>', '[FIND] <phone>', '[WALK] <phone>', '[TURNTO] <phone>', '[LOOKAT] <phone>', '[GRAB] <phone>']  }     Scene_Objects:['sponge', 'tablelamp', 'chair', 'walllamp', 'orchid', 'knifeblock', 'wallshelf', 'floor', 'ceiling', 'remote_control', 'computer', 'ceilinglamp', 'tvstand', 'mat', 'window', 'closetdrawer', 'couch', 'pillow', 'wall', 'nightstand', 'tape', 'photoframe', 'coffee_table', 'television', 'toothbrush_holder', 'razor', 'curtain', 'dresser', 'pajamas', 'table']  Task:Watch TV  response:

{  I walk into the living room and sit on the couch. I pick up the remote to turn on the television. I put down the remote on the coffee table and look at the television. }


Input: You serve as an AI task planner.   1. Your task is to create a plan to achieve a goal by converting it into a sequence of actions. Each action should follow the format  [verb] <target1> <target2> , where 'verb' represents the action, and 'target1' and 'target2' are optional arguments.  2. You must describe your plan in natural language at the beginning. After that, you should list all the actions together.   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', 'bathroom', 'trashcan', 'orchid', 'drawing', 'cpuscreen', 'knifeblock', 'floor', 'dvd_player', 'computer', 'bookmark', 'brush', 'ceilinglamp', 'faucet', 'electric_shaver', 'floor_lamp', 'mousepad', 'wall', 'powersocket', 'novel', 'food_food', 'check', 'television', 'after_shave', 'cupboard', 'sink', 'home_office', 'table', 'tooth_paste']  Task:Turn on light  response:  {       thoughts : Twist the lamp switch until the light goes on.,       actions : ['[WALK] <home_office>', '[WALK] <floor_lamp>', '[FIND] <floor_lamp>', '[SWITCHON] <floor_lamp>']  }     Scene_Objects:['filing_cabinet', 'toilet', 'freezer', 'ground_coffee', 'bathroom', 'food_carrot', 'toothbrush', 'orchid', 'knife', 'cpuscreen', 'hanger', 'bathroom_counter', 'floor', 'bookshelf', 'button', 'mat', 'shower', 'mousepad', 'oil', 'closetdrawer', 'microphone', 'oven', 'cutting_board', 'check', 'centerpiece', 'diary', 'clothes_dress', 'clothes_scarf', 'napkin', 'tooth_paste']  Task:Pet cat  response:

{  Walk into the living room. Walk up to the cat. Pet the cat with your hand. }


Input: You serve as an AI task planner.   1. Your task is to create a plan to achieve a goal by converting it into a sequence of actions. Each action should follow the format  [verb] <target1> <target2> , where 'verb' represents the action, and 'target1' and 'target2' are optional arguments.  2. You must describe your plan in natural language at the beginning. After that, you should list all the actions together.   Ensure that you response can be parsed by Python json.loads.      Here is an example plan to achieve a goal for reference:   Scene_Objects:['walllamp', 'bathroom', 'drawing', 'orchid', 'wallshelf', 'floor', 'ceiling', 'bookshelf', 'remote_control', 'toaster', 'mat', 'tvstand', 'ceilinglamp', 'shower', 'window', 'couch', 'pillow', 'wall', 'powersocket', 'photoframe', 'television', 'curtain', 'after_shave', 'doorjamb', 'mouse', 'dresser', 'door', 'table', 'light', 'dishwasher']  Task:Change TV channel  response:  {       thoughts : I go in the living room. Then I find the remote, sit on the couch and turn on the television. Then I use the remote the change the TV channel.,       actions : ['[WALK] <home_office>', '[WALK] <remote_control>', '[FIND] <remote_control>', '[FIND] <couch>', '[SIT] <couch>', '[FIND] <television>', '[SWITCHON] <television>']  }     Scene_Objects:['pot', 'filing_cabinet', 'tablelamp', 'walllamp', 'food_carrot', 'orchid', 'cpuscreen', 'wallshelf', 'floor', 'ceiling', 'phone', 'bookshelf', 'remote_control', 'computer', 'button', 'tvstand', 'window', 'closetdrawer', 'couch', 'pillow', 'nightstand', 'wall', 'basket_for_clothes', 'food_food', 'television', 'curtain', 'dresser', 'clothes_dress', 'home_office', 'table']  Task:Change TV channel  response:

{  Take TV remote to change TV Channel. Press channel/program +/- button on TV remote. }


Input: You serve as an AI task planner.   1. Your task is to create a plan to achieve a goal by converting it into a sequence of actions. Each action should follow the format  [verb] <target1> <target2> , where 'verb' represents the action, and 'target1' and 'target2' are optional arguments.  2. You must describe your plan in natural language at the beginning. After that, you should list all the actions together.   Ensure that you response can be parsed by Python json.loads.      Here is an example plan to achieve a goal for reference:   Scene_Objects:['chair', 'walllamp', 'bathroom', 'orchid', 'wallshelf', 'floor', 'ceiling', 'bookshelf', 'remote_control', 'computer', 'button', 'stovefan', 'mat', 'tvstand', 'ceilinglamp', 'shower', 'window', 'faucet', 'mousepad', 'dining_room', 'wall', 'powersocket', 'photoframe', 'television', 'curtain', 'rag', 'doorjamb', 'kitchen_counter', 'light', 'table']  Task:Change TV channel  response:  {       thoughts : walk to living room, look at the television, switch on the television, grab the remote control, press the channel button in remote control, now the tv channel is changed,       actions : ['[WALK] <home_office>', '[WALK] <television>', '[FIND] <television>', '[TURNTO] <television>', '[LOOKAT] <television>', '[SWITCHON] <television>', '[FIND] <remote_control>', '[GRAB] <remote_control>', '[FIND] <button>', '[GRAB] <button>']  }     Scene_Objects:['sheets', 'food_salt', 'chair', 'ground_coffee', 'bathroom', 'floor', 'ceiling', 'button', 'mop_bucket', 'homework', 'window', 'clothes_hat', 'clothes_pants', 'wall', 'toy', 'novel', 'coffe_maker', 'food_food', 'razor', 'wooden_spoon', 'doorjamb', 'diary', 'kitchen_counter', 'cupboard', 'sink', 'bathroom_cabinet', 'coffee_cup', 'dishwasher', 'clothes_skirt', 'coffee']  Task:Make coffee  response:

{  Walk to the kitchen at the coffee maker, grab coffee, pour coffee into coffee maker, put coffee into coffee maker, push coffee maker's button, wait to complete, grab coffee cup }


Input: You serve as an AI task planner.   1. Your task is to create a plan to achieve a goal by converting it into a sequence of actions. Each action should follow the format  [verb] <target1> <target2> , where 'verb' represents the action, and 'target1' and 'target2' are optional arguments.  2. You must describe your plan in natural language at the beginning. After that, you should list all the actions together.   Ensure that you response can be parsed by Python json.loads.      Here is an example plan to achieve a goal for reference:   Scene_Objects:['tablelamp', 'food_ice_cream', 'chair', 'nail_polish', 'trashcan', 'ceilingfan', 'drawing', 'cpuscreen', 'floor', 'ceiling', 'phone', 'character', 'desk', 'keyboard', 'bookshelf', 'computer', 'button', 'ceilinglamp', 'balanceball', 'shower', 'mousepad', 'pillow', 'wall', 'nightstand', 'basket_for_clothes', 'toothbrush_holder', 'doorjamb', 'mouse', 'light', 'vase']  Task:Browse internet  response:  {       thoughts : Walk to the Home Office.  Find the computer.  Turn on the computer.,       actions : ['[WALK] <home_office>', '[WALK] <computer>', '[FIND] <computer>', '[SWITCHON] <computer>']  }     Scene_Objects:['food_bread', 'chair', 'freezer', 'wallshelf', 'cpuscreen', 'floor', 'ceiling', 'desk', 'keyboard', 'computer', 'mat', 'stereo', 'faucet', 'oil', 'mousepad', 'couch', 'closetdrawer', 'dining_room', 'wall', 'oven', 'photoframe', 'coffee_table', 'novel', 'check', 'tray', 'food_onion', 'diary', 'mouse', 'cupboard', 'table']  Task:Read book  response:

{  I walk to the living room and pick up a book from the coffee table. I find my favorite chair.  I sit in the armchair and open the book.  I read. }


Input: You serve as an AI task planner.   1. Your task is to create a plan to achieve a goal by converting it into a sequence of actions. Each action should follow the format  [verb] <target1> <target2> , where 'verb' represents the action, and 'target1' and 'target2' are optional arguments.  2. You must describe your plan in natural language at the beginning. After that, you should list all the actions together.   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', 'chair', 'drawing', 'orchid', 'wallshelf', 'bathroom_counter', 'floor', 'ceiling', 'desk', 'keyboard', 'table_cloth', 'toaster', 'stovefan', 'tvstand', 'shower', 'faucet', 'closetdrawer', 'nightstand', 'wall', 'bench', 'coffe_maker', 'check', 'television', 'tray', 'pencil', 'shoes', 'sink', 'bathtub', 'light']  Task:Listen to music  response:  {       thoughts : turn radio on, listen to music,       actions : ['[WALK] <home_office>', '[WALK] <stereo>', '[FIND] <stereo>', '[SWITCHON] <stereo>']  }     Scene_Objects:['tea', 'microwave', 'toilet', 'chair', 'freezer', 'walllamp', 'detergent', 'cpuscreen', 'hanger', 'floor', 'desk', 'keyboard', 'computer', 'toaster', 'laptop', 'mat', 'stereo', 'mousepad', 'couch', 'wall', 'oven', 'bed', 'centerpiece', 'doorjamb', 'mouse', 'cd', 'dresser', 'food_steak', 'board_game', 'shoe_rack']  Task:Work  response:

{  first ill go to my home office adn ill switch on my laptop and with the use of mouse and keyboard il run my computer }


Input: You serve as an AI task planner.   1. Your task is to create a plan to achieve a goal by converting it into a sequence of actions. Each action should follow the format  [verb] <target1> <target2> , where 'verb' represents the action, and 'target1' and 'target2' are optional arguments.  2. You must describe your plan in natural language at the beginning. After that, you should list all the actions together.   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', 'pot', 'food_salt', 'mop', 'freezer', 'walllamp', 'detergent', 'knifeblock', 'floor', 'ceiling', 'purse', 'button', 'piano_bench', 'food_bacon', 'stovefan', 'ceilinglamp', 'tvstand', 'faucet', 'form', 'wall', 'bench', 'food_food', 'television', 'water', 'kitchen_counter', 'cupboard', 'food_steak', 'sink', 'maindoor', 'table']  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>']  }     Scene_Objects:['sheets', 'food_ice_cream', 'toilet', 'freezer', 'bathroom', 'cpuscreen', 'bathroom_counter', 'phone', 'character', 'desk', 'thread', 'clothes_jacket', 'table_cloth', 'ceilinglamp', 'washing_machine', 'window', 'mousepad', 'clothes_pants', 'oven', 'bed', 'keys', 'check', 'dishrack', 'comb', 'laundry_detergent', 'door', 'napkin', 'clothes_shirt', 'dirt', 'coffee']  Task:Wash clothes  response:

{  Walk into laundry room. Open washing machine door. Put dirty clothes into washing machine. Measure laundry detergent and place into washing machine. Turn dial to appropriate wash setting. Power on. }


Input: You serve as an AI task planner.   1. Your task is to create a plan to achieve a goal by converting it into a sequence of actions. Each action should follow the format  [verb] <target1> <target2> , where 'verb' represents the action, and 'target1' and 'target2' are optional arguments.  2. You must describe your plan in natural language at the beginning. After that, you should list all the actions together.   Ensure that you response can be parsed by Python json.loads.      Here is an example plan to achieve a goal for reference:   Scene_Objects:['pot', 'filing_cabinet', 'toilet', 'walllamp', 'hanger', 'floor', 'ceiling', 'keyboard', 'computer', 'stovefan', 'stereo', 'shower', 'window', 'mousepad', 'wall', 'nightstand', 'wall_clock', 'toy', 'photoframe', 'coffe_maker', 'curtain', 'lighter', 'towel_rack', 'kitchen_counter', 'controller', 'bathtub', 'bathroom_cabinet', 'table', 'instrument_violin', 'creditcard']  Task:Open bathroom window  response:  {       thoughts : Make sure bathroom window is unlocked. Lift up bathroom window so it is open.,       actions : ['[WALK] <bathroom>', '[WALK] <window>', '[FIND] <window>', '[OPEN] <window>']  }     Scene_Objects:['dog', 'walllamp', 'detergent', 'food_carrot', 'orchid', 'drawing', 'food_egg', 'bathroom_counter', 'floor', 'ceiling', 'bedroom', 'table_cloth', 'mat', 'faucet', 'shower', 'oil', 'clothes_socks', 'dustpan', 'wall', 'toy', 'bed', 'razor', 'water', 'coffee_pot', 'cupboard', 'hairdryer', 'sink', 'napkin', 'bathroom_cabinet', 'teeth']  Task:Wash teeth  response:


Input: You serve as an AI task planner.   1. Your task is to create a plan to achieve a goal by converting it into a sequence of actions. Each action should follow the format  [verb] <target1> <target2> , where 'verb' represents the action, and 'target1' and 'target2' are optional arguments.  2. You must describe your plan in natural language at the beginning. After that, you should list all the actions together.   Ensure that you response can be parsed by Python json.loads.      Here is an example plan to achieve a goal for reference:   Scene_Objects:['pot', 'chair', 'freezer', 'walllamp', 'trashcan', 'milk', 'knifeblock', 'floor', 'ceiling', 'keyboard', 'table_cloth', 'ceilinglamp', 'tvstand', 'faucet', 'homework', 'towel', 'dining_room', 'wall', 'nightstand', 'oven', 'food_food', 'tray', 'console', 'kitchen_counter', 'dresser', 'cupboard', 'sink', 'bag', 'napkin', 'soap']  Task:Put groceries in Fridge  response:  {       thoughts : Walk to kitchen counter, grab a grocery, walk to fridge, open fridge, put the grocery into fridge, and close fridge,       actions : ['[WALK] <dining_room>', '[WALK] <kitchen_counter>', '[FIND] <food_food>', '[GRAB] <food_food>', '[WALK] <freezer>', '[OPEN] <freezer>', '[PUTIN] <food_food> <freezer>', '[CLOSE] <freezer>']  }     Scene_Objects:['pot', 'tablelamp', 'freezer', 'ground_coffee', 'walllamp', 'food_egg', 'floor', 'ceiling', 'character', 'bedroom', 'bookshelf', 'stovefan', 'plate', 'mousepad', 'wall', 'nightstand', 'powersocket', 'novel', 'coffe_maker', 'check', 'coffee_filter', 'water', 'wooden_spoon', 'kitchen_counter', 'cupboard', 'bathroom_cabinet', 'dishwasher', 'soap', 'teeth', 'shoe_rack']  Task:Make coffee  response:

{  Walk to kitchen, open coffee maker, find coffee filter, grab coffee filter, put coffee filter in coffee maker, find ground coffee, put ground coffee in coffee maker, pour water in coffee maker, close coffee maker and switch on coffee maker. }


Input: You serve as an AI task planner.   1. Your task is to create a plan to achieve a goal by converting it into a sequence of actions. Each action should follow the format  [verb] <target1> <target2> , where 'verb' represents the action, and 'target1' and 'target2' are optional arguments.  2. You must describe your plan in natural language at the beginning. After that, you should list all the actions together.   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>']  }     Scene_Objects:['sheets', 'pot', 'food_pizza', 'food_salt', 'freezer', 'drawing', 'knife', 'cpuscreen', 'knifeblock', 'floor', 'character', 'bookshelf', 'laptop', 'plate', 'mousepad', 'candle', 'dining_room', 'wall', 'light_bulb', 'food_food', 'coffe_maker', 'tray', 'kitchen_counter', 'chessboard', 'dishrack', 'shoes', 'cupboard', 'laundry_detergent', 'dishwasher', 'instrument_violin']  Task:Wash dishes with dishwasher  response:

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


Input: You serve as an AI task planner.   1. Your task is to create a plan to achieve a goal by converting it into a sequence of actions. Each action should follow the format  [verb] <target1> <target2> , where 'verb' represents the action, and 'target1' and 'target2' are optional arguments.  2. You must describe your plan in natural language at the beginning. After that, you should list all the actions together.   Ensure that you response can be parsed by Python json.loads.      Here is an example plan to achieve a goal for reference:   Scene_Objects:['food_salt', 'chair', 'blow_dryer', 'nail_polish', 'ground_coffee', 'milk', 'knife', 'wallshelf', 'hanger', 'character', 'desk', 'keyboard', 'stovefan', 'mat', 'plate', 'food_jam', 'nightstand', 'wall', 'toy', 'bed', 'coffe_maker', 'wine', 'rag', 'centerpiece', 'pencil', 'dresser', 'door', 'bathroom_cabinet', 'table', 'dishwasher']  Task:Read book  response:  {       thoughts : Pick up the book, open to current page, read the words.,       actions : ['[WALK] <home_office>', '[WALK] <novel>', '[FIND] <novel>', '[GRAB] <novel>', '[READ] <novel>']  }     Scene_Objects:['spectacles', 'scissors', 'microwave', 'walllamp', 'nail_polish', 'detergent', 'blow_dryer', 'orchid', 'hanger', 'bathroom_counter', 'character', 'desk', 'stamp', 'computer', 'stereo', 'mousepad', 'pillow', 'powersocket', 'toy', 'check', 'food_food', 'television', 'oven_mitts', 'curtain', 'shaving_cream', 'pencil', 'cd', 'cupboard', 'instrument_guitar', 'soap']  Task:Listen to music  response:


Input: You serve as an AI task planner.   1. Your task is to create a plan to achieve a goal by converting it into a sequence of actions. Each action should follow the format  [verb] <target1> <target2> , where 'verb' represents the action, and 'target1' and 'target2' are optional arguments.  2. You must describe your plan in natural language at the beginning. After that, you should list all the actions together.   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', 'freezer', 'walllamp', 'bathroom', 'drawing', 'bathroom_counter', 'floor', 'ceiling', 'table_cloth', 'toaster', 'mat', 'tvstand', 'ceilinglamp', 'shower', 'window', 'couch', 'microphone', 'pillow', 'wall', 'wall_clock', 'nightstand', 'television', 'tray', 'curtain', 'towel_rack', 'mouse', 'kitchen_counter', 'home_office', 'table', 'soap']  Task:Relax on sofa  response:  {       thoughts : go to the living room and sit on the couch, ease into the sofa and relax.,       actions : ['[WALK] <home_office>', '[WALK] <couch>', '[LIE] <couch>']  }     Scene_Objects:['glue', 'crayon', 'chair', 'cat', 'dough', 'milk', 'hanger', 'floor', 'keyboard', 'mail', 'table_cloth', 'stovefan', 'plate', 'faucet', 'tvstand', 'window', 'couch', 'form', 'dining_room', 'cutting_board', 'photoframe', 'check', 'wine', 'dresser', 'hairbrush', 'pajamas', 'conditioner', 'home_office', 'bathroom_cabinet', 'table']  Task:Give milk to cat  response:

{  Grab milk and pour it into the plate so that the cat can drink }


Input: You serve as an AI task planner.   1. Your task is to create a plan to achieve a goal by converting it into a sequence of actions. Each action should follow the format  [verb] <target1> <target2> , where 'verb' represents the action, and 'target1' and 'target2' are optional arguments.  2. You must describe your plan in natural language at the beginning. After that, you should list all the actions together.   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', 'blender', 'tablelamp', 'ground_coffee', 'bathroom', 'toothbrush', 'drawing', 'knife', 'orchid', 'desk', 'keyboard', 'brush', 'shower', 'homework', 'food_jam', 'pillow', 'dining_room', 'bowl', 'wall_clock', 'check', 'television', 'toothbrush_holder', 'tray', 'kettle', 'kitchen_counter', 'maindoor', 'sink', 'clothes_skirt', 'tooth_paste', 'dirt']  Task:Wash teeth  response:  {       thoughts : WALK TO THE BATHROOM USE PASTE AND BRUSH TO WASH YOUR TEETH,       actions : ['[WALK] <bathroom>', '[WALK] <toothbrush_holder>', '[FIND] <toothbrush_holder>', '[FIND] <tooth_paste>', '[GRAB] <tooth_paste>', '[FIND] <toothbrush>', '[GRAB] <toothbrush>']  }     Scene_Objects:['toilet', 'freezer', 'drawing', 'knifeblock', 'floor', 'ceiling', 'ceilinglamp', 'mat', 'shower', 'picture', 'window', 'food_noodles', 'food_jam', 'wall', 'powersocket', 'oven', 'photoframe', 'check', 'television', 'toothbrush_holder', 'water', 'curtain', 'doorjamb', 'kitchen_counter', 'cd', 'headset', 'door', 'bathroom_cabinet', 'light', 'soap']  Task:Take shower  response:

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


Input: You serve as an AI task planner.   1. Your task is to create a plan to achieve a goal by converting it into a sequence of actions. Each action should follow the format  [verb] <target1> <target2> , where 'verb' represents the action, and 'target1' and 'target2' are optional arguments.  2. You must describe your plan in natural language at the beginning. After that, you should list all the actions together.   Ensure that you response can be parsed by Python json.loads.      Here is an example plan to achieve a goal for reference:   Scene_Objects:['tablelamp', 'freezer', 'walllamp', 'detergent', 'drawing', 'knife', 'wallshelf', 'hanger', 'floor', 'ceiling', 'computer', 'mop_bucket', 'bookmark', 'mat', 'tvstand', 'ceilinglamp', 'faucet', 'couch', 'clothes_hat', 'pillow', 'wall', 'box', 'photoframe', 'bed', 'coffe_maker', 'television', 'coin', 'doorjamb', 'door', 'sink']  Task:Relax on sofa  response:  {       thoughts : walk to living room ,find sofa ,sit on sofa,       actions : ['[WALK] <home_office>', '[WALK] <couch>', '[FIND] <couch>', '[SIT] <couch>']  }     Scene_Objects:['water_glass', 'food_salt', 'microwave', 'chair', 'jelly', 'knifeblock', 'kitchen_cabinet', 'floor', 'ceiling', 'phone', 'desk', 'keyboard', 'toaster', 'tvstand', 'faucet', 'shower', 'closetdrawer', 'candle', 'food_orange', 'wall', 'cup', 'oven_mitts', 'water', 'doorjamb', 'pencil', 'kitchen_counter', 'cupboard', 'sink', 'bag', 'creditcard']  Task:Drink  response:

{  Opening the kitchen cabinet to grab water glass and pour water from the faucet into it to drink. }


Input: You serve as an AI task planner.   1. Your task is to create a plan to achieve a goal by converting it into a sequence of actions. Each action should follow the format  [verb] <target1> <target2> , where 'verb' represents the action, and 'target1' and 'target2' are optional arguments.  2. You must describe your plan in natural language at the beginning. After that, you should list all the actions together.   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', 'dog', 'toothbrush', 'bills', 'drawing', 'knifeblock', 'hanger', 'bathroom_counter', 'floor', 'ceiling', 'character', 'purse', 'faucet', 'balanceball', 'food_noodles', 'wall', 'bench', 'cup', 'photoframe', 'mouthwash', 'console', 'kitchen_counter', 'cupboard', 'sink', 'bag', 'bathroom_cabinet', 'home_office', 'soap', 'hands_both']  Task:Wash hands  response:  {       thoughts : go to bathroom. walk to sink,turn on faucet, put hands in water. rub hands together. grab soap. rub soap in hands. put soap down. put hands under water. rubs hands together. turn off faucet,       actions : ['[WALK] <bathroom>', '[WALK] <sink>', '[FIND] <faucet>', '[SWITCHON] <faucet>', '[FIND] <soap>', '[GRAB] <soap>', '[FIND] <hands_both>', '[SCRUB] <hands_both>', '[PUTOBJBACK] <soap>', '[RINSE] <hands_both>', '[SWITCHOFF] <faucet>']  }     Scene_Objects:['pot', 'microwave', 'detergent', 'knifeblock', 'bathroom_counter', 'floor', 'ceiling', 'character', 'stamp', 'keyboard', 'toaster', 'plate', 'faucet', 'tvstand', 'bowl', 'wall', 'oven', 'photoframe', 'coffe_maker', 'food_food', 'ice', 'curtain', 'shaving_cream', 'kitchen_counter', 'shoes', 'dishrack', 'cupboard', 'sink', 'bathroom_cabinet', 'dishwasher']  Task:Wash dishes with dishwasher  response:

{  Walk to the kitchen. Open the dishwasher and turn on the faucet. Rinse off the dishes. Put the dishes in the dishwasher. Put detergent in the dishwasher. Close the dishwasher. Switch on the dishwasher. }


Input: You serve as an AI task planner.   1. Your task is to create a plan to achieve a goal by converting it into a sequence of actions. Each action should follow the format  [verb] <target1> <target2> , where 'verb' represents the action, and 'target1' and 'target2' are optional arguments.  2. You must describe your plan in natural language at the beginning. After that, you should list all the actions together.   Ensure that you response can be parsed by Python json.loads.      Here is an example plan to achieve a goal for reference:   Scene_Objects:['filing_cabinet', 'toilet', 'chair', 'freezer', 'walllamp', 'drawing', 'cpuscreen', 'floor', 'ceiling', 'character', 'desk', 'keyboard', 'bookshelf', 'purse', 'mail', 'computer', 'laptop', 'deck_of_cards', 'faucet', 'foundation', 'mousepad', 'wall', 'wall_clock', 'bench', 'cup', 'doorjamb', 'mouse', 'door', 'light', 'table']  Task:Sent email  response:  {       thoughts : Walk into home office. Sit down in a chair at a desk. Turn on laptop. Bring up the internet. Go to gmail website. Begin composing an email. Hit the send button.,       actions : ['[WALK] <chair>', '[SIT] <chair>', '[FIND] <laptop>', '[SWITCHON] <laptop>', '[TURNTO] <laptop>', '[LOOKAT] <laptop>', '[FIND] <mail>', '[GRAB] <mail>', '[READ] <mail>', '[FIND] <keyboard>', '[TYPE] <keyboard>', '[SWITCHOFF] <laptop>']  }     Scene_Objects:['pot', 'filing_cabinet', 'tablelamp', 'cd_player', 'chair', 'walllamp', 'orchid', 'bathroom_counter', 'floor', 'ceiling', 'bookshelf', 'envelope', 'mail', 'button', 'toaster', 'ceilinglamp', 'closetdrawer', 'couch', 'dustpan', 'pillow', 'nightstand', 'wall', 'video_game_controller', 'television', 'doorjamb', 'kitchen_counter', 'headset', 'hair', 'door', 'sink']  Task:Listen to music  response:

{  Walk to living room, walk to cd player, turn on cd player, press play button, walk to sofa, sit in sofa and listen to music }


Input: You serve as an AI task planner.   1. Your task is to create a plan to achieve a goal by converting it into a sequence of actions. Each action should follow the format  [verb] <target1> <target2> , where 'verb' represents the action, and 'target1' and 'target2' are optional arguments.  2. You must describe your plan in natural language at the beginning. After that, you should list all the actions together.   Ensure that you response can be parsed by Python json.loads.      Here is an example plan to achieve a goal for reference:   Scene_Objects:['toilet', 'chair', 'walllamp', 'cpuscreen', 'floor', 'ceiling', 'desk', 'keyboard', 'computer', 'ceilinglamp', 'mat', 'mousepad', 'closetdrawer', 'wall', 'wall_clock', 'powersocket', 'coffe_maker', 'television', 'curtain', 'doorjamb', 'centerpiece', 'mouse', 'shoes', 'dresser', 'door', 'maindoor', 'sink', 'light', 'table', 'soap']  Task:Browse internet  response:  {       thoughts : go to the office, turn computer on, open an browser or any application to open any website.,       actions : ['[WALK] <home_office>', '[WALK] <computer>', '[FIND] <computer>', '[SWITCHON] <computer>', '[FIND] <computer>']  }     Scene_Objects:['pot', 'measuring_cup', 'microwave', 'toilet', 'dog', 'bathroom', 'knifeblock', 'bills', 'bathroom_counter', 'floor', 'table_cloth', 'toaster', 'plate', 'faucet', 'couch', 'towel', 'wall', 'bed', 'oven_mitts', 'water', 'shaving_cream', 'kitchen_counter', 'shoes', 'dresser', 'cupboard', 'laundry_detergent', 'sink', 'dishwasher', 'soap', 'hands_both']  Task:Wash hands  response:

{  Walk to kitchen. Find sink. Walk to sink. Find soap. Put soap on sink. Pour water into hands. Scrub soap. Wash water. }


Input: You serve as an AI task planner.   1. Your task is to create a plan to achieve a goal by converting it into a sequence of actions. Each action should follow the format  [verb] <target1> <target2> , where 'verb' represents the action, and 'target1' and 'target2' are optional arguments.  2. You must describe your plan in natural language at the beginning. After that, you should list all the actions together.   Ensure that you response can be parsed by Python json.loads.      Here is an example plan to achieve a goal for reference:   Scene_Objects:['pot', 'tablelamp', 'microwave', 'walllamp', 'bathroom', 'wallshelf', 'cpuscreen', 'floor', 'shampoo', 'mop_bucket', 'toaster', 'mat', 'plate', 'shower', 'dish_soap', 'closetdrawer', 'dining_room', 'wall', 'photoframe', 'coffe_maker', 'colander', 'pencil', 'kitchen_counter', 'cupboard', 'clothes_dress', 'food_steak', 'home_office', 'dishwasher', 'soap', 'tooth_paste']  Task:Wash dishes with dishwasher  response:  {       thoughts : Go to the kitchen.  Find the dishwasher.  Open the dishwasher.  Find the plates.  Load the plates into the dishwasher.  Find the soap.  Load the soap into the dishwasher.  Close the dishwasher.  Turn on the dishwasher.,       actions : ['[WALK] <dining_room>', '[WALK] <dishwasher>', '[FIND] <dishwasher>', '[OPEN] <dishwasher>', '[FIND] <plate>', '[GRAB] <plate>', '[PUTBACK] <plate> <dishwasher>', '[FIND] <plate>', '[GRAB] <plate>', '[PUTBACK] <plate> <dishwasher>', '[FIND] <dish_soap>', '[GRAB] <dish_soap>', '[PUTBACK] <dish_soap> <dishwasher>', '[CLOSE] <dishwasher>', '[SWITCHON] <dishwasher>']  }     Scene_Objects:['filing_cabinet', 'tablelamp', 'microwave', 'chair', 'cat', 'drawing', 'wallshelf', 'floor', 'ceiling', 'character', 'desk', 'bedroom', 'bookshelf', 'computer', 'food_bacon', 'bookmark', 'brush', 'mat', 'mousepad', 'clothes_hat', 'wall', 'nightstand', 'powersocket', 'wall_clock', 'cup', 'oven_mitts', 'doorjamb', 'door', 'sink', 'light']  Task:Turn on light  response:

{  push any ligth button to turn it on, for example in the living room }


Input: You serve as an AI task planner.   1. Your task is to create a plan to achieve a goal by converting it into a sequence of actions. Each action should follow the format  [verb] <target1> <target2> , where 'verb' represents the action, and 'target1' and 'target2' are optional arguments.  2. You must describe your plan in natural language at the beginning. After that, you should list all the actions together.   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', 'crayon', 'chair', 'walllamp', 'drawing', 'orchid', 'wallshelf', 'cpuscreen', 'floor', 'ceiling', 'phone', 'desk', 'bookshelf', 'keyboard', 'computer', 'bookmark', 'mat', 'ceilinglamp', 'tvstand', 'mousepad', 'couch', 'pillow', 'wall', 'nightstand', 'powersocket', 'oven', 'photoframe', 'television', 'tray', 'doorjamb', 'towel_rack', 'mouse', 'kitchen_counter', 'door', 'clothes_scarf', 'light']  Task:Re arrange office  response:  {       thoughts : Walk in.Turn on light.Move furniture. Change the room,       actions : ['[WALK] <home_office>', '[WALK] <light>', '[FIND] <light>', '[SWITCHON] <light>', '[WALK] <desk>', '[PUSH] <desk>', '[WALK] <chair>', '[PUSH] <chair>', '[WALK] <couch>', '[PUSH] <couch>', '[WALK] <filing_cabinet>', '[PUSH] <filing_cabinet>']  }     Scene_Objects:['dry_pasta', 'juice', 'food_ice_cream', 'microwave', 'knifeblock', 'orchid', 'floor', 'ceiling', 'character', 'bookmark', 'toaster', 'ceilinglamp', 'laptop', 'faucet', 'stereo', 'couch', 'wall', 'toy', 'cup', 'coin', 'ice', 'wine', 'curtain', 'kitchen_counter', 'cupboard', 'laundry_detergent', 'clothes_dress', 'sink', 'instrument_guitar', 'light']  Task:Drink  response:


Input: You serve as an AI task planner.   1. Your task is to create a plan to achieve a goal by converting it into a sequence of actions. Each action should follow the format  [verb] <target1> <target2> , where 'verb' represents the action, and 'target1' and 'target2' are optional arguments.  2. You must describe your plan in natural language at the beginning. After that, you should list all the actions together.   Ensure that you response can be parsed by Python json.loads.      Here is an example plan to achieve a goal for reference:   Scene_Objects:['filing_cabinet', 'toilet', 'chair', 'freezer', 'trashcan', 'orchid', 'cpuscreen', 'hanger', 'floor', 'ceiling', 'bookshelf', 'computer', 'window', 'closetdrawer', 'clothes_pants', 'wall', 'bed', 'coffe_maker', 'television', 'tray', 'towel_rack', 'dresser', 'cupboard', 'hair', 'bathtub', 'sink', 'home_office', 'table', 'bathroom_cabinet', 'clothes_shirt']  Task:Get dressed  response:  {       thoughts : Get some clothes together that make an appropriate outfit.  Put them on,       actions : ['[WALK] <bedroom>', '[WALK] <dresser>', '[FIND] <dresser>', '[OPEN] <dresser>', '[FIND] <clothes_pants>', '[GRAB] <clothes_pants>', '[PUTON] <clothes_pants>', '[FIND] <clothes_shirt>', '[GRAB] <clothes_shirt>', '[PUTON] <clothes_shirt>', '[CLOSE] <dresser>']  }     Scene_Objects:['dry_pasta', 'pot', 'measuring_cup', 'jelly', 'chair', 'freezer', 'hanger', 'ceiling', 'thread', 'computer', 'mail', 'bookmark', 'deck_of_cards', 'faucet', 'mousepad', 'dining_room', 'broom', 'wall', 'wall_clock', 'box', 'razor', 'doorjamb', 'mouse', 'pencil', 'hairbrush', 'door', 'napkin', 'table', 'light', 'dirt']  Task:Pick up phone  response:

{  Enter the Home office, then walk to the phone, pickup the phone. }


Input: You serve as an AI task planner.   1. Your task is to create a plan to achieve a goal by converting it into a sequence of actions. Each action should follow the format  [verb] <target1> <target2> , where 'verb' represents the action, and 'target1' and 'target2' are optional arguments.  2. You must describe your plan in natural language at the beginning. After that, you should list all the actions together.   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', 'water_glass', 'microwave', 'toilet', 'freezer', 'trashcan', 'drawing', 'hanger', 'bathroom_counter', 'floor', 'ceiling', 'phone', 'character', 'desk', 'stovefan', 'mat', 'shower', 'closetdrawer', 'couch', 'wall', 'powersocket', 'oven', 'food_food', 'check', 'doorjamb', 'kitchen_counter', 'dresser', 'cupboard', 'door', 'light']  Task:Drink  response:  {       thoughts : walk to kitchen ,find fridge ,open fridge ,find water  glass , drink from water glass,       actions : ['[WALK] <dining_room>', '[WALK] <freezer>', '[FIND] <freezer>', '[OPEN] <freezer>', '[FIND] <water_glass>', '[GRAB] <water_glass>', '[DRINK] <water_glass>']  }     Scene_Objects:['dry_pasta', 'fork', 'filing_cabinet', 'chair', 'cat', 'drawing', 'hanger', 'floor', 'character', 'tea_bag', 'mat', 'picture', 'electric_shaver', 'couch', 'food_jam', 'towel', 'dining_room', 'wall', 'oven', 'coffe_maker', 'tray', 'curtain', 'doorjamb', 'diary', 'cards', 'cupboard', 'door', 'bathroom_cabinet', 'light', 'tooth_paste']  Task:Read book  response:

{  pick up  the book open the book and read }


Input: You serve as an AI task planner.   1. Your task is to create a plan to achieve a goal by converting it into a sequence of actions. Each action should follow the format  [verb] <target1> <target2> , where 'verb' represents the action, and 'target1' and 'target2' are optional arguments.  2. You must describe your plan in natural language at the beginning. After that, you should list all the actions together.   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', 'walllamp', 'drawing', 'wallshelf', 'hanger', 'floor', 'ceiling', 'shampoo', 'desk', 'keyboard', 'computer', 'mat', 'tvstand', 'ceilinglamp', 'stereo', 'closetdrawer', 'couch', 'pillow', 'wall', 'child', 'photoframe', 'food_food', 'television', 'after_shave', 'doorjamb', 'dresser', 'sink', 'bathroom_cabinet']  Task:Watch TV  response:  {       thoughts : Turn on tv.  Sit with kids.,       actions : ['[WALK] <home_office>', '[WALK] <television>', '[SWITCHON] <television>', '[WALK] <couch>', '[FIND] <child>', '[GREET] <child>', '[FIND] <child>', '[GREET] <child>', '[SIT] <couch>', '[TURNTO] <television>', '[WATCH] <television>', '[TURNTO] <television>', '[WATCH] <television>', '[TURNTO] <television>', '[WATCH] <television>']  }     Scene_Objects:['tablelamp', 'microwave', 'walllamp', 'orchid', 'hanger', 'floor', 'ceiling', 'bedroom', 'remote_control', 'computer', 'button', 'tvstand', 'stereo', 'window', 'closetdrawer', 'couch', 'candle', 'clothes_hat', 'pillow', 'nightstand', 'wall', 'cup', 'television', 'oven_mitts', 'curtain', 'centerpiece', 'coffee_pot', 'dresser', 'table', 'instrument_violin']  Task:Change TV channel  response:

{  Walk into the Living room.  Find the television remote.  Use it to turn on the television.  Point the remote at the television. Press the channel button on the remote. }


Input: You serve as an AI task planner.   1. Your task is to create a plan to achieve a goal by converting it into a sequence of actions. Each action should follow the format  [verb] <target1> <target2> , where 'verb' represents the action, and 'target1' and 'target2' are optional arguments.  2. You must describe your plan in natural language at the beginning. After that, you should list all the actions together.   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', 'walllamp', 'bathroom', 'detergent', 'bathroom_counter', 'button', 'toaster', 'brush', 'stereo', 'shower', 'faucet', 'food_orange', 'pillow', 'oven', 'photoframe', 'check', 'television', 'tray', 'kettle', 'mouse', 'cupboard', 'conditioner', 'door', 'home_office', 'table', 'dishwasher', 'clothes_skirt', '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>']  }     Scene_Objects:['fork', 'pot', 'filing_cabinet', 'chair', 'blow_dryer', 'ceiling', 'character', 'tea_bag', 'keyboard', 'piano_bench', 'ceilinglamp', 'mousepad', 'closetdrawer', 'dustpan', 'pillow', 'television', 'coffee_filter', 'drinking_glass', 'water', 'wine', 'curtain', 'pencil', 'vacuum_cleaner', 'controller', 'door', 'sink', 'napkin', 'bathroom_cabinet', 'table', 'clothes_scarf']  Task:Drink  response:

{  I walk to the kitchen. Take a glass out of the cabinet. Then I walk to the sink and turn the water on and fill the glass. Then I take a drink. }


Input: You serve as an AI task planner.   1. Your task is to create a plan to achieve a goal by converting it into a sequence of actions. Each action should follow the format  [verb] <target1> <target2> , where 'verb' represents the action, and 'target1' and 'target2' are optional arguments.  2. You must describe your plan in natural language at the beginning. After that, you should list all the actions together.   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', 'pot', 'filing_cabinet', 'tablelamp', 'microwave', 'walllamp', 'trashcan', 'floor', 'tea_bag', 'thread', 'toaster', 'ceilinglamp', 'plate', 'dish_soap', 'wall', 'bed', 'coffe_maker', 'food_food', 'check', 'oven_mitts', 'tray', 'doorjamb', 'pencil', 'kitchen_counter', 'hairbrush', 'cupboard', 'hair', 'controller', 'bathroom_cabinet', 'dishwasher']  Task:Wash dishes with dishwasher  response:  {       thoughts : Walk to the kitchen. Open the dishwasher. Grab plate and put it in the dishwasher. Grab dish soap and put it in the dishwasher. Switch on the dishwasher.,       actions : ['[WALK] <dining_room>', '[WALK] <dishwasher>', '[FIND] <dishwasher>', '[OPEN] <dishwasher>', '[FIND] <plate>', '[GRAB] <plate>', '[PUTBACK] <plate> <dishwasher>', '[FIND] <dish_soap>', '[GRAB] <dish_soap>', '[PUTBACK] <dish_soap> <dishwasher>', '[CLOSE] <dishwasher>', '[SWITCHON] <dishwasher>']  }     Scene_Objects:['sheets', 'tea', 'chair', 'drawing', 'knifeblock', 'cpuscreen', 'floor', 'desk', 'keyboard', 'bookshelf', 'computer', 'mat', 'plate', 'mousepad', 'couch', 'clothes_hat', 'wall', 'nightstand', 'cup', 'food_food', 'check', 'coffe_maker', 'after_shave', 'rag', 'doorjamb', 'mouse', 'kitchen_counter', 'comb', 'hairdryer', 'table']  Task:Read book  response:

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


Input: You serve as an AI task planner.   1. Your task is to create a plan to achieve a goal by converting it into a sequence of actions. Each action should follow the format  [verb] <target1> <target2> , where 'verb' represents the action, and 'target1' and 'target2' are optional arguments.  2. You must describe your plan in natural language at the beginning. After that, you should list all the actions together.   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', 'beer', 'toilet', 'chair', 'ceilingfan', 'drawing', 'cpuscreen', 'longboard', 'floor', 'ceiling', 'folder', 'desk', 'remote_control', 'ceilinglamp', 'tvstand', 'balanceball', 'iron', 'window', 'couch', 'microphone', 'wall', 'bench', 'light_bulb', 'television', 'curtain', 'food_steak', 'sink', 'napkin', 'home_office', 'table']  Task:Watch TV  response:  {       thoughts : I walk into my living room, find the remote and sit on my sofa. I look at the remote and switch on the television. I look at the Television.,       actions : ['[WALK] <home_office>', '[WALK] <remote_control>', '[FIND] <remote_control>', '[FIND] <couch>', '[SIT] <couch>', '[TURNTO] <remote_control>', '[LOOKAT] <remote_control>', '[FIND] <television>', '[SWITCHON] <television>', '[TURNTO] <television>', '[LOOKAT] <television>']  }     Scene_Objects:['pot', 'mop', 'microwave', 'band-aids', 'food_carrot', 'knifeblock', 'floor', 'ceiling', 'phone', 'desk', 'clothes_jacket', 'toaster', 'faucet', 'picture', 'couch', 'clothes_hat', 'dining_room', 'wall', 'cup', 'coffe_maker', 'mouthwash', 'drinking_glass', 'kettle', 'kitchen_counter', 'paper_towel', 'cupboard', 'controller', 'laundry_detergent', 'sink', 'dishwasher']  Task:Wash dishes with dishwasher  response:

{  wipe loose dirt, place in the dishwasher, turn on the dishwasher }


Input: You serve as an AI task planner.   1. Your task is to create a plan to achieve a goal by converting it into a sequence of actions. Each action should follow the format  [verb] <target1> <target2> , where 'verb' represents the action, and 'target1' and 'target2' are optional arguments.  2. You must describe your plan in natural language at the beginning. After that, you should list all the actions together.   Ensure that you response can be parsed by Python json.loads.      Here is an example plan to achieve a goal for reference:   Scene_Objects:['tablelamp', 'chair', 'walllamp', 'drawing', 'orchid', 'cpuscreen', 'wallshelf', 'hanger', 'floor', 'ceiling', 'phone', 'desk', 'keyboard', 'computer', 'mat', 'ceilinglamp', 'tvstand', 'mousepad', 'couch', 'pillow', 'dining_room', 'wall', 'nightstand', 'oven', 'television', 'doorjamb', 'mouse', 'dresser', 'door', 'soap']  Task:Work  response:  {       thoughts : I go to my home office, sit on the chair and turn on the computer. I open my email account to look for all the information I need.I pull up my online task on the computer to look at what the assigned task is.,       actions : ['[WALK] <home_office>', '[WALK] <chair>', '[FIND] <chair>', '[SIT] <chair>', '[FIND] <computer>', '[SWITCHON] <computer>', '[TURNTO] <computer>', '[LOOKAT] <computer>', '[FIND] <mouse>', '[GRAB] <mouse>', '[FIND] <keyboard>', '[TYPE] <keyboard>', '[TURNTO] <computer>', '[LOOKAT] <computer>']  }     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:

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


Input: You serve as an AI task planner.   1. Your task is to create a plan to achieve a goal by converting it into a sequence of actions. Each action should follow the format  [verb] <target1> <target2> , where 'verb' represents the action, and 'target1' and 'target2' are optional arguments.  2. You must describe your plan in natural language at the beginning. After that, you should list all the actions together.   Ensure that you response can be parsed by Python json.loads.      Here is an example plan to achieve a goal for reference:   Scene_Objects:['sheets', 'fork', 'filing_cabinet', 'tablelamp', 'blender', 'mop', 'bathroom', 'detergent', 'toothbrush', 'bills', 'hanger', 'floor', 'bedroom', 'envelope', 'toaster', 'stovefan', 'clothes_socks', 'mousepad', 'powersocket', 'basket_for_clothes', 'coffe_maker', 'toilet_paper', 'towel_rack', 'clothes_dress', 'bag', 'home_office', 'light', 'vase', '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>']  }     Scene_Objects:['filing_cabinet', 'ground_coffee', 'walllamp', 'knife', 'knifeblock', 'hanger', 'bathroom_counter', 'floor', 'desk', 'bedroom', 'button', 'stovefan', 'mat', 'shower', 'clothes_socks', 'pillow', 'wall', 'nightstand', 'basket_for_clothes', 'bed', 'light_bulb', 'check', 'video_game_controller', 'mouthwash', 'food_onion', 'vacuum_cleaner', 'pajamas', 'cupboard', 'hair', 'instrument_guitar']  Task:Go to sleep  response:

{  go to bedroom, put pajamas on, lie in bed, sleep }


Input: You serve as an AI task planner.   1. Your task is to create a plan to achieve a goal by converting it into a sequence of actions. Each action should follow the format  [verb] <target1> <target2> , where 'verb' represents the action, and 'target1' and 'target2' are optional arguments.  2. You must describe your plan in natural language at the beginning. After that, you should list all the actions together.   Ensure that you response can be parsed by Python json.loads.      Here is an example plan to achieve a goal for reference:   Scene_Objects:['tablelamp', 'juice', 'toilet', 'chair', 'trashcan', 'ceilingfan', 'drawing', 'cpuscreen', 'hanger', 'floor', 'ceiling', 'phone', 'desk', 'keyboard', 'bookshelf', 'computer', 'toaster', 'ceilinglamp', 'stovefan', 'balanceball', 'mat', 'mousepad', 'oil', 'wall', 'nightstand', 'photoframe', 'doorjamb', 'mouse', 'light', 'dishwasher']  Task:Work  response:  {       thoughts : Go to office, sit at desk, turn on computer, enter password, open application and begin work,       actions : ['[WALK] <home_office>', '[WALK] <computer>', '[FIND] <computer>', '[SWITCHON] <computer>', '[FIND] <keyboard>', '[TYPE] <keyboard>', '[FIND] <mouse>', '[PUSH] <mouse>', '[TURNTO] <computer>', '[LOOKAT] <computer>']  }     Scene_Objects:['pot', 'chair', 'drawing', 'floor', 'bedroom', 'bookshelf', 'stovefan', 'ceilinglamp', 'plate', 'dish_soap', 'towel', 'pillow', 'wall', 'cup', 'bed', 'food_food', 'check', 'coffe_maker', 'television', 'doorjamb', 'console', 'kitchen_counter', 'cupboard', 'door', 'clothes_scarf', 'table', 'dishwasher', 'clothes_skirt', 'soap', 'board_game']  Task:Wash dishes with dishwasher  response:

{  I go the in kitchen then grab the plate on the table. I put the plate and dish soap in the dishwasher. Finally, I turn on the dishwasher. }


Input: You serve as an AI task planner.   1. Your task is to create a plan to achieve a goal by converting it into a sequence of actions. Each action should follow the format  [verb] <target1> <target2> , where 'verb' represents the action, and 'target1' and 'target2' are optional arguments.  2. You must describe your plan in natural language at the beginning. After that, you should list all the actions together.   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', 'dough', 'drawing', 'orchid', 'cpuscreen', 'bathroom_counter', 'floor', 'ceiling', 'phone', 'character', 'desk', 'keyboard', 'bookshelf', 'computer', 'tvstand', 'stereo', 'mousepad', 'pillow', 'food_kiwi', 'wall', 'powersocket', 'photoframe', 'television', 'curtain', 'doorjamb', 'mouse', 'door', 'sink', 'bathtub', 'light']  Task:Listen to music  response:  {       thoughts : I go to the bedroom and sit at my desk. I turn my radio on and listen to music.,       actions : ['[WALK] <bedroom>', '[WALK] <light>', '[FIND] <light>', '[SWITCHON] <light>', '[WALK] <desk>', '[FIND] <chair>', '[SIT] <chair>', '[FIND] <stereo>', '[SWITCHON] <stereo>']  }     Scene_Objects:['fork', 'filing_cabinet', 'chair', 'dog', 'toothbrush', 'drawing', 'bills', 'ceiling', 'folder', 'desk', 'bedroom', 'remote_control', 'button', 'clothes_jacket', 'stovefan', 'mat', 'faucet', 'dining_room', 'broom', 'nightstand', 'wall', 'cutting_board', 'novel', 'mouse', 'kitchen_counter', 'cd', 'pajamas', 'sink', 'bathroom_cabinet', 'home_office']  Task:Change TV channel  response:

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


Input: You serve as an AI task planner.   1. Your task is to create a plan to achieve a goal by converting it into a sequence of actions. Each action should follow the format  [verb] <target1> <target2> , where 'verb' represents the action, and 'target1' and 'target2' are optional arguments.  2. You must describe your plan in natural language at the beginning. After that, you should list all the actions together.   Ensure that you response can be parsed by Python json.loads.      Here is an example plan to achieve a goal for reference:   Scene_Objects:['filing_cabinet', 'tea', 'chair', 'freezer', 'bathroom', 'trashcan', 'toothbrush', 'cpuscreen', 'bathroom_counter', 'floor', 'ceiling', 'longboard', 'character', 'bedroom', 'computer', 'plate', 'stereo', 'window', 'food_kiwi', 'wall', 'nightstand', 'box', 'bed', 'clothes_gloves', 'coffe_maker', 'wooden_spoon', 'curtain', 'shoes', 'dishwasher', 'creditcard']  Task:Listen to music  response:  {       thoughts : I go into my bedroom and see my stereo. I decide to play music. I walk over to the stereo and turn it on. I sit down on the bed to listen to the music.,       actions : ['[WALK] <bedroom>', '[WALK] <stereo>', '[FIND] <stereo>', '[TURNTO] <stereo>', '[LOOKAT] <stereo>', '[SWITCHON] <stereo>', '[FIND] <bed>', '[SIT] <bed>']  }     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:


Input: You serve as an AI task planner.   1. Your task is to create a plan to achieve a goal by converting it into a sequence of actions. Each action should follow the format  [verb] <target1> <target2> , where 'verb' represents the action, and 'target1' and 'target2' are optional arguments.  2. You must describe your plan in natural language at the beginning. After that, you should list all the actions together.   Ensure that you response can be parsed by Python json.loads.      Here is an example plan to achieve a goal for reference:   Scene_Objects:['tablelamp', 'chair', 'walllamp', 'orchid', 'drawing', 'cpuscreen', 'wallshelf', 'hanger', 'clothes_underwear', 'floor', 'ceiling', 'phone', 'desk', 'keyboard', 'computer', 'ceilinglamp', 'tvstand', 'mat', 'mousepad', 'couch', 'pillow', 'wall', 'nightstand', 'oven', 'television', 'doorjamb', 'shaving_cream', 'mouse', 'dresser', 'door']  Task:Browse internet  response:  {       thoughts : switch on the computer,  grab a chair and sit in front of the computer. type with keyboard and browse the internet.,       actions : ['[WALK] <home_office>', '[WALK] <computer>', '[FIND] <computer>', '[FIND] <chair>', '[SIT] <chair>', '[SWITCHON] <computer>', '[TURNTO] <computer>', '[LOOKAT] <computer>', '[FIND] <keyboard>', '[TYPE] <keyboard>']  }     Scene_Objects:['juice', 'toilet', 'freezer', 'band-aids', 'ground_coffee', 'drawing', 'knifeblock', 'bathroom_counter', 'floor', 'ceiling', 'bedroom', 'mat', 'shower', 'couch', 'food_jam', 'wall', 'pasta', 'powersocket', 'oven', 'novel', 'coffe_maker', 'food_food', 'check', 'curtain', 'doorjamb', 'door', 'napkin', 'light', 'table', 'clothes_skirt']  Task:Go to toilet  response:

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


Input: You serve as an AI task planner.   1. Your task is to create a plan to achieve a goal by converting it into a sequence of actions. Each action should follow the format  [verb] <target1> <target2> , where 'verb' represents the action, and 'target1' and 'target2' are optional arguments.  2. You must describe your plan in natural language at the beginning. After that, you should list all the actions together.   Ensure that you response can be parsed by Python json.loads.      Here is an example plan to achieve a goal for reference:   Scene_Objects:['tablelamp', 'toilet', 'freezer', 'bathroom', 'orchid', 'phone', 'dvd_player', 'character', 'bedroom', 'ceilinglamp', 'balanceball', 'iron', 'window', 'couch', 'food_orange', 'wall', 'tape', 'cup', 'basket_for_clothes', 'check', 'wooden_spoon', 'console', 'mouse', 'kitchen_counter', 'hairbrush', 'food_steak', 'sink', 'home_office', 'soap', 'hands_both']  Task:Wash hands  response:  {       thoughts : Wash hands with soap,       actions : ['[WALK] <bathroom>', '[WALK] <soap>', '[FIND] <soap>', '[GRAB] <soap>', '[FIND] <hands_both>', '[SCRUB] <hands_both>', '[WASH] <hands_both>', '[RINSE] <hands_both>']  }     Scene_Objects:['spectacles', 'tablelamp', 'toilet', 'bathroom', 'knifeblock', 'drawing', 'cpuscreen', 'orchid', 'hanger', 'floor', 'bedroom', 'bookshelf', 'mop_bucket', 'stovefan', 'mat', 'homework', 'electric_shaver', 'clothes_socks', 'closetdrawer', 'food_orange', 'pillow', 'bowl', 'basket_for_clothes', 'cup', 'coffe_maker', 'tray', 'shaving_cream', 'cupboard', 'sink', 'board_game']  Task:Pet cat  response:

{  Find Cat in living room.  Walk to cat.  Pet cat. }


Input: You serve as an AI task planner.   1. Your task is to create a plan to achieve a goal by converting it into a sequence of actions. Each action should follow the format  [verb] <target1> <target2> , where 'verb' represents the action, and 'target1' and 'target2' are optional arguments.  2. You must describe your plan in natural language at the beginning. After that, you should list all the actions together.   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', 'tea', 'chair', 'drawing', 'knifeblock', 'cpuscreen', 'floor', 'desk', 'keyboard', 'bookshelf', 'computer', 'mat', 'plate', 'mousepad', 'couch', 'clothes_hat', 'wall', 'nightstand', 'cup', 'food_food', 'check', 'coffe_maker', 'after_shave', 'rag', 'doorjamb', 'mouse', 'kitchen_counter', 'comb', 'hairdryer', 'table']  Task:Read book  response:  {       thoughts : go to living room,find the text book on the self ,sat on the chair ,open and read the book,       actions : ['[WALK] <home_office>', '[WALK] <novel>', '[FIND] <novel>', '[GRAB] <novel>', '[WALK] <home_office>', '[WALK] <chair>', '[FIND] <chair>', '[SIT] <chair>', '[READ] <novel>']  }     Scene_Objects:['tablelamp', 'chair', 'walllamp', 'orchid', 'drawing', 'knifeblock', 'floor', 'ceiling', 'remote_control', 'computer', 'ceilinglamp', 'tvstand', 'window', 'foundation', 'homework', 'closetdrawer', 'couch', 'pillow', 'broom', 'nightstand', 'wall', 'oven', 'light_bulb', 'television', 'curtain', 'dresser', 'bathroom_cabinet', 'table', 'dishwasher', 'creditcard']  Task:Watch TV  response:

{  I get home from work and decide to watch tv. I go to the living room and turn on the tv. I sit on the couch and use the remote to switch the channels to find what I want to watch. }


Input: You serve as an AI task planner.   1. Your task is to create a plan to achieve a goal by converting it into a sequence of actions. Each action should follow the format  [verb] <target1> <target2> , where 'verb' represents the action, and 'target1' and 'target2' are optional arguments.  2. You must describe your plan in natural language at the beginning. After that, you should list all the actions together.   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', '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:  {       thoughts : 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.,       actions : ['[WALK] <home_office>', '[WALK] <television>', '[FIND] <television>', '[WALK] <couch>', '[SIT] <couch>', '[FIND] <remote_control>', '[GRAB] <remote_control>', '[TURNTO] <television>', '[LOOKAT] <television>', '[SWITCHON] <television>']  }     Scene_Objects:['water_glass', 'food_pizza', 'chair', 'drawing', 'food_egg', 'hanger', 'floor', 'phone', 'ceiling', 'mail', 'table_cloth', 'stovefan', 'ceilinglamp', 'stereo', 'homework', 'couch', 'microphone', 'form', 'food_orange', 'bowl', 'oven', 'box', 'newspaper', 'tray', 'kitchen_counter', 'cupboard', 'controller', 'bathroom_cabinet', 'table', 'shoe_rack']  Task:Drink  response:

{  walk to kitchen, walk to table, grab water glass and drink water }


Input: You serve as an AI task planner.   1. Your task is to create a plan to achieve a goal by converting it into a sequence of actions. Each action should follow the format  [verb] <target1> <target2> , where 'verb' represents the action, and 'target1' and 'target2' are optional arguments.  2. You must describe your plan in natural language at the beginning. After that, you should list all the actions together.   Ensure that you response can be parsed by Python json.loads.      Here is an example plan to achieve a goal for reference:   Scene_Objects:['filing_cabinet', 'tablelamp', 'microwave', 'freezer', 'bathroom', 'milk', 'floor', 'bookshelf', 'closetdrawer', 'pillow', 'wall', 'wall_clock', 'bench', 'oven', 'toy', 'cutting_board', 'shelf', 'cup', 'standingmirror', 'bed', 'check', 'food_food', 'coffe_maker', 'after_shave', 'console', 'pencil', 'comb', 'sink', 'home_office', 'scrabble']  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>']  }     Scene_Objects:['dry_pasta', 'pot', 'food_pizza', 'toilet', 'chair', 'freezer', 'walllamp', 'food_butter', 'drawing', 'knifeblock', 'kitchen_cabinet', 'floor', 'ceiling', 'food_chicken', 'stovefan', 'mat', 'ceilinglamp', 'shower', 'toaster', 'nightstand', 'wall', 'powersocket', 'oven', 'pasta', 'box', 'food_cheese', 'photoframe', 'food_food', 'wooden_spoon', 'food_onion', 'tray', 'doorjamb', 'kitchen_counter', 'comb', 'cupboard', 'door', 'light', 'table', 'dishwasher']  Task:Cook some food  response:

{  Walk to the kitchen and open the fridge. From the fridge take some chicken and close the fridge. Walk to the table and put the chicken on the table. Plug in oven and put the chicken into the oven. }


Input: You serve as an AI task planner.   1. Your task is to create a plan to achieve a goal by converting it into a sequence of actions. Each action should follow the format  [verb] <target1> <target2> , where 'verb' represents the action, and 'target1' and 'target2' are optional arguments.  2. You must describe your plan in natural language at the beginning. After that, you should list all the actions together.   Ensure that you response can be parsed by Python json.loads.      Here is an example plan to achieve a goal for reference:   Scene_Objects:['tablelamp', 'toilet', 'chair', 'trashcan', 'ceilingfan', 'drawing', 'cpuscreen', 'bathroom_counter', 'floor', 'ceiling', 'phone', 'desk', 'keyboard', 'bookshelf', 'computer', 'ceilinglamp', 'balanceball', 'mousepad', 'couch', 'wall', 'nightstand', 'toy', 'photoframe', 'curtain', 'rag', 'doorjamb', 'mouse', 'dresser', 'door', 'light']  Task:Browse internet  response:  {       thoughts : walk into Living room, look for computer, walk to computer, turn on computer, grab mouse, click mouse,       actions : ['[WALK] <home_office>', '[WALK] <computer>', '[FIND] <computer>', '[TURNTO] <computer>', '[LOOKAT] <computer>', '[WALK] <computer>', '[TURNTO] <computer>', '[FIND] <mouse>', '[GRAB] <mouse>']  }     Scene_Objects:['microwave', 'board_game', 'chair', 'ground_coffee', 'detergent', 'knifeblock', 'floor', 'ceiling', 'alcohol', 'toaster', 'faucet', 'picture', 'closetdrawer', 'couch', 'dining_room', 'broom', 'wall', 'coffe_maker', 'check', 'water', 'drinking_glass', 'after_shave', 'rag', 'kitchen_counter', 'shoes', 'cupboard', 'hair', 'sink', 'table', 'tooth_paste']  Task:Drink  response:

{  Walk to kitchen. Walk to faucet. Switch on faucet. Pour water into drinking glass. Switch off faucet. Drink water. }


Input: You serve as an AI task planner.   1. Your task is to create a plan to achieve a goal by converting it into a sequence of actions. Each action should follow the format  [verb] <target1> <target2> , where 'verb' represents the action, and 'target1' and 'target2' are optional arguments.  2. You must describe your plan in natural language at the beginning. After that, you should list all the actions together.   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', 'cpuscreen', 'floor', 'ceiling', 'phone', 'character', 'folder', 'desk', 'alcohol', 'stovefan', 'plate', 'mousepad', 'wall', 'oven', 'food_food', 'check', 'tray', 'doorjamb', 'cards', 'mouse', 'kitchen_counter', 'shoes', 'cupboard', 'clothes_dress', 'sink', 'clothes_scarf', 'light', 'clothes_shirt', 'teeth']  Task:Pick up phone  response:  {       thoughts : walk over and pick up the phone,       actions : ['[WALK] <phone>', '[GRAB] <phone>']  }     Scene_Objects:['chair', 'walllamp', 'orchid', 'cpuscreen', 'floor', 'ceiling', 'desk', 'keyboard', 'computer', 'mat', 'ceilinglamp', 'tvstand', 'shower', 'plate', 'mousepad', 'closetdrawer', 'microphone', 'pillow', 'wall', 'bed', 'television', 'razor', 'doorjamb', 'kettle', 'mouse', 'address_book', 'door', 'light', 'table', 'dishwasher']  Task:Work  response:

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


Input: You serve as an AI task planner.   1. Your task is to create a plan to achieve a goal by converting it into a sequence of actions. Each action should follow the format  [verb] <target1> <target2> , where 'verb' represents the action, and 'target1' and 'target2' are optional arguments.  2. You must describe your plan in natural language at the beginning. After that, you should list all the actions together.   Ensure that you response can be parsed by Python json.loads.      Here is an example plan to achieve a goal for reference:   Scene_Objects:['toilet', 'chair', 'walllamp', 'bathroom', 'drawing', 'wallshelf', 'hanger', 'floor', 'ceiling', 'character', 'bedroom', 'bookshelf', 'keyboard', 'computer', 'stovefan', 'mat', 'toaster', 'ceilinglamp', 'window', 'floor_lamp', 'couch', 'coffe_maker', 'curtain', 'doorjamb', 'kitchen_counter', 'comb', 'door', 'bathtub', 'bathroom_cabinet', 'coffee']  Task:Turn on light  response:  {       thoughts : Turning on lights,       actions : ['[WALK] <bedroom>', '[WALK] <floor_lamp>', '[FIND] <floor_lamp>', '[SWITCHON] <floor_lamp>']  }     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:

{  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. }


Input: You serve as an AI task planner.   1. Your task is to create a plan to achieve a goal by converting it into a sequence of actions. Each action should follow the format  [verb] <target1> <target2> , where 'verb' represents the action, and 'target1' and 'target2' are optional arguments.  2. You must describe your plan in natural language at the beginning. After that, you should list all the actions together.   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', 'pot', 'fork', 'scissors', 'food_ice_cream', 'microwave', 'walllamp', 'knifeblock', 'knife', 'wallshelf', 'floor', 'ceiling', 'phone', 'alcohol', 'clothes_jacket', 'toaster', 'stovefan', 'faucet', 'couch', 'wall', 'nightstand', 'oven', 'food_food', 'tray', 'rag', 'pencil', 'kitchen_counter', 'cupboard', 'sink', 'colander']  Task:Clean  response:  {       thoughts : Take out a rag. Turn on faucet and get water on the rag. Clean counter off.,       actions : ['[WALK] <dining_room>', '[WALK] <rag>', '[FIND] <rag>', '[GRAB] <rag>', '[WALK] <sink>', '[FIND] <faucet>', '[SWITCHON] <faucet>', '[PUTBACK] <rag> <sink>', '[SWITCHOFF] <faucet>', '[GRAB] <rag>', '[SQUEEZE] <rag>', '[WALK] <kitchen_counter>', '[WIPE] <kitchen_counter>', '[PUTOBJBACK] <rag>']  }     Scene_Objects:['glue', 'toilet', 'freezer', 'wallshelf', 'hanger', 'bathroom_counter', 'bookshelf', 'mail', 'brush', 'mat', 'shoe-shine_kit', 'homework', 'closetdrawer', 'couch', 'food_orange', 'towel', 'dining_room', 'wall', 'powersocket', 'box', 'novel', 'check', 'coffe_maker', 'tray', 'doorjamb', 'diary', 'cupboard', 'home_office', 'bathroom_cabinet', 'soap']  Task:Read book  response:

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


Input: You serve as an AI task planner.   1. Your task is to create a plan to achieve a goal by converting it into a sequence of actions. Each action should follow the format  [verb] <target1> <target2> , where 'verb' represents the action, and 'target1' and 'target2' are optional arguments.  2. You must describe your plan in natural language at the beginning. After that, you should list all the actions together.   Ensure that you response can be parsed by Python json.loads.      Here is an example plan to achieve a goal for reference:   Scene_Objects:['filing_cabinet', 'chair', 'freezer', 'dog', 'walllamp', 'bathroom', 'orchid', 'cpuscreen', 'bathroom_counter', 'floor', 'ceiling', 'phone', 'character', 'desk', 'keyboard', 'envelope', 'computer', 'ceilinglamp', 'mat', 'mousepad', 'wall', 'pasta', 'nightstand', 'bench', 'photoframe', 'tray', 'mouse', 'door', 'table', 'soap']  Task:Work  response:  {       thoughts : go to home office. turn the computer on. begin working,       actions : ['[WALK] <home_office>', '[WALK] <computer>', '[FIND] <computer>', '[SWITCHON] <computer>']  }     Scene_Objects:['sheets', 'filing_cabinet', 'mop', 'bathroom', 'food_egg', 'clothes_underwear', 'bathroom_counter', 'phone', 'ceiling', 'computer', 'toaster', 'mat', 'shoe-shine_kit', 'shower', 'clothes_hat', 'clothes_pants', 'food_orange', 'food_kiwi', 'basket_for_clothes', 'coffe_maker', 'television', 'curtain', 'mouse', 'cd', 'comb', 'clothes_dress', 'clothes_skirt', 'soap', 'clothes_shirt', 'washing_machine']  Task:Wash clothes  response:

{  I need to get the dirty clothes basket.  Walk to bathroom.  Put all the clothes in washing machine.  Add soap.  Turn on machine. }


Input: You serve as an AI task planner.   1. Your task is to create a plan to achieve a goal by converting it into a sequence of actions. Each action should follow the format  [verb] <target1> <target2> , where 'verb' represents the action, and 'target1' and 'target2' are optional arguments.  2. You must describe your plan in natural language at the beginning. After that, you should list all the actions together.   Ensure that you response can be parsed by Python json.loads.      Here is an example plan to achieve a goal for reference:   Scene_Objects:['microwave', 'chair', 'walllamp', 'bathroom', 'orchid', 'cpuscreen', 'floor', 'ceiling', 'desk', 'keyboard', 'food_cake', 'computer', 'food_bacon', 'toaster', 'ceilinglamp', 'tvstand', 'shower', 'mousepad', 'couch', 'wall', 'powersocket', 'bed', 'television', 'doorjamb', 'mouse', 'hairdryer', 'door', 'sink', 'home_office', 'table']  Task:Work  response:  {       thoughts : Using desktop computer in home office,       actions : ['[WALK] <home_office>', '[WALK] <desk>', '[FIND] <desk>', '[WALK] <desk>', '[FIND] <computer>', '[SWITCHON] <computer>', '[FIND] <chair>', '[PULL] <chair>', '[SIT] <chair>', '[FIND] <mouse>', '[GRAB] <mouse>', '[FIND] <keyboard>', '[TYPE] <keyboard>', '[TURNTO] <computer>', '[LOOKAT] <computer>']  }     Scene_Objects:['fork', 'food_bread', 'scissors', 'microwave', 'jelly', 'detergent', 'toothbrush', 'drawing', 'knife', 'cpuscreen', 'floor', 'ceiling', 'phone', 'envelope', 'shower', 'faucet', 'window', 'candle', 'pillow', 'wall', 'tape', 'keys', 'coffe_maker', 'doorjamb', 'mouse', 'kitchen_counter', 'comb', 'cupboard', 'sink', 'light']  Task:Pick up phone  response:

{  I walk over to the phone and pick it up. }


Input: You serve as an AI task planner.   1. Your task is to create a plan to achieve a goal by converting it into a sequence of actions. Each action should follow the format  [verb] <target1> <target2> , where 'verb' represents the action, and 'target1' and 'target2' are optional arguments.  2. You must describe your plan in natural language at the beginning. After that, you should list all the actions together.   Ensure that you response can be parsed by Python json.loads.      Here is an example plan to achieve a goal for reference:   Scene_Objects:['filing_cabinet', 'food_bread', 'scissors', 'measuring_cup', 'toilet', 'ceilingfan', 'drawing', 'cpuscreen', 'hanger', 'bathroom_counter', 'floor', 'ceiling', 'desk', 'remote_control', 'purse', 'brush', 'ceilinglamp', 'tvstand', 'balanceball', 'faucet', 'window', 'couch', 'form', 'dining_room', 'wall', 'powersocket', 'television', 'curtain', 'food_onion', 'table']  Task:Watch TV  response:  {       thoughts : Walk to living room. Find remote control. Look at remote control. Push power on button. Find sofa. Sit down on sofa. Watch Television.,       actions : ['[WALK] <home_office>', '[WALK] <remote_control>', '[FIND] <remote_control>', '[TURNTO] <remote_control>', '[LOOKAT] <remote_control>', '[FIND] <television>', '[SWITCHON] <television>', '[FIND] <couch>', '[SIT] <couch>', '[TURNTO] <television>', '[WATCH] <television>']  }     Scene_Objects:['tablelamp', 'chair', 'walllamp', 'cat', 'orchid', 'wallshelf', 'bathroom_counter', 'floor', 'ceiling', 'desk', 'clothes_jacket', 'stovefan', 'ceilinglamp', 'shower', 'mousepad', 'couch', 'food_jam', 'form', 'pillow', 'wall', 'nightstand', 'box', 'food_food', 'television', 'coffee_pot', 'kettle', 'cards', 'mouse', 'home_office', 'dishwasher']  Task:Pet cat  response:

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


Input: You serve as an AI task planner.   1. Your task is to create a plan to achieve a goal by converting it into a sequence of actions. Each action should follow the format  [verb] <target1> <target2> , where 'verb' represents the action, and 'target1' and 'target2' are optional arguments.  2. You must describe your plan in natural language at the beginning. After that, you should list all the actions together.   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', 'crayon', 'chair', 'cat', 'dough', 'milk', 'hanger', 'floor', 'keyboard', 'mail', 'table_cloth', 'stovefan', 'plate', 'faucet', 'tvstand', 'window', 'couch', 'form', 'dining_room', 'cutting_board', 'photoframe', 'check', 'wine', 'dresser', 'hairbrush', 'pajamas', 'conditioner', 'home_office', 'bathroom_cabinet', 'table']  Task:Give milk to cat  response:  {       thoughts : Grab milk and pour it into the plate so that the cat can drink,       actions : ['[WALK] <home_office>', '[WALK] <cat>', '[FIND] <cat>', '[TURNTO] <cat>', '[POINTAT] <cat>', '[PULL] <cat>', '[FIND] <milk>', '[GRAB] <milk>', '[FIND] <plate>', '[POUR] <milk> <plate>', '[TOUCH] <cat>', '[SCRUB] <cat>']  }     Scene_Objects:['pot', 'tablelamp', 'microwave', 'ground_coffee', 'food_carrot', 'drawing', 'knifeblock', 'cpuscreen', 'hanger', 'floor', 'toaster', 'plate', 'faucet', 'foundation', 'mousepad', 'food_jam', 'food_kiwi', 'wall', 'pasta', 'powersocket', 'food_food', 'coffe_maker', 'rag', 'shaving_cream', 'kitchen_counter', 'dishrack', 'dresser', 'cupboard', 'sink', 'dishwasher']  Task:Wash dishes with dishwasher  response:

{  Take a dish and put it in the dishwasher to be washed }


Input: You serve as an AI task planner.   1. Your task is to create a plan to achieve a goal by converting it into a sequence of actions. Each action should follow the format  [verb] <target1> <target2> , where 'verb' represents the action, and 'target1' and 'target2' are optional arguments.  2. You must describe your plan in natural language at the beginning. After that, you should list all the actions together.   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', 'drawing', 'cpuscreen', 'hanger', 'floor', 'ceiling', 'character', 'desk', 'bookshelf', 'computer', 'tvstand', 'faucet', 'stereo', 'mousepad', 'closetdrawer', 'couch', 'food_orange', 'wall', 'powersocket', 'shelf', 'food_food', 'oven_mitts', 'curtain', 'doorjamb', 'coffee_pot', 'mouse', 'vacuum_cleaner', 'dresser', 'light', 'table']  Task:Turn on light  response:  {       thoughts : approach the light switch, raise hand to the switch, flip the switch,       actions : ['[WALK] <home_office>', '[WALK] <light>', '[FIND] <light>', '[SWITCHON] <light>']  }     Scene_Objects:['tablelamp', 'chair', 'walllamp', 'orchid', 'drawing', 'floor', 'ceiling', 'computer', 'button', 'toaster', 'ceilinglamp', 'tvstand', 'window', 'closetdrawer', 'couch', 'pillow', 'nightstand', 'wall', 'basket_for_clothes', 'food_food', 'check', 'television', 'tray', 'curtain', 'dresser', 'door', 'home_office', 'table', 'clothes_shirt', 'coffee']  Task:Watch TV  response:

{  I walk to the living room. I reach for the remote. I push the on button on the remote. I sit down on the couch and watch television. }


Input: You serve as an AI task planner.   1. Your task is to create a plan to achieve a goal by converting it into a sequence of actions. Each action should follow the format  [verb] <target1> <target2> , where 'verb' represents the action, and 'target1' and 'target2' are optional arguments.  2. You must describe your plan in natural language at the beginning. After that, you should list all the actions together.   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>']  }     Scene_Objects:['pot', 'chair', 'walllamp', 'knife', 'desk', 'bookshelf', 'button', 'clothes_jacket', 'stovefan', 'deck_of_cards', 'mousepad', 'closetdrawer', 'oil', 'towel', 'pillow', 'broom', 'basket_for_clothes', 'photoframe', 'novel', 'coffe_maker', 'television', 'wine', 'curtain', 'after_shave', 'cards', 'home_office', 'light', 'clothes_skirt', 'soap', 'washing_machine']  Task:Wash clothes  response:

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


Input: You serve as an AI task planner.   1. Your task is to create a plan to achieve a goal by converting it into a sequence of actions. Each action should follow the format  [verb] <target1> <target2> , where 'verb' represents the action, and 'target1' and 'target2' are optional arguments.  2. You must describe your plan in natural language at the beginning. After that, you should list all the actions together.   Ensure that you response can be parsed by Python json.loads.      Here is an example plan to achieve a goal for reference:   Scene_Objects:['pot', 'filing_cabinet', 'freezer', 'blow_dryer', 'walllamp', 'drawing', 'knifeblock', 'cpuscreen', 'bathroom_counter', 'ceiling', 'character', 'faucet', 'picture', 'iron', 'mousepad', 'bowl', 'wall', 'powersocket', 'bench', 'photoframe', 'toilet_paper', 'coffe_maker', 'toothbrush_holder', 'tray', 'doorjamb', 'dishrack', 'sink', 'bathroom_cabinet', 'home_office', 'light']  Task:Get toilet paper  response:  {       thoughts : There are extra toilet papers in the bottom cabinet.,       actions : ['[WALK] <bathroom>', '[WALK] <bathroom_cabinet>', '[FIND] <bathroom_cabinet>', '[OPEN] <bathroom_cabinet>', '[FIND] <toilet_paper>', '[GRAB] <toilet_paper>', '[CLOSE] <bathroom_cabinet>']  }     Scene_Objects:['scissors', 'freezer', 'walllamp', 'knifeblock', 'wallshelf', 'clothes_underwear', 'ceiling', 'bookshelf', 'keyboard', 'ceilinglamp', 'plate', 'stereo', 'clothes_socks', 'clothes_pants', 'pillow', 'bowl', 'powersocket', 'cutting_board', 'basket_for_clothes', 'razor', 'coin', 'wine', 'curtain', 'pencil', 'kitchen_counter', 'cd', 'dresser', 'laundry_detergent', 'clothes_shirt', 'washing_machine']  Task:Wash clothes  response:

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


Input: You serve as an AI task planner.   1. Your task is to create a plan to achieve a goal by converting it into a sequence of actions. Each action should follow the format  [verb] <target1> <target2> , where 'verb' represents the action, and 'target1' and 'target2' are optional arguments.  2. You must describe your plan in natural language at the beginning. After that, you should list all the actions together.   Ensure that you response can be parsed by Python json.loads.      Here is an example plan to achieve a goal for reference:   Scene_Objects:['freezer', 'bathroom', 'detergent', 'cat', 'trashcan', 'cpuscreen', 'floor', 'ceiling', 'character', 'desk', 'keyboard', 'computer', 'stovefan', 'ceilinglamp', 'mousepad', 'form', 'wall', 'powersocket', 'photoframe', 'food_food', 'check', 'coffee_filter', 'doorjamb', 'cards', 'mouse', 'kitchen_counter', 'controller', 'door', 'light', 'coffee']  Task:Put groceries in Fridge  response:  {       thoughts : I take the groceries out of the grocery bags, throw away grocery bags, categorize the food so that I know where it goes in the fridge, open the fridge, and place each item in the fridge before closing the fridge.,       actions : ['[WALK] <dining_room>', '[WALK] <freezer>', '[FIND] <freezer>', '[OPEN] <freezer>', '[FIND] <food_food>', '[GRAB] <food_food>', '[PUTIN] <food_food> <freezer>', '[CLOSE] <freezer>']  }     Scene_Objects:['fork', 'tea', 'jelly', 'dog', 'chair', 'ground_coffee', 'bathroom', 'phone', 'bedroom', 'stovefan', 'mat', 'plate', 'faucet', 'shoe-shine_kit', 'wall', 'nightstand', 'powersocket', 'cup', 'basket_for_clothes', 'newspaper', 'food_food', 'coffe_maker', 'tray', 'curtain', 'food_steak', 'door', 'bag', 'instrument_guitar', 'light', 'dishwasher']  Task:Set up table  response:

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


Input: You serve as an AI task planner.   1. Your task is to create a plan to achieve a goal by converting it into a sequence of actions. Each action should follow the format  [verb] <target1> <target2> , where 'verb' represents the action, and 'target1' and 'target2' are optional arguments.  2. You must describe your plan in natural language at the beginning. After that, you should list all the actions together.   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', 'jelly', 'freezer', 'walllamp', 'bathroom', 'hanger', 'folder', 'bedroom', 'desk', 'tvstand', 'window', 'food_jam', 'microphone', 'dining_room', 'wall_clock', 'powersocket', 'bench', 'shelf', 'bed', 'video_game_controller', 'food_donut', 'water', 'doorjamb', 'cards', 'towel_rack', 'mouse', 'sink', 'colander', 'hands_both']  Task:Wash hands  response:  {       thoughts : walk to bathroom, look at the water, wash hands,       actions : ['[WALK] <bathroom>', '[WALK] <water>', '[FIND] <water>', '[TURNTO] <water>', '[LOOKAT] <water>', '[FIND] <hands_both>', '[WASH] <hands_both>']  }     Scene_Objects:['dog', 'freezer', 'bathroom', 'food_carrot', 'knifeblock', 'food_egg', 'hanger', 'floor', 'phone', 'stovefan', 'mat', 'plate', 'stereo', 'dish_soap', 'food_noodles', 'closetdrawer', 'mousepad', 'dustpan', 'cup', 'food_food', 'coffe_maker', 'check', 'oven_mitts', 'water', 'food_rice', 'curtain', 'mouse', 'hairbrush', 'sink', 'home_office']  Task:Wash dishes by hand  response:

{  walk to kitchen, fins soap, arrange dishes, wash dishes }