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', 'toilet', 'walllamp', 'bills', 'drawing', 'cpuscreen', 'bathroom_counter', 'ceiling', 'cleaning_solution', 'mop_bucket', 'table_cloth', 'faucet', 'shower', 'iron', 'clothes_socks', 'pillow', 'wall', 'food_food', 'mirror', 'wine', 'doorjamb', 'coffee_pot', 'paper_towel', 'cupboard', 'conditioner', 'door', 'sink', 'bathroom_cabinet', 'dishwasher', 'scrabble']  Task:Clean mirror  response:  {       thoughts : First spray the mirrors with Windex or window type spray.  Take paper towels and wipe until sparkly clean.  If they have streaks, repeat the process.,       actions : ['[WALK] <bathroom>', '[WALK] <bathroom_cabinet>', '[OPEN] <bathroom_cabinet>', '[FIND] <paper_towel>', '[GRAB] <paper_towel>', '[CLOSE] <bathroom_cabinet>', '[WALK] <mirror>', '[FIND] <cleaning_solution>', '[RINSE] <cleaning_solution>', '[WIPE] <mirror>']  }     Scene_Objects:['pot', 'detergent', 'drawing', 'floor', 'ceiling', 'bookshelf', 'computer', 'stovefan', 'ceilinglamp', 'laptop', 'shower', 'window', 'oil', 'clothes_socks', 'couch', 'food_orange', 'pillow', 'wall', 'novel', 'coffe_maker', 'television', 'food_rice', 'rag', 'doorjamb', 'cupboard', 'door', 'sink', 'napkin', 'table', 'light']  Task:Relax  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:['juice', 'toilet', 'chair', 'freezer', 'detergent', 'food_carrot', 'drawing', 'knifeblock', 'floor', 'ceiling', 'food_chicken', 'bedroom', 'piano_bench', 'ceilinglamp', 'mat', 'shower', 'faucet', 'oil', 'food_orange', 'wall', 'nightstand', 'powersocket', 'photoframe', 'food_food', 'check', 'doorjamb', 'vacuum_cleaner', 'door', 'table', 'light']  Task:Put groceries in Fridge  response:  {       thoughts : Put the groceries on the table into the fridge,       actions : ['[WALK] <dining_room>', '[WALK] <table>', '[FIND] <food_chicken>', '[GRAB] <food_chicken>', '[FIND] <freezer>', '[OPEN] <freezer>', '[PUTBACK] <food_chicken> <freezer>', '[CLOSE] <freezer>', '[FIND] <food_carrot>', '[GRAB] <food_carrot>', '[FIND] <freezer>', '[OPEN] <freezer>', '[PUTIN] <food_carrot> <freezer>', '[CLOSE] <freezer>']  }     Scene_Objects:['tablelamp', 'crayon', 'chair', 'freezer', 'trashcan', 'ceilingfan', 'drawing', 'cpuscreen', 'floor', 'ceiling', 'phone', 'desk', 'keyboard', 'bookshelf', 'computer', 'button', 'ceilinglamp', 'balanceball', 'mousepad', 'pillow', 'wall', 'nightstand', 'bench', 'razor', 'coin', 'doorjamb', 'mouse', 'conditioner', 'light', 'dishwasher']  Task:Turn on computer  response:


Input: You serve as an AI task planner.   1. Your task is to create a plan to achieve a goal by converting it into a sequence of actions. Each action should follow the format  [verb] <target1> <target2> , where 'verb' represents the action, and 'target1' and 'target2' are optional arguments.  2. You must describe your plan in natural language at the beginning. After that, you should list all the actions together.   Ensure that you response can be parsed by Python json.loads.      Here is an example plan to achieve a goal for reference:   Scene_Objects:['sheets', 'tablelamp', 'detergent', 'ceilingfan', 'hanger', 'bathroom_counter', 'phone', 'bedroom', 'bookshelf', 'keyboard', 'food_cake', 'clothes_jacket', 'button', 'laptop', 'tvstand', 'mat', 'dustpan', 'food_food', 'after_shave', 'towel_rack', 'pencil', 'kitchen_counter', 'laundry_detergent', 'sink', 'clothes_scarf', 'bathroom_cabinet', 'table', 'vase', 'washing_machine', 'coffee']  Task:Wash clothes  response:  {       thoughts :  I walk to entrance hall   I walk to bedroom   I find basket of clothes   I lift basket of  clothes   I walk to kitchen   I find washing machine   I open washing machine    I put laundry in washing machine   I add laundry detergent     I close washing machine lid   I switch washing machine on ,       actions : ['[WALK] <home_office>', '[WALK] <bedroom>', '[WALK] <basket_for_clothes>', '[FIND] <basket_for_clothes>', '[GRAB] <basket_for_clothes>', '[WALK] <dining_room>', '[WALK] <washing_machine>', '[FIND] <washing_machine>', '[OPEN] <washing_machine>', '[PUTBACK] <basket_for_clothes> <washing_machine>', '[FIND] <laundry_detergent>', '[GRAB] <laundry_detergent>', '[PUTBACK] <laundry_detergent> <washing_machine>', '[CLOSE] <washing_machine>', '[TURNTO] <washing_machine>']  }     Scene_Objects:['pot', 'chair', 'ceilingfan', 'trashcan', 'drawing', 'clothes_underwear', 'floor', 'ceiling', 'character', 'bookshelf', 'table_cloth', 'mop_bucket', 'ceilinglamp', 'tvstand', 'balanceball', 'mat', 'window', 'food_noodles', 'couch', 'wall', 'nightstand', 'food_food', 'television', 'curtain', 'cupboard', 'table', 'light', 'vase', 'dishwasher', 'dirt']  Task:Watch TV  response:

{  Sit on the couch or the chair or the floor and watch cable, movies, or netflix. }


Input: You serve as an AI task planner.   1. Your task is to create a plan to achieve a goal by converting it into a sequence of actions. Each action should follow the format  [verb] <target1> <target2> , where 'verb' represents the action, and 'target1' and 'target2' are optional arguments.  2. You must describe your plan in natural language at the beginning. After that, you should list all the actions together.   Ensure that you response can be parsed by Python json.loads.      Here is an example plan to achieve a goal for reference:   Scene_Objects:['tablelamp', 'chair', 'bathroom', 'cat', 'milk', 'orchid', 'floor', 'dvd_player', 'desk', 'keyboard', 'purse', 'table_cloth', 'mat', 'shower', 'window', 'clothes_socks', 'couch', 'clothes_pants', 'pillow', 'wall', 'powersocket', 'mouthwash', 'television', 'curtain', 'food_onion', 'doorjamb', 'kitchen_counter', 'bathtub', 'napkin', 'table']  Task:Pet cat  response:  {       thoughts : I walk into the living room. I see my cat on the couch. I go sit next to the cat on the couch. I pet the cat on the back.,       actions : ['[WALK] <home_office>', '[WALK] <cat>', '[FIND] <cat>', '[TURNTO] <cat>', '[LOOKAT] <cat>', '[FIND] <couch>', '[SIT] <couch>', '[TOUCH] <cat>']  }     Scene_Objects:['pot', 'chair', 'walllamp', 'trashcan', 'milk', 'knifeblock', 'hanger', 'floor', 'ceiling', 'phone', 'ceilinglamp', 'tvstand', 'stereo', 'electric_shaver', 'food_noodles', 'form', 'bowl', 'wall', 'nightstand', 'cup', 'check', 'toothbrush_holder', 'after_shave', 'towel_rack', 'kitchen_counter', 'dresser', 'cupboard', 'light', 'board_game', 'clothes_shirt']  Task:Put on coat  response:

{  Open closet and grab coat.  Put on coat and fasten the front closed.  Close closet. }


Input: You serve as an AI task planner.   1. Your task is to create a plan to achieve a goal by converting it into a sequence of actions. Each action should follow the format  [verb] <target1> <target2> , where 'verb' represents the action, and 'target1' and 'target2' are optional arguments.  2. You must describe your plan in natural language at the beginning. After that, you should list all the actions together.   Ensure that you response can be parsed by Python json.loads.      Here is an example plan to achieve a goal for reference:   Scene_Objects:['tablelamp', 'chair', 'walllamp', 'drawing', 'orchid', 'cpuscreen', 'wallshelf', 'hanger', 'floor', 'ceiling', 'phone', 'desk', 'keyboard', 'computer', 'mat', 'ceilinglamp', 'tvstand', 'mousepad', 'oil', 'couch', 'pillow', 'wall', 'nightstand', 'oven', 'television', 'doorjamb', 'mouse', 'dresser', 'door', 'creditcard']  Task:Browse internet  response:  {       thoughts : Walk to the Home office. Sit on the chair. Switch on the computer. Type with keyboard for internet.,       actions : ['[WALK] <home_office>', '[WALK] <chair>', '[FIND] <chair>', '[SIT] <chair>', '[FIND] <computer>', '[SWITCHON] <computer>', '[FIND] <keyboard>', '[TYPE] <keyboard>']  }     Scene_Objects:['tablelamp', 'food_salt', 'beer', 'toilet', 'freezer', 'trashcan', 'drawing', 'bathroom_counter', 'floor', 'ceiling', 'table_cloth', 'shoe-shine_kit', 'faucet', 'couch', 'candle', 'wall', 'nightstand', 'bench', 'powersocket', 'photoframe', 'video_game_controller', 'curtain', 'rag', 'console', 'cupboard', 'laundry_detergent', 'sink', 'bathroom_cabinet', 'table', 'colander']  Task:Wash sink  response:

{  I spray some cleaner and wait a minte or so then wipe it out. }


Input: You serve as an AI task planner.   1. Your task is to create a plan to achieve a goal by converting it into a sequence of actions. Each action should follow the format  [verb] <target1> <target2> , where 'verb' represents the action, and 'target1' and 'target2' are optional arguments.  2. You must describe your plan in natural language at the beginning. After that, you should list all the actions together.   Ensure that you response can be parsed by Python json.loads.      Here is an example plan to achieve a goal for reference:   Scene_Objects:['sheets', 'pot', 'drawing', 'knifeblock', 'cpuscreen', 'bathroom_counter', 'floor', 'ceiling', 'phone', 'mat', 'faucet', 'couch', 'dining_room', 'wall', 'newspaper', 'toilet_paper', 'television', 'oven_mitts', 'water', 'tray', 'vacuum_cleaner', 'controller', 'door', 'sink', 'napkin', 'bathroom_cabinet', 'instrument_guitar', 'light', 'soap', 'teeth']  Task:Wash teeth  response:  {       thoughts : Wash the teeth,       actions : ['[WALK] <bathroom>', '[WALK] <faucet>', '[FIND] <faucet>', '[SWITCHON] <faucet>', '[FIND] <water>', '[TURNTO] <water>', '[POINTAT] <water>', '[FIND] <teeth>', '[WASH] <teeth>', '[SWITCHOFF] <faucet>']  }     Scene_Objects:['pot', 'tablelamp', 'scissors', 'walllamp', 'bathroom', 'detergent', 'trashcan', 'knifeblock', 'cpuscreen', 'ceiling', 'character', 'stamp', 'bookshelf', 'stovefan', 'plate', 'faucet', 'balanceball', 'mousepad', 'wall', 'cup', 'bed', 'food_food', 'coffe_maker', 'wine', 'kitchen_counter', 'cupboard', 'hair', 'laundry_detergent', 'sink', 'table']  Task:Get out dish  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_ice_cream', 'toilet', 'walllamp', 'nail_polish', 'dough', 'orchid', 'wallshelf', 'floor', 'ceiling', 'bookshelf', 'remote_control', 'keyboard', 'computer', 'stovefan', 'mat', 'tvstand', 'ceilinglamp', 'shower', 'window', 'wall', 'nightstand', 'powersocket', 'photoframe', 'television', 'curtain', 'doorjamb', 'cards', 'dishrack', 'door', 'light']  Task:Change TV channel  response:  {       thoughts : first i will go to living room and then take the remote and swtitch on television after that il change the channel,       actions : ['[WALK] <home_office>', '[WALK] <television>', '[FIND] <television>', '[SWITCHON] <television>', '[FIND] <remote_control>', '[TURNTO] <remote_control>', '[POINTAT] <remote_control>', '[TOUCH] <remote_control>', '[TURNTO] <television>', '[WATCH] <television>']  }     Scene_Objects:['pot', 'blender', 'microwave', 'detergent', 'trashcan', 'drawing', 'cpuscreen', 'longboard', 'floor', 'keyboard', 'toaster', 'laptop', 'stereo', 'window', 'food_peanut_butter', 'dining_room', 'broom', 'nightstand', 'oven', 'cup', 'photoframe', 'bed', 'television', 'after_shave', 'curtain', 'pencil', 'bathroom_cabinet', 'light', 'dishwasher', 'vase']  Task:Clean  response:


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', 'glue', 'measuring_cup', 'microwave', 'chair', 'blow_dryer', 'knifeblock', 'drawing', 'orchid', 'floor', 'phone', 'bookshelf', 'toaster', 'ceilinglamp', 'plate', 'faucet', 'wall', 'nightstand', 'photoframe', 'food_food', 'coffee_pot', 'pencil', 'kitchen_counter', 'cupboard', 'door', 'sink', 'instrument_violin', 'table', 'soap', 'tooth_paste']  Task:Bring dirty plate to sink  response:  {       thoughts : Stand up from the table.  Pick up dirty plate.  Walk to sink.  Put plate in sink.,       actions : ['[WALK] <dining_room>', '[WALK] <table>', '[FIND] <table>', '[TURNTO] <table>', '[FIND] <plate>', '[GRAB] <plate>', '[WALK] <dining_room>', '[WALK] <sink>', '[FIND] <sink>', '[PUTBACK] <plate> <sink>']  }     Scene_Objects:['pot', 'food_salt', 'beer', 'chair', 'freezer', 'knifeblock', 'bathroom_counter', 'longboard', 'phone', 'keyboard', 'computer', 'food_bacon', 'tvstand', 'balanceball', 'stereo', 'mousepad', 'clothes_pants', 'nightstand', 'bench', 'bed', 'photoframe', 'novel', 'television', 'pencil', 'kitchen_counter', 'vacuum_cleaner', 'food_steak', 'sink', 'hairdryer', 'vase']  Task:Read book  response:

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


Input: You serve as an AI task planner.   1. Your task is to create a plan to achieve a goal by converting it into a sequence of actions. Each action should follow the format  [verb] <target1> <target2> , where 'verb' represents the action, and 'target1' and 'target2' are optional arguments.  2. You must describe your plan in natural language at the beginning. After that, you should list all the actions together.   Ensure that you response can be parsed by Python json.loads.      Here is an example plan to achieve a goal for reference:   Scene_Objects:['glue', 'beer', 'measuring_cup', 'toilet', 'freezer', 'food_carrot', 'drawing', 'food_egg', 'hanger', 'floor', 'ceiling', 'bedroom', 'mat', 'laptop', 'shower', 'tvstand', 'closetdrawer', 'food_orange', 'nightstand', 'wall', 'powersocket', 'food_cheese', 'photoframe', 'bed', 'food_food', 'drinking_glass', 'wine', 'doorjamb', 'door', 'light']  Task:Drink  response:  {       thoughts : Robot Drinks the water,       actions : ['[WALK] <dining_room>', '[WALK] <freezer>', '[FIND] <freezer>', '[OPEN] <freezer>', '[FIND] <drinking_glass>', '[GRAB] <drinking_glass>', '[DRINK] <drinking_glass>', '[PUTOBJBACK] <drinking_glass>', '[CLOSE] <freezer>']  }     Scene_Objects:['glue', 'sheets', 'food_bread', 'food_pizza', 'tablelamp', 'scissors', 'toilet', 'walllamp', 'woman', 'knifeblock', 'hanger', 'bathroom_counter', 'man', 'tea_bag', 'keyboard', 'mail', 'stereo', 'window', 'couch', 'child', 'powersocket', 'photoframe', 'novel', 'coffe_maker', 'video_game_controller', 'ice', 'rag', 'headset', 'chessboard', 'maindoor']  Task:Greet guests  response:

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


Input: You serve as an AI task planner.   1. Your task is to create a plan to achieve a goal by converting it into a sequence of actions. Each action should follow the format  [verb] <target1> <target2> , where 'verb' represents the action, and 'target1' and 'target2' are optional arguments.  2. You must describe your plan in natural language at the beginning. After that, you should list all the actions together.   Ensure that you response can be parsed by Python json.loads.      Here is an example plan to achieve a goal for reference:   Scene_Objects:['sheets', 'microwave', 'chair', 'bathroom', 'orchid', 'food_egg', 'cpuscreen', 'floor', 'phone', 'bedroom', 'desk', 'stovefan', 'toaster', 'ceilinglamp', 'shower', 'mat', 'food_peanut_butter', 'wall', 'pasta', 'powersocket', 'oven', 'cup', 'bed', 'after_shave', 'food_onion', 'chessboard', 'dresser', 'cupboard', 'clothes_scarf', 'home_office']  Task:Pet cat  response:  {       thoughts : I walk to my living room, find my cat, scrub it using my hand.,       actions : ['[WALK] <home_office>', '[WALK] <cat>', '[FIND] <cat>', '[SCRUB] <cat>']  }     Scene_Objects:['filing_cabinet', 'microwave', 'band-aids', 'drawing', 'longboard', 'floor', 'ceiling', 'folder', 'computer', 'clothes_jacket', 'alcohol', 'ceilinglamp', 'balanceball', 'window', 'foundation', 'couch', 'food_peanut_butter', 'wall', 'powersocket', 'oven', 'television', 'wine', 'towel_rack', 'pencil', 'shoes', 'dresser', 'cupboard', 'table', 'light', 'dishwasher']  Task:Arrange furniture  response:


Input: You serve as an AI task planner.   1. Your task is to create a plan to achieve a goal by converting it into a sequence of actions. Each action should follow the format  [verb] <target1> <target2> , where 'verb' represents the action, and 'target1' and 'target2' are optional arguments.  2. You must describe your plan in natural language at the beginning. After that, you should list all the actions together.   Ensure that you response can be parsed by Python json.loads.      Here is an example plan to achieve a goal for reference:   Scene_Objects:['pot', 'water_glass', 'microwave', 'toilet', 'chair', 'freezer', 'bathroom', 'wallshelf', 'bookshelf', 'clothes_jacket', 'toaster', 'ceilinglamp', 'faucet', 'window', 'closetdrawer', 'dining_room', 'nightstand', 'wall', 'wall_clock', 'powersocket', 'basket_for_clothes', 'novel', 'coffe_maker', 'tray', 'doorjamb', 'console', 'dishrack', 'hairdryer', 'door', 'bathtub']  Task:Drink  response:  {       thoughts : Drink water,       actions : ['[WALK] <dining_room>', '[WALK] <water_glass>', '[FIND] <water_glass>', '[GRAB] <water_glass>', '[DRINK] <water_glass>']  }     Scene_Objects:['food_pizza', 'nail_polish', 'food_carrot', 'drawing', 'knife', 'floor', 'ceiling', 'desk', 'mat', 'stereo', 'shower', 'clothes_socks', 'candle', 'pillow', 'dining_room', 'nightstand', 'bench', 'newspaper', 'check', 'video_game_controller', 'doorjamb', 'cards', 'chessboard', 'pajamas', 'clothes_dress', 'table', 'light', 'board_game', 'laser_pointer', 'coffee']  Task:Play games  response:

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


Input: You serve as an AI task planner.   1. Your task is to create a plan to achieve a goal by converting it into a sequence of actions. Each action should follow the format  [verb] <target1> <target2> , where 'verb' represents the action, and 'target1' and 'target2' are optional arguments.  2. You must describe your plan in natural language at the beginning. After that, you should list all the actions together.   Ensure that you response can be parsed by Python json.loads.      Here is an example plan to achieve a goal for reference:   Scene_Objects:['microwave', 'chair', 'food_butter', 'food_carrot', 'drawing', 'orchid', 'knifeblock', 'knife', 'cpuscreen', 'floor', 'ceiling', 'bookshelf', 'toaster', 'mat', 'food_noodles', 'couch', 'pillow', 'wall', 'bed', 'photoframe', 'food_food', 'curtain', 'doorjamb', 'towel_rack', 'cupboard', 'door', 'bathroom_cabinet', 'table', 'light', 'dirt']  Task:Relax on sofa  response:  {       thoughts : Relax on the sofa in the living room.,       actions : ['[WALK] <home_office>', '[WALK] <couch>', '[FIND] <couch>', '[SIT] <couch>']  }     Scene_Objects:['glue', 'pot', 'freezer', 'walllamp', 'bathroom', 'trashcan', 'knifeblock', 'drawing', 'orchid', 'floor', 'ceiling', 'bedroom', 'keyboard', 'stovefan', 'ceilinglamp', 'toaster', 'form', 'wall', 'oven', 'food_vegetable', 'photoframe', 'tray', 'kitchen_counter', 'cupboard', 'maindoor', 'home_office', 'dishwasher', 'clothes_skirt', 'soap', 'creditcard']  Task:Cook some food  response:

{  I prepare meals and cook them on the stove. }


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

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


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', 'microwave', 'chair', 'freezer', 'nail_polish', 'bathroom', 'food_butter', 'knifeblock', 'cpuscreen', 'hanger', 'ceiling', 'dvd_player', 'stamp', 'bookshelf', 'keyboard', 'computer', 'stovefan', 'mat', 'tvstand', 'iron', 'nightstand', 'oven', 'cutting_board', 'check', 'television', 'coin', 'tray', 'doorjamb', 'bathroom_cabinet', 'teeth']  Task:Answer door  response:  {       thoughts : Walk up to the door.  Open the door and greet whomever is out side,       actions : ['[WALK] <home_office>', '[WALK] <man>', '[FIND] <man>', '[GREET] <man>']  }     Scene_Objects:['crayon', 'cd_player', 'chair', 'toilet', 'walllamp', 'cat', 'hanger', 'floor', 'phone', 'remote_control', 'purse', 'alcohol', 'tvstand', 'iron', 'picture', 'window', 'wall', 'nightstand', 'powersocket', 'bench', 'cutting_board', 'basket_for_clothes', 'after_shave', 'doorjamb', 'kitchen_counter', 'comb', 'dresser', 'cupboard', 'door', 'light']  Task:Listen to music  response:

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


Input: You serve as an AI task planner.   1. Your task is to create a plan to achieve a goal by converting it into a sequence of actions. Each action should follow the format  [verb] <target1> <target2> , where 'verb' represents the action, and 'target1' and 'target2' are optional arguments.  2. You must describe your plan in natural language at the beginning. After that, you should list all the actions together.   Ensure that you response can be parsed by Python json.loads.      Here is an example plan to achieve a goal for reference:   Scene_Objects:['sponge', 'filing_cabinet', 'tablelamp', 'bathroom', 'trashcan', 'food_butter', 'cpuscreen', 'desk', 'bookshelf', 'computer', 'mop_bucket', 'mat', 'closetdrawer', 'form', 'dining_room', 'nightstand', 'bench', 'oven', 'powersocket', 'toy', 'photoframe', 'coffe_maker', 'television', 'towel_rack', 'mouse', 'kitchen_counter', 'dresser', 'bathtub', 'sink', 'home_office']  Task:Pick up toys  response:  {       thoughts : Grab toys off floor.  Put it in a container.,       actions : ['[WALK] <bedroom>', '[WALK] <toy>', '[FIND] <toy>', '[GRAB] <toy>', '[WALK] <filing_cabinet>', '[OPEN] <filing_cabinet>', '[PUTBACK] <toy> <filing_cabinet>', '[FIND] <toy>', '[GRAB] <toy>', '[WALK] <filing_cabinet>', '[PUTBACK] <toy> <filing_cabinet>', '[FIND] <toy>', '[GRAB] <toy>', '[WALK] <filing_cabinet>', '[PUTBACK] <toy> <filing_cabinet>', '[CLOSE] <filing_cabinet>']  }     Scene_Objects:['tablelamp', 'microwave', 'toilet', 'chair', 'trashcan', 'ceilingfan', 'drawing', 'cpuscreen', 'floor', 'ceiling', 'phone', 'desk', 'keyboard', 'bookshelf', 'computer', 'piano_bench', 'bookmark', 'ceilinglamp', 'balanceball', 'mousepad', 'wall', 'nightstand', 'powersocket', 'doorjamb', 'mouse', 'dresser', 'maindoor', 'light', 'instrument_violin', 'shoe_rack']  Task:Write an email  response:

{  Compose an email in the home office. }


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', 'blender', 'crayon', 'microwave', 'toilet', 'walllamp', 'milk', 'drawing', 'bathroom_counter', 'phone', 'desk', 'envelope', 'table_cloth', 'ceilinglamp', 'plate', 'faucet', 'picture', 'couch', 'clothes_pants', 'powersocket', 'bench', 'newspaper', 'tray', 'rag', 'kitchen_counter', 'laundry_detergent', 'soap', 'scrabble', 'washing_machine']  Task:Wash clothes  response:  {       thoughts : Walk to bathroom. Open washing maschine. Grab pants and put it into washing maschine. Pour laundry detergent into washing machine and close the washing maschine. Plug in washing machine.,       actions : ['[WALK] <bathroom>', '[WALK] <washing_machine>', '[FIND] <washing_machine>', '[OPEN] <washing_machine>', '[FIND] <clothes_pants>', '[GRAB] <clothes_pants>', '[PUTBACK] <clothes_pants> <washing_machine>', '[WALK] <laundry_detergent>', '[FIND] <laundry_detergent>', '[GRAB] <laundry_detergent>', '[POUR] <laundry_detergent> <washing_machine>', '[CLOSE] <washing_machine>', '[PLUGIN] <washing_machine>']  }     Scene_Objects:['filing_cabinet', 'tablelamp', 'crayon', 'freezer', 'bathroom', 'food_carrot', 'drawing', 'knifeblock', 'floor', 'desk', 'ceilinglamp', 'stereo', 'window', 'couch', 'food_orange', 'pillow', 'form', 'dining_room', 'wall', 'bench', 'coffe_maker', 'television', 'rag', 'pencil', 'comb', 'table', 'tooth_paste', 'clothes_shirt', 'scrabble', 'creditcard']  Task:Relax on sofa  response:

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


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

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


Input: You serve as an AI task planner.   1. Your task is to create a plan to achieve a goal by converting it into a sequence of actions. Each action should follow the format  [verb] <target1> <target2> , where 'verb' represents the action, and 'target1' and 'target2' are optional arguments.  2. You must describe your plan in natural language at the beginning. After that, you should list all the actions together.   Ensure that you response can be parsed by Python json.loads.      Here is an example plan to achieve a goal for reference:   Scene_Objects:['juice', 'food_ice_cream', 'blow_dryer', 'detergent', 'ceilingfan', 'drawing', 'hanger', 'longboard', 'floor', 'ceiling', 'phone', 'bedroom', 'keyboard', 'remote_control', 'ceilinglamp', 'tvstand', 'balanceball', 'faucet', 'window', 'shoe-shine_kit', 'couch', 'food_orange', 'wall', 'tape', 'television', 'curtain', 'kitchen_counter', 'conditioner', 'bathroom_cabinet', 'table']  Task:Relax on sofa  response:  {       thoughts : For relaxing walk to living room. Find the sofa to relax. Arrange the sofa to relax. Sit on the sofa to relaxing.,       actions : ['[WALK] <home_office>', '[WALK] <couch>', '[FIND] <couch>', '[FIND] <conditioner>', '[FIND] <remote_control>', '[FIND] <television>', '[SWITCHON] <television>', '[LIE] <couch>']  }     Scene_Objects:['pot', 'scissors', 'tea', 'chair', 'freezer', 'walllamp', 'trashcan', 'knifeblock', 'hanger', 'kitchen_cabinet', 'floor', 'ceiling', 'phone', 'food_chicken', 'button', 'stovefan', 'toaster', 'ceilinglamp', 'wall', 'oven', 'bed', 'food_food', 'tray', 'doorjamb', 'kitchen_counter', 'dresser', 'cupboard', 'door', 'light', 'dishwasher']  Task:Cook some food  response:

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


Input: You serve as an AI task planner.   1. Your task is to create a plan to achieve a goal by converting it into a sequence of actions. Each action should follow the format  [verb] <target1> <target2> , where 'verb' represents the action, and 'target1' and 'target2' are optional arguments.  2. You must describe your plan in natural language at the beginning. After that, you should list all the actions together.   Ensure that you response can be parsed by Python json.loads.      Here is an example plan to achieve a goal for reference:   Scene_Objects:['filing_cabinet', 'microwave', 'chair', 'walllamp', 'orchid', 'cpuscreen', 'wallshelf', 'bathroom_counter', 'floor', 'ceiling', 'phone', 'desk', 'keyboard', 'computer', 'ceilinglamp', 'tvstand', 'mat', 'mousepad', 'pillow', 'dining_room', 'wall', 'nightstand', 'powersocket', 'cutting_board', 'television', 'curtain', 'doorjamb', 'mouse', 'door', 'table']  Task:Watch youtube  response:  {       thoughts : Go to youtube.Com watch videos,       actions : ['[WALK] <home_office>', '[WALK] <chair>', '[FIND] <chair>', '[SIT] <chair>', '[FIND] <computer>', '[SWITCHON] <computer>', '[TURNTO] <computer>', '[LOOKAT] <computer>']  }     Scene_Objects:['tablelamp', 'beer', 'toilet', 'dough', 'toothbrush', 'drawing', 'floor', 'ceiling', 'computer', 'ceilinglamp', 'tvstand', 'stereo', 'shower', 'window', 'oil', 'couch', 'bowl', 'wall', 'oven', 'toy', 'cup', 'bed', 'food_food', 'television', 'wooden_spoon', 'towel_rack', 'comb', 'cupboard', 'table', 'dishwasher']  Task:Relax on sofa  response:

{  Walk to living room. Find couch. Sit on couch }


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', 'filing_cabinet', 'tablelamp', 'microwave', 'chair', 'bathroom', 'drawing', 'cpuscreen', 'floor', 'phone', 'desk', 'bedroom', 'ceilinglamp', 'shoe-shine_kit', 'faucet', 'clothes_pants', 'dining_room', 'wall', 'tape', 'basket_for_clothes', 'bed', 'coffe_maker', 'chessboard', 'clothes_dress', 'door', 'home_office', 'light', 'soap', 'washing_machine']  Task:Wash clothes  response:  {       thoughts : Walk to Bathroom. Find basket for clothes. Lift clothes dress from basket. Find washing machine. Walk to washing machine. Put clothes in washing machine. Put soap in washing machine. Switch on washing machine.,       actions : ['[WALK] <bathroom>', '[WALK] <basket_for_clothes>', '[FIND] <basket_for_clothes>', '[FIND] <clothes_dress>', '[GRAB] <clothes_dress>', '[FIND] <washing_machine>', '[WALK] <washing_machine>', '[OPEN] <washing_machine>', '[PUTBACK] <clothes_dress> <washing_machine>', '[FIND] <soap>', '[GRAB] <soap>', '[PUTBACK] <soap> <washing_machine>', '[CLOSE] <washing_machine>', '[SWITCHON] <washing_machine>']  }     Scene_Objects:['dry_pasta', 'toilet', 'ceilingfan', 'milk', 'knife', 'drawing', 'cpuscreen', 'bathroom_counter', 'floor', 'character', 'desk', 'keyboard', 'food_cake', 'computer', 'stovefan', 'deck_of_cards', 'mousepad', 'wall', 'wall_clock', 'photoframe', 'bed', 'video_game_controller', 'coffee_pot', 'mouse', 'door', 'bathroom_cabinet', 'light', 'soap', 'scrabble', 'coffee']  Task:Go to toilet  response:

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


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', 'detergent', 'food_butter', 'clothes_underwear', 'hanger', 'floor', 'stamp', 'bookshelf', 'computer', 'clothes_jacket', 'table_cloth', 'mat', 'shoe-shine_kit', 'clothes_socks', 'closetdrawer', 'couch', 'clothes_pants', 'basket_for_clothes', 'check', 'mouthwash', 'food_rice', 'vacuum_cleaner', 'laundry_detergent', 'clothes_dress', 'bathroom_cabinet', 'light', 'dishwasher', 'clothes_shirt', 'washing_machine', 'creditcard']  Task:Wash clothes  response:  {       thoughts : I grab the basket for clothes from the bedroom. I carry it and walk to the washing machine. I open the washing machine. I grab the dirty clothes. I put the clothes in the washing machine. I grab the laundry detergent and put it in the washing machine. I close the washing machine. I switch on the washing machine.,       actions : ['[WALK] <bedroom>', '[WALK] <basket_for_clothes>', '[FIND] <basket_for_clothes>', '[GRAB] <basket_for_clothes>', '[WALK] <washing_machine>', '[DROP] <basket_for_clothes>', '[OPEN] <washing_machine>', '[FIND] <clothes_pants>', '[GRAB] <clothes_pants>', '[PUTBACK] <clothes_pants> <washing_machine>', '[FIND] <clothes_shirt>', '[GRAB] <clothes_shirt>', '[PUTBACK] <clothes_shirt> <washing_machine>', '[FIND] <clothes_underwear>', '[GRAB] <clothes_underwear>', '[PUTBACK] <clothes_underwear> <washing_machine>', '[FIND] <clothes_socks>', '[GRAB] <clothes_socks>', '[PUTBACK] <clothes_socks> <washing_machine>', '[FIND] <laundry_detergent>', '[GRAB] <laundry_detergent>', '[PUTBACK] <laundry_detergent> <washing_machine>', '[GRAB] <laundry_detergent>', '[PUTOBJBACK] <laundry_detergent>', '[CLOSE] <washing_machine>', '[SWITCHON] <washing_machine>']  }     Scene_Objects:['filing_cabinet', 'tablelamp', 'beer', 'microwave', 'toilet', 'nail_polish', 'knifeblock', 'hanger', 'bedroom', 'keyboard', 'mail', 'button', 'mat', 'stereo', 'iron', 'shower', 'mousepad', 'dustpan', 'photoframe', 'newspaper', 'food_food', 'video_game_controller', 'coffe_maker', 'coin', 'curtain', 'kettle', 'napkin', 'home_office', 'light', 'teeth']  Task:Listen to music  response:

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


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', 'food_pizza', 'chair', 'cat', 'drawing', 'floor', 'tea_bag', 'bookshelf', 'thread', 'toaster', 'ceilinglamp', 'stovefan', 'window', 'couch', 'food_orange', 'wall', 'food_food', 'television', 'oven_mitts', 'food_onion', 'curtain', 'after_shave', 'comb', 'napkin', 'home_office', 'table', 'dishwasher', 'bathroom_cabinet', 'laser_pointer', 'scrabble']  Task:Relax on sofa  response:  {       thoughts : go to the living room,find the sofa,sat down in the sofa,take some relaxation.,       actions : ['[WALK] <home_office>', '[WALK] <couch>', '[FIND] <couch>', '[SIT] <couch>']  }     Scene_Objects:['blender', 'food_ice_cream', 'bathroom', 'cat', 'drawing', 'bills', 'bathroom_counter', 'floor', 'stovefan', 'ceilinglamp', 'mat', 'toaster', 'window', 'mousepad', 'couch', 'towel', 'wall', 'powersocket', 'tape', 'food_cheese', 'novel', 'television', 'wooden_spoon', 'curtain', 'shaving_cream', 'chessboard', 'shoes', 'food_steak', 'table', 'light']  Task:Relax on sofa  response:

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


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', 'blender', 'crayon', 'microwave', 'walllamp', 'drawing', 'hanger', 'floor', 'ceiling', 'character', 'bedroom', 'envelope', 'stovefan', 'window', 'oil', 'wall', 'powersocket', 'bench', 'toy', 'keys', 'food_donut', 'wooden_spoon', 'curtain', 'doorjamb', 'maindoor', 'bathtub', 'bathroom_cabinet', 'light', 'dirt', 'teeth']  Task:Turn on light  response:  {       thoughts : walk in kitchen. switch on light. walk in living room. switch on light.walk in entrance hall. switch on light.,       actions : ['[WALK] <dining_room>', '[WALK] <light>', '[FIND] <light>', '[SWITCHON] <light>', '[WALK] <home_office>', '[WALK] <home_office>']  }     Scene_Objects:['pot', 'crayon', 'microwave', 'chair', 'freezer', 'detergent', 'food_egg', 'hanger', 'floor', 'ceiling', 'toaster', 'plate', 'shower', 'mousepad', 'broom', 'wall', 'pasta', 'keys', 'novel', 'coffe_maker', 'toothbrush_holder', 'coffee_filter', 'wooden_spoon', 'towel_rack', 'controller', 'maindoor', 'sink', 'dishwasher', 'coffee', 'creditcard']  Task:Make coffee  response:

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


Input: You serve as an AI task planner.   1. Your task is to create a plan to achieve a goal by converting it into a sequence of actions. Each action should follow the format  [verb] <target1> <target2> , where 'verb' represents the action, and 'target1' and 'target2' are optional arguments.  2. You must describe your plan in natural language at the beginning. After that, you should list all the actions together.   Ensure that you response can be parsed by Python json.loads.      Here is an example plan to achieve a goal for reference:   Scene_Objects:['pot', 'filing_cabinet', 'tablelamp', 'tea', 'knifeblock', 'cpuscreen', 'folder', 'bedroom', 'table_cloth', 'toaster', 'plate', 'homework', 'oil', 'closetdrawer', 'powersocket', 'tape', 'bed', 'novel', 'coffe_maker', 'television', 'razor', 'wine', 'doorjamb', 'shoes', 'dishrack', 'headset', 'cupboard', 'hairdryer', 'light', 'shoe_rack']  Task:Listen to music  response:  {       thoughts : walk into living room, walk to stereo, turn on stereo, listen to music,       actions : ['[WALK] <home_office>', '[WALK] <stereo>', '[FIND] <stereo>', '[SWITCHON] <stereo>']  }     Scene_Objects:['pot', 'filing_cabinet', 'tablelamp', 'food_ice_cream', 'walllamp', 'ceilingfan', 'drawing', 'floor', 'ceiling', 'dvd_player', 'character', 'remote_control', 'toaster', 'ceilinglamp', 'tvstand', 'balanceball', 'window', 'electric_shaver', 'mousepad', 'couch', 'form', 'wall', 'nightstand', 'clothes_gloves', 'television', 'curtain', 'headset', 'maindoor', 'table', 'clothes_shirt']  Task:Watch TV  response:

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


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', 'food_pizza', 'filing_cabinet', 'microwave', 'chair', 'walllamp', 'orchid', 'knifeblock', 'bathroom_counter', 'ceiling', 'phone', 'stamp', 'keyboard', 'thread', 'computer', 'stovefan', 'toaster', 'plate', 'shower', 'mousepad', 'form', 'wall', 'food_cheese', 'bed', 'console', 'headset', 'dresser', 'spoon', 'bathroom_cabinet', 'bag']  Task:Walk to room  response:  {       thoughts : Leave the living room and enter the hall,       actions : ['[WALK] <home_office>', '[WALK] <home_office>']  }     Scene_Objects:['dry_pasta', 'filing_cabinet', 'toilet', 'detergent', 'ceilingfan', 'drawing', 'knifeblock', 'hanger', 'bathroom_counter', 'floor', 'ceiling', 'phone', 'remote_control', 'thread', 'toaster', 'ceilinglamp', 'tvstand', 'balanceball', 'faucet', 'window', 'shower', 'couch', 'pillow', 'wall', 'food_cheese', 'television', 'curtain', 'centerpiece', 'home_office', 'table']  Task:Watch TV  response:

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


Input: You serve as an AI task planner.   1. Your task is to create a plan to achieve a goal by converting it into a sequence of actions. Each action should follow the format  [verb] <target1> <target2> , where 'verb' represents the action, and 'target1' and 'target2' are optional arguments.  2. You must describe your plan in natural language at the beginning. After that, you should list all the actions together.   Ensure that you response can be parsed by Python json.loads.      Here is an example plan to achieve a goal for reference:   Scene_Objects:['food_pizza', 'tablelamp', 'chair', 'freezer', 'detergent', 'bathroom_counter', 'desk', 'bedroom', 'keyboard', 'button', 'stovefan', 'ceilinglamp', 'stereo', 'shower', 'window', 'clothes_socks', 'dining_room', 'nightstand', 'wall', 'bench', 'oven', 'powersocket', 'bed', 'television', 'curtain', 'doorjamb', 'dresser', 'napkin', 'bathroom_cabinet', 'soap']  Task:Listen to music  response:  {       thoughts : Walk into living room, look for radio, grab on button,       actions : ['[WALK] <home_office>', '[WALK] <stereo>', '[FIND] <stereo>', '[TURNTO] <stereo>', '[LOOKAT] <stereo>', '[FIND] <button>', '[GRAB] <button>']  }     Scene_Objects:['sheets', 'glue', 'chair', 'walllamp', 'ceilingfan', 'knife', 'orchid', 'cpuscreen', 'longboard', 'floor', 'ceiling', 'phone', 'character', 'desk', 'bookshelf', 'keyboard', 'computer', 'balanceball', 'mousepad', 'clothes_socks', 'bowl', 'wall', 'check', 'television', 'mouse', 'kitchen_counter', 'cd', 'door', 'light', 'soap']  Task:Pick up phone  response:

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


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:['glue', 'shoe_rack', 'food_salt', 'beer', 'measuring_cup', 'microwave', 'trashcan', 'food_carrot', 'orchid', 'drawing', 'bookshelf', 'envelope', 'alcohol', 'ceilinglamp', 'plate', 'food_jam', 'pillow', 'oven', 'newspaper', 'photoframe', 'coffe_maker', 'food_food', 'tray', 'lighter', 'doorjamb', 'coffee_pot', 'towel_rack', 'cupboard', 'hairdryer', 'creditcard']  Task:Pet cat  response:


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', 'sheets', 'food_bread', 'food_pizza', 'tablelamp', 'scissors', 'toilet', 'walllamp', 'woman', 'knifeblock', 'hanger', 'bathroom_counter', 'man', 'tea_bag', 'keyboard', 'mail', 'stereo', 'window', 'couch', 'child', 'powersocket', 'photoframe', 'novel', 'coffe_maker', 'video_game_controller', 'ice', 'rag', 'headset', 'chessboard', 'maindoor']  Task:Greet guests  response:  {       thoughts : Greet guests when they knock on the door and invite them to enter my home,       actions : ['[WALK] <home_office>', '[WALK] <child>', '[FIND] <child>', '[GREET] <child>', '[FIND] <man>', '[GREET] <man>', '[FIND] <woman>', '[GREET] <woman>']  }     Scene_Objects:['bathroom', 'ceilingfan', 'drawing', 'floor', 'ceiling', 'folder', 'character', 'remote_control', 'food_cake', 'toaster', 'ceilinglamp', 'tvstand', 'balanceball', 'picture', 'window', 'couch', 'wall', 'oven', 'bench', 'photoframe', 'coffee_table', 'food_food', 'television', 'curtain', 'lighter', 'towel_rack', 'controller', 'maindoor', 'table', 'light']  Task:Change TV channel  response:

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


Input: You serve as an AI task planner.   1. Your task is to create a plan to achieve a goal by converting it into a sequence of actions. Each action should follow the format  [verb] <target1> <target2> , where 'verb' represents the action, and 'target1' and 'target2' are optional arguments.  2. You must describe your plan in natural language at the beginning. After that, you should list all the actions together.   Ensure that you response can be parsed by Python json.loads.      Here is an example plan to achieve a goal for reference:   Scene_Objects:['pot', 'food_salt', 'beer', 'chair', 'freezer', 'knifeblock', 'bathroom_counter', 'longboard', 'phone', 'keyboard', 'computer', 'food_bacon', 'tvstand', 'balanceball', 'stereo', 'mousepad', 'clothes_pants', 'nightstand', 'bench', 'bed', 'photoframe', 'novel', 'television', 'pencil', 'kitchen_counter', 'vacuum_cleaner', 'food_steak', 'sink', 'hairdryer', 'vase']  Task:Read book  response:  {       thoughts : Go to the book shelf, get a book, open the book and read the book.,       actions : ['[WALK] <home_office>', '[WALK] <novel>', '[FIND] <novel>', '[GRAB] <novel>', '[READ] <novel>']  }     Scene_Objects:['beer', 'toilet', 'walllamp', 'detergent', 'dough', 'drawing', 'needle', 'bathroom_counter', 'floor', 'ceiling', 'dvd_player', 'desk', 'table_cloth', 'faucet', 'window', 'mousepad', 'couch', 'dining_room', 'wall', 'pasta', 'photoframe', 'food_food', 'check', 'food_donut', 'dishrack', 'cupboard', 'sink', 'clothes_scarf', 'bathroom_cabinet', 'soap']  Task:Wash hands  response:

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


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', 'crayon', 'microwave', 'toilet', 'chair', 'dough', 'drawing', 'knifeblock', 'clothes_underwear', 'floor', 'folder', 'bedroom', 'toaster', 'ceilinglamp', 'plate', 'faucet', 'candle', 'clothes_hat', 'wall', 'food_food', 'food_onion', 'cards', 'mouse', 'kitchen_counter', 'cupboard', 'conditioner', 'laundry_detergent', 'sink', 'bathroom_cabinet', 'dirt']  Task:Wash dishes by hand  response:  {       thoughts : I walk into the kitchen to the sink. I put dishes in sink and wash them with my hands,       actions : ['[WALK] <dining_room>', '[WALK] <plate>', '[FIND] <plate>', '[GRAB] <plate>', '[FIND] <sink>', '[PUTBACK] <plate> <sink>', '[WASH] <plate>']  }     Scene_Objects:['glue', 'food_pizza', 'tea', 'freezer', 'walllamp', 'knifeblock', 'food_egg', 'cpuscreen', 'bathroom_counter', 'phone', 'computer', 'toaster', 'brush', 'ceilinglamp', 'mat', 'window', 'mousepad', 'pillow', 'wall', 'clothes_gloves', 'novel', 'check', 'food_onion', 'console', 'kitchen_counter', 'vacuum_cleaner', 'hair', 'controller', 'bathroom_cabinet', 'instrument_violin']  Task:Read book  response:

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


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', 'tablelamp', 'microwave', 'toilet', 'freezer', 'walllamp', 'trashcan', 'drawing', 'wallshelf', 'floor', 'ceiling', 'phone', 'toaster', 'stovefan', 'mat', 'faucet', 'shower', 'window', 'wall', 'wall_clock', 'oven', 'coffe_maker', 'water', 'tray', 'doorjamb', 'towel_rack', 'kitchen_counter', 'cupboard', 'door', 'sink']  Task:Drink  response:  {       thoughts : I need to go to Kitchen.  Get a cup.  Fill cup.  Drink,       actions : ['[WALK] <dining_room>', '[WALK] <cupboard>', '[FIND] <cupboard>', '[OPEN] <cupboard>', '[FIND] <water_glass>', '[GRAB] <water_glass>', '[WALK] <freezer>', '[WALK] <water>', '[FIND] <water>', '[GRAB] <water>', '[POUR] <water> <water_glass>', '[DRINK] <water_glass>']  }     Scene_Objects:['tablelamp', 'toilet', 'chair', 'walllamp', 'trashcan', 'ceilingfan', 'drawing', 'cpuscreen', 'floor', 'ceiling', 'phone', 'desk', 'bookshelf', 'keyboard', 'computer', 'bookmark', 'ceilinglamp', 'balanceball', 'shower', 'mousepad', 'pillow', 'wall', 'nightstand', 'photoframe', 'doorjamb', 'cards', 'mouse', 'bathroom_cabinet', 'light', 'soap']  Task:Work  response:

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


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', 'juice', 'dog', 'orchid', 'floor', 'desk', 'button', 'clothes_jacket', 'mat', 'stereo', 'shower', 'window', 'couch', 'pillow', 'wall', 'wall_clock', 'bench', 'cutting_board', 'toilet_paper', 'mouthwash', 'television', 'curtain', 'after_shave', 'doorjamb', 'hair', 'food_steak', 'napkin', 'home_office', 'table', 'vase']  Task:Listen to music  response:  {       thoughts : sitting down to listen to music on the radio,       actions : ['[WALK] <home_office>', '[WALK] <stereo>', '[FIND] <stereo>', '[SWITCHON] <stereo>', '[FIND] <couch>', '[SIT] <couch>']  }     Scene_Objects:['pot', 'filing_cabinet', 'beer', 'crayon', 'detergent', 'drawing', 'food_egg', 'floor', 'ceiling', 'bedroom', 'brush', 'mat', 'ceilinglamp', 'shower', 'balanceball', 'window', 'couch', 'towel', 'wall', 'bench', 'light_bulb', 'television', 'water', 'curtain', 'mouse', 'kitchen_counter', 'door', 'home_office', 'soap', 'laser_pointer']  Task:Take shower  response:

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


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', 'walllamp', 'cat', 'drawing', 'wallshelf', 'cpuscreen', 'floor', 'phone', 'desk', 'bookshelf', 'stovefan', 'mat', 'tvstand', 'ceilinglamp', 'toaster', 'window', 'oil', 'closetdrawer', 'couch', 'form', 'pillow', 'wall', 'wall_clock', 'coffe_maker', 'television', 'curtain', 'mouse', 'home_office', 'table', 'coffee']  Task:Pet cat  response:  {       thoughts : I walk into the living room. I see my cat on the couch. I go sit next to the cat on the couch. I pet the cat on the back.,       actions : ['[WALK] <home_office>', '[WALK] <cat>', '[FIND] <cat>', '[TURNTO] <cat>', '[LOOKAT] <cat>', '[FIND] <couch>', '[SIT] <couch>', '[TOUCH] <cat>']  }     Scene_Objects:['sheets', 'scissors', 'toilet', 'jelly', 'ground_coffee', 'ceilingfan', 'drawing', 'bathroom_counter', 'floor', 'ceiling', 'bookshelf', 'clothes_jacket', 'faucet', 'mousepad', 'wall', 'oven', 'cup', 'photoframe', 'video_game_controller', 'television', 'tray', 'doorjamb', 'mouse', 'conditioner', 'sink', 'bathroom_cabinet', 'home_office', 'vase', 'soap', 'hands_both']  Task:Wash hands  response:


Input: You serve as an AI task planner.   1. Your task is to create a plan to achieve a goal by converting it into a sequence of actions. Each action should follow the format  [verb] <target1> <target2> , where 'verb' represents the action, and 'target1' and 'target2' are optional arguments.  2. You must describe your plan in natural language at the beginning. After that, you should list all the actions together.   Ensure that you response can be parsed by Python json.loads.      Here is an example plan to achieve a goal for reference:   Scene_Objects:['tea', 'toilet', 'walllamp', 'bathroom', 'detergent', 'drawing', 'bills', 'floor', 'character', 'bookshelf', 'computer', 'stovefan', 'ceilinglamp', 'tvstand', 'stereo', 'closetdrawer', 'form', 'dining_room', 'nightstand', 'powersocket', 'cup', 'bed', 'tray', 'mouse', 'kitchen_counter', 'cupboard', 'bathroom_cabinet', 'home_office', 'dirt', 'electrical_outlet']  Task:Turn on radio  response:  {       thoughts : Go to the radio.  Switch on the power button.  Tune the station.  Set the volume.  Listen to the music.,       actions : ['[WALK] <home_office>', '[WALK] <stereo>', '[FIND] <stereo>', '[FIND] <electrical_outlet>', '[TURNTO] <electrical_outlet>', '[PLUGIN] <stereo>', '[SWITCHON] <electrical_outlet>', '[SWITCHON] <stereo>']  }     Scene_Objects:['microwave', 'toilet', 'chair', 'freezer', 'ceilingfan', 'drawing', 'cpuscreen', 'floor', 'ceiling', 'desk', 'bookshelf', 'keyboard', 'computer', 'ceilinglamp', 'tvstand', 'balanceball', 'faucet', 'window', 'mousepad', 'couch', 'dining_room', 'wall', 'television', 'toothbrush_holder', 'curtain', 'kettle', 'mouse', 'bag', 'table', 'vase']  Task:Watch TV  response:

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


Input: You serve as an AI task planner.   1. Your task is to create a plan to achieve a goal by converting it into a sequence of actions. Each action should follow the format  [verb] <target1> <target2> , where 'verb' represents the action, and 'target1' and 'target2' are optional arguments.  2. You must describe your plan in natural language at the beginning. After that, you should list all the actions together.   Ensure that you response can be parsed by Python json.loads.      Here is an example plan to achieve a goal for reference:   Scene_Objects:['pot', 'water_glass', 'microwave', 'toilet', 'drawing', 'wallshelf', 'ceiling', 'desk', 'bookmark', 'toaster', 'stovefan', 'mat', 'shower', 'couch', 'wall', 'oven', 'coffe_maker', 'coin', 'water', 'tray', 'towel_rack', 'kitchen_counter', 'shoes', 'vacuum_cleaner', 'cupboard', 'controller', 'hairdryer', 'spoon', 'dishwasher', 'creditcard']  Task:Drink  response:  {       thoughts : I go to the kitchen, take a glass from the cupboard, fill with water and drink,       actions : ['[WALK] <dining_room>', '[WALK] <cupboard>', '[FIND] <cupboard>', '[OPEN] <cupboard>', '[FIND] <water_glass>', '[GRAB] <water_glass>', '[WALK] <water>', '[FIND] <water>', '[GRAB] <water>', '[POUR] <water> <water_glass>', '[DRINK] <water_glass>', '[RINSE] <water_glass>', '[PUTBACK] <water_glass> <cupboard>']  }     Scene_Objects:['glue', 'pot', 'food_ice_cream', 'walllamp', 'nail_polish', 'detergent', 'knife', 'needle', 'cpuscreen', 'bathroom_counter', 'character', 'bedroom', 'remote_control', 'envelope', 'alcohol', 'button', 'deck_of_cards', 'iron', 'nightstand', 'pasta', 'television', 'wine', 'towel_rack', 'mouse', 'dresser', 'cupboard', 'door', 'bathroom_cabinet', 'dishwasher', 'vase']  Task:Change TV channel  response:

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


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', 'toilet', 'chair', 'freezer', 'walllamp', 'blow_dryer', 'toothbrush', 'drawing', 'kitchen_cabinet', 'floor', 'ceiling', 'character', 'bedroom', 'keyboard', 'ceilinglamp', 'stereo', 'shower', 'foundation', 'food_peanut_butter', 'towel', 'wall', 'clothes_gloves', 'food_food', 'toilet_paper', 'tray', 'after_shave', 'dresser', 'cupboard', 'door', 'light']  Task:Look in refrigerator  response:  {       thoughts : Approach the refrigerator. Use the handle to open the refrigerator door. Look at each shelf of the refrigerator. Look in each refrigerator drawer. Close the refrigerator door.,       actions : ['[WALK] <dining_room>', '[WALK] <freezer>', '[FIND] <freezer>', '[TURNTO] <freezer>', '[WALK] <freezer>', '[OPEN] <freezer>', '[TURNTO] <freezer>', '[LOOKAT] <freezer>', '[FIND] <kitchen_cabinet>', '[OPEN] <kitchen_cabinet>', '[FIND] <food_food>', '[CLOSE] <kitchen_cabinet>', '[CLOSE] <freezer>']  }     Scene_Objects:['juice', 'bathroom', 'ceilingfan', 'drawing', 'bills', 'knife', 'orchid', 'floor', 'ceiling', 'bookshelf', 'remote_control', 'button', 'bookmark', 'ceilinglamp', 'tvstand', 'balanceball', 'mat', 'window', 'couch', 'pillow', 'wall', 'oven', 'keys', 'television', 'coffee_filter', 'curtain', 'centerpiece', 'cupboard', 'bathroom_cabinet', 'table']  Task:Change TV channel  response:


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', 'microwave', 'toilet', 'food_carrot', 'drawing', 'orchid', 'wallshelf', 'floor', 'ceiling', 'folder', 'tea_bag', 'mat', 'shower', 'window', 'mousepad', 'couch', 'pillow', 'wall', 'pasta', 'nightstand', 'photoframe', 'novel', 'food_food', 'tray', 'curtain', 'doorjamb', 'door', 'table', 'light', 'board_game']  Task:Read book  response:  {       thoughts : Bring book, lie on the sofa, read book,       actions : ['[WALK] <home_office>', '[WALK] <novel>', '[GRAB] <novel>', '[WALK] <couch>', '[LIE] <couch>', '[READ] <novel>']  }     Scene_Objects:['sponge', 'fork', 'sheets', 'tablelamp', 'mop', 'detergent', 'ceilingfan', 'milk', 'hanger', 'ceiling', 'desk', 'window', 'mousepad', 'clothes_socks', 'clothes_pants', 'pillow', 'dining_room', 'bench', 'cutting_board', 'bed', 'novel', 'check', 'television', 'curtain', 'cards', 'towel_rack', 'cd', 'shoes', 'napkin', 'table']  Task:Pick up phone  response:


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', 'filing_cabinet', 'tea', 'microwave', 'dog', 'freezer', 'walllamp', 'drawing', 'orchid', 'hanger', 'keyboard', 'button', 'ceilinglamp', 'stereo', 'homework', 'mousepad', 'closetdrawer', 'food_peanut_butter', 'food_jam', 'wall', 'oven', 'food_cheese', 'keys', 'tray', 'lighter', 'mouse', 'kitchen_counter', 'cd', 'clothes_dress', 'bathroom_cabinet']  Task:Pet cat  response:  {       thoughts : Petting the cat,       actions : ['[WALK] <home_office>', '[WALK] <cat>', '[FIND] <cat>', '[TOUCH] <cat>']  }     Scene_Objects:['sponge', 'juice', 'freezer', 'ceilingfan', 'drawing', 'knifeblock', 'bathroom_counter', 'floor', 'ceiling', 'longboard', 'desk', 'mop_bucket', 'stovefan', 'toaster', 'faucet', 'food_jam', 'wall', 'photoframe', 'novel', 'coffe_maker', 'video_game_controller', 'shaving_cream', 'towel_rack', 'hairbrush', 'sink', 'bathroom_cabinet', 'home_office', 'vase', 'soap', 'hands_both']  Task:Wash hands  response:


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', 'dog', 'bathroom', 'drawing', 'cpuscreen', 'floor', 'ceiling', 'desk', 'piano_bench', 'stovefan', 'toaster', 'mat', 'faucet', 'shower', 'pillow', 'towel', 'wall', 'oven', 'coffe_maker', 'television', 'coffee_filter', 'tray', 'doorjamb', 'towel_rack', 'kitchen_counter', 'cupboard', 'door', 'sink', 'bathtub', 'coffee']  Task:Make coffee  response:  {       thoughts : Open coffee maker. Put filter in main basket, put ground coffee in filter, fill reservoir with water, turn on coffee maker.,       actions : ['[WALK] <dining_room>', '[WALK] <coffe_maker>', '[FIND] <coffe_maker>', '[OPEN] <coffe_maker>', '[FIND] <coffee_filter>', '[GRAB] <coffee_filter>', '[PUTBACK] <coffee_filter> <coffe_maker>', '[FIND] <coffee>', '[GRAB] <coffee>', '[PUTBACK] <coffee> <coffe_maker>']  }     Scene_Objects:['filing_cabinet', 'microwave', 'toilet', 'freezer', 'cat', 'orchid', 'drawing', 'hanger', 'ceiling', 'dvd_player', 'desk', 'mail', 'piano_bench', 'toaster', 'mat', 'tvstand', 'ceilinglamp', 'mousepad', 'food_orange', 'pillow', 'bench', 'bed', 'check', 'doorjamb', 'cd', 'controller', 'laundry_detergent', 'sink', 'home_office', 'dishwasher']  Task:Pet cat  response:

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


Input: You serve as an AI task planner.   1. Your task is to create a plan to achieve a goal by converting it into a sequence of actions. Each action should follow the format  [verb] <target1> <target2> , where 'verb' represents the action, and 'target1' and 'target2' are optional arguments.  2. You must describe your plan in natural language at the beginning. After that, you should list all the actions together.   Ensure that you response can be parsed by Python json.loads.      Here is an example plan to achieve a goal for reference:   Scene_Objects:['sheets', 'walllamp', 'drawing', 'needle', 'wallshelf', 'floor', 'ceiling', 'shampoo', 'character', 'computer', 'toaster', 'mat', 'tvstand', 'deck_of_cards', 'stovefan', 'ceilinglamp', 'couch', 'pillow', 'wall', 'nightstand', 'photoframe', 'coffe_maker', 'television', 'tray', 'doorjamb', 'pencil', 'conditioner', 'door', 'table', 'dishwasher']  Task:Relax on sofa  response:  {       thoughts : Walk to living room. Find couch. Sit on couch,       actions : ['[WALK] <home_office>', '[WALK] <couch>', '[FIND] <couch>', '[SIT] <couch>']  }     Scene_Objects:['fork', 'food_bread', 'filing_cabinet', 'tablelamp', 'freezer', 'walllamp', 'trashcan', 'milk', 'knifeblock', 'bills', 'floor', 'ceiling', 'character', 'food_cake', 'piano_bench', 'brush', 'ceilinglamp', 'mousepad', 'towel', 'wall', 'bed', 'food_food', 'food_donut', 'ice', 'curtain', 'kettle', 'dresser', 'light', 'soap', 'coffee']  Task:Put groceries in Fridge  response:

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


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_pizza', 'mop', 'cat', 'knife', 'drawing', 'bathroom_counter', 'floor', 'ceiling', 'shampoo', 'dvd_player', 'keyboard', 'computer', 'mat', 'ceilinglamp', 'faucet', 'stereo', 'window', 'couch', 'towel', 'wall', 'novel', 'tray', 'doorjamb', 'hairbrush', 'sink', 'bathroom_cabinet', 'soap', 'hands_both', 'shoe_rack']  Task:Wash hands  response:  {       thoughts : I go to the sink, turn on the water,  put soap on my hands, rub them together, then rinse them off and turn off the water. I then towel off my hands.,       actions : ['[WALK] <bathroom>', '[WALK] <sink>', '[FIND] <faucet>', '[SWITCHON] <faucet>', '[FIND] <soap>', '[GRAB] <soap>', '[FIND] <hands_both>', '[WASH] <hands_both>', '[RINSE] <hands_both>', '[SWITCHOFF] <faucet>', '[FIND] <towel>', '[GRAB] <towel>', '[FIND] <hands_both>', '[WIPE] <hands_both>']  }     Scene_Objects:['dry_pasta', 'pot', 'ceilingfan', 'toothbrush', 'knifeblock', 'drawing', 'bathroom_counter', 'floor', 'ceiling', 'phone', 'piano_bench', 'toaster', 'faucet', 'window', 'mousepad', 'clothes_pants', 'wall', 'nightstand', 'pasta', 'photoframe', 'toothbrush_holder', 'shoes', 'dresser', 'clothes_dress', 'door', 'sink', 'bathroom_cabinet', 'clothes_skirt', 'tooth_paste', 'laser_pointer']  Task:Brush teeth  response:

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


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', 'glue', 'measuring_cup', 'microwave', 'chair', 'blow_dryer', 'knifeblock', 'drawing', 'orchid', 'floor', 'phone', 'bookshelf', 'toaster', 'ceilinglamp', 'plate', 'faucet', 'wall', 'nightstand', 'photoframe', 'food_food', 'coffee_pot', 'pencil', 'kitchen_counter', 'cupboard', 'door', 'sink', 'instrument_violin', 'table', 'soap', 'tooth_paste']  Task:Bring dirty plate to sink  response:  {       thoughts : Stand up from the table.  Pick up dirty plate.  Walk to sink.  Put plate in sink.,       actions : ['[WALK] <dining_room>', '[WALK] <table>', '[FIND] <table>', '[TURNTO] <table>', '[FIND] <plate>', '[GRAB] <plate>', '[WALK] <dining_room>', '[WALK] <sink>', '[FIND] <sink>', '[PUTBACK] <plate> <sink>']  }     Scene_Objects:['sheets', 'food_pizza', 'filing_cabinet', 'freezer', 'drawing', 'hanger', 'kitchen_cabinet', 'floor', 'phone', 'bathroom_counter', 'folder', 'stamp', 'keyboard', 'computer', 'food_bacon', 'table_cloth', 'brush', 'mat', 'plate', 'clothes_socks', 'couch', 'bowl', 'bench', 'toy', 'bed', 'check', 'cupboard', 'door', 'table', 'light']  Task:Set up table  response:

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


Input: You serve as an AI task planner.   1. Your task is to create a plan to achieve a goal by converting it into a sequence of actions. Each action should follow the format  [verb] <target1> <target2> , where 'verb' represents the action, and 'target1' and 'target2' are optional arguments.  2. You must describe your plan in natural language at the beginning. After that, you should list all the actions together.   Ensure that you response can be parsed by Python json.loads.      Here is an example plan to achieve a goal for reference:   Scene_Objects:['sheets', 'glue', 'measuring_cup', 'dog', 'walllamp', 'bathroom', 'floor', 'phone', 'bedroom', 'mat', 'stereo', 'faucet', 'window', 'closetdrawer', 'dining_room', 'food_cheese', 'standingmirror', 'bed', 'check', 'television', 'coffee_filter', 'food_rice', 'ice', 'curtain', 'doorjamb', 'pencil', 'conditioner', 'bathtub', 'napkin', 'vase']  Task:Listen to music  response:  {       thoughts : Listen to music,       actions : ['[WALK] <home_office>', '[WALK] <stereo>', '[FIND] <stereo>', '[SWITCHON] <stereo>']  }     Scene_Objects:['scissors', 'tea', 'chair', 'trashcan', 'cpuscreen', 'hanger', 'floor', 'ceiling', 'phone', 'character', 'desk', 'tea_bag', 'bookshelf', 'keyboard', 'computer', 'picture', 'mousepad', 'food_jam', 'wall', 'cutting_board', 'cup', 'novel', 'tray', 'doorjamb', 'mouse', 'dresser', 'cupboard', 'door', 'light', 'dishwasher']  Task:Read book  response:

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


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', 'crayon', 'chair', 'walllamp', 'hanger', 'floor', 'ceiling', 'phone', 'tea_bag', 'clothes_jacket', 'toaster', 'mat', 'ceilinglamp', 'faucet', 'dish_soap', 'mousepad', 'dustpan', 'clothes_hat', 'wall', 'cup', 'coffe_maker', 'coffee_filter', 'curtain', 'coffee_pot', 'mouse', 'kitchen_counter', 'dishrack', 'cupboard', 'sink', 'napkin']  Task:Wash dishes  response:  {       thoughts : Place all of the dirty dishes in a sink full of clean, soapy water.  Wash them.  Rinse them in fresh, running water.  Place them in the strainer to dry.,       actions : ['[WALK] <dining_room>', '[WALK] <sink>', '[FIND] <faucet>', '[SWITCHON] <faucet>', '[SWITCHOFF] <faucet>', '[FIND] <dish_soap>', '[GRAB] <dish_soap>', '[POUR] <dish_soap> <sink>', '[PUTOBJBACK] <dish_soap>', '[FIND] <sponge>', '[GRAB] <sponge>', '[FIND] <cup>', '[GRAB] <cup>', '[SCRUB] <cup>', '[PUTOBJBACK] <cup>', '[FIND] <cup>', '[GRAB] <cup>', '[SCRUB] <cup>', '[PUTOBJBACK] <cup>', '[PUTBACK] <sponge> <sink>', '[SWITCHON] <faucet>', '[RINSE] <cup>', '[GRAB] <cup>', '[FIND] <dishrack>', '[PUTBACK] <cup> <dishrack>', '[RINSE] <cup>', '[GRAB] <cup>', '[PUTBACK] <cup> <dishrack>', '[RINSE] <sponge>', '[SWITCHOFF] <faucet>', '[GRAB] <sponge>', '[PUTOBJBACK] <sponge>']  }     Scene_Objects:['sheets', 'crayon', 'chair', 'band-aids', 'bathroom', 'food_butter', 'ceilingfan', 'hanger', 'bathroom_counter', 'floor', 'ceiling', 'phone', 'longboard', 'folder', 'bookshelf', 'brush', 'shoe-shine_kit', 'stereo', 'food_jam', 'wall', 'powersocket', 'coffe_maker', 'food_food', 'television', 'wooden_spoon', 'doorjamb', 'dresser', 'cupboard', 'door', 'light']  Task:Turn on light  response:

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


Input: You serve as an AI task planner.   1. Your task is to create a plan to achieve a goal by converting it into a sequence of actions. Each action should follow the format  [verb] <target1> <target2> , where 'verb' represents the action, and 'target1' and 'target2' are optional arguments.  2. You must describe your plan in natural language at the beginning. After that, you should list all the actions together.   Ensure that you response can be parsed by Python json.loads.      Here is an example plan to achieve a goal for reference:   Scene_Objects:['fork', 'chair', 'milk', 'drawing', 'cpuscreen', 'shampoo', 'folder', 'bookshelf', 'computer', 'table_cloth', 'ceilinglamp', 'mat', 'oil', 'mousepad', 'couch', 'towel', 'nightstand', 'wall', 'cutting_board', 'cup', 'photoframe', 'bed', 'food_donut', 'mouse', 'kitchen_counter', 'pajamas', 'sink', 'napkin', 'home_office', 'tooth_paste']  Task:Open front door  response:  {       thoughts : Walk over to the front door, turn the knob, and open the door.,       actions : ['[WALK] <home_office>']  }     Scene_Objects:['food_pizza', 'mop', 'walllamp', 'drawing', 'bathroom_counter', 'floor', 'ceiling', 'bedroom', 'bookshelf', 'envelope', 'faucet', 'picture', 'homework', 'window', 'mousepad', 'clothes_hat', 'towel', 'wall', 'photoframe', 'hands_both', 'food_food', 'doorjamb', 'kettle', 'dresser', 'door', 'sink', 'bathroom_cabinet', 'light', 'vase', 'teeth']  Task:Wash teeth  response:

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


Input: You serve as an AI task planner.   1. Your task is to create a plan to achieve a goal by converting it into a sequence of actions. Each action should follow the format  [verb] <target1> <target2> , where 'verb' represents the action, and 'target1' and 'target2' are optional arguments.  2. You must describe your plan in natural language at the beginning. After that, you should list all the actions together.   Ensure that you response can be parsed by Python json.loads.      Here is an example plan to achieve a goal for reference:   Scene_Objects:['sponge', 'microwave', 'chair', 'jelly', 'knifeblock', 'floor', 'ceiling', 'character', 'alcohol', 'toaster', 'plate', 'faucet', 'drying_rack', 'window', 'tvstand', 'dish_soap', 'closetdrawer', 'couch', 'towel', 'pillow', 'food_kiwi', 'wall', 'toy', 'novel', 'curtain', 'kitchen_counter', 'cupboard', 'sink', 'instrument_guitar', 'shoe_rack']  Task:Do dishes  response:  {       thoughts : Wash dirty dishes, dry them and then put them away,       actions : ['[WALK] <dining_room>', '[WALK] <sink>', '[FIND] <faucet>', '[SWITCHON] <faucet>', '[FIND] <dish_soap>', '[GRAB] <dish_soap>', '[POUR] <dish_soap> <sink>', '[PUTOBJBACK] <dish_soap>', '[FIND] <sponge>', '[GRAB] <sponge>', '[FIND] <plate>', '[GRAB] <plate>', '[SCRUB] <plate>', '[RINSE] <plate>', '[FIND] <drying_rack>', '[PUTBACK] <plate> <drying_rack>', '[FIND] <plate>', '[GRAB] <plate>', '[SCRUB] <plate>', '[RINSE] <plate>', '[PUTBACK] <plate> <drying_rack>', '[PUTOBJBACK] <sponge>', '[SWITCHOFF] <faucet>']  }     Scene_Objects:['sponge', 'tea', 'toilet', 'walllamp', 'bathroom', 'trashcan', 'drawing', 'ceiling', 'bookshelf', 'computer', 'button', 'mail', 'stovefan', 'ceilinglamp', 'window', 'couch', 'wall', 'bench', 'tape', 'cup', 'coffe_maker', 'tray', 'headset', 'comb', 'cupboard', 'sink', 'home_office', 'table', 'bathroom_cabinet', 'vase']  Task:Read book  response:


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', 'drawing', 'cpuscreen', 'bathroom_counter', 'floor', 'desk', 'bedroom', 'keyboard', 'tvstand', 'stereo', 'balanceball', 'picture', 'mousepad', 'couch', 'clothes_hat', 'pillow', 'dining_room', 'wall', 'nightstand', 'bench', 'photoframe', 'bed', 'toilet_paper', 'coffe_maker', 'cards', 'mouse', 'kitchen_counter', 'cd', 'vase']  Task:Go to toilet  response:  {       thoughts : Walk to the bathroom.  Find the toilet.  Lift the top of the toilet.  Sit on the toilet.,       actions : ['[WALK] <bathroom>', '[WALK] <toilet>', '[FIND] <toilet>', '[OPEN] <toilet>', '[SIT] <toilet>']  }     Scene_Objects:['food_bread', 'freezer', 'cat', 'food_carrot', 'dough', 'orchid', 'needle', 'hanger', 'longboard', 'floor', 'ceiling', 'bathroom_counter', 'ceilinglamp', 'mat', 'stereo', 'couch', 'dustpan', 'pillow', 'wall', 'powersocket', 'light_bulb', 'food_food', 'coffe_maker', 'video_game_controller', 'oven_mitts', 'food_rice', 'vacuum_cleaner', 'dresser', 'door', 'hairdryer']  Task:Put groceries in Fridge  response:

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


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', 'freezer', 'walllamp', 'bathroom', 'trashcan', 'orchid', 'floor', 'toaster', 'mat', 'faucet', 'shower', 'pillow', 'wall', 'nightstand', 'bench', 'toy', 'coffe_maker', 'television', 'curtain', 'after_shave', 'doorjamb', 'towel_rack', 'kitchen_counter', 'chessboard', 'sink', 'home_office', 'bathroom_cabinet', 'table', 'instrument_violin']  Task:Go to toilet  response:  {       thoughts : Walk to the bathroom.  Find the toilet.  Lift the top of the toilet.  Sit on the toilet.,       actions : ['[WALK] <bathroom>', '[WALK] <toilet>', '[FIND] <toilet>', '[OPEN] <toilet>', '[SIT] <toilet>']  }     Scene_Objects:['food_pizza', 'food_ice_cream', 'mop', 'chair', 'freezer', 'walllamp', 'cat', 'trashcan', 'toothbrush', 'hanger', 'bathroom_counter', 'floor', 'keyboard', 'dining_room', 'bench', 'powersocket', 'cup', 'photoframe', 'novel', 'toothbrush_holder', 'curtain', 'mouse', 'headset', 'pajamas', 'door', 'dishwasher', 'vase', 'tooth_paste', 'clothes_shirt', 'teeth']  Task:Wash teeth  response:

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


Input: You serve as an AI task planner.   1. Your task is to create a plan to achieve a goal by converting it into a sequence of actions. Each action should follow the format  [verb] <target1> <target2> , where 'verb' represents the action, and 'target1' and 'target2' are optional arguments.  2. You must describe your plan in natural language at the beginning. After that, you should list all the actions together.   Ensure that you response can be parsed by Python json.loads.      Here is an example plan to achieve a goal for reference:   Scene_Objects:['filing_cabinet', 'microwave', 'toilet', 'detergent', 'cat', 'food_butter', 'knife', 'phone', 'character', 'table_cloth', 'mat', 'deck_of_cards', 'stereo', 'form', 'pillow', 'dining_room', 'nightstand', 'wall', 'basket_for_clothes', 'photoframe', 'tray', 'doorjamb', 'kitchen_counter', 'chessboard', 'dresser', 'clothes_dress', 'table', 'soap', 'washing_machine', 'creditcard']  Task:Wash clothes  response:  {       thoughts : Walk to Bathroom. Find basket for clothes. Lift clothes dress from basket. Find washing machine. Walk to washing machine. Put clothes in washing machine. Put soap in washing machine. Switch on washing machine.,       actions : ['[WALK] <bathroom>', '[WALK] <basket_for_clothes>', '[FIND] <basket_for_clothes>', '[FIND] <clothes_dress>', '[GRAB] <clothes_dress>', '[FIND] <washing_machine>', '[WALK] <washing_machine>', '[OPEN] <washing_machine>', '[PUTBACK] <clothes_dress> <washing_machine>', '[FIND] <soap>', '[GRAB] <soap>', '[PUTBACK] <soap> <washing_machine>', '[CLOSE] <washing_machine>', '[SWITCHON] <washing_machine>']  }     Scene_Objects:['sheets', 'pot', 'mop', 'dog', 'jelly', 'drawing', 'knife', 'bathroom_counter', 'floor', 'ceiling', 'longboard', 'character', 'computer', 'stovefan', 'faucet', 'oil', 'dining_room', 'wall', 'nightstand', 'oven', 'cutting_board', 'photoframe', 'check', 'tray', 'sink', 'napkin', 'bathroom_cabinet', 'soap', 'dirt', 'hands_both']  Task:Wash hands  response:

{  go to the bathroom and wash your 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:['sheets', 'spectacles', 'scissors', 'knife', 'hanger', 'bathroom_counter', 'floor', 'bedroom', 'desk', 'keyboard', 'piano_bench', 'stovefan', 'stereo', 'window', 'wall', 'powersocket', 'cutting_board', 'cup', 'bed', 'console', 'pencil', 'shoes', 'door', 'bathtub', 'bag', 'instrument_guitar', 'table', 'home_office', 'light', 'board_game']  Task:Listen to music  response:  {       thoughts : I walk into my room and turn the radio on so that I can listen to music.,       actions : ['[WALK] <bedroom>', '[WALK] <stereo>', '[FIND] <stereo>', '[SWITCHON] <stereo>']  }     Scene_Objects:['food_bread', 'microwave', 'freezer', 'walllamp', 'bathroom', 'toothbrush', 'orchid', 'hanger', 'longboard', 'phone', 'desk', 'computer', 'food_bacon', 'table_cloth', 'clothes_jacket', 'brush', 'ceilinglamp', 'faucet', 'foundation', 'mousepad', 'clothes_pants', 'pasta', 'light_bulb', 'toothbrush_holder', 'coin', 'coffee_filter', 'towel_rack', 'hair', 'vase', 'tooth_paste']  Task:Wash teeth  response:

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


Input: You serve as an AI task planner.   1. Your task is to create a plan to achieve a goal by converting it into a sequence of actions. Each action should follow the format  [verb] <target1> <target2> , where 'verb' represents the action, and 'target1' and 'target2' are optional arguments.  2. You must describe your plan in natural language at the beginning. After that, you should list all the actions together.   Ensure that you response can be parsed by Python json.loads.      Here is an example plan to achieve a goal for reference:   Scene_Objects:['sheets', 'pot', 'tablelamp', 'microwave', 'detergent', 'clothes_underwear', 'ceiling', 'character', 'desk', 'mail', 'table_cloth', 'bookmark', 'shoe-shine_kit', 'faucet', 'electric_shaver', 'mousepad', 'candle', 'food_jam', 'food_orange', 'nightstand', 'powersocket', 'newspaper', 'coin', 'food_onion', 'pencil', 'dresser', 'home_office', 'dishwasher', 'tooth_paste', 'coffee']  Task:Browse internet  response:  {       thoughts : The task is browse and surf on the internet regarding a particular topic,       actions : ['[WALK] <bedroom>', '[WALK] <laptop>', '[FIND] <laptop>', '[SWITCHON] <laptop>', '[TURNTO] <laptop>', '[LOOKAT] <laptop>', '[WATCH] <laptop>']  }     Scene_Objects:['water_glass', 'scissors', 'tablelamp', 'bathroom', 'drawing', 'floor', 'desk', 'computer', 'food_bacon', 'stovefan', 'ceilinglamp', 'shower', 'window', 'couch', 'clothes_hat', 'towel', 'wall', 'oven', 'photoframe', 'check', 'food_food', 'television', 'coffe_maker', 'tray', 'centerpiece', 'pencil', 'chessboard', 'hair', 'table', 'vase']  Task:Relax on sofa  response:


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', 'tea', 'microwave', 'chair', 'walllamp', 'blow_dryer', 'bathroom', 'knifeblock', 'wallshelf', 'floor', 'ceiling', 'ceilinglamp', 'plate', 'mousepad', 'food_noodles', 'couch', 'closetdrawer', 'food_jam', 'form', 'pillow', 'wall', 'nightstand', 'razor', 'television', 'shaving_cream', 'kitchen_counter', 'bathroom_cabinet', 'dishwasher', 'soap', 'teeth']  Task:Text friends while sitting on couch  response:  {       thoughts : Text while sitting,       actions : ['[WALK] <home_office>', '[WALK] <phone>', '[FIND] <phone>', '[GRAB] <phone>', '[WALK] <couch>', '[SIT] <couch>', '[TURNTO] <phone>', '[LOOKAT] <phone>', '[TOUCH] <phone>']  }     Scene_Objects:['fork', 'blow_dryer', 'bathroom', 'ceilingfan', 'drawing', 'hanger', 'kitchen_cabinet', 'floor', 'phone', 'desk', 'computer', 'laptop', 'plate', 'stereo', 'oil', 'clothes_hat', 'wall', 'bench', 'oven', 'powersocket', 'newspaper', 'coffe_maker', 'curtain', 'rag', 'kitchen_counter', 'maindoor', 'home_office', 'table', 'light', 'soap']  Task:Set up table  response:

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


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', 'chair', 'drawing', 'bills', 'knife', 'floor', 'ceilinglamp', 'stereo', 'window', 'couch', 'food_jam', 'form', 'towel', 'dining_room', 'wall', 'basket_for_clothes', 'photoframe', 'novel', 'food_food', 'check', 'television', 'oven_mitts', 'razor', 'tray', 'pencil', 'dresser', 'pajamas', 'table', 'soap']  Task:Read book  response:  {       thoughts : Sit and read,       actions : ['[WALK] <home_office>', '[WALK] <filing_cabinet>', '[OPEN] <filing_cabinet>', '[FIND] <novel>', '[GRAB] <novel>', '[CLOSE] <filing_cabinet>', '[WALK] <couch>', '[SIT] <couch>', '[READ] <novel>']  }     Scene_Objects:['chair', 'bathroom', 'ceilingfan', 'drawing', 'floor', 'ceiling', 'tea_bag', 'keyboard', 'remote_control', 'toaster', 'ceilinglamp', 'tvstand', 'balanceball', 'stovefan', 'window', 'mat', 'plate', 'couch', 'candle', 'microphone', 'dining_room', 'wall', 'powersocket', 'box', 'photoframe', 'coffe_maker', 'television', 'curtain', 'table', 'dishwasher']  Task:Watch TV  response:

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


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:['ironing_board', 'sheets', 'tablelamp', 'detergent', 'knifeblock', 'bathroom_counter', 'phone', 'desk', 'keyboard', 'computer', 'ceilinglamp', 'tvstand', 'iron', 'window', 'couch', 'pillow', 'bowl', 'nightstand', 'food_cheese', 'video_game_controller', 'tray', 'curtain', 'doorjamb', 'towel_rack', 'kitchen_counter', 'pajamas', 'bag', 'dishwasher', 'board_game', 'clothes_shirt']  Task:Iron shirt  response:  {       thoughts : Set up an ironing board and an iron.  Lay a shirt on board.  Run iron over shirt until it is free of wrinkles.,       actions : ['[WALK] <bedroom>', '[WALK] <ironing_board>', '[FIND] <ironing_board>', '[FIND] <clothes_shirt>', '[GRAB] <clothes_shirt>', '[PUTBACK] <clothes_shirt> <ironing_board>', '[FIND] <iron>', '[GRAB] <iron>', '[PLUGIN] <iron>', '[PLUGOUT] <iron>', '[PUTOBJBACK] <iron>']  }     Scene_Objects:['sheets', 'food_pizza', 'tablelamp', 'blender', 'scissors', 'freezer', 'walllamp', 'ground_coffee', 'orchid', 'character', 'bedroom', 'bookshelf', 'alcohol', 'button', 'toaster', 'stereo', 'homework', 'electric_shaver', 'mousepad', 'couch', 'bowl', 'toy', 'clothes_gloves', 'coffe_maker', 'kitchen_counter', 'conditioner', 'napkin', 'table', 'light', 'dishwasher']  Task:Listen to music  response:

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


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', 'ground_coffee', 'walllamp', 'food_carrot', 'orchid', 'drawing', 'floor', 'ceiling', 'bedroom', 'bookshelf', 'keyboard', 'mail', 'mat', 'faucet', 'wall', 'nightstand', 'powersocket', 'oven', 'cup', 'photoframe', 'bed', 'novel', 'curtain', 'doorjamb', 'diary', 'cupboard', 'door', 'sink', 'instrument_guitar']  Task:Read book  response:  {       thoughts : Walk over to the bookshelf. Pick storybook off the shelf. Sit on bed. Open storybook and read out loud.,       actions : ['[WALK] <bedroom>', '[WALK] <bookshelf>', '[FIND] <novel>', '[GRAB] <novel>', '[TURNTO] <novel>', '[LOOKAT] <novel>', '[WALK] <bed>', '[SIT] <bed>', '[READ] <novel>']  }     Scene_Objects:['pot', 'ground_coffee', 'walllamp', 'detergent', 'knifeblock', 'longboard', 'floor', 'ceiling', 'toaster', 'stovefan', 'plate', 'faucet', 'candle', 'wall', 'box', 'coffe_maker', 'food_food', 'television', 'coffee_filter', 'water', 'towel_rack', 'kitchen_counter', 'chessboard', 'cupboard', 'hair', 'maindoor', 'sink', 'napkin', 'dishwasher', 'tooth_paste']  Task:Make coffee  response:

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


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', 'cpuscreen', 'hanger', 'floor', 'ceiling', 'desk', 'keyboard', 'computer', 'clothes_socks', 'closetdrawer', 'mousepad', 'clothes_pants', 'wall', 'powersocket', 'oven', 'cup', 'newspaper', 'food_food', 'check', 'coffe_maker', 'shaving_cream', 'mouse', 'pencil', 'shoes', 'dresser', 'hair', 'conditioner', 'light', 'clothes_shirt', 'shoe_rack']  Task:Get dressed  response:  {       thoughts : Open drawer. Pull out pants and put them on. Take a shirt out and put it on. Put on socks and shoes.,       actions : ['[WALK] <bedroom>', '[WALK] <dresser>', '[OPEN] <dresser>', '[FIND] <clothes_pants>', '[GRAB] <clothes_pants>', '[PUTON] <clothes_pants>', '[FIND] <clothes_shirt>', '[GRAB] <clothes_shirt>', '[PUTON] <clothes_shirt>', '[FIND] <clothes_socks>', '[GRAB] <clothes_socks>', '[PUTON] <clothes_socks>', '[CLOSE] <dresser>', '[FIND] <shoes>', '[GRAB] <shoes>', '[PUTON] <shoes>']  }     Scene_Objects:['microwave', 'walllamp', 'bathroom', 'food_carrot', 'toothbrush', 'orchid', 'knife', 'longboard', 'character', 'bedroom', 'computer', 'faucet', 'homework', 'clothes_socks', 'food_noodles', 'dining_room', 'photoframe', 'check', 'television', 'after_shave', 'rag', 'lighter', 'towel_rack', 'kitchen_counter', 'dresser', 'clothes_dress', 'home_office', 'light', 'laser_pointer', 'scrabble']  Task:Pick up phone  response:

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