Input: You serve as an AI task planner.   1. Your task is to create a plan to achieve a goal by converting it into a sequence of actions. Each action should follow the format  [verb] <target1> <target2> , where 'verb' represents the action, and 'target1' and 'target2' are optional arguments.  2. You must describe your plan in natural language at the beginning. After that, you should list all the actions together.   Ensure that you response can be parsed by Python json.loads.      Here is an example plan to achieve a goal for reference:   Scene_Objects:['food_salt', 'microwave', 'trashcan', 'drawing', 'floor', 'dvd_player', 'desk', 'envelope', 'ceilinglamp', 'tvstand', 'mat', 'window', 'mousepad', 'couch', 'pillow', 'dining_room', 'broom', 'wall', 'nightstand', 'cup', 'check', 'television', 'coin', 'colander', 'after_shave', 'cd', 'cupboard', 'table', 'vase', 'soap']  Task:Relax on sofa  response:  {       thoughts : Go to the living room. Find the sofa. Sit on the sofa. Close your eyes. Breath calmly. Relax,       actions : ['[WALK] <home_office>', '[WALK] <couch>', '[FIND] <couch>', '[SIT] <couch>']  }     Scene_Objects:['filing_cabinet', 'juice', 'cat', 'food_butter', 'orchid', 'hanger', 'floor', 'shampoo', 'phone', 'mat', 'shower', 'electric_shaver', 'dustpan', 'microphone', 'towel', 'pillow', 'dining_room', 'wall', 'bench', 'tape', 'food_cheese', 'check', 'wine', 'curtain', 'vacuum_cleaner', 'dresser', 'sink', 'napkin', 'bathroom_cabinet', 'vase']  Task:Read book  response:

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


Input: You serve as an AI task planner.   1. Your task is to create a plan to achieve a goal by converting it into a sequence of actions. Each action should follow the format  [verb] <target1> <target2> , where 'verb' represents the action, and 'target1' and 'target2' are optional arguments.  2. You must describe your plan in natural language at the beginning. After that, you should list all the actions together.   Ensure that you response can be parsed by Python json.loads.      Here is an example plan to achieve a goal for reference:   Scene_Objects:['drawing', 'bills', 'bathroom_counter', 'floor', 'ceiling', 'character', 'computer', 'toaster', 'ceilinglamp', 'window', 'food_noodles', 'couch', 'microphone', 'pillow', 'wall', 'newspaper', 'novel', 'coffe_maker', 'television', 'coin', 'toothbrush_holder', 'shoes', 'dresser', 'cupboard', 'laundry_detergent', 'bathroom_cabinet', 'table', 'vase', 'laser_pointer', 'creditcard']  Task:Read book  response:  {       thoughts : Sit on couch. Grab book. Open book. Read book.,       actions : ['[WALK] <couch>', '[SIT] <couch>', '[FIND] <novel>', '[GRAB] <novel>', '[READ] <novel>']  }     Scene_Objects:['sheets', 'filing_cabinet', 'chair', 'freezer', 'ground_coffee', 'ceilingfan', 'drawing', 'needle', 'floor', 'ceiling', 'bookshelf', 'remote_control', 'computer', 'food_bacon', 'ceilinglamp', 'tvstand', 'balanceball', 'window', 'couch', 'clothes_pants', 'wall', 'toy', 'food_food', 'television', 'oven_mitts', 'curtain', 'diary', 'headset', 'home_office', 'table']  Task:Change TV channel  response:

{  I go in the living room. Then I find the remote, sit on the couch and turn on the television. Then I use the remote the change the TV channel. }


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', 'pot', 'filing_cabinet', 'microwave', 'chair', 'cpuscreen', 'hanger', 'bathroom_counter', 'floor', 'ceiling', 'face', 'toaster', 'stovefan', 'faucet', 'oil', 'towel', 'wall', 'facial_cleanser', 'check', 'coffe_maker', 'tray', 'rag', 'mouse', 'kitchen_counter', 'dresser', 'door', 'sink', 'bathroom_cabinet', 'table', 'soap']  Task:Wash face  response:  {       thoughts : Turn the faucet on. Wet the face. Take facial cleanser out of packaging. Lather on face. Rinse face with water. Turn off the faucet. Dry face with towel.,       actions : ['[WALK] <bathroom>', '[WALK] <sink>', '[FIND] <faucet>', '[SWITCHON] <faucet>', '[FIND] <face>', '[WASH] <face>', '[FIND] <rag>', '[GRAB] <rag>', '[RINSE] <rag>', '[FIND] <facial_cleanser>', '[GRAB] <facial_cleanser>', '[POUR] <facial_cleanser> <rag>', '[PUTOBJBACK] <facial_cleanser>', '[SCRUB] <face>', '[RINSE] <rag>', '[PUTOBJBACK] <rag>', '[RINSE] <face>', '[SWITCHOFF] <faucet>', '[FIND] <towel>', '[GRAB] <towel>', '[WIPE] <face>', '[PUTOBJBACK] <towel>']  }     Scene_Objects:['chair', 'freezer', 'detergent', 'food_butter', 'trashcan', 'hanger', 'floor', 'phone', 'ceiling', 'bedroom', 'computer', 'button', 'mat', 'laptop', 'plate', 'window', 'wall', 'nightstand', 'bed', 'check', 'curtain', 'doorjamb', 'dresser', 'cupboard', 'controller', 'door', 'light', 'dishwasher', 'laser_pointer', 'shoe_rack']  Task:Pick up phone  response:

{  first i will go to home office and switch on the lights and answer the call after then i will put back it and switch off the lights and close the door }


Input: You serve as an AI task planner.   1. Your task is to create a plan to achieve a goal by converting it into a sequence of actions. Each action should follow the format  [verb] <target1> <target2> , where 'verb' represents the action, and 'target1' and 'target2' are optional arguments.  2. You must describe your plan in natural language at the beginning. After that, you should list all the actions together.   Ensure that you response can be parsed by Python json.loads.      Here is an example plan to achieve a goal for reference:   Scene_Objects:['sponge', 'toilet', 'chair', 'freezer', 'band-aids', 'walllamp', 'cat', 'drawing', 'orchid', 'floor', 'ceiling', 'phone', 'bedroom', 'ceilinglamp', 'tvstand', 'clothes_socks', 'couch', 'pillow', 'dining_room', 'wall', 'bench', 'clothes_gloves', 'novel', 'tray', 'doorjamb', 'kitchen_counter', 'door', 'table', 'light', 'dishwasher']  Task:Pet cat  response:  {       thoughts : walk to entrance hall, look at the sofa, sit on the sofa, look at the cat, allow cat to near with you, touch the cat smoothly on it head, now pet the cat smoothly,       actions : ['[WALK] <home_office>', '[WALK] <couch>', '[FIND] <couch>', '[TURNTO] <couch>', '[LOOKAT] <couch>', '[SIT] <couch>', '[FIND] <cat>', '[TURNTO] <cat>', '[LOOKAT] <cat>', '[TOUCH] <cat>']  }     Scene_Objects:['food_bread', 'scissors', 'mop', 'chair', 'ceilingfan', 'milk', 'toothbrush', 'knifeblock', 'phone', 'bookshelf', 'stovefan', 'toaster', 'tvstand', 'shower', 'couch', 'food_peanut_butter', 'dustpan', 'oven', 'photoframe', 'clothes_gloves', 'bed', 'video_game_controller', 'tray', 'towel_rack', 'clothes_scarf', 'table', 'light', 'soap', 'tooth_paste', 'scrabble']  Task:Wash teeth  response:

{  before going to bed or when wake up earily morning brush teeth }


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', 'freezer', 'bathroom', 'food_carrot', 'drawing', 'orchid', 'wallshelf', 'food_egg', 'bathroom_counter', 'shampoo', 'phone', 'mat', 'ceilinglamp', 'shower', 'electric_shaver', 'clothes_socks', 'couch', 'microphone', 'dining_room', 'food_kiwi', 'nightstand', 'wall', 'check', 'food_food', 'after_shave', 'mouse', 'kitchen_counter', 'cupboard', 'home_office', 'laser_pointer']  Task:Turn on light  response:  {       thoughts : I go home and it's dark so I can not see anything,       actions : ['[WALK] <home_office>', '[WALK] <floor_lamp>', '[FIND] <floor_lamp>', '[SWITCHON] <floor_lamp>']  }     Scene_Objects:['tablelamp', 'measuring_cup', 'toilet', 'drawing', 'bathroom_counter', 'floor', 'ceiling', 'longboard', 'button', 'ceilinglamp', 'faucet', 'oil', 'teeth', 'clothes_hat', 'towel', 'wall', 'photoframe', 'bed', 'doorjamb', 'diary', 'kitchen_counter', 'dishrack', 'coffee', 'hairbrush', 'maindoor', 'sink', 'bathroom_cabinet', 'vase', 'soap', 'hands_both']  Task:Wash hands  response:

{  Go to the bathroom. Turn on the sink. Rinse hands. Apply soap and scrub your hands together. Rinse hands again. Turn off faucet. Dry hands on a towel. }


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', 'filing_cabinet', 'blender', 'chair', 'freezer', 'walllamp', 'nail_polish', 'detergent', 'drawing', 'knife', 'wallshelf', 'bathroom_counter', 'floor', 'desk', 'computer', 'mat', 'ceilinglamp', 'plate', 'faucet', 'mousepad', 'candle', 'microphone', 'bowl', 'wall', 'nightstand', 'bench', 'bed', 'keys', 'food_food', 'table']  Task:Eat  response:  {       thoughts : I get my prepared dinner set on the dining table, sit down on chair, pick up utensils, eat food,       actions : ['[WALK] <dining_room>', '[WALK] <food_food>', '[FIND] <food_food>', '[GRAB] <food_food>', '[WALK] <dining_room>', '[WALK] <table>', '[FIND] <table>', '[PUTBACK] <food_food> <table>', '[FIND] <chair>', '[SIT] <chair>', '[FIND] <fork>', '[GRAB] <fork>', '[FIND] <knife>', '[GRAB] <knife>', '[FIND] <plate>', '[EAT] <plate>']  }     Scene_Objects:['blender', 'dog', 'band-aids', 'drawing', 'bathroom_counter', 'floor', 'longboard', 'bedroom', 'food_cake', 'computer', 'table_cloth', 'ceilinglamp', 'tvstand', 'faucet', 'mat', 'window', 'couch', 'dustpan', 'clothes_pants', 'bowl', 'wall', 'television', 'oven_mitts', 'after_shave', 'doorjamb', 'towel_rack', 'cards', 'shoes', 'home_office', 'table']  Task:Relax on sofa  response:

