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', 'mop', 'walllamp', 'detergent', 'food_carrot', 'toothbrush', 'knifeblock', 'orchid', 'clothes_underwear', 'hanger', 'phone', 'stovefan', 'shower', 'homework', 'couch', 'food_jam', 'microphone', 'bowl', 'photoframe', 'check', 'curtain', 'console', 'mouse', 'pencil', 'dresser', 'sink', 'soap', 'creditcard']  Task:Pet dog  response:  {       thoughts : Pet my dog in hall,       actions : ['[WALK] <home_office>', '[WALK] <dog>', '[TURNTO] <dog>', '[LOOKAT] <dog>', '[TOUCH] <dog>']  }     Scene_Objects:['sheets', 'tablelamp', 'toilet', 'detergent', 'trashcan', 'drawing', 'orchid', 'cpuscreen', 'floor', 'ceiling', 'character', 'bedroom', 'folder', 'mat', 'shower', 'food_noodles', 'couch', 'pillow', 'wall', 'oven', 'food_food', 'coffe_maker', 'doorjamb', 'door', 'bathtub', 'home_office', 'table', 'light', 'clothes_skirt', 'shoe_rack']  Task:Relax on sofa  response:

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


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_ice_cream', 'toilet', 'bathroom', 'detergent', 'ceilingfan', 'food_butter', 'drawing', 'orchid', 'knifeblock', 'floor', 'ceiling', 'desk', 'bookshelf', 'remote_control', 'ceilinglamp', 'tvstand', 'balanceball', 'window', 'couch', 'pillow', 'wall', 'food_food', 'television', 'tray', 'curtain', 'after_shave', 'cupboard', 'table', 'laser_pointer']  Task:Watch TV  response:  {       thoughts : TURN ON TV, SIT ON COUCH ACROSS THE ROOM, USE REMOTE TO LOOK FOR SHOW TO WATCH,       actions : ['[WALK] <home_office>', '[WALK] <couch>', '[FIND] <couch>', '[SIT] <couch>', '[FIND] <remote_control>', '[GRAB] <remote_control>', '[FIND] <television>', '[SWITCHON] <television>', '[TURNTO] <television>', '[WATCH] <television>']  }     Scene_Objects:['pot', 'toilet', 'chair', 'freezer', 'walllamp', 'knifeblock', 'food_egg', 'kitchen_cabinet', 'floor', 'phone', 'ceiling', 'food_chicken', 'stovefan', 'toaster', 'faucet', 'form', 'wall', 'powersocket', 'oven', 'bench', 'coffe_maker', 'tray', 'doorjamb', 'lighter', 'kitchen_counter', 'cupboard', 'laundry_detergent', 'food_steak', 'sink', 'light']  Task:Cook some food  response:

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


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', 'toilet', 'dog', 'chair', 'walllamp', 'drawing', 'cpuscreen', 'wallshelf', 'hanger', 'floor', 'desk', 'envelope', 'mat', 'tvstand', 'ceilinglamp', 'shower', 'window', 'mousepad', 'couch', 'pillow', 'wall', 'nightstand', 'television', 'oven_mitts', 'curtain', 'controller', 'home_office', 'table']  Task:Relax on sofa  response:  {       thoughts : I walk into the living room. I cross the room to the couch. I sit down and relax.,       actions : ['[WALK] <home_office>', '[WALK] <couch>', '[SIT] <couch>']  }     Scene_Objects:['sheets', 'walllamp', 'drawing', 'orchid', 'wallshelf', 'clothes_underwear', 'floor', 'ceiling', 'dvd_player', 'bookshelf', 'remote_control', 'mat', 'tvstand', 'ceilinglamp', 'shower', 'window', 'couch', 'pillow', 'wall', 'nightstand', 'powersocket', 'photoframe', 'bed', 'coffe_maker', 'television', 'curtain', 'doorjamb', 'door', 'table', 'light']  Task:Watch TV  response:

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


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:['chair', 'bathroom', 'orchid', 'wallshelf', 'ceiling', 'phone', 'stamp', 'bookshelf', 'mail', 'computer', 'tvstand', 'shower', 'couch', 'pillow', 'oven', 'powersocket', 'box', 'bed', 'clothes_gloves', 'photoframe', 'check', 'curtain', 'pencil', 'dresser', 'cupboard', 'door', 'sink', 'bathtub', 'home_office', 'dishwasher']  Task:Pet cat  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:['glue', 'beer', 'measuring_cup', 'toilet', 'freezer', 'food_carrot', 'drawing', 'food_egg', 'hanger', 'floor', 'ceiling', 'bedroom', 'mat', 'laptop', 'shower', 'tvstand', 'closetdrawer', 'food_orange', 'nightstand', 'wall', 'powersocket', 'food_cheese', 'photoframe', 'bed', 'food_food', 'drinking_glass', 'wine', 'doorjamb', 'door', 'light']  Task:Drink  response:  {       thoughts : Robot Drinks the water,       actions : ['[WALK] <dining_room>', '[WALK] <freezer>', '[FIND] <freezer>', '[OPEN] <freezer>', '[FIND] <drinking_glass>', '[GRAB] <drinking_glass>', '[DRINK] <drinking_glass>', '[PUTOBJBACK] <drinking_glass>', '[CLOSE] <freezer>']  }     Scene_Objects:['pot', 'filing_cabinet', 'microwave', 'walllamp', 'drawing', 'knifeblock', 'wallshelf', 'floor', 'ceiling', 'phone', 'keyboard', 'computer', 'stovefan', 'plate', 'faucet', 'tvstand', 'window', 'dish_soap', 'towel', 'dining_room', 'wall', 'wall_clock', 'oven', 'coffe_maker', 'food_food', 'curtain', 'kitchen_counter', 'cupboard', 'food_steak', 'sink']  Task:Wash dishes by hand  response:

{  Walk to Kitchen, find sink, find dishes and dish soap. Put soap on plate. open faucet, rinse dishes close faucet. }


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', 'toilet', 'freezer', 'knifeblock', 'drawing', 'wallshelf', 'ceiling', 'phone', 'desk', 'keyboard', 'face', 'toaster', 'laptop', 'tvstand', 'shower', 'stereo', 'homework', 'oil', 'towel', 'oven', 'basket_for_clothes', 'tray', 'towel_rack', 'hair', 'cupboard', 'door', 'bathtub', 'clothes_shirt']  Task:Rain welcome  response:  {       thoughts : The robot would greet me and then hand me a towel.  It would make an appropriate quip about the weather while I dried off.  It would receive the wet towel when I was done.,       actions : ['[WALK] <bedroom>', '[WALK] <towel>', '[FIND] <towel>', '[GRAB] <towel>', '[FIND] <face>', '[WIPE] <face>', '[FIND] <hair>', '[WIPE] <hair>', '[PUTOBJBACK] <towel>']  }     Scene_Objects:['chair', 'walllamp', 'orchid', 'drawing', 'wallshelf', 'cpuscreen', 'floor', 'ceiling', 'bedroom', 'bookshelf', 'stovefan', 'mat', 'tvstand', 'ceilinglamp', 'shower', 'window', 'picture', 'mousepad', 'pillow', 'wall', 'nightstand', 'powersocket', 'photoframe', 'television', 'curtain', 'doorjamb', 'towel_rack', 'dresser', 'bathroom_cabinet', 'light']  Task:Watch TV  response:

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


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', 'blender', 'chair', 'bathroom', 'detergent', 'drawing', 'cpuscreen', 'floor', 'phone', 'desk', 'mat', 'tvstand', 'clothes_pants', 'wall', 'nightstand', 'powersocket', 'photoframe', 'bed', 'novel', 'check', 'keys', 'tray', 'after_shave', 'curtain', 'doorjamb', 'kitchen_counter', 'cupboard', 'door', 'bathtub', 'tooth_paste']  Task:Read  response:  {       thoughts : I like to read books in my bedroom.,       actions : ['[WALK] <bedroom>', '[WALK] <desk>', '[FIND] <novel>', '[GRAB] <novel>', '[WALK] <bed>', '[LIE] <bed>', '[READ] <novel>']  }     Scene_Objects:['blow_dryer', 'walllamp', 'bathroom_counter', 'phone', 'desk', 'bookshelf', 'remote_control', 'keyboard', 'computer', 'button', 'clothes_jacket', 'stovefan', 'toaster', 'window', 'couch', 'bench', 'oven', 'cup', 'coffe_maker', 'television', 'ice', 'towel_rack', 'pencil', 'kitchen_counter', 'vacuum_cleaner', 'dresser', 'bathtub', 'napkin', 'bathroom_cabinet', 'colander']  Task:Change TV channel  response:

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


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:['blender', 'mop', 'walllamp', 'trashcan', 'wallshelf', 'floor', 'ceiling', 'folder', 'bedroom', 'tvstand', 'shower', 'foundation', 'window', 'mousepad', 'wall', 'powersocket', 'photoframe', 'light_bulb', 'food_food', 'coffe_maker', 'television', 'food_donut', 'curtain', 'centerpiece', 'towel_rack', 'kitchen_counter', 'cupboard', 'door', 'light', 'dishwasher']  Task:Take shower  response:  {       thoughts : Walk to the bathroom and wash with the shower.,       actions : ['[WALK] <bathroom>', '[WALK] <shower>', '[FIND] <shower>', '[WASH] <shower>']  }     Scene_Objects:['pot', 'microwave', 'jelly', 'walllamp', 'orchid', 'knifeblock', 'wallshelf', 'drawing', 'bathroom_counter', 'floor', 'ceiling', 'cleaning_solution', 'toaster', 'mat', 'faucet', 'window', 'couch', 'bowl', 'wall', 'oven', 'cup', 'food_food', 'curtain', 'doorjamb', 'kitchen_counter', 'cupboard', 'sink', 'spoon', 'instrument_violin', 'hands_both']  Task:Wash hands  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', 'ground_coffee', 'walllamp', 'detergent', 'knifeblock', 'longboard', 'floor', 'ceiling', 'toaster', 'stovefan', 'plate', 'faucet', 'candle', 'wall', 'box', 'coffe_maker', 'food_food', 'television', 'coffee_filter', 'water', 'towel_rack', 'kitchen_counter', 'chessboard', 'cupboard', 'hair', 'maindoor', 'sink', 'napkin', 'dishwasher', 'tooth_paste']  Task:Make coffee  response:  {       thoughts : I walk to the kitchen and find the coffee machine. I open the coffee machine and pour a filter in it. I open the cupboard and grab ground coffee. I put ground coffee in the filter and water in the coffee machine. I close the coffee machine. I switch on the coffee machine and wait,       actions : ['[WALK] <dining_room>', '[WALK] <coffe_maker>', '[FIND] <coffe_maker>', '[OPEN] <coffe_maker>', '[FIND] <coffee_filter>', '[GRAB] <coffee_filter>', '[PUTBACK] <coffee_filter> <coffe_maker>', '[FIND] <cupboard>', '[OPEN] <cupboard>', '[FIND] <ground_coffee>', '[GRAB] <ground_coffee>', '[PUTBACK] <ground_coffee> <coffe_maker>', '[WALK] <water>', '[FIND] <water>', '[GRAB] <water>', '[POUR] <water> <coffe_maker>', '[CLOSE] <coffe_maker>', '[SWITCHON] <coffe_maker>']  }     Scene_Objects:['filing_cabinet', 'trashcan', 'desk', 'keyboard', 'stovefan', 'ceilinglamp', 'mat', 'toaster', 'stereo', 'window', 'couch', 'dining_room', 'nightstand', 'wall', 'cutting_board', 'bed', 'photoframe', 'coffe_maker', 'television', 'tray', 'curtain', 'doorjamb', 'kitchen_counter', 'cupboard', 'hairdryer', 'bathtub', 'bathroom_cabinet', 'home_office', 'dishwasher', 'table']  Task:Pick up phone  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:['food_bread', 'food_pizza', 'microwave', 'dog', 'band-aids', 'orchid', 'wallshelf', 'floor', 'desk', 'mat', 'window', 'closetdrawer', 'couch', 'pillow', 'wall', 'pasta', 'tape', 'cutting_board', 'bed', 'standingmirror', 'television', 'curtain', 'doorjamb', 'conditioner', 'sink', 'home_office', 'table', 'light', 'bathroom_cabinet', 'soap']  Task:Relax on sofa  response:  {       thoughts : I walk to the living room. I see the couch.  I sit down on the couch, then lie down and put my feet up.,       actions : ['[WALK] <home_office>', '[WALK] <couch>', '[FIND] <couch>', '[SIT] <couch>', '[LIE] <couch>']  }     Scene_Objects:['sheets', 'filing_cabinet', 'freezer', 'walllamp', 'bills', 'drawing', 'cpuscreen', 'orchid', 'clothes_underwear', 'bathroom_counter', 'floor', 'ceiling', 'bookshelf', 'ceilinglamp', 'tvstand', 'faucet', 'wall', 'nightstand', 'curtain', 'doorjamb', 'chessboard', 'shoes', 'cupboard', 'sink', 'bathroom_cabinet', 'home_office', 'dishwasher', 'light', 'soap', 'hands_both']  Task:Wash hands  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', 'walllamp', 'orchid', 'needle', 'cpuscreen', 'floor', 'ceiling', 'desk', 'keyboard', 'computer', 'clothes_jacket', 'mat', 'ceilinglamp', 'tvstand', 'mousepad', 'closetdrawer', 'pillow', 'wall', 'photoframe', 'coffe_maker', 'television', 'doorjamb', 'mouse', 'kitchen_counter', 'cupboard', 'door', 'sink', 'light', 'table']  Task:Browse internet  response:  {       thoughts : I go to my desk. I turn on the computer. I open a web page and look at it.,       actions : ['[WALK] <home_office>', '[WALK] <computer>', '[FIND] <computer>', '[SWITCHON] <computer>', '[TURNTO] <computer>', '[LOOKAT] <computer>']  }     Scene_Objects:['toilet', 'band-aids', 'drawing', 'orchid', 'kitchen_cabinet', 'floor', 'bathroom_counter', 'phone', 'bookshelf', 'computer', 'stovefan', 'mat', 'plate', 'ceilinglamp', 'tvstand', 'window', 'couch', 'food_peanut_butter', 'pillow', 'wall', 'nightstand', 'bench', 'powersocket', 'oven', 'cutting_board', 'curtain', 'mouse', 'table', 'dishwasher', 'light']  Task:Set up table  response:

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


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', 'freezer', 'walllamp', 'orchid', 'cpuscreen', 'floor', 'ceiling', 'dvd_player', 'desk', 'keyboard', 'bookshelf', 'computer', 'mat', 'ceilinglamp', 'faucet', 'picture', 'window', 'mousepad', 'oil', 'clothes_hat', 'wall', 'keys', 'food_food', 'coin', 'food_onion', 'mouse', 'cupboard', 'laundry_detergent', 'door', 'table']  Task:Write an email  response:  {       thoughts : I walk into the home office and walk to the desk. I pull out the chair and sit down. I turn on the computer. After the computer is turned on I click on my email program.  When the program is loaded I write an email.,       actions : ['[WALK] <home_office>', '[WALK] <desk>', '[FIND] <chair>', '[PULL] <chair>', '[SIT] <chair>', '[FIND] <computer>', '[SWITCHON] <computer>', '[FIND] <keyboard>', '[TYPE] <keyboard>']  }     Scene_Objects:['sponge', 'microwave', 'toilet', 'freezer', 'walllamp', 'knifeblock', 'cpuscreen', 'bathroom_counter', 'floor', 'ceiling', 'phone', 'bedroom', 'bookshelf', 'plate', 'faucet', 'drying_rack', 'dish_soap', 'couch', 'dining_room', 'wall', 'oven', 'newspaper', 'photoframe', 'check', 'toilet_paper', 'kitchen_counter', 'cupboard', 'sink', 'bathtub', 'table']  Task:Wash dishes by hand  response:

{  I walk in to the Kitchen. I find a plate, a sponge, and the dish soap. I find the faucet. I turn the faucet on. I pour water on the sponge and plate. I add dish soap to the sponge. I put the dish soap back. I scrub the plate. I rinse the plate. I place the plate on the drying rack. I rinse the sponge. I turn the faucet off. }


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', 'glue', 'microwave', 'bathroom', 'trashcan', 'toothbrush', 'drawing', 'knifeblock', 'food_egg', 'floor', 'ceiling', 'desk', 'purse', 'food_bacon', 'ceilinglamp', 'plate', 'laptop', 'deck_of_cards', 'window', 'couch', 'food_orange', 'wall', 'powersocket', 'photoframe', 'check', 'television', 'spoon', 'home_office', 'table', 'teeth']  Task:Relax on sofa  response:  {       thoughts : I walk to the sofa, and lie down on the sofa.,       actions : ['[WALK] <couch>', '[LIE] <couch>']  }     Scene_Objects:['fork', 'pot', 'tablelamp', 'microwave', 'drawing', 'orchid', 'kitchen_cabinet', 'floor', 'phone', 'bookshelf', 'computer', 'stovefan', 'mat', 'plate', 'ceilinglamp', 'deck_of_cards', 'faucet', 'couch', 'wall', 'nightstand', 'bench', 'oven', 'box', 'cup', 'check', 'razor', 'food_onion', 'dresser', 'door', 'table']  Task:Set up table  response:

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


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:['ceilingfan', 'toothbrush', 'drawing', 'food_egg', 'bathroom_counter', 'floor', 'ceiling', 'phone', 'longboard', 'mop_bucket', 'mat', 'tvstand', 'faucet', 'couch', 'clothes_pants', 'towel', 'wall', 'basket_for_clothes', 'photoframe', 'light_bulb', 'wooden_spoon', 'after_shave', 'coffee', 'sink', 'bathroom_cabinet', 'home_office', 'soap', 'laser_pointer', 'hands_both', 'shoe_rack']  Task:Wash hands  response:  {       thoughts : Turn faucet clockwise to turn on water.  Place hands under stream of water, pick up soap, rub hands with soap.  Put soap back down.  Rub hands together with soap on them.  Rinse hands under water from faucet.  Turn faucet counterclockwise to turn water off.  Dry hands by rubbing them on a towel.,       actions : ['[WALK] <bathroom>', '[WALK] <sink>', '[FIND] <faucet>', '[SWITCHON] <faucet>', '[FIND] <soap>', '[GRAB] <soap>', '[FIND] <hands_both>', '[SCRUB] <hands_both>', '[PUTOBJBACK] <soap>', '[WASH] <hands_both>', '[SWITCHOFF] <faucet>', '[FIND] <towel>', '[GRAB] <towel>', '[WIPE] <hands_both>', '[PUTOBJBACK] <towel>']  }     Scene_Objects:['walllamp', 'orchid', 'drawing', 'wallshelf', 'floor', 'ceiling', 'bookshelf', 'remote_control', 'toaster', 'mat', 'tvstand', 'ceilinglamp', 'shower', 'window', 'oil', 'couch', 'pillow', 'wall', 'powersocket', 'photoframe', 'check', 'television', 'oven_mitts', 'curtain', 'doorjamb', 'towel_rack', 'dresser', 'door', 'light', 'table']  Task:Watch TV  response:

{  Turn on the TV, sit on the couch, find a show, and watch 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:['sponge', 'microwave', 'chair', 'jelly', 'knifeblock', 'floor', 'ceiling', 'character', 'alcohol', 'toaster', 'plate', 'faucet', 'drying_rack', 'window', 'tvstand', 'dish_soap', 'closetdrawer', 'couch', 'towel', 'pillow', 'food_kiwi', 'wall', 'toy', 'novel', 'curtain', 'kitchen_counter', 'cupboard', 'sink', 'instrument_guitar', 'shoe_rack']  Task:Do dishes  response:  {       thoughts : Wash dirty dishes, dry them and then put them away,       actions : ['[WALK] <dining_room>', '[WALK] <sink>', '[FIND] <faucet>', '[SWITCHON] <faucet>', '[FIND] <dish_soap>', '[GRAB] <dish_soap>', '[POUR] <dish_soap> <sink>', '[PUTOBJBACK] <dish_soap>', '[FIND] <sponge>', '[GRAB] <sponge>', '[FIND] <plate>', '[GRAB] <plate>', '[SCRUB] <plate>', '[RINSE] <plate>', '[FIND] <drying_rack>', '[PUTBACK] <plate> <drying_rack>', '[FIND] <plate>', '[GRAB] <plate>', '[SCRUB] <plate>', '[RINSE] <plate>', '[PUTBACK] <plate> <drying_rack>', '[PUTOBJBACK] <sponge>', '[SWITCHOFF] <faucet>']  }     Scene_Objects:['food_pizza', 'tablelamp', 'chair', 'freezer', 'detergent', 'bathroom_counter', 'desk', 'bedroom', 'keyboard', 'button', 'stovefan', 'ceilinglamp', 'stereo', 'shower', 'window', 'clothes_socks', 'dining_room', 'nightstand', 'wall', 'bench', 'oven', 'powersocket', 'bed', 'television', 'curtain', 'doorjamb', 'dresser', 'napkin', 'bathroom_cabinet', 'soap']  Task:Listen to music  response:

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


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:['dog', 'walllamp', 'drawing', 'orchid', 'wallshelf', 'floor', 'ceiling', 'bookshelf', 'remote_control', 'mat', 'tvstand', 'ceilinglamp', 'shower', 'window', 'mousepad', 'couch', 'pillow', 'wall', 'powersocket', 'photoframe', 'television', 'curtain', 'doorjamb', 'kitchen_counter', 'door', 'bathtub', 'sink', 'table', 'light', 'dishwasher']  Task:Relax on sofa  response:  {       thoughts : walk into living room and go to sofa and turn on tv,       actions : ['[WALK] <home_office>', '[WALK] <remote_control>', '[FIND] <remote_control>', '[WALK] <remote_control>', '[GRAB] <remote_control>', '[FIND] <couch>', '[WALK] <couch>', '[LIE] <couch>', '[FIND] <television>', '[SWITCHON] <television>', '[DROP] <remote_control>']  }     Scene_Objects:['pot', 'microwave', 'ground_coffee', 'walllamp', 'bathroom', 'knifeblock', 'drawing', 'floor', 'ceiling', 'character', 'bookshelf', 'toaster', 'stovefan', 'faucet', 'wall', 'oven', 'tape', 'cup', 'coffe_maker', 'food_food', 'toilet_paper', 'coffee_filter', 'water', 'tray', 'kitchen_counter', 'cupboard', 'sink', 'table', 'dishwasher', 'shoe_rack']  Task:Make coffee  response:

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


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', 'food_butter', 'food_carrot', 'drawing', 'orchid', 'knifeblock', 'knife', 'cpuscreen', 'floor', 'ceiling', 'bookshelf', 'toaster', 'mat', 'food_noodles', 'couch', 'pillow', 'wall', 'bed', 'photoframe', 'food_food', 'curtain', 'doorjamb', 'towel_rack', 'cupboard', 'door', 'bathroom_cabinet', 'table', 'light', 'dirt']  Task:Relax on sofa  response:  {       thoughts : Relax on the sofa in the living room.,       actions : ['[WALK] <home_office>', '[WALK] <couch>', '[FIND] <couch>', '[SIT] <couch>']  }     Scene_Objects:['sheets', 'filing_cabinet', 'food_pizza', 'walllamp', 'orchid', 'needle', 'cpuscreen', 'bathroom_counter', 'shampoo', 'desk', 'bookshelf', 'computer', 'stovefan', 'ceilinglamp', 'toaster', 'shower', 'faucet', 'couch', 'dining_room', 'cup', 'bed', 'tray', 'curtain', 'wooden_spoon', 'pencil', 'door', 'bathroom_cabinet', 'light', 'dishwasher', 'table']  Task:Pick up phone  response:

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


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', 'scissors', 'jelly', 'walllamp', 'bathroom', 'ceilingfan', 'drawing', 'hanger', 'floor', 'ceiling', 'desk', 'remote_control', 'computer', 'ceilinglamp', 'tvstand', 'balanceball', 'shoe-shine_kit', 'window', 'couch', 'food_jam', 'wall', 'novel', 'television', 'curtain', 'doorjamb', 'comb', 'clothes_dress', 'sink', 'home_office', 'table']  Task:Change TV channel  response:  {       thoughts : first i will go to living room and then take the remote and swtitch on television after that il change the channel,       actions : ['[WALK] <home_office>', '[WALK] <television>', '[FIND] <television>', '[SWITCHON] <television>', '[FIND] <remote_control>', '[TURNTO] <remote_control>', '[POINTAT] <remote_control>', '[TOUCH] <remote_control>', '[TURNTO] <television>', '[WATCH] <television>']  }     Scene_Objects:['chair', 'walllamp', 'orchid', 'drawing', 'wallshelf', 'floor', 'ceiling', 'bookshelf', 'remote_control', 'keyboard', 'mat', 'tvstand', 'ceilinglamp', 'shower', 'window', 'faucet', 'couch', 'pillow', 'wall', 'powersocket', 'photoframe', 'television', 'curtain', 'doorjamb', 'cupboard', 'door', 'home_office', 'light', 'table', 'bathroom_cabinet']  Task:Watch TV  response:

{  Walk to living room. Find remote control. Look at remote control. Push power on button. Find sofa. Sit down on sofa. 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:['tablelamp', 'toilet', 'chair', 'walllamp', 'bathroom', 'bathroom_counter', 'floor', 'ceiling', 'bedroom', 'bookshelf', 'button', 'food_bacon', 'stovefan', 'mat', 'shower', 'faucet', 'closetdrawer', 'towel', 'wall', 'wall_clock', 'oven', 'nightstand', 'keys', 'tray', 'doorjamb', 'lighter', 'sink', 'bathtub', 'bathroom_cabinet', 'soap']  Task:Take shower  response:  {       thoughts : I want to take a shower so I go to the bathroom, turn on the shower, get the soap, lather and wash, then I rinse, turn off shower, get a towel and dry off.,       actions : ['[WALK] <bathroom>', '[WALK] <shower>', '[FIND] <faucet>', '[SWITCHON] <faucet>', '[FIND] <soap>', '[GRAB] <soap>', '[RINSE] <shower>', '[SWITCHOFF] <faucet>', '[FIND] <towel>', '[GRAB] <towel>']  }     Scene_Objects:['walllamp', 'cat', 'trashcan', 'drawing', 'orchid', 'knife', 'cpuscreen', 'floor', 'ceiling', 'phone', 'bookshelf', 'keyboard', 'mail', 'toaster', 'mat', 'tvstand', 'couch', 'pillow', 'broom', 'wall', 'nightstand', 'powersocket', 'television', 'food_donut', 'doorjamb', 'door', 'bathroom_cabinet', 'light', 'table', 'dirt']  Task:Pet cat  response:

{  My cat looks like it wants attention, so I will go pet it on the couch. }


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', 'food_bread', 'juice', 'toilet', 'chair', 'freezer', 'ground_coffee', 'walllamp', 'food_butter', 'food_carrot', 'drawing', 'floor', 'ceiling', 'stovefan', 'mat', 'ceilinglamp', 'shower', 'food_peanut_butter', 'food_jam', 'bowl', 'wall', 'nightstand', 'oven', 'powersocket', 'cup', 'food_cheese', 'photoframe', 'coffe_maker', 'food_food', 'tray', 'doorjamb', 'kitchen_counter', 'cupboard', 'door', 'food_steak', 'light', 'dishwasher', 'table']  Task:Grab some juice  response:  {       thoughts : I go to the fridge, and grab some juice out of it. I then get a glass, and pour the juice into the glass.,       actions : ['[WALK] <dining_room>', '[WALK] <cupboard>', '[FIND] <cupboard>', '[OPEN] <cupboard>', '[FIND] <cup>', '[GRAB] <cup>', '[CLOSE] <cupboard>', '[WALK] <freezer>', '[OPEN] <freezer>', '[FIND] <juice>', '[GRAB] <juice>', '[POUR] <juice> <cup>', '[PUTOBJBACK] <juice>', '[CLOSE] <freezer>', '[FIND] <table>', '[PUTBACK] <cup> <table>']  }     Scene_Objects:['fork', 'food_bread', 'tablelamp', 'crayon', 'tea', 'toilet', 'walllamp', 'knife', 'floor', 'ceiling', 'toaster', 'mat', 'plate', 'faucet', 'dish_soap', 'couch', 'wall', 'oven', 'novel', 'coffe_maker', 'drinking_glass', 'tray', 'doorjamb', 'kettle', 'kitchen_counter', 'dresser', 'cupboard', 'door', 'dishwasher', 'clothes_shirt']  Task:Wash dishes with dishwasher  response:

{  Walk to the kitchen and turn to the dishwasher, put the knife, glass, fork and plate into 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:['pot', 'tablelamp', 'walllamp', 'woman', 'drawing', 'phone', 'desk', 'man', 'toaster', 'laptop', 'mat', 'shower', 'electric_shaver', 'oil', 'form', 'pillow', 'dining_room', 'oven', 'shelf', 'bed', 'standingmirror', 'toothbrush_holder', 'tray', 'curtain', 'doorjamb', 'mouse', 'door', 'bathroom_cabinet', 'tooth_paste', 'scrabble']  Task:Greet guests  response:  {       thoughts : Answer the door. Smile and give a warm hello, or other appropriate greeting. With newcomers to your home, offer your hand to be shook. With old friends it is appropriate to hug, or kiss one another on the cheek.,       actions : ['[WALK] <home_office>', '[WALK] <man>', '[FIND] <man>', '[GREET] <man>', '[FIND] <woman>', '[GREET] <woman>']  }     Scene_Objects:['microwave', 'toilet', 'chair', 'bathroom', 'detergent', 'orchid', 'knifeblock', 'drawing', 'bathroom_counter', 'bedroom', 'keyboard', 'button', 'toaster', 'tvstand', 'food_noodles', 'pillow', 'check', 'television', 'oven_mitts', 'wine', 'curtain', 'rag', 'doorjamb', 'kettle', 'mouse', 'pencil', 'hairbrush', 'food_steak', 'home_office', 'dishwasher']  Task:Pet cat  response:

{  Find the cat; pet the cat by touching 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:['food_bread', 'chair', 'bathroom', 'detergent', 'orchid', 'knife', 'hanger', 'floor', 'character', 'computer', 'mail', 'table_cloth', 'toaster', 'foundation', 'window', 'mousepad', 'bench', 'shelf', 'photoframe', 'bed', 'coffe_maker', 'cards', 'chessboard', 'controller', 'door', 'maindoor', 'bathtub', 'light', 'vase', 'laser_pointer']  Task:Pick up phone  response:  {       thoughts : walk into living room, look at the phone when it ringing, grab the phone or pickup the phone,       actions : ['[WALK] <home_office>', '[WALK] <phone>', '[FIND] <phone>', '[TURNTO] <phone>', '[LOOKAT] <phone>']  }     Scene_Objects:['food_pizza', 'drawing', 'orchid', 'floor', 'ceiling', 'phone', 'computer', 'tvstand', 'plate', 'faucet', 'shower', 'couch', 'pillow', 'dining_room', 'wall', 'pasta', 'newspaper', 'novel', 'check', 'toilet_paper', 'food_food', 'doorjamb', 'towel_rack', 'kitchen_counter', 'cupboard', 'controller', 'door', 'table', 'light', 'dishwasher']  Task:Relax on sofa  response:

{  I walk into the living room. I cross the room to the couch. I sit down and relax. }


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', 'chair', 'freezer', 'walllamp', 'bathroom', 'drawing', 'wallshelf', 'floor', 'ceiling', 'bedroom', 'computer', 'button', 'mat', 'shoe-shine_kit', 'pillow', 'wall', 'oven', 'tape', 'bed', 'photoframe', 'novel', 'food_food', 'curtain', 'coffee_pot', 'mouse', 'pencil', 'conditioner', 'sink', 'coffee']  Task:Read to child  response:  {       thoughts : Read a book out loud to a child,       actions : ['[WALK] <bedroom>', '[WALK] <child>', '[FIND] <child>', '[GREET] <child>', '[WALK] <filing_cabinet>', '[OPEN] <filing_cabinet>', '[FIND] <novel>', '[GRAB] <novel>', '[WALK] <chair>', '[PULL] <chair>', '[SIT] <chair>', '[TURNTO] <novel>', '[LOOKAT] <novel>', '[TURNTO] <novel>', '[POINTAT] <novel>', '[TURNTO] <novel>', '[POINTAT] <novel>', '[READ] <novel>', '[READ] <novel>', '[READ] <novel>']  }     Scene_Objects:['tablelamp', 'juice', 'toilet', 'chair', 'freezer', 'dough', 'orchid', 'bathroom_counter', 'floor', 'ceiling', 'bookshelf', 'computer', 'toaster', 'mat', 'pillow', 'dining_room', 'wall', 'oven', 'photoframe', 'food_food', 'coffe_maker', 'tray', 'curtain', 'centerpiece', 'doorjamb', 'kitchen_counter', 'cupboard', 'laundry_detergent', 'bag', 'dishwasher']  Task:Put groceries in Fridge  response:

{  walk to kitchen, walk to fridge, look at bags, grab groceries, put groceries in 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:['sheets', 'pot', 'filing_cabinet', 'walllamp', 'drawing', 'cpuscreen', 'floor', 'phone', 'button', 'mat', 'stereo', 'window', 'homework', 'foundation', 'couch', 'pillow', 'wall', 'toy', 'cup', 'light_bulb', 'television', 'razor', 'curtain', 'after_shave', 'doorjamb', 'rag', 'coffee_pot', 'laundry_detergent', 'bathtub', 'table']  Task:Arrange furniture  response:  {       thoughts : Move furniture where you want it.,       actions : ['[WALK] <home_office>', '[WALK] <coffee_table>', '[PUSH] <coffee_table>', '[WALK] <couch>', '[PUSH] <couch>', '[WALK] <couch>', '[PUSH] <couch>', '[WALK] <filing_cabinet>', '[PUSH] <filing_cabinet>']  }     Scene_Objects:['microwave', 'toilet', 'walllamp', 'bathroom', 'orchid', 'wallshelf', 'bathroom_counter', 'floor', 'phone', 'ceiling', 'desk', 'bookshelf', 'keyboard', 'computer', 'stovefan', 'tvstand', 'faucet', 'plate', 'mousepad', 'wall', 'powersocket', 'bench', 'oven', 'cutting_board', 'tape', 'cup', 'doorjamb', 'sink', 'light', 'table']  Task:Pick up phone  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:['chair', 'walllamp', 'detergent', 'drawing', 'orchid', 'floor', 'character', 'keyboard', 'toaster', 'mat', 'faucet', 'stereo', 'couch', 'towel', 'wall', 'wall_clock', 'nightstand', 'cup', 'coffe_maker', 'kitchen_counter', 'shoes', 'cd', 'hairbrush', 'cupboard', 'sink', 'bathroom_cabinet', 'dishwasher', 'soap', 'scrabble', 'hands_both']  Task:Wash hands  response:  {       thoughts : I have had my lunch and walked towards the sink and applied soap to my hands and washed cleanly.,       actions : ['[WALK] <dining_room>', '[WALK] <sink>', '[FIND] <soap>', '[GRAB] <soap>', '[FIND] <hands_both>', '[WASH] <hands_both>', '[FIND] <towel>', '[GRAB] <towel>', '[WIPE] <hands_both>']  }     Scene_Objects:['pot', 'microwave', 'walllamp', 'ground_coffee', 'orchid', 'drawing', 'cpuscreen', 'floor', 'phone', 'ceiling', 'toaster', 'ceilinglamp', 'plate', 'tvstand', 'window', 'dish_soap', 'pillow', 'wall', 'oven', 'powersocket', 'photoframe', 'coffe_maker', 'razor', 'tray', 'mouse', 'kitchen_counter', 'cupboard', 'bathtub', 'dishwasher', 'instrument_violin']  Task:Wash dishes with dishwasher  response:

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


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_pizza', 'tablelamp', 'food_salt', 'cd_player', 'chair', 'freezer', 'bathroom', 'food_carrot', 'orchid', 'knifeblock', 'floor', 'ceiling', 'phone', 'desk', 'bedroom', 'keyboard', 'remote_control', 'computer', 'window', 'mousepad', 'wall', 'nightstand', 'light_bulb', 'check', 'food_onion', 'curtain', 'mouse', 'door', 'light', 'tooth_paste']  Task:Listen to music  response:  {       thoughts : Walk to CD player and turn it on then go and sit in a chair and turn the remote control on and then listen to some music.,       actions : ['[WALK] <cd_player>', '[SWITCHON] <cd_player>', '[FIND] <chair>', '[SIT] <chair>', '[FIND] <remote_control>', '[TOUCH] <remote_control>']  }     Scene_Objects:['food_salt', 'toilet', 'walllamp', 'bathroom', 'trashcan', 'knifeblock', 'floor', 'tea_bag', 'bookshelf', 'food_bacon', 'toaster', 'plate', 'tvstand', 'dish_soap', 'mousepad', 'couch', 'wall', 'oven', 'powersocket', 'photoframe', 'coffe_maker', 'food_food', 'toothbrush_holder', 'ice', 'mouse', 'kitchen_counter', 'vacuum_cleaner', 'cupboard', 'clothes_dress', 'dishwasher']  Task:Wash dishes with dishwasher  response:

{  Go to kitchen to put dirty dishs into dishwasher with soap to clean the dirty dishes }


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', 'juice', 'microwave', 'knifeblock', 'floor', 'ceiling', 'character', 'bookshelf', 'envelope', 'mop_bucket', 'toaster', 'mat', 'faucet', 'dish_soap', 'couch', 'wall', 'cup', 'photoframe', 'toilet_paper', 'video_game_controller', 'wooden_spoon', 'tray', 'console', 'mouse', 'kitchen_counter', 'dishrack', 'cupboard', 'sink', 'light']  Task:Wash dishes  response:  {       thoughts : Place all of the dirty dishes in a sink full of clean, soapy water.  Wash them.  Rinse them in fresh, running water.  Place them in the strainer to dry.,       actions : ['[WALK] <dining_room>', '[WALK] <sink>', '[FIND] <faucet>', '[SWITCHON] <faucet>', '[SWITCHOFF] <faucet>', '[FIND] <dish_soap>', '[GRAB] <dish_soap>', '[POUR] <dish_soap> <sink>', '[PUTOBJBACK] <dish_soap>', '[FIND] <sponge>', '[GRAB] <sponge>', '[FIND] <cup>', '[GRAB] <cup>', '[SCRUB] <cup>', '[PUTOBJBACK] <cup>', '[FIND] <cup>', '[GRAB] <cup>', '[SCRUB] <cup>', '[PUTOBJBACK] <cup>', '[PUTBACK] <sponge> <sink>', '[SWITCHON] <faucet>', '[RINSE] <cup>', '[GRAB] <cup>', '[FIND] <dishrack>', '[PUTBACK] <cup> <dishrack>', '[RINSE] <cup>', '[GRAB] <cup>', '[PUTBACK] <cup> <dishrack>', '[RINSE] <sponge>', '[SWITCHOFF] <faucet>', '[GRAB] <sponge>', '[PUTOBJBACK] <sponge>']  }     Scene_Objects:['dry_pasta', 'tablelamp', 'toilet', 'freezer', 'walllamp', 'drawing', 'character', 'bedroom', 'toaster', 'deck_of_cards', 'faucet', 'shower', 'plate', 'window', 'mousepad', 'couch', 'candle', 'clothes_hat', 'nightstand', 'photoframe', 'coffe_maker', 'coffee_filter', 'tray', 'mouse', 'pencil', 'bathtub', 'bathroom_cabinet', 'table', 'dishwasher', 'board_game']  Task:Listen to music  response:

{  I walk into the bedroom. I walk to stereo. I turn on stereo. }


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', 'drawing', 'cpuscreen', 'floor', 'ceiling', 'desk', 'bookshelf', 'keyboard', 'computer', 'piano_bench', 'mat', 'shoe-shine_kit', 'balanceball', 'oil', 'clothes_hat', 'dining_room', 'wall', 'powersocket', 'photoframe', 'bed', 'food_food', 'mouthwash', 'doorjamb', 'towel_rack', 'vacuum_cleaner', 'door', 'home_office', 'light', 'soap']  Task:Turn on light  response:  {       thoughts : switching on the light,       actions : ['[WALK] <bedroom>', '[WALK] <light>', '[FIND] <light>', '[SWITCHON] <light>']  }     Scene_Objects:['fork', 'pot', 'microwave', 'toilet', 'cat', 'wallshelf', 'bathroom_counter', 'floor', 'dvd_player', 'bookshelf', 'stovefan', 'ceilinglamp', 'toaster', 'mat', 'shower', 'faucet', 'tvstand', 'couch', 'towel', 'wall', 'bench', 'cutting_board', 'bed', 'razor', 'television', 'curtain', 'kitchen_counter', 'dresser', 'home_office', 'light']  Task:Pet cat  response:


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:['blender', 'tea', 'microwave', 'jelly', 'band-aids', 'freezer', 'bathroom', 'needle', 'ceiling', 'character', 'keyboard', 'mop_bucket', 'ceilinglamp', 'mat', 'tvstand', 'faucet', 'closetdrawer', 'couch', 'pillow', 'nightstand', 'oven', 'photoframe', 'coffe_maker', 'check', 'television', 'cards', 'laundry_detergent', 'clothes_dress', 'home_office', 'table']  Task:Put umbrella away  response:  {       thoughts : Place the umbrella in the umbrella bucket point first.,       actions : ['[WALK] <home_office>', '[WALK] <mop_bucket>']  }     Scene_Objects:['food_salt', 'walllamp', 'toothbrush', 'drawing', 'wallshelf', 'cpuscreen', 'floor', 'dvd_player', 'keyboard', 'toaster', 'plate', 'foundation', 'dish_soap', 'form', 'wall', 'bench', 'novel', 'coffe_maker', 'check', 'food_donut', 'curtain', 'towel_rack', 'kitchen_counter', 'cupboard', 'sink', 'home_office', 'instrument_guitar', 'dishwasher', 'soap', 'scrabble']  Task:Wash dishes with dishwasher  response:

{  Wash a plate using the dishwasher in the kitchen. }


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', 'walllamp', 'drawing', 'orchid', 'food_egg', 'floor', 'ceiling', 'phone', 'character', 'remote_control', 'button', 'stovefan', 'ceilinglamp', 'tvstand', 'mat', 'faucet', 'shower', 'couch', 'clothes_hat', 'wall', 'powersocket', 'basket_for_clothes', 'check', 'mouthwash', 'television', 'food_onion', 'doorjamb', 'controller', 'door', 'table']  Task:Change TV channel  response:  {       thoughts : Walk to TV, grab remote control, press change channel button, repeat pressing change channel button util find the channel wanted, put back remote control,       actions : ['[WALK] <television>', '[FIND] <remote_control>', '[GRAB] <remote_control>', '[FIND] <button>', '[TOUCH] <button>', '[TURNTO] <television>', '[WATCH] <television>', '[TOUCH] <button>', '[TURNTO] <television>', '[WATCH] <television>', '[PUTOBJBACK] <remote_control>']  }     Scene_Objects:['tablelamp', 'freezer', 'trashcan', 'drawing', 'orchid', 'floor', 'ceiling', 'keyboard', 'bookshelf', 'piano_bench', 'stovefan', 'ceilinglamp', 'shower', 'window', 'couch', 'pillow', 'food_kiwi', 'wall', 'nightstand', 'toy', 'bed', 'doorjamb', 'diary', 'pencil', 'kitchen_counter', 'dresser', 'cupboard', 'door', 'table', 'light']  Task:Relax on sofa  response:

{  I walk to the sofa, and lie down on the sofa. }


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:['band-aids', 'trashcan', 'wallshelf', 'clothes_underwear', 'desk', 'keyboard', 'mail', 'computer', 'tvstand', 'shower', 'window', 'clothes_socks', 'couch', 'food_peanut_butter', 'pillow', 'basket_for_clothes', 'keys', 'coffe_maker', 'television', 'food_donut', 'tray', 'rag', 'headset', 'clothes_scarf', 'bathtub', 'sink', 'light', 'dishwasher', 'soap', 'washing_machine']  Task:Wash clothes  response:  {       thoughts : Get dirty clothes out of basket for clothes in bedroom, carry dirty clothes to laundry room, place dirty clothes in washing machine, add laundry detergent to washing machine, turn washing machine on, set type of wash, start washing machine,       actions : ['[WALK] <bedroom>', '[WALK] <basket_for_clothes>', '[FIND] <basket_for_clothes>', '[OPEN] <basket_for_clothes>', '[GRAB] <basket_for_clothes>', '[WALK] <bathroom>', '[WALK] <washing_machine>', '[FIND] <washing_machine>', '[OPEN] <washing_machine>', '[PUTBACK] <basket_for_clothes> <washing_machine>', '[FIND] <soap>', '[GRAB] <soap>', '[PUTBACK] <soap> <washing_machine>', '[FIND] <washing_machine>', '[CLOSE] <washing_machine>', '[SWITCHON] <washing_machine>']  }     Scene_Objects:['filing_cabinet', 'toilet', 'freezer', 'detergent', 'knifeblock', 'phone', 'bookshelf', 'computer', 'mop_bucket', 'brush', 'clothes_socks', 'mousepad', 'dining_room', 'nightstand', 'basket_for_clothes', 'food_food', 'curtain', 'doorjamb', 'towel_rack', 'mouse', 'kitchen_counter', 'dresser', 'laundry_detergent', 'bathtub', 'sink', 'home_office', 'napkin', 'dishwasher', 'bathroom_cabinet', 'washing_machine']  Task:Wash clothes  response:

{  \ I walk to entrance hall\  \ I walk to bedroom\  \ I find basket of clothes\  \ I lift basket of  clothes\  \ I walk to kitchen\  \ I find washing machine\  \ I open washing machine \  \ I put laundry in washing machine\  \ I add laundry detergent\  \  \ I close washing machine lid\  \ I switch washing machine 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:['filing_cabinet', 'tablelamp', 'juice', 'microwave', 'chair', 'trashcan', 'drawing', 'cpuscreen', 'wallshelf', 'floor', 'ceiling', 'computer', 'table_cloth', 'tvstand', 'shower', 'mousepad', 'dining_room', 'wall', 'nightstand', 'powersocket', 'photoframe', 'food_food', 'television', 'tray', 'doorjamb', 'cupboard', 'sink', 'bathroom_cabinet', 'light', 'board_game']  Task:Turn on light  response:  {       thoughts : walk into living room, walk to light, turn on light switch.,       actions : ['[WALK] <home_office>', '[WALK] <light>', '[SWITCHON] <light>']  }     Scene_Objects:['walllamp', 'detergent', 'drawing', 'orchid', 'wallshelf', 'bathroom_counter', 'floor', 'ceiling', 'desk', 'bookshelf', 'keyboard', 'computer', 'ceilinglamp', 'shower', 'stereo', 'couch', 'pillow', 'wall', 'oven', 'mouthwash', 'curtain', 'doorjamb', 'mouse', 'kitchen_counter', 'door', 'instrument_guitar', 'table', 'light', 'dishwasher', 'colander']  Task:Relax on sofa  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:['food_bread', 'microwave', 'freezer', 'walllamp', 'bathroom', 'toothbrush', 'orchid', 'hanger', 'longboard', 'phone', 'desk', 'computer', 'food_bacon', 'table_cloth', 'clothes_jacket', 'brush', 'ceilinglamp', 'faucet', 'foundation', 'mousepad', 'clothes_pants', 'pasta', 'light_bulb', 'toothbrush_holder', 'coin', 'coffee_filter', 'towel_rack', 'hair', 'vase', 'tooth_paste']  Task:Wash teeth  response:  {       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:['pot', 'filing_cabinet', 'beer', 'microwave', 'walllamp', 'drawing', 'orchid', 'wallshelf', 'floor', 'ceiling', 'keyboard', 'food_cake', 'ceilinglamp', 'faucet', 'window', 'mousepad', 'couch', 'pillow', 'wall', 'photoframe', 'tray', 'curtain', 'doorjamb', 'towel_rack', 'door', 'bathtub', 'bathroom_cabinet', 'table', 'light', 'dishwasher']  Task:Relax on sofa  response:

{  Walk to living room. Sit on sofa. Lie down on sofa. }


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_pizza', 'food_ice_cream', 'microwave', 'freezer', 'ground_coffee', 'nail_polish', 'milk', 'hanger', 'floor', 'ceiling', 'toaster', 'ceilinglamp', 'faucet', 'clothes_hat', 'wall', 'wall_clock', 'oven', 'cutting_board', 'shelf', 'coffe_maker', 'check', 'television', 'coffee_filter', 'water', 'curtain', 'kitchen_counter', 'maindoor', 'sink', 'vase', 'soap']  Task:Make coffee  response:  {       thoughts : Walk to kitchen. Find coffee maker. Find coffee filter. Put it in the coffee maker. Find ground coffee. Put it in the coffee maker. Find Water. Put it in the coffe maker. Switch on the coffee maker.,       actions : ['[WALK] <dining_room>', '[WALK] <coffe_maker>', '[FIND] <coffe_maker>', '[FIND] <coffee_filter>', '[GRAB] <coffee_filter>', '[OPEN] <coffe_maker>', '[PUTBACK] <coffee_filter> <coffe_maker>', '[FIND] <ground_coffee>', '[GRAB] <ground_coffee>', '[PUTBACK] <ground_coffee> <coffe_maker>', '[FIND] <water>', '[SWITCHON] <coffe_maker>']  }     Scene_Objects:['water_glass', 'tablelamp', 'crayon', 'freezer', 'knifeblock', 'bathroom_counter', 'shampoo', 'ceiling', 'thread', 'faucet', 'shower', 'mousepad', 'food_kiwi', 'nightstand', 'wall', 'bench', 'powersocket', 'cup', 'clothes_gloves', 'novel', 'food_food', 'coffe_maker', 'toothbrush_holder', 'water', 'doorjamb', 'mouse', 'shoes', 'dresser', 'cupboard', 'table']  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:['sheets', 'scissors', 'freezer', 'walllamp', 'ground_coffee', 'bathroom', 'ceilingfan', 'clothes_underwear', 'bathroom_counter', 'character', 'thread', 'piano_bench', 'toaster', 'deck_of_cards', 'homework', 'couch', 'dustpan', 'powersocket', 'newspaper', 'clothes_gloves', 'novel', 'coffe_maker', 'doorjamb', 'chessboard', 'cd', 'napkin', 'home_office', 'instrument_guitar', 'clothes_skirt', 'light']  Task:Close door  response:  {       thoughts : Push the door shut until it latches.,       actions : ['[RUN] <home_office>']  }     Scene_Objects:['microwave', 'walllamp', 'bathroom', 'detergent', 'cpuscreen', 'ceiling', 'computer', 'toaster', 'brush', 'laptop', 'faucet', 'mousepad', 'clothes_pants', 'dirt', 'powersocket', 'oven', 'cup', 'bed', 'food_food', 'television', 'toothbrush_holder', 'tray', 'curtain', 'doorjamb', 'mouse', 'chessboard', 'laundry_detergent', 'sink', 'dishwasher', 'washing_machine']  Task:Wash clothes  response:

{  Walk to bathroom. Open washing maschine. Grab pants and put it into washing maschine. Pour laundry detergent into washing machine and close the washing maschine. Plug in washing machine. }


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', 'chair', 'freezer', 'walllamp', 'orchid', 'drawing', 'bathroom_counter', 'floor', 'bookmark', 'toaster', 'mat', 'tvstand', 'faucet', 'shower', 'laptop', 'mousepad', 'wall', 'oven', 'powersocket', 'towel_rack', 'kitchen_counter', 'headset', 'door', 'sink', 'bathtub', 'home_office', 'bathroom_cabinet', 'light']  Task:Go to toilet  response:  {       thoughts : I go to the bathroom. I locate the toilet. I walk to the toilet.,       actions : ['[WALK] <bathroom>', '[WALK] <toilet>', '[FIND] <toilet>', '[WALK] <toilet>']  }     Scene_Objects:['sheets', 'tablelamp', 'toilet', 'walllamp', 'bathroom', 'trashcan', 'wallshelf', 'clothes_underwear', 'floor', 'desk', 'mail', 'button', 'stovefan', 'toaster', 'mousepad', 'soap', 'pillow', 'dining_room', 'photoframe', 'television', 'doorjamb', 'towel_rack', 'mouse', 'dresser', 'controller', 'bathtub', 'bathroom_cabinet', 'colander', 'clothes_shirt', 'coffee']  Task:Pet cat  response:

{  Find a cat in the kitchen and touch 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:['dry_pasta', 'pot', 'measuring_cup', 'microwave', 'chair', 'orchid', 'floor', 'ceiling', 'phone', 'desk', 'bedroom', 'cleaning_solution', 'keyboard', 'mop_bucket', 'stovefan', 'faucet', 'couch', 'clothes_pants', 'coffe_maker', 'mirror', 'curtain', 'rag', 'coffee_pot', 'towel_rack', 'kitchen_counter', 'dresser', 'cupboard', 'door', 'sink', 'dishwasher']  Task:Clean mirror  response:  {       thoughts : Spray the mirror with a cleaner, take a dry rag and wipe the mirror down until its clean.,       actions : ['[WALK] <bathroom>', '[WALK] <cleaning_solution>', '[FIND] <cleaning_solution>', '[GRAB] <cleaning_solution>', '[FIND] <rag>', '[GRAB] <rag>', '[POUR] <cleaning_solution> <rag>', '[PUTOBJBACK] <cleaning_solution>', '[WALK] <mirror>', '[WIPE] <mirror>', '[PUTOBJBACK] <rag>']  }     Scene_Objects:['sheets', 'jelly', 'freezer', 'ground_coffee', 'walllamp', 'trashcan', 'floor', 'ceiling', 'bookshelf', 'computer', 'toaster', 'stovefan', 'mat', 'mousepad', 'couch', 'clothes_hat', 'dining_room', 'wall', 'nightstand', 'cup', 'light_bulb', 'coffe_maker', 'coffee_filter', 'water', 'coffee_pot', 'kitchen_counter', 'cupboard', 'laundry_detergent', 'sink', 'dishwasher']  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:['fork', 'chair', 'walllamp', 'milk', 'drawing', 'wallshelf', 'hanger', 'floor', 'ceiling', 'desk', 'remote_control', 'computer', 'mat', 'tvstand', 'ceilinglamp', 'faucet', 'closetdrawer', 'couch', 'candle', 'pillow', 'wall', 'cup', 'photoframe', 'television', 'curtain', 'doorjamb', 'mouse', 'dresser', 'bathroom_cabinet', 'teeth']  Task:Watch TV  response:  {       thoughts : SIT ON THE COUCH, TURN TV ON WITH REMOTE, FIND A SHOW,       actions : ['[WALK] <home_office>', '[WALK] <remote_control>', '[FIND] <remote_control>', '[GRAB] <remote_control>', '[FIND] <couch>', '[SIT] <couch>', '[FIND] <television>', '[SWITCHON] <television>', '[PUTBACK] <remote_control> <couch>', '[TURNTO] <television>', '[WATCH] <television>']  }     Scene_Objects:['dry_pasta', 'sheets', 'ground_coffee', 'walllamp', 'trashcan', 'drawing', 'orchid', 'needle', 'hanger', 'floor', 'ceiling', 'desk', 'computer', 'toaster', 'ceilinglamp', 'couch', 'pillow', 'wall', 'nightstand', 'check', 'food_food', 'television', 'food_onion', 'doorjamb', 'pencil', 'door', 'home_office', 'table', 'light', 'coffee']  Task:Relax on sofa  response:

{  Walk to the living room. Walk to the sofa and sit on the sofa. }


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', 'ground_coffee', 'trashcan', 'drawing', 'bathroom_counter', 'floor', 'shampoo', 'character', 'computer', 'ceilinglamp', 'mat', 'iron', 'plate', 'window', 'couch', 'dining_room', 'wall', 'powersocket', 'basket_for_clothes', 'photoframe', 'newspaper', 'video_game_controller', 'television', 'centerpiece', 'doorjamb', 'towel_rack', 'door', 'bathroom_cabinet', 'table']  Task:Read book  response:  {       thoughts : Sit on a couch, grab a book, open it, and scan the pages,       actions : ['[WALK] <home_office>', '[WALK] <novel>', '[FIND] <novel>', '[GRAB] <novel>', '[WALK] <couch>', '[SIT] <couch>', '[TURNTO] <novel>', '[LOOKAT] <novel>', '[READ] <novel>', '[READ] <novel>', '[READ] <novel>']  }     Scene_Objects:['pot', 'filing_cabinet', 'crayon', 'microwave', 'walllamp', 'dough', 'knifeblock', 'wallshelf', 'floor', 'phone', 'shampoo', 'desk', 'keyboard', 'bookmark', 'mat', 'shoe-shine_kit', 'floor_lamp', 'mousepad', 'pillow', 'powersocket', 'novel', 'curtain', 'centerpiece', 'kitchen_counter', 'door', 'bathtub', 'home_office', 'table', 'clothes_skirt', 'colander']  Task:Read book  response:

{  Turn a light on and read a book in the bedroom. }


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', 'freezer', 'detergent', 'knifeblock', 'phone', 'bookshelf', 'computer', 'mop_bucket', 'brush', 'clothes_socks', 'mousepad', 'dining_room', 'nightstand', 'basket_for_clothes', 'food_food', 'curtain', 'doorjamb', 'towel_rack', 'mouse', 'kitchen_counter', 'dresser', 'laundry_detergent', 'bathtub', 'sink', 'home_office', 'napkin', 'dishwasher', 'bathroom_cabinet', 'washing_machine']  Task:Wash clothes  response:  {       thoughts :  I walk to entrance hall   I walk to bedroom   I find basket of clothes   I lift basket of  clothes   I walk to kitchen   I find washing machine   I open washing machine    I put laundry in washing machine   I add laundry detergent     I close washing machine lid   I switch washing machine on ,       actions : ['[WALK] <home_office>', '[WALK] <bedroom>', '[WALK] <basket_for_clothes>', '[FIND] <basket_for_clothes>', '[GRAB] <basket_for_clothes>', '[WALK] <dining_room>', '[WALK] <washing_machine>', '[FIND] <washing_machine>', '[OPEN] <washing_machine>', '[PUTBACK] <basket_for_clothes> <washing_machine>', '[FIND] <laundry_detergent>', '[GRAB] <laundry_detergent>', '[PUTBACK] <laundry_detergent> <washing_machine>', '[CLOSE] <washing_machine>', '[TURNTO] <washing_machine>']  }     Scene_Objects:['walllamp', 'bathroom', 'orchid', 'drawing', 'wallshelf', 'floor', 'ceiling', 'bookshelf', 'alcohol', 'stovefan', 'mat', 'tvstand', 'ceilinglamp', 'shower', 'window', 'couch', 'pillow', 'dining_room', 'wall', 'powersocket', 'bench', 'photoframe', 'food_food', 'television', 'curtain', 'doorjamb', 'door', 'sink', 'light', 'table']  Task:Watch TV  response:

{  walk to living room, find the television, switch on the television, find the sofa, walk to sofa, sit in sofa, watch 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:['filing_cabinet', 'tablelamp', 'dog', 'freezer', 'orchid', 'drawing', 'wallshelf', 'ceiling', 'character', 'mail', 'clothes_jacket', 'computer', 'mat', 'faucet', 'window', 'closetdrawer', 'nightstand', 'wall_clock', 'oven', 'basket_for_clothes', 'coffe_maker', 'mouse', 'dresser', 'cupboard', 'laundry_detergent', 'sink', 'bathroom_cabinet', 'light', 'scrabble', 'washing_machine']  Task:Wash clothes  response:  {       thoughts : Pick up my dirty clothes, load the washer, add detergent, turn on washer,       actions : ['[WALK] <bedroom>', '[WALK] <basket_for_clothes>', '[GRAB] <basket_for_clothes>', '[WALK] <home_office>', '[WALK] <washing_machine>', '[OPEN] <washing_machine>', '[PUTBACK] <basket_for_clothes> <washing_machine>', '[FIND] <laundry_detergent>', '[GRAB] <laundry_detergent>', '[PUTBACK] <laundry_detergent> <washing_machine>', '[RUN] <washing_machine>']  }     Scene_Objects:['sponge', 'toilet', 'orchid', 'drawing', 'ceiling', 'bedroom', 'computer', 'mat', 'shoe-shine_kit', 'stereo', 'ceilinglamp', 'window', 'tvstand', 'food_orange', 'nightstand', 'bench', 'bed', 'coffe_maker', 'food_food', 'television', 'doorjamb', 'mouse', 'pencil', 'dresser', 'pajamas', 'cupboard', 'bathtub', 'table', 'clothes_shirt', 'coffee']  Task:Listen to music  response:

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


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', 'walllamp', 'bathroom', 'food_carrot', 'toothbrush', 'orchid', 'knife', 'longboard', 'character', 'bedroom', 'computer', 'faucet', 'homework', 'clothes_socks', 'food_noodles', 'dining_room', 'photoframe', 'check', 'television', 'after_shave', 'rag', 'lighter', 'towel_rack', 'kitchen_counter', 'dresser', 'clothes_dress', 'home_office', 'light', 'laser_pointer', 'scrabble']  Task:Pick up phone  response:  {       thoughts : I walk to the home office. I find the telephone. I pick up the telephone handset.,       actions : ['[WALK] <home_office>', '[WALK] <phone>', '[FIND] <phone>', '[GRAB] <phone>']  }     Scene_Objects:['pot', 'toilet', 'chair', 'walllamp', 'knifeblock', 'drawing', 'floor', 'phone', 'keyboard', 'toaster', 'stovefan', 'plate', 'shower', 'tvstand', 'dish_soap', 'couch', 'wall', 'coffe_maker', 'video_game_controller', 'food_onion', 'rag', 'towel_rack', 'mouse', 'kettle', 'kitchen_counter', 'cupboard', 'door', 'sink', 'spoon', '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:['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:  {       thoughts : Enter the Home office, then walk to the phone, pickup the phone.,       actions : ['[WALK] <home_office>', '[WALK] <phone>', '[GRAB] <phone>']  }     Scene_Objects:['filing_cabinet', 'tablelamp', 'mop', 'walllamp', 'detergent', 'orchid', 'cpuscreen', 'floor', 'ceiling', 'character', 'toaster', 'stereo', 'window', 'wall', 'bed', 'novel', 'coffe_maker', 'coffee_filter', 'water', 'kitchen_counter', 'shoes', 'dresser', 'cupboard', 'sink', 'bathtub', 'spoon', 'light', 'dishwasher', 'table', '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:['filing_cabinet', 'food_ice_cream', 'chair', 'nail_polish', 'bathroom', 'cat', 'dough', 'toothbrush', 'desk', 'button', 'stovefan', 'shower', 'faucet', 'window', 'pillow', 'nightstand', 'wall_clock', 'oven', 'cutting_board', 'novel', 'check', 'television', 'toothbrush_holder', 'lighter', 'kettle', 'chessboard', 'dresser', 'sink', 'home_office', 'clothes_skirt']  Task:Keep cats out of room  response:  {       thoughts : Stand in the doorway and create a loud noise so the cats will stay out.,       actions : ['[WALK] <bedroom>', '[WALK] <cat>', '[FIND] <cat>', '[TURNTO] <cat>', '[LOOKAT] <cat>', '[FIND] <cat>', '[TURNTO] <cat>', '[LOOKAT] <cat>']  }     Scene_Objects:['spectacles', 'juice', 'food_salt', 'chair', 'freezer', 'ground_coffee', 'blow_dryer', 'nail_polish', 'food_egg', 'wallshelf', 'floor', 'ceiling', 'character', 'keyboard', 'computer', 'mop_bucket', 'toaster', 'ceilinglamp', 'clothes_hat', 'wall', 'food_food', 'food_donut', 'tray', 'towel_rack', 'mouse', 'kitchen_counter', 'dresser', 'cupboard', 'sink', 'laser_pointer']  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:['filing_cabinet', 'chair', 'freezer', 'walllamp', 'cpuscreen', 'bathroom_counter', 'floor', 'ceiling', 'desk', 'keyboard', 'computer', 'ceilinglamp', 'tvstand', 'mousepad', 'closetdrawer', 'pillow', 'dining_room', 'wall', 'wall_clock', 'powersocket', 'photoframe', 'coffe_maker', 'television', 'doorjamb', 'centerpiece', 'mouse', 'cupboard', 'sink', 'bathroom_cabinet', 'table']  Task:Browse internet  response:  {       thoughts : Go find a computer, turn it on, click google, and browse the internet.,       actions : ['[WALK] <home_office>', '[WALK] <computer>', '[FIND] <computer>', '[SWITCHON] <computer>', '[TURNTO] <computer>', '[LOOKAT] <computer>']  }     Scene_Objects:['pot', 'microwave', 'freezer', 'walllamp', 'bathroom', 'trashcan', 'knifeblock', 'wallshelf', 'floor', 'ceiling', 'phone', 'bedroom', 'bookshelf', 'food_bacon', 'mat', 'plate', 'faucet', 'shower', 'wall', 'nightstand', 'oven', 'toy', 'wooden_spoon', 'tray', 'kitchen_counter', 'cupboard', 'sink', 'spoon', 'bathroom_cabinet', 'bathtub']  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:['sheets', 'microwave', 'chair', 'bathroom', 'orchid', 'food_egg', 'cpuscreen', 'floor', 'phone', 'bedroom', 'desk', 'stovefan', 'toaster', 'ceilinglamp', 'shower', 'mat', 'food_peanut_butter', 'wall', 'pasta', 'powersocket', 'oven', 'cup', 'bed', 'after_shave', 'food_onion', 'chessboard', 'dresser', 'cupboard', 'clothes_scarf', 'home_office']  Task:Pet cat  response:  {       thoughts : I walk to my living room, find my cat, scrub it using my hand.,       actions : ['[WALK] <home_office>', '[WALK] <cat>', '[FIND] <cat>', '[SCRUB] <cat>']  }     Scene_Objects:['pot', 'microwave', 'walllamp', 'trashcan', 'knifeblock', 'wallshelf', 'floor', 'ceiling', 'stovefan', 'faucet', 'food_jam', 'wall', 'nightstand', 'oven', 'cup', 'photoframe', 'light_bulb', 'bed', 'clothes_gloves', 'television', 'water', 'tray', 'lighter', 'towel_rack', 'kitchen_counter', 'cupboard', 'sink', 'bathroom_cabinet', 'table', 'colander']  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', 'chair', 'freezer', 'bathroom', 'orchid', 'floor', 'ceiling', 'character', 'bedroom', 'computer', 'toaster', 'stovefan', 'ceilinglamp', 'picture', 'tooth_paste', 'couch', 'pillow', 'wall', 'nightstand', 'food_food', 'check', 'television', 'tray', 'doorjamb', 'mouse', 'kitchen_counter', 'cupboard', 'home_office', 'bathroom_cabinet', 'board_game']  Task:Put groceries in Fridge  response:  {       thoughts : Walk to the kitchen. Open the fridge, take the groceries and put in it. Closed 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:['tablelamp', 'scissors', 'microwave', 'toilet', 'trashcan', 'drawing', 'orchid', 'cpuscreen', 'floor', 'ceiling', 'character', 'food_cake', 'food_bacon', 'table_cloth', 'bookmark', 'ceilinglamp', 'tvstand', 'faucet', 'couch', 'pillow', 'bowl', 'dining_room', 'wall', 'coffe_maker', 'doorjamb', 'door', 'home_office', 'table', 'light', 'dishwasher']  Task:Relax on sofa  response:

{  go to the living room,find the sofa,sat down in the sofa,take some relaxation. }


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', 'drawing', 'orchid', 'cpuscreen', 'floor', 'ceiling', 'phone', 'desk', 'keyboard', 'bookshelf', 'purse', 'computer', 'stovefan', 'ceilinglamp', 'toaster', 'shower', 'wall', 'powersocket', 'bench', 'cup', 'coffe_maker', 'tray', 'doorjamb', 'kitchen_counter', 'door', 'sink', 'bathroom_cabinet', 'light', 'home_office']  Task:Turn off light  response:  {       thoughts : Grasp light switch, flip light switch.,       actions : ['[WALK] <bedroom>', '[WALK] <light>', '[FIND] <light>', '[TURNTO] <light>', '[SWITCHOFF] <light>']  }     Scene_Objects:['sheets', 'filing_cabinet', 'measuring_cup', 'chair', 'walllamp', 'bathroom', 'drawing', 'ceiling', 'phone', 'desk', 'bedroom', 'keyboard', 'bookshelf', 'food_cake', 'toaster', 'shower', 'picture', 'electric_shaver', 'window', 'nightstand', 'basket_for_clothes', 'bed', 'food_food', 'curtain', 'doorjamb', 'cupboard', 'napkin', 'instrument_guitar', 'bathroom_cabinet', 'light']  Task:Pet cat  response:

{  Walk into the living room, sit down by the cat, put out hand, stroke the cat from head to tail }


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:['pot', 'filing_cabinet', 'tablelamp', 'microwave', 'band-aids', 'walllamp', 'blow_dryer', 'detergent', 'bathroom', 'orchid', 'knifeblock', 'wallshelf', 'floor', 'bookshelf', 'stovefan', 'tvstand', 'faucet', 'stereo', 'pillow', 'dining_room', 'wall', 'nightstand', 'oven', 'clothes_gloves', 'water', 'kitchen_counter', 'cupboard', 'laundry_detergent', 'sink', 'napkin']  Task:Drink  response:

{  Walk to kitchen, grab a glass, walk to sink, turn on tap and pour water into glass, drink from glass. }


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', 'walllamp', 'drawing', 'cpuscreen', 'character', 'desk', 'keyboard', 'bookshelf', 'computer', 'button', 'alcohol', 'laptop', 'plate', 'faucet', 'homework', 'mousepad', 'dining_room', 'check', 'food_food', 'television', 'tray', 'wooden_spoon', 'mouse', 'shoes', 'conditioner', 'maindoor', 'napkin', 'home_office', 'soap', 'instrument_violin']  Task:Browse internet  response:  {       thoughts : I turn on computer. I use keyboard to type. I open browser. I search.,       actions : ['[WALK] <bedroom>', '[WALK] <computer>', '[FIND] <keyboard>', '[TYPE] <keyboard>', '[TURNTO] <computer>', '[LOOKAT] <computer>']  }     Scene_Objects:['walllamp', 'drawing', 'orchid', 'wallshelf', 'floor', 'ceiling', 'phone', 'bookshelf', 'remote_control', 'mat', 'tvstand', 'ceilinglamp', 'shower', 'window', 'couch', 'pillow', 'wall', 'powersocket', 'photoframe', 'coffee_table', 'television', 'wooden_spoon', 'curtain', 'doorjamb', 'centerpiece', 'door', 'bathroom_cabinet', 'table', 'light', 'board_game']  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:['food_ice_cream', 'microwave', 'toilet', 'freezer', 'trashcan', 'drawing', 'knife', 'wallshelf', 'kitchen_cabinet', 'floor', 'ceiling', 'character', 'ceilinglamp', 'mat', 'shower', 'food_jam', 'dining_room', 'wall', 'bench', 'cutting_board', 'food_vegetable', 'photoframe', 'television', 'doorjamb', 'kitchen_counter', 'cupboard', 'door', 'bathtub', 'table', 'light']  Task:Chop vegetables  response:  {       thoughts : Cut up veggies with knife,       actions : ['[WALK] <dining_room>', '[WALK] <kitchen_cabinet>', '[FIND] <kitchen_cabinet>', '[OPEN] <kitchen_cabinet>', '[FIND] <knife>', '[GRAB] <knife>', '[FIND] <cutting_board>', '[GRAB] <cutting_board>', '[CLOSE] <kitchen_cabinet>', '[WALK] <table>', '[PUTBACK] <knife> <table>', '[PUTBACK] <cutting_board> <table>', '[WALK] <freezer>', '[OPEN] <freezer>', '[FIND] <food_vegetable>', '[GRAB] <food_vegetable>', '[CLOSE] <freezer>', '[WALK] <table>', '[PUTBACK] <food_vegetable> <cutting_board>', '[GRAB] <knife>', '[CUT] <food_vegetable>', '[PUTOBJBACK] <knife>']  }     Scene_Objects:['scissors', 'tablelamp', 'chair', 'walllamp', 'trashcan', 'drawing', 'knifeblock', 'wallshelf', 'cpuscreen', 'bathroom_counter', 'floor', 'desk', 'computer', 'faucet', 'foundation', 'couch', 'wall', 'cup', 'coffe_maker', 'razor', 'tray', 'wooden_spoon', 'towel_rack', 'cupboard', 'laundry_detergent', 'sink', 'bathtub', 'bathroom_cabinet', 'dishwasher', 'hands_both']  Task:Wash hands  response:

{  Going to the sink and scrubbing hands }


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', 'walllamp', 'ground_coffee', 'drawing', 'orchid', 'wallshelf', 'floor', 'ceiling', 'phone', 'bookshelf', 'remote_control', 'mat', 'tvstand', 'ceilinglamp', 'shower', 'window', 'couch', 'pillow', 'wall', 'powersocket', 'oven', 'photoframe', 'television', 'curtain', 'doorjamb', 'towel_rack', 'pencil', 'door', 'table', 'light']  Task:Watch TV  response:  {       thoughts : walk to living room, find couch, sit on couch, find remote control , turn on tv by pressing button,       actions : ['[WALK] <home_office>', '[WALK] <couch>', '[FIND] <couch>', '[SIT] <couch>', '[FIND] <remote_control>', '[FIND] <television>', '[TURNTO] <television>']  }     Scene_Objects:['water_glass', 'pot', 'microwave', 'toilet', 'band-aids', 'walllamp', 'trashcan', 'knifeblock', 'drawing', 'ceiling', 'desk', 'stovefan', 'faucet', 'mousepad', 'wall', 'nightstand', 'oven', 'check', 'food_food', 'water', 'tray', 'doorjamb', 'kitchen_counter', 'cd', 'cupboard', 'laundry_detergent', 'sink', 'bathroom_cabinet', 'soap', 'laser_pointer']  Task:Drink  response:

{  I walk to the kitchen. open the cupboard. Find the water glass, grab it. Fill the glass with water 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:['microwave', 'chair', 'hanger', 'bathroom_counter', 'character', 'keyboard', 'bookshelf', 'computer', 'stovefan', 'plate', 'tvstand', 'faucet', 'shower', 'dish_soap', 'mousepad', 'wall', 'wall_clock', 'oven', 'photoframe', 'bed', 'television', 'tray', 'towel_rack', 'dresser', 'door', 'sink', 'bathroom_cabinet', 'table', 'dishwasher', 'dirt']  Task:Wash dishes with dishwasher  response:  {       thoughts : walk into kitchen, find dishwasher, put plates in dishwasher, put soap in dishwasher, turn on dishwasher,       actions : ['[WALK] <dining_room>', '[WALK] <dishwasher>', '[FIND] <dishwasher>', '[OPEN] <dishwasher>', '[FIND] <dish_soap>', '[GRAB] <dish_soap>', '[PUTBACK] <dish_soap> <dishwasher>', '[FIND] <plate>', '[GRAB] <plate>', '[PUTBACK] <plate> <dishwasher>', '[FIND] <plate>', '[GRAB] <plate>', '[PUTBACK] <plate> <dishwasher>', '[CLOSE] <dishwasher>', '[SWITCHON] <dishwasher>']  }     Scene_Objects:['walllamp', 'bathroom', 'drawing', 'orchid', 'wallshelf', 'floor', 'ceiling', 'bookshelf', 'remote_control', 'stovefan', 'mat', 'tvstand', 'ceilinglamp', 'shower', 'window', 'foundation', 'couch', 'food_orange', 'pillow', 'wall', 'powersocket', 'photoframe', 'television', 'curtain', 'doorjamb', 'console', 'door', 'home_office', 'table', 'light']  Task:Relax on sofa  response:

{  Go into the living room. Walk over to the sofa. Lie down on the sofa. Turn on and watch TV. }


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:['spectacles', 'sheets', 'drawing', 'cpuscreen', 'ceiling', 'desk', 'bookmark', 'mat', 'plate', 'stereo', 'deck_of_cards', 'mousepad', 'couch', 'clothes_hat', 'clothes_pants', 'bench', 'clothes_gloves', 'video_game_controller', 'curtain', 'towel_rack', 'cd', 'dishrack', 'chessboard', 'pajamas', 'laundry_detergent', 'maindoor', 'door', 'sink', 'bathroom_cabinet', 'clothes_shirt']  Task:Listen to music  response:  {       thoughts : Find the radio; switch on the radio and listen to music.,       actions : ['[WALK] <home_office>', '[WALK] <stereo>', '[FIND] <stereo>', '[SWITCHON] <stereo>']  }     Scene_Objects:['pot', 'walllamp', 'cat', 'knifeblock', 'cpuscreen', 'floor', 'ceiling', 'character', 'bedroom', 'alcohol', 'button', 'toaster', 'ceilinglamp', 'tvstand', 'couch', 'food_orange', 'wall', 'photoframe', 'coffe_maker', 'check', 'curtain', 'doorjamb', 'shaving_cream', 'kitchen_counter', 'cupboard', 'sink', 'coffee_cup', 'dishwasher', 'table', '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:['pot', 'tablelamp', 'cat', 'ceilingfan', 'drawing', 'bathroom_counter', 'floor', 'ceiling', 'folder', 'character', 'keyboard', 'remote_control', 'button', 'table_cloth', 'toaster', 'ceilinglamp', 'tvstand', 'balanceball', 'window', 'oil', 'couch', 'pillow', 'wall', 'check', 'television', 'curtain', 'door', 'home_office', 'table', 'bathroom_cabinet']  Task:Change TV channel  response:  {       thoughts : Pickup remote control for the living room TV and push the change channel button,       actions : ['[WALK] <home_office>', '[WALK] <couch>', '[FIND] <couch>', '[SIT] <couch>', '[FIND] <remote_control>', '[GRAB] <remote_control>', '[FIND] <button>', '[PUSH] <button>', '[FIND] <television>', '[TURNTO] <television>', '[WATCH] <television>']  }     Scene_Objects:['toilet', 'chair', 'ground_coffee', 'floor', 'ceiling', 'tea_bag', 'keyboard', 'table_cloth', 'ceilinglamp', 'stereo', 'faucet', 'mousepad', 'couch', 'candle', 'dustpan', 'pillow', 'dining_room', 'wall', 'powersocket', 'cup', 'photoframe', 'tray', 'curtain', 'door', 'bathtub', 'sink', 'light', 'table', 'dishwasher', 'shoe_rack']  Task:Listen to music  response:

{  I walk into my room and turn the radio on so that I can listen to music. }