{  I walk into the living room. I bend down. I 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:['tablelamp', 'chair', 'walllamp', 'bathroom', 'orchid', 'cpuscreen', 'wallshelf', 'hanger', 'clothes_underwear', 'floor', 'ceiling', 'phone', 'desk', 'keyboard', 'computer', 'ceilinglamp', 'tvstand', 'mat', 'mousepad', 'couch', 'pillow', 'wall', 'nightstand', 'check', 'television', 'doorjamb', 'mouse', 'dresser', 'door', 'light']  Task:Research  response:  {       thoughts : I read different articles online to gain a better understanding of a particular business, industry, method, terminology, etc.,       actions : ['[WALK] <home_office>', '[WALK] <computer>', '[FIND] <computer>', '[SWITCHON] <computer>', '[TURNTO] <computer>', '[LOOKAT] <computer>', '[FIND] <check>', '[GRAB] <check>', '[READ] <check>']  }     Scene_Objects:['tablelamp', 'chair', 'freezer', 'nail_polish', 'trashcan', 'bills', 'drawing', 'hanger', 'bathroom_counter', 'character', 'bedroom', 'keyboard', 'computer', 'stereo', 'shower', 'form', 'dining_room', 'powersocket', 'oven', 'bench', 'cup', 'coffe_maker', 'mouthwash', 'television', 'coin', 'wooden_spoon', 'tray', 'doorjamb', 'mouse', 'bathroom_cabinet']  Task:Listen to music  response:

{  I reach out arm. I put hand on radio. I turn on radio. I pick a station. }


Input: You serve as an AI task planner.   1. Your task is to create a plan to achieve a goal by converting it into a sequence of actions. Each action should follow the format  [verb] <target1> <target2> , where 'verb' represents the action, and 'target1' and 'target2' are optional arguments.  2. You must describe your plan in natural language at the beginning. After that, you should list all the actions together.   Ensure that you response can be parsed by Python json.loads.      Here is an example plan to achieve a goal for reference:   Scene_Objects:['tablelamp', 'freezer', 'bathroom', 'drawing', 'knifeblock', 'cpuscreen', 'bathroom_counter', 'floor', 'ceiling', 'phone', 'bedroom', 'desk', 'bookshelf', 'shower', 'homework', 'wall', 'powersocket', 'box', 'bed', 'coffe_maker', 'television', 'after_shave', 'doorjamb', 'towel_rack', 'mouse', 'cards', 'cupboard', 'home_office', 'light', 'dishwasher']  Task:Turn on light  response:  {       thoughts : Walk into living room. Find wall. Find light button. Switch on light button.,       actions : ['[WALK] <home_office>', '[WALK] <light>', '[FIND] <light>', '[SWITCHON] <light>']  }     Scene_Objects:['pot', 'food_bread', 'food_ice_cream', 'toilet', 'chair', 'freezer', 'ceilingfan', 'drawing', 'longboard', 'floor', 'ceiling', 'remote_control', 'ceilinglamp', 'tvstand', 'balanceball', 'mat', 'window', 'oil', 'couch', 'wall', 'bench', 'mouthwash', 'television', 'curtain', 'shaving_cream', 'mouse', 'headset', 'bathroom_cabinet', 'table', 'light']  Task:Watch TV  response:

{  go to the living room. find the remote. sit on the couch. turn on the 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:['sheets', 'juice', 'microwave', 'freezer', 'bills', 'floor', 'ceiling', 'desk', 'tea_bag', 'computer', 'ceilinglamp', 'plate', 'window', 'mousepad', 'couch', 'dining_room', 'broom', 'wall', 'powersocket', 'novel', 'food_food', 'mouthwash', 'television', 'curtain', 'rag', 'towel_rack', 'kitchen_counter', 'comb', 'door', 'laser_pointer']  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:['food_pizza', 'filing_cabinet', 'tablelamp', 'chair', 'freezer', 'detergent', 'hanger', 'floor', 'ceiling', 'phone', 'purse', 'computer', 'mail', 'toaster', 'tvstand', 'mousepad', 'wall', 'check', 'ice', 'tray', 'doorjamb', 'towel_rack', 'coffee_pot', 'cards', 'dresser', 'cupboard', 'door', 'napkin', 'light', 'scrabble']  Task:Pick up phone  response:

{  I walk over to the phone. .I reach my arm out. I open my hand. I place my hand on the phone. I close my fingers around the phone. I pick up the phone. }


Input: You serve as an AI task planner.   1. Your task is to create a plan to achieve a goal by converting it into a sequence of actions. Each action should follow the format  [verb] <target1> <target2> , where 'verb' represents the action, and 'target1' and 'target2' are optional arguments.  2. You must describe your plan in natural language at the beginning. After that, you should list all the actions together.   Ensure that you response can be parsed by Python json.loads.      Here is an example plan to achieve a goal for reference:   Scene_Objects:['filing_cabinet', 'tablelamp', 'chair', 'ground_coffee', 'wallshelf', 'hanger', 'floor', 'stamp', 'desk', 'bookshelf', 'tea_bag', 'envelope', 'computer', 'mop_bucket', 'mat', 'shower', 'foundation', 'form', 'wall', 'powersocket', 'cutting_board', 'photoframe', 'novel', 'check', 'television', 'wooden_spoon', 'after_shave', 'doorjamb', 'door', 'light']  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:['pot', 'food_bread', 'freezer', 'food_butter', 'toothbrush', 'knifeblock', 'food_egg', 'cpuscreen', 'longboard', 'bathroom_counter', 'phone', 'ceiling', 'tea_bag', 'plate', 'shower', 'deck_of_cards', 'window', 'electric_shaver', 'dish_soap', 'broom', 'bench', 'powersocket', 'tape', 'mouthwash', 'centerpiece', 'shaving_cream', 'mouse', 'bathroom_cabinet', 'dishwasher', 'coffee']  Task:Wash dishes by hand  response:

{  Pick up dish.  Put in soapy water.  Wash dish. }


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', 'pot', 'blender', 'beer', 'microwave', 'knifeblock', 'cpuscreen', 'hanger', 'floor', 'ceiling', 'table_cloth', 'toaster', 'plate', 'faucet', 'tvstand', 'window', 'dish_soap', 'food_orange', 'wall', 'cup', 'bed', 'food_food', 'tray', 'wooden_spoon', 'mouse', 'pencil', 'kitchen_counter', 'dishrack', 'cupboard', 'sink']  Task:Wash dirty dishes  response:  {       thoughts : Wet the sponge, apply soap to sponge, scrub dishes, rinse dishes, place on dish rack.,       actions : ['[WALK] <dining_room>', '[WALK] <sink>', '[FIND] <sponge>', '[GRAB] <sponge>', '[FIND] <faucet>', '[SWITCHON] <faucet>', '[PUTBACK] <sponge> <sink>', '[GRAB] <sponge>', '[FIND] <dish_soap>', '[GRAB] <dish_soap>', '[POUR] <dish_soap> <sponge>', '[PUTOBJBACK] <dish_soap>', '[FIND] <plate>', '[GRAB] <plate>', '[SCRUB] <plate>', '[RINSE] <plate>', '[FIND] <dishrack>', '[PUTBACK] <plate> <dishrack>', '[FIND] <plate>', '[GRAB] <plate>', '[SCRUB] <plate>', '[RINSE] <plate>', '[PUTBACK] <plate> <dishrack>', '[RINSE] <sponge>', '[PUTOBJBACK] <sponge>', '[SWITCHOFF] <faucet>']  }     Scene_Objects:['tea', 'freezer', 'walllamp', 'knifeblock', 'kitchen_cabinet', 'floor', 'ceiling', 'dvd_player', 'desk', 'table_cloth', 'ceilinglamp', 'plate', 'mousepad', 'couch', 'candle', 'tape', 'light_bulb', 'novel', 'coin', 'water', 'drinking_glass', 'wine', 'tray', 'coffee_pot', 'mouse', 'cd', 'conditioner', 'maindoor', 'napkin', 'home_office']  Task:Drink  response:

{  You walk to the kitchen and open the kitchen cabinet and grab a drinking glass. You find the water and pour the water into the drinking glass. You drink the water from the 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:['filing_cabinet', 'tablelamp', 'dog', 'freezer', 'dough', 'knifeblock', 'knife', 'hanger', 'bathroom_counter', 'ceiling', 'toaster', 'tvstand', 'faucet', 'couch', 'pasta', 'powersocket', 'oven', 'photoframe', 'novel', 'television', 'wooden_spoon', 'curtain', 'coffee_pot', 'mouse', 'dresser', 'door', 'sink', 'home_office', 'light', 'bathroom_cabinet']  Task:Greet guests  response:  {       thoughts : Say hi,       actions : ['[WALK] <home_office>', '[WALK] <child>', '[FIND] <child>', '[GREET] <child>']  }     Scene_Objects:['sheets', 'scissors', 'mop', 'toilet', 'blow_dryer', 'detergent', 'drawing', 'cpuscreen', 'bathroom_counter', 'floor', 'ceiling', 'desk', 'keyboard', 'toaster', 'tvstand', 'shower', 'mousepad', 'pillow', 'wall', 'powersocket', 'oven', 'cup', 'photoframe', 'bed', 'food_onion', 'doorjamb', 'shaving_cream', 'mouse', 'kitchen_counter', 'bathroom_cabinet']  Task:Go to toilet  response:

{  I walk to bathroom, I open the door of the bathroom, and sit on the toilet. }


Input: You serve as an AI task planner.   1. Your task is to create a plan to achieve a goal by converting it into a sequence of actions. Each action should follow the format  [verb] <target1> <target2> , where 'verb' represents the action, and 'target1' and 'target2' are optional arguments.  2. You must describe your plan in natural language at the beginning. After that, you should list all the actions together.   Ensure that you response can be parsed by Python json.loads.      Here is an example plan to achieve a goal for reference:   Scene_Objects:['tablelamp', 'crayon', 'tea', 'mop', 'microwave', 'toilet', 'toothbrush', 'drawing', 'knifeblock', 'orchid', 'phone', 'ceiling', 'computer', 'stovefan', 'toaster', 'tvstand', 'window', 'floor_lamp', 'couch', 'clothes_hat', 'photoframe', 'after_shave', 'food_onion', 'headset', 'chessboard', 'cupboard', 'controller', 'door', 'bathroom_cabinet', 'clothes_skirt']  Task:Switch on lamp  response:  {       thoughts : Press the button so the light comes on.,       actions : ['[WALK] <bedroom>', '[WALK] <floor_lamp>', '[FIND] <floor_lamp>', '[SWITCHON] <floor_lamp>']  }     Scene_Objects:['sheets', 'pot', 'chair', 'freezer', 'food_carrot', 'cpuscreen', 'bathroom_counter', 'floor', 'ceiling', 'thread', 'mail', 'ceilinglamp', 'mat', 'iron', 'balanceball', 'faucet', 'food_orange', 'pillow', 'wall', 'pasta', 'box', 'cup', 'newspaper', 'food_food', 'check', 'toilet_paper', 'chessboard', 'maindoor', 'napkin', 'creditcard']  Task:Put groceries in Fridge  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_pizza', 'toilet', 'freezer', 'drawing', 'cpuscreen', 'floor', 'ceiling', 'envelope', 'table_cloth', 'stovefan', 'ceilinglamp', 'mat', 'shower', 'stereo', 'mousepad', 'towel', 'wall', 'powersocket', 'photoframe', 'bed', 'toilet_paper', 'tray', 'curtain', 'doorjamb', 'dresser', 'controller', 'door', 'food_steak', 'light', 'tooth_paste']  Task:Take shower  response:  {       thoughts : walk to bathroom , find shower , take a shower,       actions : ['[WALK] <bathroom>', '[WALK] <shower>', '[FIND] <shower>']  }     Scene_Objects:['filing_cabinet', 'food_salt', 'chair', 'blow_dryer', 'bathroom', 'drawing', 'knifeblock', 'bathroom_counter', 'floor', 'shampoo', 'bookshelf', 'purse', 'keyboard', 'ceilinglamp', 'deck_of_cards', 'shower', 'window', 'couch', 'wall', 'powersocket', 'tape', 'photoframe', 'television', 'food_rice', 'after_shave', 'controller', 'conditioner', 'door', 'table', 'scrabble']  Task:Relax on sofa  response:

{  I walk into the living room and I 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:['filing_cabinet', 'food_pizza', 'tablelamp', 'food_ice_cream', 'crayon', 'shampoo', 'keyboard', 'mail', 'bookmark', 'stovefan', 'faucet', 'pillow', 'dining_room', 'broom', 'wall', 'love_seat', 'photoframe', 'novel', 'food_food', 'wine', 'tray', 'after_shave', 'shaving_cream', 'kettle', 'headset', 'pajamas', 'laundry_detergent', 'door', 'bathroom_cabinet', 'shoe_rack']  Task:Read book  response:  {       thoughts : Obtain a book from the book shelf. Sit in the easy chair.  Read the book.  Mark the stopping point with a bookmark.  Put the book back on the book shelf.,       actions : ['[WALK] <home_office>', '[WALK] <novel>', '[FIND] <novel>', '[GRAB] <novel>', '[FIND] <love_seat>', '[SIT] <love_seat>', '[READ] <novel>', '[FIND] <bookmark>', '[GRAB] <bookmark>', '[PUTBACK] <bookmark> <novel>', '[PUTOBJBACK] <novel>']  }     Scene_Objects:['sheets', 'filing_cabinet', 'beer', 'jelly', 'bathroom', 'ceilingfan', 'drawing', 'floor', 'ceiling', 'keyboard', 'clothes_jacket', 'table_cloth', 'toaster', 'ceilinglamp', 'tvstand', 'balanceball', 'window', 'homework', 'food_noodles', 'couch', 'wall', 'oven', 'basket_for_clothes', 'cup', 'television', 'curtain', 'conditioner', 'maindoor', 'table', 'vase']  Task:Watch TV  response:

{  Walk into the living room. Sit on the couch. Turn on 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:['food_ice_cream', 'measuring_cup', 'toilet', 'chair', 'drawing', 'food_egg', 'clothes_underwear', 'hanger', 'bathroom_counter', 'floor', 'ceiling', 'stamp', 'bookshelf', 'button', 'shoe-shine_kit', 'shower', 'window', 'broom', 'wall', 'wall_clock', 'powersocket', 'bench', 'standingmirror', 'novel', 'coin', 'doorjamb', 'door', 'light', 'table', 'creditcard']  Task:Read  response:  {       thoughts : We pick out a book from the bookshelf and read it.,       actions : ['[WALK] <novel>', '[WALK] <bookshelf>', '[FIND] <novel>', '[GRAB] <novel>', '[FIND] <chair>', '[SIT] <chair>', '[READ] <novel>']  }     Scene_Objects:['pot', 'food_pizza', 'tablelamp', 'food_salt', 'freezer', 'walllamp', 'trashcan', 'food_carrot', 'knifeblock', 'floor', 'ceiling', 'food_bacon', 'stovefan', 'ceilinglamp', 'toaster', 'mousepad', 'wall', 'nightstand', 'oven', 'toy', 'box', 'photoframe', 'keys', 'toothbrush_holder', 'tray', 'kitchen_counter', 'hair', 'door', 'sink', 'dishwasher']  Task:Cook some food  response:

{  go to the kitchen and cook some thing to eat }


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:['tablelamp', 'microwave', 'freezer', 'bathroom', 'cpuscreen', 'desk', 'tea_bag', 'alcohol', 'tvstand', 'oven', 'tape', 'cutting_board', 'cup', 'clothes_gloves', 'novel', 'toilet_paper', 'television', 'coffee_filter', 'wooden_spoon', 'mouse', 'cd', 'controller', 'maindoor', 'sink', 'home_office', 'light', 'dishwasher', 'soap', 'dirt', 'shoe_rack']  Task:Listen to music  response:

{  Walk into living room. Turn on radio. }


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', 'pot', 'toilet', 'chair', 'freezer', 'food_butter', 'food_carrot', 'drawing', 'floor', 'ceiling', 'keyboard', 'mat', 'ceilinglamp', 'shower', 'oil', 'food_peanut_butter', 'food_orange', 'nightstand', 'wall', 'powersocket', 'photoframe', 'food_food', 'food_onion', 'doorjamb', 'pencil', 'dresser', 'door', 'napkin', 'light', 'shoe_rack']  Task:Put groceries in Fridge  response:  {       thoughts : put away groceries in fridge. open the door, put on shelf, close the door.,       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', 'toilet', 'chair', 'trashcan', 'ceilingfan', 'drawing', 'cpuscreen', 'bathroom_counter', 'floor', 'ceiling', 'phone', 'desk', 'keyboard', 'bookshelf', 'computer', 'ceilinglamp', 'balanceball', 'mousepad', 'couch', 'wall', 'nightstand', 'toy', 'photoframe', 'curtain', 'rag', 'doorjamb', 'mouse', 'dresser', 'door', 'light']  Task:Browse internet  response:

{  walk into Living room, look for computer, walk to computer, turn on computer, grab mouse, click mouse }


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', 'detergent', 'food_carrot', 'clothes_underwear', 'hanger', 'floor', 'ceiling', 'phone', 'computer', 'bookmark', 'toaster', 'balanceball', 'wall', 'powersocket', 'photoframe', 'coffee_filter', 'tray', 'doorjamb', 'cards', 'mouse', 'shaving_cream', 'shoes', 'dresser', 'cupboard', 'door', 'napkin', 'home_office', 'light', 'vase']  Task:Turn on light  response:  {       thoughts : switching on light in an area,       actions : ['[WALK] <home_office>', '[WALK] <light>', '[FIND] <light>', '[SWITCHON] <light>']  }     Scene_Objects:['glue', 'scissors', 'tablelamp', 'freezer', 'trashcan', 'drawing', 'floor', 'shampoo', 'folder', 'bookshelf', 'purse', 'computer', 'window', 'wall', 'powersocket', 'cutting_board', 'cup', 'bed', 'photoframe', 'television', 'curtain', 'food_onion', 'shaving_cream', 'mouse', 'pencil', 'hair', 'maindoor', 'clothes_scarf', 'home_office', 'colander']  Task:Go to sleep  response:


Input: You serve as an AI task planner.   1. Your task is to create a plan to achieve a goal by converting it into a sequence of actions. Each action should follow the format  [verb] <target1> <target2> , where 'verb' represents the action, and 'target1' and 'target2' are optional arguments.  2. You must describe your plan in natural language at the beginning. After that, you should list all the actions together.   Ensure that you response can be parsed by Python json.loads.      Here is an example plan to achieve a goal for reference:   Scene_Objects:['dry_pasta', 'walllamp', 'cat', 'drawing', 'orchid', 'cpuscreen', 'hanger', 'bathroom_counter', 'floor', 'character', 'envelope', 'computer', 'toaster', 'mat', 'tvstand', 'ceilinglamp', 'shower', 'window', 'mousepad', 'couch', 'pillow', 'wall', 'wall_clock', 'oven', 'coffe_maker', 'television', 'curtain', 'hair', 'bathroom_cabinet', 'table']  Task:Pet cat  response:  {       thoughts : I would walk into the living room. Then sit on the couch and pet the cat.,       actions : ['[WALK] <home_office>', '[WALK] <couch>', '[SIT] <couch>', '[FIND] <cat>', '[TOUCH] <cat>']  }     Scene_Objects:['pot', 'toilet', 'jelly', 'ceilingfan', 'drawing', 'hanger', 'floor', 'stamp', 'desk', 'ceilinglamp', 'balanceball', 'faucet', 'window', 'couch', 'clothes_pants', 'pillow', 'wall', 'nightstand', 'bed', 'photoframe', 'television', 'oven_mitts', 'food_rice', 'doorjamb', 'cards', 'shaving_cream', 'sink', 'table', 'light', 'shoe_rack']  Task:Relax on sofa  response:

{  go to living room 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:['filing_cabinet', 'microwave', 'toilet', 'chair', 'freezer', 'bathroom', 'orchid', 'floor', 'bedroom', 'bookshelf', 'toaster', 'tvstand', 'faucet', 'shower', 'stereo', 'closetdrawer', 'couch', 'broom', 'wall', 'wall_clock', 'photoframe', 'bed', 'television', 'mouse', 'kitchen_counter', 'comb', 'dresser', 'sink', 'spoon', 'clothes_skirt']  Task:Go to toilet  response:  {       thoughts : I walk into the bath room and go to the toilet,       actions : ['[WALK] <bathroom>', '[WALK] <toilet>', '[FIND] <toilet>', '[SIT] <toilet>']  }     Scene_Objects:['pot', 'chair', 'ground_coffee', 'food_butter', 'toothbrush', 'knifeblock', 'drawing', 'phone', 'keyboard', 'bookshelf', 'table_cloth', 'mat', 'plate', 'electric_shaver', 'window', 'pillow', 'nightstand', 'oven', 'newspaper', 'clothes_gloves', 'photoframe', 'toilet_paper', 'water', 'centerpiece', 'towel_rack', 'kettle', 'pencil', 'clothes_scarf', 'tooth_paste', 'teeth']  Task:Wash teeth  response:

{  Walk to bathroom. Find tooth paste, tooth brush and water. Squeeze tooth paste on tooth brush. Wash teeth. }


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', 'pot', 'blender', 'beer', 'microwave', 'knifeblock', 'cpuscreen', 'hanger', 'floor', 'ceiling', 'table_cloth', 'toaster', 'plate', 'faucet', 'tvstand', 'window', 'dish_soap', 'food_orange', 'wall', 'cup', 'bed', 'food_food', 'tray', 'wooden_spoon', 'mouse', 'pencil', 'kitchen_counter', 'dishrack', 'cupboard', 'sink']  Task:Wash dirty dishes  response:  {       thoughts : Wet the sponge, apply soap to sponge, scrub dishes, rinse dishes, place on dish rack.,       actions : ['[WALK] <dining_room>', '[WALK] <sink>', '[FIND] <sponge>', '[GRAB] <sponge>', '[FIND] <faucet>', '[SWITCHON] <faucet>', '[PUTBACK] <sponge> <sink>', '[GRAB] <sponge>', '[FIND] <dish_soap>', '[GRAB] <dish_soap>', '[POUR] <dish_soap> <sponge>', '[PUTOBJBACK] <dish_soap>', '[FIND] <plate>', '[GRAB] <plate>', '[SCRUB] <plate>', '[RINSE] <plate>', '[FIND] <dishrack>', '[PUTBACK] <plate> <dishrack>', '[FIND] <plate>', '[GRAB] <plate>', '[SCRUB] <plate>', '[RINSE] <plate>', '[PUTBACK] <plate> <dishrack>', '[RINSE] <sponge>', '[PUTOBJBACK] <sponge>', '[SWITCHOFF] <faucet>']  }     Scene_Objects:['food_bread', 'tablelamp', 'walllamp', 'ground_coffee', 'ceilingfan', 'drawing', 'bathroom_counter', 'floor', 'ceiling', 'phone', 'desk', 'mat', 'faucet', 'couch', 'pillow', 'wall', 'pasta', 'wall_clock', 'cup', 'photoframe', 'bed', 'television', 'water', 'wine', 'curtain', 'paper_towel', 'sink', 'bathroom_cabinet', 'soap', 'hands_both']  Task:Wash hands  response:

{  I walk into the bathroom. I turn on the water. I put soap on my hands. I rinse my hands. I turn off the water. I dry my 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:['scissors', 'tablelamp', 'chair', 'freezer', 'walllamp', 'drawing', 'wallshelf', 'hanger', 'floor', 'ceiling', 'desk', 'keyboard', 'computer', 'mat', 'tvstand', 'ceilinglamp', 'faucet', 'shower', 'closetdrawer', 'couch', 'pillow', 'wall', 'nightstand', 'photoframe', 'newspaper', 'television', 'doorjamb', 'dresser', 'soap', 'instrument_violin']  Task:Watch TV  response:  {       thoughts : I sit on my couch and watch TV in my living room,       actions : ['[WALK] <home_office>', '[WALK] <television>', '[SWITCHON] <television>', '[TURNTO] <television>', '[LOOKAT] <television>', '[TOUCH] <television>', '[TURNTO] <television>', '[LOOKAT] <television>', '[TOUCH] <television>', '[TURNTO] <television>', '[LOOKAT] <television>', '[WALK] <couch>', '[SIT] <couch>', '[TURNTO] <television>', '[LOOKAT] <television>', '[WATCH] <television>', '[WATCH] <television>', '[WATCH] <television>']  }     Scene_Objects:['spectacles', 'pot', 'tablelamp', 'chair', 'dog', 'walllamp', 'ceilingfan', 'knifeblock', 'needle', 'bathroom_counter', 'floor', 'computer', 'shoe-shine_kit', 'dustpan', 'box', 'cup', 'bed', 'keys', 'television', 'food_donut', 'tray', 'curtain', 'doorjamb', 'kettle', 'kitchen_counter', 'shoes', 'comb', 'sink', 'bathroom_cabinet', 'board_game']  Task:Brush teeth  response:

{  go to the bathroom and brush your teeth }


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', 'chair', 'walllamp', 'knifeblock', 'cpuscreen', 'wallshelf', 'bathroom_counter', 'floor', 'ceiling', 'ceilinglamp', 'faucet', 'couch', 'dustpan', 'pillow', 'towel', 'wall', 'nightstand', 'oven', 'box', 'bed', 'keys', 'check', 'toilet_paper', 'television', 'kitchen_counter', 'dresser', 'instrument_guitar', 'soap', 'tooth_paste']  Task:Relax on sofa  response:  {       thoughts : Go to living room.  Find sofa.  Sit on sofa.,       actions : ['[WALK] <home_office>', '[WALK] <couch>', '[FIND] <couch>', '[SIT] <couch>']  }     Scene_Objects:['food_pizza', 'tablelamp', 'jelly', 'ceilingfan', 'knifeblock', 'cpuscreen', 'bathroom_counter', 'floor', 'bookshelf', 'computer', 'clothes_jacket', 'piano_bench', 'stovefan', 'toaster', 'tvstand', 'ceilinglamp', 'balanceball', 'stereo', 'brush', 'food_jam', 'clothes_hat', 'nightstand', 'pasta', 'powersocket', 'bench', 'bed', 'oven_mitts', 'tray', 'towel_rack', 'home_office']  Task:Listen to music  response:

{  I walk to the radio.  I switch on the radio and listen }


Input: You serve as an AI task planner.   1. Your task is to create a plan to achieve a goal by converting it into a sequence of actions. Each action should follow the format  [verb] <target1> <target2> , where 'verb' represents the action, and 'target1' and 'target2' are optional arguments.  2. You must describe your plan in natural language at the beginning. After that, you should list all the actions together.   Ensure that you response can be parsed by Python json.loads.      Here is an example plan to achieve a goal for reference:   Scene_Objects:['walllamp', 'orchid', 'drawing', 'wallshelf', 'bathroom_counter', 'floor', 'ceiling', 'phone', 'bookshelf', 'remote_control', 'envelope', 'clothes_jacket', 'mat', 'tvstand', 'ceilinglamp', 'shower', 'window', 'couch', 'pillow', 'wall', 'powersocket', 'bench', 'photoframe', 'bed', 'television', 'curtain', 'doorjamb', 'door', 'light', 'table']  Task:Watch TV  response:  {       thoughts : Enter the living room, find TV remote, grab TV remote, switch on TV, find sofa, sit down on the sofa, watch TV,       actions : ['[WALK] <home_office>', '[WALK] <remote_control>', '[FIND] <remote_control>', '[GRAB] <remote_control>', '[FIND] <television>', '[SWITCHON] <television>', '[FIND] <couch>', '[WALK] <couch>', '[SIT] <couch>', '[TURNTO] <television>', '[WATCH] <television>']  }     Scene_Objects:['sponge', 'chair', 'ceilingfan', 'drawing', 'cpuscreen', 'floor', 'ceiling', 'desk', 'keyboard', 'remote_control', 'food_cake', 'envelope', 'computer', 'ceilinglamp', 'tvstand', 'balanceball', 'faucet', 'window', 'couch', 'wall', 'wall_clock', 'light_bulb', 'television', 'curtain', 'hair', 'food_steak', 'sink', 'bathroom_cabinet', 'table', 'dishwasher']  Task:Watch TV  response:

{  I enter the living room and sit on the couch. I grab the remote and turn on the 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', 'toilet', 'chair', 'walllamp', 'trashcan', 'ceilingfan', 'drawing', 'cpuscreen', 'hanger', 'floor', 'ceiling', 'phone', 'desk', 'bookshelf', 'keyboard', 'envelope', 'computer', 'bookmark', 'ceilinglamp', 'balanceball', 'mousepad', 'wall', 'nightstand', 'photoframe', 'check', 'doorjamb', 'mouse', 'dresser', 'cupboard', 'door', 'light']  Task:Work  response:  {       thoughts : I go to the home office to work on my project. I turn on the light and walk to my desk. I turn on the computer. Then I look through the documents. After I'm done, I turn off the computer.,       actions : ['[WALK] <home_office>', '[WALK] <light>', '[FIND] <light>', '[SWITCHON] <light>', '[WALK] <desk>', '[FIND] <computer>', '[SWITCHON] <computer>', '[FIND] <check>', '[TURNTO] <check>', '[LOOKAT] <check>', '[SWITCHOFF] <computer>']  }     Scene_Objects:['freezer', 'trashcan', 'food_carrot', 'orchid', 'bathroom_counter', 'floor', 'ceiling', 'desk', 'alcohol', 'button', 'ceilinglamp', 'plate', 'clothes_socks', 'couch', 'food_orange', 'wall', 'bench', 'powersocket', 'photoframe', 'light_bulb', 'food_food', 'coffee_filter', 'drinking_glass', 'water', 'towel_rack', 'dishrack', 'cupboard', 'clothes_dress', 'light', 'colander']  Task:Drink  response:

{  im feeling thirsty im going to kitchen and open the freezer where i can find some cold water and im going to drink it to end up my thirst }


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', 'filing_cabinet', 'food_bread', 'microwave', 'trashcan', 'drawing', 'knifeblock', 'cpuscreen', 'hanger', 'bathroom_counter', 'bedroom', 'tea_bag', 'tvstand', 'window', 'form', 'pillow', 'broom', 'bench', 'basket_for_clothes', 'newspaper', 'bed', 'check', 'coffe_maker', 'tray', 'door', 'home_office', 'light', 'bathroom_cabinet', 'tooth_paste', 'coffee']  Task:Get dressed  response:  {       thoughts : I get dressed in my bedroom in the mornings.,       actions : ['[WALK] <bedroom>', '[WALK] <shoes>', '[FIND] <shoes>', '[GRAB] <shoes>', '[PUTON] <shoes>']  }     Scene_Objects:['pot', 'food_bread', 'microwave', 'bathroom', 'ceilingfan', 'drawing', 'bathroom_counter', 'floor', 'ceiling', 'phone', 'toaster', 'mat', 'faucet', 'towel', 'wall', 'bench', 'photoframe', 'light_bulb', 'lighter', 'pencil', 'chessboard', 'dresser', 'hair', 'cupboard', 'sink', 'bathroom_cabinet', 'vase', 'soap', 'hands_both', 'shoe_rack']  Task:Wash hands  response:

{  I go to the sink, turn on the water,  put soap on my hands, rub them together, then rinse them off and turn off the water. I then towel off my hands. }


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:['jelly', 'trashcan', 'cpuscreen', 'clothes_underwear', 'ceiling', 'folder', 'desk', 'computer', 'stovefan', 'shower', 'mousepad', 'candle', 'clothes_hat', 'dining_room', 'newspaper', 'photoframe', 'food_food', 'video_game_controller', 'oven_mitts', 'curtain', 'pencil', 'kitchen_counter', 'dishrack', 'laundry_detergent', 'door', 'light', 'dishwasher', 'soap', 'tooth_paste', 'washing_machine']  Task:Wash clothes  response:  {       thoughts : Walk to bathroom. Open washer. Put clothes in washer. Put soap in washer. Close washer. Turn washer on.,       actions : ['[WALK] <home_office>', '[WALK] <washing_machine>', '[FIND] <washing_machine>', '[OPEN] <washing_machine>', '[FIND] <clothes_underwear>', '[GRAB] <clothes_underwear>', '[PUTBACK] <clothes_underwear> <washing_machine>', '[FIND] <soap>', '[GRAB] <soap>', '[PUTBACK] <soap> <washing_machine>', '[CLOSE] <washing_machine>', '[SWITCHON] <washing_machine>']  }     Scene_Objects:['filing_cabinet', 'chair', 'bathroom', 'milk', 'knifeblock', 'cpuscreen', 'floor', 'ceiling', 'phone', 'character', 'desk', 'bookshelf', 'keyboard', 'purse', 'computer', 'shower', 'window', 'electric_shaver', 'mousepad', 'oil', 'couch', 'form', 'wall', 'food_food', 'television', 'rag', 'lighter', 'mouse', 'controller', 'sink']  Task:Pick up phone  response:

{  first when i hear the ringing sound i will run to my living room and picks up and i will say hello }


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', 'food_ice_cream', 'toilet', 'freezer', 'drawing', 'floor', 'ceiling', 'phone', 'stovefan', 'mat', 'ceilinglamp', 'shower', 'bowl', 'nightstand', 'wall', 'powersocket', 'oven', 'photoframe', 'bed', 'food_food', 'coffe_maker', 'wooden_spoon', 'doorjamb', 'pencil', 'comb', 'door', 'light', 'soap', 'scrabble', 'creditcard']  Task:Put groceries in Fridge  response:  {       thoughts : In the kitchen where I left the bags of groceries, I grab cheese from the grocery bag, I walk over to the refrigerator, open it up, neatly put cheese in the fridge, Close the fridge,       actions : ['[WALK] <dining_room>', '[WALK] <food_food>', '[FIND] <food_food>', '[GRAB] <food_food>', '[WALK] <freezer>', '[OPEN] <freezer>', '[PUTIN] <food_food> <freezer>', '[CLOSE] <freezer>']  }     Scene_Objects:['water_glass', 'chair', 'cat', 'hanger', 'bathroom_counter', 'floor', 'bookshelf', 'keyboard', 'ceilinglamp', 'shower', 'foundation', 'couch', 'food_orange', 'powersocket', 'bench', 'clothes_gloves', 'toilet_paper', 'razor', 'food_donut', 'mouse', 'kitchen_counter', 'shoes', 'dishrack', 'dresser', 'pajamas', 'laundry_detergent', 'clothes_scarf', 'home_office', 'laser_pointer', 'creditcard']  Task:Drink  response:

{  Pour water into a glass and drink from the 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:['pot', 'tablelamp', 'chair', 'bathroom', 'trashcan', 'ceilingfan', 'drawing', 'cpuscreen', 'bathroom_counter', 'floor', 'ceiling', 'phone', 'desk', 'keyboard', 'bookshelf', 'computer', 'ceilinglamp', 'deck_of_cards', 'balanceball', 'mousepad', 'dustpan', 'wall', 'nightstand', 'photoframe', 'wine', 'doorjamb', 'mouse', 'dresser', 'light', 'colander']  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:['sheets', 'pot', 'chair', 'freezer', 'detergent', 'trashcan', 'dough', 'clothes_underwear', 'folder', 'stamp', 'bookshelf', 'clothes_jacket', 'table_cloth', 'mousepad', 'couch', 'food_jam', 'clothes_hat', 'pillow', 'nightstand', 'bench', 'oven', 'cutting_board', 'bed', 'food_food', 'check', 'doorjamb', 'console', 'cupboard', 'home_office', 'table']  Task:Pick up phone  response:

{  i go find the phone. i pick up the phone }


Input: You serve as an AI task planner.   1. Your task is to create a plan to achieve a goal by converting it into a sequence of actions. Each action should follow the format  [verb] <target1> <target2> , where 'verb' represents the action, and 'target1' and 'target2' are optional arguments.  2. You must describe your plan in natural language at the beginning. After that, you should list all the actions together.   Ensure that you response can be parsed by Python json.loads.      Here is an example plan to achieve a goal for reference:   Scene_Objects:['measuring_cup', 'chair', 'walllamp', 'trashcan', 'orchid', 'drawing', 'knifeblock', 'hanger', 'bathroom_counter', 'ceiling', 'bedroom', 'bookshelf', 'clothes_jacket', 'faucet', 'couch', 'clothes_pants', 'form', 'wall', 'cutting_board', 'photoframe', 'check', 'food_food', 'curtain', 'doorjamb', 'towel_rack', 'clothes_dress', 'door', 'sink', 'bathroom_cabinet', 'washing_machine']  Task:Wash clothes  response:  {       thoughts : Walk to bathroom, open cabinet and collect clothes and put them into washing machine and wash clothes,       actions : ['[WALK] <bathroom>', '[WALK] <bathroom_cabinet>', '[FIND] <bathroom_cabinet>', '[OPEN] <bathroom_cabinet>', '[FIND] <clothes_dress>', '[GRAB] <clothes_dress>', '[FIND] <washing_machine>', '[OPEN] <washing_machine>', '[PUTBACK] <clothes_dress> <washing_machine>', '[FIND] <clothes_pants>', '[GRAB] <clothes_pants>', '[PUTBACK] <clothes_pants> <washing_machine>', '[FIND] <clothes_jacket>', '[GRAB] <clothes_jacket>', '[PUTBACK] <clothes_jacket> <washing_machine>', '[CLOSE] <washing_machine>', '[SWITCHON] <washing_machine>']  }     Scene_Objects:['fork', 'toilet', 'freezer', 'ground_coffee', 'ceilingfan', 'milk', 'floor', 'ceiling', 'shampoo', 'purse', 'ceilinglamp', 'mat', 'faucet', 'oil', 'wall', 'pasta', 'tape', 'novel', 'food_food', 'food_donut', 'wooden_spoon', 'mouse', 'kitchen_counter', 'door', 'home_office', 'bathroom_cabinet', 'vase', 'soap', 'instrument_violin', 'creditcard']  Task:Put groceries in Fridge  response:

{  I walk in to the kitchen. I open the fridge. I place the groceries in the fridge. I 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:['water_glass', 'food_pizza', 'pot', 'microwave', 'bathroom', 'bills', 'knifeblock', 'cpuscreen', 'drawing', 'longboard', 'floor', 'phone', 'folder', 'bedroom', 'keyboard', 'mail', 'food_bacon', 'piano_bench', 'button', 'table_cloth', 'shower', 'couch', 'dining_room', 'wall', 'powersocket', 'cutting_board', 'water', 'tray', 'pencil', 'door']  Task:Drink  response:  {       thoughts : Drinking a glass of water,       actions : ['[WALK] <dining_room>', '[WALK] <water>', '[FIND] <water>', '[GRAB] <water>', '[FIND] <water_glass>', '[POUR] <water> <water_glass>', '[FIND] <water_glass>', '[GRAB] <water_glass>', '[DRINK] <water_glass>']  }     Scene_Objects:['filing_cabinet', 'food_ice_cream', 'crayon', 'bathroom', 'drawing', 'floor', 'phone', 'character', 'keyboard', 'remote_control', 'button', 'ceilinglamp', 'shower', 'window', 'foundation', 'mousepad', 'couch', 'pillow', 'wall', 'oven', 'check', 'food_food', 'television', 'dresser', 'sink', 'table', 'dishwasher', 'clothes_skirt', 'tooth_paste', 'dirt']  Task:Change TV channel  response:

{  go to living room. grab remote control. sit on couch. point remote at tv. push buttons. }


Input: You serve as an AI task planner.   1. Your task is to create a plan to achieve a goal by converting it into a sequence of actions. Each action should follow the format  [verb] <target1> <target2> , where 'verb' represents the action, and 'target1' and 'target2' are optional arguments.  2. You must describe your plan in natural language at the beginning. After that, you should list all the actions together.   Ensure that you response can be parsed by Python json.loads.      Here is an example plan to achieve a goal for reference:   Scene_Objects:['water_glass', 'microwave', 'needle', 'kitchen_cabinet', 'desk', 'alcohol', 'mat', 'ceilinglamp', 'balanceball', 'window', 'couch', 'clothes_pants', 'dining_room', 'nightstand', 'wall', 'wall_clock', 'oven', 'toilet_paper', 'mouthwash', 'water', 'ice', 'tray', 'rag', 'doorjamb', 'towel_rack', 'coffee_pot', 'pencil', 'door', 'dishwasher', 'vase']  Task:Drink  response:  {       thoughts : Get a glass of water to drink,       actions : ['[WALK] <dining_room>', '[WALK] <kitchen_cabinet>', '[FIND] <kitchen_cabinet>', '[FIND] <kitchen_cabinet>', '[FIND] <water>', '[GRAB] <water>', '[FIND] <water_glass>', '[POUR] <water> <water_glass>', '[GRAB] <water_glass>', '[DRINK] <water_glass>']  }     Scene_Objects:['tablelamp', 'scissors', 'chair', 'freezer', 'dog', 'trashcan', 'ceilingfan', 'drawing', 'bills', 'cpuscreen', 'floor', 'ceiling', 'phone', 'desk', 'bedroom', 'keyboard', 'bookshelf', 'computer', 'ceilinglamp', 'balanceball', 'faucet', 'mousepad', 'wall', 'nightstand', 'television', 'doorjamb', 'cards', 'mouse', 'light', 'table']  Task:Browse internet  response:

{  I go to my desk. I turn on the computer. I open a web page and look at 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:['pot', 'tablelamp', 'chair', 'walllamp', 'drawing', 'orchid', 'cpuscreen', 'wallshelf', 'hanger', 'floor', 'phone', 'ceiling', 'desk', 'keyboard', 'computer', 'mat', 'ceilinglamp', 'tvstand', 'mousepad', 'couch', 'pillow', 'wall', 'nightstand', 'oven', 'powersocket', 'television', 'tray', 'doorjamb', 'towel_rack', 'mouse', 'dresser', 'door', 'light']  Task:Surf web for money legitimate making opportunities  response:  {       thoughts : Sit down in front of computer. Turn computer on. Go online. Surf the web.,       actions : ['[WALK] <home_office>', '[WALK] <desk>', '[FIND] <chair>', '[SIT] <chair>', '[FIND] <computer>', '[SWITCHON] <computer>', '[TURNTO] <computer>', '[LOOKAT] <computer>', '[FIND] <keyboard>', '[TYPE] <keyboard>']  }     Scene_Objects:['tablelamp', 'food_ice_cream', 'measuring_cup', 'freezer', 'ceilingfan', 'cpuscreen', 'longboard', 'ceiling', 'character', 'bedroom', 'toaster', 'stereo', 'balanceball', 'oil', 'couch', 'food_orange', 'pillow', 'food_kiwi', 'nightstand', 'photoframe', 'coffe_maker', 'rag', 'doorjamb', 'towel_rack', 'shoes', 'controller', 'napkin', 'bathroom_cabinet', 'laser_pointer', 'dirt']  Task:Pick up phone  response:

{  Go to the living room.  Find the telephone.  Lift up the receiver. }


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', 'toilet', 'chair', 'walllamp', 'detergent', 'trashcan', 'food_carrot', 'knifeblock', 'drawing', 'cpuscreen', 'knife', 'bathroom_counter', 'desk', 'keyboard', 'bookshelf', 'table_cloth', 'toaster', 'ceilinglamp', 'faucet', 'mousepad', 'pillow', 'dining_room', 'oven', 'photoframe', 'food_food', 'kitchen_counter', 'dresser', 'sink', 'home_office']  Task:Turn off light  response:  {       thoughts : Walk to the lamp.  Find the switch.  Click the switch off.,       actions : ['[WALK] <bedroom>', '[WALK] <floor_lamp>', '[SWITCHOFF] <floor_lamp>']  }     Scene_Objects:['mop', 'bathroom', 'ceilingfan', 'drawing', 'cpuscreen', 'hanger', 'floor', 'ceiling', 'remote_control', 'computer', 'clothes_jacket', 'toaster', 'ceilinglamp', 'tvstand', 'balanceball', 'window', 'food_noodles', 'couch', 'clothes_pants', 'pillow', 'wall', 'oven', 'check', 'television', 'tray', 'curtain', 'sink', 'table', 'light', 'teeth']  Task:Watch TV  response:

{  You walk to the living room and sit on the sofa. You grab the remote control, look at it and point at the television, you 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:['dry_pasta', 'pot', 'food_salt', 'jelly', 'walllamp', 'detergent', 'knife', 'drawing', 'hanger', 'floor', 'dvd_player', 'character', 'desk', 'bedroom', 'plate', 'dish_soap', 'oil', 'wall', 'powersocket', 'bed', 'light_bulb', 'coffe_maker', 'toilet_paper', 'rag', 'doorjamb', 'kitchen_counter', 'cupboard', 'sink', 'spoon', 'dishwasher']  Task:Wash dishes with dishwasher  response:  {       thoughts : Put dishes in the dishwasher and start the dishwasher.,       actions : ['[RUN] <dining_room>', '[WALK] <bowl>', '[FIND] <bowl>', '[GRAB] <bowl>', '[WALK] <dishwasher>', '[OPEN] <dishwasher>', '[PUTBACK] <bowl> <dishwasher>', '[FIND] <plate>', '[GRAB] <plate>', '[WALK] <dishwasher>', '[PUTBACK] <plate> <dishwasher>', '[FIND] <dish_soap>', '[GRAB] <dish_soap>', '[WALK] <dishwasher>', '[PUTBACK] <dish_soap> <dishwasher>', '[CLOSE] <dishwasher>', '[SWITCHON] <dishwasher>']  }     Scene_Objects:['pot', 'chair', 'freezer', 'walllamp', 'trashcan', 'knifeblock', 'needle', 'cpuscreen', 'floor', 'character', 'keyboard', 'table_cloth', 'plate', 'faucet', 'window', 'oil', 'mousepad', 'pillow', 'wall', 'oven', 'food_cheese', 'bed', 'tray', 'kettle', 'kitchen_counter', 'dresser', 'cupboard', 'sink', 'home_office', 'light']  Task:Wash dishes by hand  response:

{  Walking towards sink and look at the leftover plates. Scrape dishes to remove leftover food - use a rubber spatula or paper towel. Fill sink or dishpan with clean, hot water. Then wash and rinse to removing residues. Finally leave it to dry. }


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', 'microwave', 'ceilingfan', 'drawing', 'hanger', 'bathroom_counter', 'floor', 'ceiling', 'food_cake', 'thread', 'faucet', 'towel', 'dining_room', 'wall', 'nightstand', 'bench', 'photoframe', 'water', 'rag', 'lighter', 'cards', 'console', 'mouse', 'conditioner', 'sink', 'bathroom_cabinet', 'table', 'soap', 'laser_pointer', 'hands_both']  Task:Wash hands  response:  {       thoughts : Go into the bathroom and go over to the sink. Grab soap and turn on the water. Wet your hands and rub them together so that the soap lathers. Rub the soap all over your hands thoroughly. Rinse off the soap with water and turn off the sink. Dry your hands with a towel.,       actions : ['[WALK] <bathroom>', '[WALK] <sink>', '[FIND] <soap>', '[GRAB] <soap>', '[FIND] <water>', '[GRAB] <water>', '[FIND] <hands_both>', '[POUR] <water> <hands_both>', '[FIND] <hands_both>', '[SCRUB] <hands_both>', '[PUTOBJBACK] <soap>', '[RINSE] <hands_both>', '[FIND] <towel>', '[GRAB] <towel>', '[WIPE] <hands_both>']  }     Scene_Objects:['tablelamp', 'chair', 'trashcan', 'ceilingfan', 'drawing', 'cpuscreen', 'floor', 'ceiling', 'phone', 'desk', 'keyboard', 'bookshelf', 'purse', 'computer', 'ceilinglamp', 'mat', 'balanceball', 'electric_shaver', 'window', 'mousepad', 'dustpan', 'pillow', 'wall', 'nightstand', 'photoframe', 'food_food', 'doorjamb', 'mouse', 'door', 'light']  Task:Browse internet  response:

{  turn on the computer and browse the internet }


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', 'water_glass', 'pot', 'glue', 'walllamp', 'trashcan', 'knifeblock', 'ceiling', 'clothes_jacket', 'stovefan', 'toaster', 'mat', 'faucet', 'microphone', 'wall', 'cup', 'bed', 'food_food', 'check', 'water', 'food_donut', 'curtain', 'kitchen_counter', 'chessboard', 'cupboard', 'laundry_detergent', 'sink', 'spoon', 'bathroom_cabinet', 'dirt']  Task:Drink  response:  {       thoughts : I walk to the kitchen. open the cupboard. Find the water glass, grab it. Fill the glass with water and drink water.,       actions : ['[WALK] <dining_room>', '[WALK] <cupboard>', '[FIND] <cupboard>', '[OPEN] <cupboard>', '[FIND] <water_glass>', '[GRAB] <water_glass>', '[WALK] <water>', '[FIND] <water>', '[GRAB] <water>', '[POUR] <water> <water_glass>', '[DRINK] <water_glass>']  }     Scene_Objects:['filing_cabinet', 'tablelamp', 'tea', 'toilet', 'chair', 'detergent', 'trashcan', 'ceilingfan', 'drawing', 'cpuscreen', 'floor', 'ceiling', 'phone', 'desk', 'keyboard', 'bookshelf', 'computer', 'mail', 'ceilinglamp', 'balanceball', 'mousepad', 'wall', 'nightstand', 'novel', 'food_onion', 'doorjamb', 'mouse', 'napkin', 'light', 'clothes_skirt']  Task:Browse internet  response:

{  I go to the living room, where my computer is. I locate it, switch it on and type desired URL adress in the web browser. }


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', 'drawing', 'knife', 'wallshelf', 'orchid', 'hanger', 'bathroom_counter', 'floor', 'ceiling', 'desk', 'remote_control', 'computer', 'mat', 'tvstand', 'ceilinglamp', 'oil', 'closetdrawer', 'couch', 'pillow', 'wall', 'box', 'photoframe', 'television', 'coffee_filter', 'after_shave', 'doorjamb', 'diary', 'kitchen_counter', 'dresser']  Task:Change TV channel  response:  {       thoughts : Walk to livingroom, grab remote and change the channel on television.,       actions : ['[WALK] <home_office>', '[WALK] <remote_control>', '[FIND] <remote_control>', '[GRAB] <remote_control>', '[FIND] <television>', '[SWITCHON] <television>', '[PUTOBJBACK] <remote_control>']  }     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:

{  Walk to the Home Office.  Find the computer.  Turn on the computer. }


Input: You serve as an AI task planner.   1. Your task is to create a plan to achieve a goal by converting it into a sequence of actions. Each action should follow the format  [verb] <target1> <target2> , where 'verb' represents the action, and 'target1' and 'target2' are optional arguments.  2. You must describe your plan in natural language at the beginning. After that, you should list all the actions together.   Ensure that you response can be parsed by Python json.loads.      Here is an example plan to achieve a goal for reference:   Scene_Objects:['pot', 'tablelamp', 'microwave', 'toothbrush', 'drawing', 'orchid', 'wallshelf', 'kitchen_cabinet', 'floor', 'ceiling', 'desk', 'bedroom', 'stovefan', 'toaster', 'ceilinglamp', 'faucet', 'shower', 'mousepad', 'pillow', 'wall', 'pasta', 'oven', 'coffe_maker', 'water', 'tray', 'towel_rack', 'kitchen_counter', 'headset', 'sauce_pan', 'cupboard']  Task:Cook some food  response:  {       thoughts : Cook some pasta on the stove,       actions : ['[WALK] <dining_room>', '[WALK] <kitchen_cabinet>', '[FIND] <kitchen_cabinet>', '[OPEN] <kitchen_cabinet>', '[FIND] <pasta>', '[GRAB] <pasta>', '[FIND] <water>', '[GRAB] <water>', '[FIND] <sauce_pan>', '[POUR] <water> <sauce_pan>', '[FIND] <oven>', '[SWITCHON] <oven>', '[PUTBACK] <pasta> <sauce_pan>', '[FIND] <sauce_pan>', '[GRAB] <sauce_pan>', '[PUTBACK] <sauce_pan> <oven>']  }     Scene_Objects:['tablelamp', 'juice', 'toilet', 'chair', 'trashcan', 'ceilingfan', 'drawing', 'cpuscreen', 'hanger', 'floor', 'ceiling', 'phone', 'desk', 'keyboard', 'bookshelf', 'computer', 'toaster', 'ceilinglamp', 'stovefan', 'balanceball', 'mat', 'mousepad', 'oil', 'wall', 'nightstand', 'photoframe', 'doorjamb', 'mouse', 'light', 'dishwasher']  Task:Work  response:

{  Go to office, sit at desk, turn on computer, enter password, open application and begin work }


Input: You serve as an AI task planner.   1. Your task is to create a plan to achieve a goal by converting it into a sequence of actions. Each action should follow the format  [verb] <target1> <target2> , where 'verb' represents the action, and 'target1' and 'target2' are optional arguments.  2. You must describe your plan in natural language at the beginning. After that, you should list all the actions together.   Ensure that you response can be parsed by Python json.loads.      Here is an example plan to achieve a goal for reference:   Scene_Objects:['tablelamp', 'crayon', 'toilet', 'chair', 'bathroom', 'orchid', 'floor', 'ceiling', 'character', 'bedroom', 'desk', 'computer', 'tvstand', 'faucet', 'stereo', 'food_orange', 'photoframe', 'novel', 'television', 'curtain', 'doorjamb', 'diary', 'towel_rack', 'mouse', 'shoes', 'dresser', 'cupboard', 'sink', 'bathtub', 'home_office']  Task:Get dressed  response:  {       thoughts : I get dressed in my bedroom in the mornings.,       actions : ['[WALK] <bedroom>', '[WALK] <shoes>', '[FIND] <shoes>', '[GRAB] <shoes>', '[PUTON] <shoes>']  }     Scene_Objects:['sponge', 'sheets', 'filing_cabinet', 'food_bread', 'toilet', 'ground_coffee', 'drawing', 'cpuscreen', 'bathroom_counter', 'floor', 'ceiling', 'desk', 'keyboard', 'alcohol', 'table_cloth', 'tvstand', 'balanceball', 'shower', 'plate', 'iron', 'mousepad', 'wall', 'oven', 'photoframe', 'light_bulb', 'coffe_maker', 'centerpiece', 'mouse', 'dresser', 'maindoor']  Task:Go to toilet  response:

{  I walk to the entrance of the bathroom. I turn to the door. I open the door to the bathroom. I walk inside of the bathroom. I find the toilet inside of the bathroom and walk over to it. I turn and look at the toilet. }


Input: You serve as an AI task planner.   1. Your task is to create a plan to achieve a goal by converting it into a sequence of actions. Each action should follow the format  [verb] <target1> <target2> , where 'verb' represents the action, and 'target1' and 'target2' are optional arguments.  2. You must describe your plan in natural language at the beginning. After that, you should list all the actions together.   Ensure that you response can be parsed by Python json.loads.      Here is an example plan to achieve a goal for reference:   Scene_Objects:['microwave', 'toilet', 'chair', 'freezer', 'detergent', 'trashcan', 'drawing', 'wallshelf', 'clothes_underwear', 'floor', 'ceiling', 'phone', 'computer', 'toaster', 'mat', 'tvstand', 'shower', 'closetdrawer', 'wall', 'oven', 'cup', 'novel', 'water', 'drinking_glass', 'doorjamb', 'mouse', 'kitchen_counter', 'comb', 'cupboard', 'door']  Task:Drink  response:  {       thoughts : go to the kitchen,       actions : ['[WALK] <dining_room>', '[WALK] <freezer>', '[FIND] <freezer>', '[OPEN] <freezer>', '[FIND] <drinking_glass>', '[GRAB] <drinking_glass>', '[FIND] <water>', '[DRINK] <drinking_glass>']  }     Scene_Objects:['pot', 'freezer', 'ceilingfan', 'dough', 'milk', 'knifeblock', 'bills', 'floor', 'ceiling', 'bedroom', 'keyboard', 'bookshelf', 'computer', 'mop_bucket', 'ceilinglamp', 'microphone', 'wall', 'bench', 'powersocket', 'clothes_gloves', 'light_bulb', 'food_food', 'coffe_maker', 'tray', 'curtain', 'shaving_cream', 'controller', 'door', 'maindoor', 'dirt']  Task:Put groceries in Fridge  response:

{  Go to kitchen and 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:['spectacles', 'sheets', 'filing_cabinet', 'food_salt', 'toilet', 'band-aids', 'walllamp', 'wallshelf', 'cpuscreen', 'hanger', 'floor', 'phone', 'computer', 'mop_bucket', 'stovefan', 'tvstand', 'deck_of_cards', 'closetdrawer', 'newspaper', 'coffe_maker', 'doorjamb', 'dresser', 'cupboard', 'door', 'food_steak', 'bag', 'sink', 'table', 'dishwasher', 'bathroom_cabinet']  Task:Put umbrella away  response:  {       thoughts : Place the umbrella in the umbrella bucket point first.,       actions : ['[WALK] <home_office>', '[WALK] <mop_bucket>']  }     Scene_Objects:['filing_cabinet', 'juice', 'freezer', 'blow_dryer', 'trashcan', 'drawing', 'cpuscreen', 'longboard', 'floor', 'bookmark', 'ceilinglamp', 'mat', 'window', 'couch', 'microphone', 'clothes_hat', 'pillow', 'wall', 'bench', 'cup', 'keys', 'television', 'towel_rack', 'cd', 'cupboard', 'conditioner', 'door', 'home_office', 'table', 'vase']  Task:Relax on sofa  response:

{  Go to the living room and relax on the sofa with a book }


Input: You serve as an AI task planner.   1. Your task is to create a plan to achieve a goal by converting it into a sequence of actions. Each action should follow the format  [verb] <target1> <target2> , where 'verb' represents the action, and 'target1' and 'target2' are optional arguments.  2. You must describe your plan in natural language at the beginning. After that, you should list all the actions together.   Ensure that you response can be parsed by Python json.loads.      Here is an example plan to achieve a goal for reference:   Scene_Objects:['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:  {       thoughts : walk over and pick up the phone,       actions : ['[WALK] <phone>', '[GRAB] <phone>']  }     Scene_Objects:['food_pizza', 'tablelamp', 'toilet', 'chair', 'walllamp', 'trashcan', 'ceilingfan', 'drawing', 'cpuscreen', 'floor', 'ceiling', 'phone', 'desk', 'keyboard', 'bookshelf', 'computer', 'ceilinglamp', 'balanceball', 'faucet', 'mousepad', 'wall', 'nightstand', 'cup', 'coffe_maker', 'doorjamb', 'mouse', 'chessboard', 'controller', 'bathroom_cabinet', 'light']  Task:Write an email  response:

{  enter office, find computer, turn it on, }


Input: You serve as an AI task planner.   1. Your task is to create a plan to achieve a goal by converting it into a sequence of actions. Each action should follow the format  [verb] <target1> <target2> , where 'verb' represents the action, and 'target1' and 'target2' are optional arguments.  2. You must describe your plan in natural language at the beginning. After that, you should list all the actions together.   Ensure that you response can be parsed by Python json.loads.      Here is an example plan to achieve a goal for reference:   Scene_Objects:['sponge', 'pot', 'filing_cabinet', 'sheets', 'detergent', 'milk', 'hanger', 'phone', 'desk', 'clothes_jacket', 'plate', 'dish_soap', 'mousepad', 'couch', 'candle', 'pillow', 'bowl', 'basket_for_clothes', 'standingmirror', 'keys', 'food_food', 'check', 'razor', 'coffee_filter', 'mouse', 'kitchen_counter', 'controller', 'door', 'bathtub', 'dishwasher']  Task:Wash dishes with dishwasher  response:  {       thoughts : Put dishes in the dishwasher and start the dishwasher.,       actions : ['[RUN] <dining_room>', '[WALK] <bowl>', '[FIND] <bowl>', '[GRAB] <bowl>', '[WALK] <dishwasher>', '[OPEN] <dishwasher>', '[PUTBACK] <bowl> <dishwasher>', '[FIND] <plate>', '[GRAB] <plate>', '[WALK] <dishwasher>', '[PUTBACK] <plate> <dishwasher>', '[FIND] <dish_soap>', '[GRAB] <dish_soap>', '[WALK] <dishwasher>', '[PUTBACK] <dish_soap> <dishwasher>', '[CLOSE] <dishwasher>', '[SWITCHON] <dishwasher>']  }     Scene_Objects:['filing_cabinet', 'walllamp', 'drawing', 'cpuscreen', 'floor', 'ceiling', 'desk', 'bookshelf', 'keyboard', 'computer', 'button', 'mat', 'balanceball', 'window', 'candle', 'wall', 'powersocket', 'photoframe', 'novel', 'coffee_filter', 'ice', 'doorjamb', 'kettle', 'console', 'door', 'bathroom_cabinet', 'light', 'home_office', 'table', 'soap']  Task:Turn on light  response:

{  I walk to wall. I put my hand on the switch. I push the button. I turn on the lights. }


Input: You serve as an AI task planner.   1. Your task is to create a plan to achieve a goal by converting it into a sequence of actions. Each action should follow the format  [verb] <target1> <target2> , where 'verb' represents the action, and 'target1' and 'target2' are optional arguments.  2. You must describe your plan in natural language at the beginning. After that, you should list all the actions together.   Ensure that you response can be parsed by Python json.loads.      Here is an example plan to achieve a goal for reference:   Scene_Objects:['walllamp', 'drawing', 'orchid', 'wallshelf', 'cpuscreen', 'floor', 'ceiling', 'bookshelf', 'remote_control', 'computer', 'mat', 'tvstand', 'ceilinglamp', 'shower', 'window', 'couch', 'pillow', 'wall', 'powersocket', 'bench', 'photoframe', 'check', 'television', 'curtain', 'doorjamb', 'laundry_detergent', 'door', 'table', 'light', 'soap']  Task:Watch TV  response:  {       thoughts : turn tv on, watch TV,       actions : ['[WALK] <home_office>', '[WALK] <couch>', '[FIND] <couch>', '[SIT] <couch>', '[FIND] <remote_control>', '[TURNTO] <remote_control>', '[FIND] <television>', '[TURNTO] <television>', '[WATCH] <television>']  }     Scene_Objects:['food_bread', 'scissors', 'toilet', 'freezer', 'ground_coffee', 'ceilingfan', 'knifeblock', 'orchid', 'hanger', 'floor', 'bedroom', 'tea_bag', 'envelope', 'clothes_jacket', 'toaster', 'balanceball', 'faucet', 'iron', 'bed', 'coffe_maker', 'wooden_spoon', 'cards', 'headset', 'dresser', 'napkin', 'spoon', 'vase', 'instrument_violin', 'laser_pointer', 'creditcard']  Task:Receive credit card  response:

{  hear the dooble, go to door, take de envelope, open it with a scissor, take the creditcard }


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', 'beer', 'detergent', 'food_butter', 'orchid', 'hanger', 'floor', 'ceiling', 'computer', 'toaster', 'mat', 'closetdrawer', 'broom', 'wall', 'nightstand', 'toy', 'newspaper', 'toilet_paper', 'television', 'wine', 'doorjamb', 'kitchen_counter', 'shoes', 'chessboard', 'dresser', 'door', 'dishwasher', 'instrument_violin', 'laser_pointer']  Task:Put away shoes  response:  {       thoughts : Pick up shoes from entry hall. Open entry way closet. Put shoes in closet. Close closet door.,       actions : ['[WALK] <home_office>', '[WALK] <shoes>', '[FIND] <shoes>', '[GRAB] <shoes>', '[FIND] <dresser>', '[OPEN] <dresser>', '[PUTIN] <shoes> <dresser>', '[CLOSE] <dresser>']  }     Scene_Objects:['tea', 'jelly', 'dog', 'walllamp', 'bathroom_counter', 'thread', 'table_cloth', 'tvstand', 'balanceball', 'shower', 'window', 'oil', 'microphone', 'clothes_hat', 'nightstand', 'photoframe', 'bed', 'check', 'coffe_maker', 'toothbrush_holder', 'kitchen_counter', 'dresser', 'cupboard', 'controller', 'laundry_detergent', 'maindoor', 'sink', 'bathroom_cabinet', 'vase', 'soap']  Task:Change TV channel  response:

{  take remote control, push \ change channel\  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:['crayon', 'needle', 'clothes_underwear', 'phone', 'desk', 'stamp', 'clothes_jacket', 'stovefan', 'mat', 'tvstand', 'window', 'towel', 'pillow', 'cutting_board', 'basket_for_clothes', 'cup', 'bed', 'photoframe', 'newspaper', 'food_food', 'mouthwash', 'television', 'wine', 'kettle', 'dresser', 'bathtub', 'bathroom_cabinet', 'table', 'soap', 'washing_machine']  Task:Wash clothes  response:  {       thoughts : Walk to the kitchen and find the basket of clothes. Put the soap and clothes into the washing machine. Turn on the washing machine.,       actions : ['[WALK] <dining_room>', '[WALK] <basket_for_clothes>', '[FIND] <basket_for_clothes>', '[FIND] <washing_machine>', '[TURNTO] <washing_machine>', '[FIND] <soap>', '[GRAB] <soap>', '[OPEN] <washing_machine>', '[PUTBACK] <soap> <washing_machine>', '[FIND] <clothes_jacket>', '[GRAB] <clothes_jacket>', '[PUTBACK] <clothes_jacket> <washing_machine>', '[CLOSE] <washing_machine>', '[SWITCHON] <washing_machine>']  }     Scene_Objects:['dry_pasta', 'pot', 'food_pizza', 'food_ice_cream', 'freezer', 'walllamp', 'knife', 'bathroom_counter', 'floor', 'stamp', 'tea_bag', 'keyboard', 'food_cake', 'bookmark', 'toaster', 'plate', 'stereo', 'dish_soap', 'food_noodles', 'wall', 'oven', 'bench', 'coffe_maker', 'food_food', 'tray', 'food_onion', 'dishrack', 'conditioner', 'bathroom_cabinet', 'dishwasher']  Task:Wash dishes with dishwasher  response:

{  Walk to kitchen. Find dishwasher. Open dishwasher. Find dishrack. Find plate 1. Grab plate 1. Put plate 1 in dishrack. Repeat for dish 2. Find dish soap. Grab dish soap. Put dish soap to dishwasher. Close dishwasher. Switch on 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:['sheets', 'toilet', 'freezer', 'cat', 'orchid', 'floor', 'ceiling', 'phone', 'desk', 'keyboard', 'bookshelf', 'computer', 'stovefan', 'ceilinglamp', 'tvstand', 'balanceball', 'oil', 'couch', 'clothes_hat', 'wall', 'basket_for_clothes', 'food_food', 'coffe_maker', 'curtain', 'doorjamb', 'towel_rack', 'comb', 'dresser', 'maindoor', 'soap']  Task:Put groceries in Fridge  response:  {       thoughts : I put my groceries into the fridge.,       actions : ['[WALK] <food_food>', '[GRAB] <food_food>', '[FIND] <freezer>', '[OPEN] <freezer>', '[PUTIN] <food_food> <freezer>', '[CLOSE] <freezer>']  }     Scene_Objects:['filing_cabinet', 'toilet', 'ceilingfan', 'food_egg', 'hanger', 'ceiling', 'dvd_player', 'character', 'thread', 'clothes_jacket', 'toaster', 'deck_of_cards', 'foundation', 'mousepad', 'oil', 'pillow', 'oven', 'toy', 'food_food', 'check', 'lighter', 'centerpiece', 'dishrack', 'coffee', 'hair', 'laundry_detergent', 'maindoor', 'sink', 'door', 'teeth']  Task:Turn on light  response:

{  I walk into my bedroom, go to the lamp and use the switch to turn it on. }


Input: You serve as an AI task planner.   1. Your task is to create a plan to achieve a goal by converting it into a sequence of actions. Each action should follow the format  [verb] <target1> <target2> , where 'verb' represents the action, and 'target1' and 'target2' are optional arguments.  2. You must describe your plan in natural language at the beginning. After that, you should list all the actions together.   Ensure that you response can be parsed by Python json.loads.      Here is an example plan to achieve a goal for reference:   Scene_Objects:['pot', 'chair', 'walllamp', 'knife', 'desk', 'bookshelf', 'button', 'clothes_jacket', 'stovefan', 'deck_of_cards', 'mousepad', 'closetdrawer', 'oil', 'towel', 'pillow', 'broom', 'basket_for_clothes', 'photoframe', 'novel', 'coffe_maker', 'television', 'wine', 'curtain', 'after_shave', 'cards', 'home_office', 'light', 'clothes_skirt', 'soap', 'washing_machine']  Task:Wash clothes  response:  {       thoughts : walk to the bathroom, grab the basket for clothes, find soap, put in washing machine, turn on,       actions : ['[WALK] <bathroom>', '[WALK] <basket_for_clothes>', '[FIND] <basket_for_clothes>', '[GRAB] <basket_for_clothes>', '[WALK] <washing_machine>', '[OPEN] <washing_machine>', '[PUTBACK] <basket_for_clothes> <washing_machine>', '[FIND] <soap>', '[GRAB] <soap>', '[WALK] <washing_machine>', '[PUTBACK] <soap> <washing_machine>', '[CLOSE] <washing_machine>', '[SWITCHON] <washing_machine>']  }     Scene_Objects:['sheets', 'microwave', 'chair', 'freezer', 'food_butter', 'drawing', 'food_egg', 'floor', 'ceiling', 'character', 'stovefan', 'ceilinglamp', 'faucet', 'shower', 'couch', 'wall', 'nightstand', 'bench', 'oven', 'cup', 'novel', 'ice', 'curtain', 'doorjamb', 'kettle', 'pencil', 'headset', 'sink', 'bathroom_cabinet', 'light']  Task:Drink  response:

{  Walk into kitchen, look for cup, walk to cup, look for refrigerator, walk to refrigerator, open door, grab water, pour water into 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:['toilet', 'bathroom', 'trashcan', 'cpuscreen', 'bathroom_counter', 'floor', 'ceiling', 'phone', 'desk', 'bookshelf', 'alcohol', 'mat', 'electric_shaver', 'oil', 'wall', 'powersocket', 'box', 'food_cheese', 'photoframe', 'bed', 'food_food', 'coffe_maker', 'doorjamb', 'lighter', 'dishrack', 'door', 'bathroom_cabinet', 'light', 'dishwasher', 'coffee']  Task:Turn on light  response:  {       thoughts : push any ligth button to turn it on, for example in the living room,       actions : ['[WALK] <home_office>', '[WALK] <light>', '[FIND] <light>', '[SWITCHON] <light>']  }     Scene_Objects:['glue', 'pot', 'chair', 'band-aids', 'detergent', 'drawing', 'needle', 'hanger', 'floor', 'ceiling', 'phone', 'desk', 'computer', 'stovefan', 'ceilinglamp', 'tvstand', 'towel', 'dining_room', 'wall', 'basket_for_clothes', 'novel', 'after_shave', 'doorjamb', 'centerpiece', 'headset', 'dresser', 'cupboard', 'door', 'light', 'scrabble']  Task:Turn on light  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_salt', 'toilet', 'walllamp', 'food_carrot', 'knife', 'wallshelf', 'thread', 'envelope', 'computer', 'stovefan', 'ceilinglamp', 'shower', 'couch', 'pillow', 'broom', 'wall', 'bench', 'powersocket', 'tape', 'shelf', 'basket_for_clothes', 'photoframe', 'bed', 'oven_mitts', 'towel_rack', 'shaving_cream', 'kitchen_counter', 'shoes', 'table', 'shoe_rack']  Task:Listen to music  response:  {       thoughts : I walk to the living room. I find a radio there and switch it on to listen to music.,       actions : ['[WALK] <home_office>', '[WALK] <stereo>', '[FIND] <stereo>', '[SWITCHON] <stereo>']  }     Scene_Objects:['scissors', 'microwave', 'toilet', 'freezer', 'ceilingfan', 'drawing', 'knifeblock', 'food_egg', 'cpuscreen', 'clothes_underwear', 'tea_bag', 'keyboard', 'faucet', 'clothes_socks', 'food_noodles', 'dining_room', 'bench', 'cup', 'bed', 'check', 'toilet_paper', 'television', 'after_shave', 'console', 'comb', 'hairbrush', 'cupboard', 'bathroom_cabinet', 'board_game', 'teeth']  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:['tablelamp', 'chair', 'walllamp', 'drawing', 'orchid', 'cpuscreen', 'wallshelf', 'hanger', 'clothes_underwear', 'floor', 'ceiling', 'phone', 'desk', 'keyboard', 'computer', 'button', 'mat', 'ceilinglamp', 'tvstand', 'mousepad', 'couch', 'pillow', 'wall', 'nightstand', 'oven', 'television', 'doorjamb', 'mouse', 'dresser', 'door']  Task:Work  response:  {       thoughts : Go to the computer, sit in the chair, pull up computer screen get the mouse and keyboard load work software,       actions : ['[WALK] <home_office>', '[WALK] <chair>', '[FIND] <chair>', '[SIT] <chair>', '[FIND] <computer>', '[SWITCHON] <computer>', '[TURNTO] <computer>', '[LOOKAT] <computer>', '[FIND] <mouse>', '[GRAB] <mouse>', '[FIND] <mousepad>', '[PUTBACK] <mouse> <mousepad>', '[TURNTO] <computer>', '[POINTAT] <computer>', '[PULL] <mouse>', '[FIND] <button>', '[PUSH] <button>', '[GRAB] <mouse>', '[PUTOBJBACK] <mouse>', '[FIND] <keyboard>', '[TYPE] <keyboard>']  }     Scene_Objects:['pot', 'food_bread', 'ceilingfan', 'drawing', 'knife', 'longboard', 'floor', 'ceiling', 'keyboard', 'remote_control', 'ceilinglamp', 'tvstand', 'balanceball', 'laptop', 'window', 'foundation', 'clothes_socks', 'couch', 'dining_room', 'broom', 'wall', 'cup', 'coffee_table', 'television', 'toothbrush_holder', 'curtain', 'lighter', 'mouse', 'maindoor', 'table']  Task:Watch TV  response:

{  Sit down, turn on the TV with the remote control that is on the coffee 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:['toilet', 'ceilingfan', 'drawing', 'knife', 'cpuscreen', 'floor', 'ceiling', 'desk', 'remote_control', 'button', 'toaster', 'ceilinglamp', 'tvstand', 'balanceball', 'window', 'couch', 'food_orange', 'dining_room', 'wall', 'tape', 'photoframe', 'television', 'tray', 'curtain', 'kitchen_counter', 'vacuum_cleaner', 'sink', 'instrument_guitar', 'table', 'bathroom_cabinet']  Task:Watch TV  response:  {       thoughts : Walk to living room.  Find remote control.  Find television.  Point remote at television.  Press  on  button.  Watch.,       actions : ['[WALK] <home_office>', '[WALK] <television>', '[FIND] <television>', '[FIND] <remote_control>', '[TURNTO] <television>', '[POINTAT] <television>', '[FIND] <button>', '[PUSH] <button>', '[TURNTO] <television>', '[WATCH] <television>']  }     Scene_Objects:['crayon', 'chair', 'ground_coffee', 'trashcan', 'dough', 'toothbrush', 'knifeblock', 'hanger', 'floor', 'ceiling', 'phone', 'desk', 'computer', 'mop_bucket', 'toaster', 'stovefan', 'dining_room', 'food_kiwi', 'wall', 'nightstand', 'oven', 'bed', 'doorjamb', 'mouse', 'dresser', 'cupboard', 'door', 'light', 'board_game', 'coffee']  Task:Pick up phone  response:

{  I walk to the kitchen and find the phone. I pick up the phone. I hold it to my ear. }


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', '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:  {       thoughts : Walk to bathroom. Open washing maschine. Grab pants and put it into washing maschine. Pour laundry detergent into washing machine and close the washing maschine. Plug in washing machine.,       actions : ['[WALK] <bathroom>', '[WALK] <washing_machine>', '[FIND] <washing_machine>', '[OPEN] <washing_machine>', '[FIND] <clothes_pants>', '[GRAB] <clothes_pants>', '[PUTBACK] <clothes_pants> <washing_machine>', '[WALK] <laundry_detergent>', '[FIND] <laundry_detergent>', '[GRAB] <laundry_detergent>', '[POUR] <laundry_detergent> <washing_machine>', '[CLOSE] <washing_machine>', '[PLUGIN] <washing_machine>']  }     Scene_Objects:['pot', 'food_pizza', 'walllamp', 'trashcan', 'knifeblock', 'drawing', 'needle', 'floor', 'ceiling', 'clothes_jacket', 'stovefan', 'toaster', 'window', 'homework', 'oil', 'dustpan', 'bowl', 'wall', 'pasta', 'oven', 'toy', 'food_food', 'oven_mitts', 'tray', 'kitchen_counter', 'napkin', 'table', 'dishwasher', 'laser_pointer', 'teeth']  Task:Cook some food  response:

{  I switch on the stove and cook my groceries there. }


Input: You serve as an AI task planner.   1. Your task is to create a plan to achieve a goal by converting it into a sequence of actions. Each action should follow the format  [verb] <target1> <target2> , where 'verb' represents the action, and 'target1' and 'target2' are optional arguments.  2. You must describe your plan in natural language at the beginning. After that, you should list all the actions together.   Ensure that you response can be parsed by Python json.loads.      Here is an example plan to achieve a goal for reference:   Scene_Objects:['food_salt', 'freezer', 'walllamp', 'drawing', 'floor', 'ceiling', 'bookshelf', 'mail', 'table_cloth', 'shower', 'foundation', 'dustpan', 'microphone', 'wall', 'powersocket', 'food_food', 'check', 'television', 'rag', 'doorjamb', 'kitchen_counter', 'shoes', 'cupboard', 'door', 'sink', 'hairdryer', 'light', 'clothes_skirt', 'scrabble', 'creditcard']  Task:Turn off light  response:  {       thoughts : Hit the switch.,       actions : ['[WALK] <bedroom>', '[WALK] <light>', '[SWITCHOFF] <light>']  }     Scene_Objects:['glue', 'pot', 'blow_dryer', 'ceilingfan', 'drawing', 'bathroom_counter', 'floor', 'stovefan', 'ceilinglamp', 'balanceball', 'stereo', 'window', 'shower', 'clothes_socks', 'couch', 'candle', 'broom', 'wall', 'wall_clock', 'bed', 'television', 'curtain', 'pencil', 'kitchen_counter', 'dresser', 'napkin', 'spoon', 'table', 'dirt', 'creditcard']  Task:Relax on sofa  response: