[System]
You are InternVL, a robotic entity agent.

You are given one observation of the scene and a task to perform. Based on the task, You should return a set of points as the trajectory to execute the task. The point trajectory format should be "<point>[[x1, y1], [x2, y2], [x3, y3],...]</point>". The point coordinates are normalized to integers between 0 and 1000. Please return the point trajectory directly.

[User]
Image-1:<image>
 You need to reach for the pot.

[Assistant] <point>[[513, 215], [496, 285], [470, 356], [434, 422]]</point>

[User]
Image-2:<image>
 You need to reach for the spoon.

[Assistant] <point>[[396, 207], [384, 346], [388, 449], [398, 596]]</point>


[System]
You are InternVL, a robotic entity agent.

You are given one observation of the scene and a task to perform. Based on the task, You should return a set of points as the trajectory to execute the task. The point trajectory format should be "<point>[[x1, y1], [x2, y2], [x3, y3],...]</point>". The point coordinates are normalized to integers between 0 and 1000. Please return the point trajectory directly.

[User]
Image-1:<image>
 You need to reach for the rag.

[Assistant] <point>[[513, 197], [398, 270], [286, 354], [176, 447]]</point>

[User]
Image-2:<image>
 You need to reach for the spoon.

[Assistant] <point>[[737, 152], [686, 280], [634, 495], [604, 662]]</point>


[System]
You are InternVL, a robotic entity agent.

You are given one observation of the scene and a task to perform. Based on the task, You should return a set of points as the trajectory to execute the task. The point trajectory format should be "<point>[[x1, y1], [x2, y2], [x3, y3],...]</point>". The point coordinates are normalized to integers between 0 and 1000. Please return the point trajectory directly.

[User]
Image-1:<image>
 You need to move towards the banana in the colander.

[Assistant] <point>[[684, 273], [572, 391], [475, 508], [373, 654]]</point>

[User]
Image-2:<image>
 You need to reach for the purple cloth.

[Assistant] <point>[[498, 235], [473, 366], [475, 480], [498, 611]]</point>


[System]
You are InternVL, a robotic entity agent.

You are given one observation of the scene and a task to perform. Based on the task, You should return a set of points as the trajectory to execute the task. The point trajectory format should be "<point>[[x1, y1], [x2, y2], [x3, y3],...]</point>". The point coordinates are normalized to integers between 0 and 1000. Please return the point trajectory directly.

[User]
Image-1:<image>
 You need to move towards the broccoli in the pot.

[Assistant] <point>[[330, 162], [464, 197], [564, 250], [659, 316]]</point>

[User]
Image-2:<image>
 You need to move towards the beet in the pot.

[Assistant] <point>[[513, 263], [481, 318], [458, 384], [441, 460]]</point>


[System]
You are InternVL, a robotic entity agent.

You are given one observation of the scene and a task to perform. Based on the task, You should return a set of points as the trajectory to execute the task. The point trajectory format should be "<point>[[x1, y1], [x2, y2], [x3, y3],...]</point>". The point coordinates are normalized to integers between 0 and 1000. Please return the point trajectory directly.

[User]
Image-1:<image>
 You need to move towards the carrot.

[Assistant] <point>[[502, 169], [420, 298], [339, 455], [278, 591]]</point>

[User]
Image-2:<image>
 You need to move a sushi roll to the right of a pot.

[Assistant] <point>[[335, 250], [403, 293], [447, 361], [477, 439]]</point>


[System]
You are InternVL, a robotic entity agent.

You are given one observation of the scene and a task to perform. Based on the task, You should return a set of points as the trajectory to execute the task. The point trajectory format should be "<point>[[x1, y1], [x2, y2], [x3, y3],...]</point>". The point coordinates are normalized to integers between 0 and 1000. Please return the point trajectory directly.

[User]
Image-1:<image>
 You need to move towards the bowl with corn.

[Assistant] <point>[[623, 247], [540, 295], [475, 343], [403, 404]]</point>

[User]
Image-2:<image>
 You need to move towards the microwave handle.

[Assistant] <point>[[339, 449], [470, 447], [562, 442], [712, 422]]</point>


[System]
You are InternVL, a robotic entity agent.

You are given one observation of the scene and a task to perform. Based on the task, You should return a set of points as the trajectory to execute the task. The point trajectory format should be "<point>[[x1, y1], [x2, y2], [x3, y3],...]</point>". The point coordinates are normalized to integers between 0 and 1000. Please return the point trajectory directly.

[User]
Image-1:<image>
 You need to reach towards the broccoli.

[Assistant] <point>[[464, 116], [466, 359], [479, 561], [496, 753]]</point>

[User]
Image-2:<image>
 You need to move towards the cup.

[Assistant] <point>[[801, 298], [661, 298], [515, 306], [354, 333]]</point>


[System]
You are InternVL, a robotic entity agent.

You are given one observation of the scene and a task to perform. Based on the task, You should return a set of points as the trajectory to execute the task. The point trajectory format should be "<point>[[x1, y1], [x2, y2], [x3, y3],...]</point>". The point coordinates are normalized to integers between 0 and 1000. Please return the point trajectory directly.

[User]
Image-1:<image>
 You need to reach for the potato in the bowl.

[Assistant] <point>[[331, 207], [350, 318], [360, 429], [366, 551]]</point>

[User]
Image-2:<image>
 You need to move the mushroom towards the pot.

[Assistant] <point>[[532, 326], [445, 247], [350, 202], [269, 189]]</point>


[System]
You are InternVL, a robotic entity agent.

You are given one observation of the scene and a task to perform. Based on the task, You should return a set of points as the trajectory to execute the task. The point trajectory format should be "<point>[[x1, y1], [x2, y2], [x3, y3],...]</point>". The point coordinates are normalized to integers between 0 and 1000. Please return the point trajectory directly.

[User]
Image-1:<image>
 You need to reach for the sausage.

[Assistant] <point>[[311, 227], [362, 348], [407, 482], [436, 619]]</point>

[User]
Image-2:<image>
 You need to reach for the yellow brush.

[Assistant] <point>[[250, 265], [354, 293], [438, 328], [525, 386]]</point>


[System]
You are InternVL, a robotic entity agent.

You are given one observation of the scene and a task to perform. Based on the task, You should return a set of points as the trajectory to execute the task. The point trajectory format should be "<point>[[x1, y1], [x2, y2], [x3, y3],...]</point>". The point coordinates are normalized to integers between 0 and 1000. Please return the point trajectory directly.

[User]
Image-1:<image>
 You need to reach for the carrot.

[Assistant] <point>[[441, 162], [481, 308], [506, 442], [528, 626]]</point>

[User]
Image-2:<image>
 You need to move towards the eggplant.

[Assistant] <point>[[458, 172], [386, 265], [305, 384], [235, 510]]</point>


[System]
You are InternVL, a robotic entity agent.

You are given one observation of the scene and a task to perform. Based on the task, You should return a set of points as the trajectory to execute the task. The point trajectory format should be "<point>[[x1, y1], [x2, y2], [x3, y3],...]</point>". The point coordinates are normalized to integers between 0 and 1000. Please return the point trajectory directly.

[User]
Image-1:<image>
 You need to move towards the microwave.

[Assistant] <point>[[547, 598], [453, 485], [337, 336], [259, 217]]</point>

[User]
Image-2:<image>
 You need to reach for the orange cloth.

[Assistant] <point>[[182, 298], [358, 328], [496, 361], [633, 419]]</point>


[System]
You are InternVL, a robotic entity agent.

You are given one observation of the scene and a task to perform. Based on the task, You should return a set of points as the trajectory to execute the task. The point trajectory format should be "<point>[[x1, y1], [x2, y2], [x3, y3],...]</point>". The point coordinates are normalized to integers between 0 and 1000. Please return the point trajectory directly.

[User]
Image-1:<image>
 You need to reach for the spoon.

[Assistant] <point>[[278, 236], [426, 317], [556, 398], [625, 494], [715, 653]]</point>

[User]
Image-2:<image>
 You need to reach for the cloth.

[Assistant] <point>[[695, 413], [565, 371], [443, 336], [382, 340]]</point>


[System]
You are InternVL, a robotic entity agent.

You are given one observation of the scene and a task to perform. Based on the task, You should return a set of points as the trajectory to execute the task. The point trajectory format should be "<point>[[x1, y1], [x2, y2], [x3, y3],...]</point>". The point coordinates are normalized to integers between 0 and 1000. Please return the point trajectory directly.

[User]
Image-1:<image>
 You need to reach for the cloth.

[Assistant] <point>[[365, 290], [400, 425], [434, 541], [472, 622]]</point>

[User]
Image-2:<image>
 You need to reach for the plate with the carrot on it.

[Assistant] <point>[[507, 208], [605, 293], [698, 386], [773, 537]]</point>


[System]
You are InternVL, a robotic entity agent.

You are given one observation of the scene and a task to perform. Based on the task, You should return a set of points as the trajectory to execute the task. The point trajectory format should be "<point>[[x1, y1], [x2, y2], [x3, y3],...]</point>". The point coordinates are normalized to integers between 0 and 1000. Please return the point trajectory directly.

[User]
Image-1:<image>
 You need to reach for the pepper.

[Assistant] <point>[[220, 69], [336, 166], [423, 266], [515, 413], [605, 637]]</point>

[User]
Image-2:<image>
 You need to move towards the blueberries.

[Assistant] <point>[[498, 263], [669, 382], [756, 483], [799, 537]]</point>


[System]
You are InternVL, a robotic entity agent.

You are given one observation of the scene and a task to perform. Based on the task, You should return a set of points as the trajectory to execute the task. The point trajectory format should be "<point>[[x1, y1], [x2, y2], [x3, y3],...]</point>". The point coordinates are normalized to integers between 0 and 1000. Please return the point trajectory directly.

[User]
Image-1:<image>
 You need to reach for the fruit in the bowl.

[Assistant] <point>[[420, 147], [498, 282], [559, 413], [608, 494], [686, 637]]</point>

[User]
Image-2:<image>
 You need to approach the pot.

[Assistant] <point>[[892, 224], [782, 201], [643, 197], [539, 220], [417, 259], [342, 340]]</point>


[System]
You are InternVL, a robotic entity agent.

You are given one observation of the scene and a task to perform. Based on the task, You should return a set of points as the trajectory to execute the task. The point trajectory format should be "<point>[[x1, y1], [x2, y2], [x3, y3],...]</point>". The point coordinates are normalized to integers between 0 and 1000. Please return the point trajectory directly.

[User]
Image-1:<image>
 You need to lower towards the pot.

[Assistant] <point>[[379, 232], [330, 263], [287, 309], [258, 363]]</point>

[User]
Image-2:<image>
 You need to move towards the pot.

[Assistant] <point>[[660, 309], [498, 351], [397, 398], [284, 475]]</point>


[System]
You are InternVL, a robotic entity agent.

You are given one observation of the scene and a task to perform. Based on the task, You should return a set of points as the trajectory to execute the task. The point trajectory format should be "<point>[[x1, y1], [x2, y2], [x3, y3],...]</point>". The point coordinates are normalized to integers between 0 and 1000. Please return the point trajectory directly.

[User]
Image-1:<image>
 You need to move towards the beet.

[Assistant] <point>[[290, 440], [426, 409], [524, 413], [608, 413]]</point>

[User]
Image-2:<image>
 You need to reach for the pan.

[Assistant] <point>[[605, 39], [544, 131], [492, 232], [405, 332]]</point>


[System]
You are InternVL, a robotic entity agent.

You are given one observation of the scene and a task to perform. Based on the task, You should return a set of points as the trajectory to execute the task. The point trajectory format should be "<point>[[x1, y1], [x2, y2], [x3, y3],...]</point>". The point coordinates are normalized to integers between 0 and 1000. Please return the point trajectory directly.

[User]
Image-1:<image>
 You need to reach for the knife.

[Assistant] <point>[[420, 174], [481, 243], [542, 328]]</point>

[User]
Image-2:<image>
 You need to reach for the cloth.

[Assistant] <point>[[133, 394], [258, 440], [376, 506], [527, 645]]</point>


[System]
You are InternVL, a robotic entity agent.

You are given one observation of the scene and a task to perform. Based on the task, You should return a set of points as the trajectory to execute the task. The point trajectory format should be "<point>[[x1, y1], [x2, y2], [x3, y3],...]</point>". The point coordinates are normalized to integers between 0 and 1000. Please return the point trajectory directly.

[User]
Image-1:<image>
 You need to reach for the fish-shaped object in the pot.

[Assistant] <point>[[200, 278], [298, 340], [376, 382], [426, 440], [559, 618]]</point>

[User]
Image-2:<image>
 You need to move the lime bottle towards the yellow napkin.

[Assistant] <point>[[625, 193], [654, 259], [683, 317], [704, 371]]</point>


[System]
You are InternVL, a robotic entity agent.

You are given one observation of the scene and a task to perform. Based on the task, You should return a set of points as the trajectory to execute the task. The point trajectory format should be "<point>[[x1, y1], [x2, y2], [x3, y3],...]</point>". The point coordinates are normalized to integers between 0 and 1000. Please return the point trajectory directly.

[User]
Image-1:<image>
 You need to approach the pot.

[Assistant] <point>[[313, 112], [345, 216], [388, 332], [431, 459]]</point>

[User]
Image-2:<image>
 You need to move the spoon towards the bottom left corner of the counter.

[Assistant] <point>[[278, 232], [197, 309], [162, 390]]</point>


[System]
You are InternVL, a robotic entity agent.

You are given one observation of the scene and a task to perform. Based on the task, You should return a set of points as the trajectory to execute the task. The point trajectory format should be "<point>[[x1, y1], [x2, y2], [x3, y3],...]</point>". The point coordinates are normalized to integers between 0 and 1000. Please return the point trajectory directly.

[User]
Image-1:<image>
 You need to move towards the container.

[Assistant] <point>[[295, 208], [347, 313], [414, 440], [484, 633]]</point>

[User]
Image-2:<image>
 You need to reach for the potato in the bowl.

[Assistant] <point>[[266, 347], [391, 297], [475, 305], [562, 328], [605, 359]]</point>


[System]
You are InternVL, a robotic entity agent.

You are given one observation of the scene and a task to perform. Based on the task, You should return a set of points as the trajectory to execute the task. The point trajectory format should be "<point>[[x1, y1], [x2, y2], [x3, y3],...]</point>". The point coordinates are normalized to integers between 0 and 1000. Please return the point trajectory directly.

[User]
Image-1:<image>
 You need to reach for the pot.

[Assistant] <point>[[446, 193], [530, 232], [568, 290], [634, 390]]</point>

[User]
Image-2:<image>
 You need to place the bowl on the surface.

[Assistant] <point>[[321, 166], [405, 212], [466, 309], [521, 440], [539, 548]]</point>


[System]
You are InternVL, a robotic entity agent.

You are given one observation of the scene and a task to perform. Based on the task, You should return a set of points as the trajectory to execute the task. The point trajectory format should be "<point>[[x1, y1], [x2, y2], [x3, y3],...]</point>". The point coordinates are normalized to integers between 0 and 1000. Please return the point trajectory directly.

[User]
Image-1:<image>
 You need to reach for the strawberry.

[Assistant] <point>[[301, 247], [429, 259], [533, 317], [591, 347]]</point>

[User]
Image-2:<image>
 You need to reach for the towel.

[Assistant] <point>[[443, 301], [394, 340], [281, 409], [203, 475]]</point>


[System]
You are InternVL, a robotic entity agent.

You are given one observation of the scene and a task to perform. Based on the task, You should return a set of points as the trajectory to execute the task. The point trajectory format should be "<point>[[x1, y1], [x2, y2], [x3, y3],...]</point>". The point coordinates are normalized to integers between 0 and 1000. Please return the point trajectory directly.

[User]
Image-1:<image>
 You need to move towards the pan containing broccoli.

[Assistant] <point>[[165, 479], [281, 413], [400, 394], [486, 390]]</point>

[User]
Image-2:<image>
 You need to reach for the spoon.

[Assistant] <point>[[365, 212], [408, 320], [466, 456], [533, 676]]</point>


[System]
You are InternVL, a robotic entity agent.

You are given one observation of the scene and a task to perform. Based on the task, You should return a set of points as the trajectory to execute the task. The point trajectory format should be "<point>[[x1, y1], [x2, y2], [x3, y3],...]</point>". The point coordinates are normalized to integers between 0 and 1000. Please return the point trajectory directly.

[User]
Image-1:<image>
 You need to reach into the laundry machine.

[Assistant] <point>[[333, 205], [446, 197], [544, 197], [637, 205]]</point>

[User]
Image-2:<image>
 You need to pull the clothing out of the machine.

[Assistant] <point>[[689, 185], [628, 232], [573, 297], [489, 398], [420, 517]]</point>


[System]
You are InternVL, a robotic entity agent.

You are given one observation of the scene and a task to perform. Based on the task, You should return a set of points as the trajectory to execute the task. The point trajectory format should be "<point>[[x1, y1], [x2, y2], [x3, y3],...]</point>". The point coordinates are normalized to integers between 0 and 1000. Please return the point trajectory directly.

[User]
Image-1:<image>
 You need to reach for the vessel.

[Assistant] <point>[[709, 212], [582, 205], [507, 236], [385, 270], [304, 336], [264, 425]]</point>

[User]
Image-2:<image>
 You need to reach for the pear in the bowl.

[Assistant] <point>[[336, 139], [350, 236], [350, 328], [347, 378]]</point>


[System]
You are InternVL, a robotic entity agent.

You are given one observation of the scene and a task to perform. Based on the task, You should return a set of points as the trajectory to execute the task. The point trajectory format should be "<point>[[x1, y1], [x2, y2], [x3, y3],...]</point>". The point coordinates are normalized to integers between 0 and 1000. Please return the point trajectory directly.

[User]
Image-1:<image>
 You need to pull the microwave door closed.

[Assistant] <point>[[319, 189], [449, 143], [524, 135], [608, 124]]</point>

[User]
Image-2:<image>
 You need to move towards the sushi container.

[Assistant] <point>[[515, 363], [431, 409], [330, 436], [287, 467]]</point>


[System]
You are InternVL, a robotic entity agent.

You are given one observation of the scene and a task to perform. Based on the task, You should return a set of points as the trajectory to execute the task. The point trajectory format should be "<point>[[x1, y1], [x2, y2], [x3, y3],...]</point>". The point coordinates are normalized to integers between 0 and 1000. Please return the point trajectory directly.

[User]
Image-1:<image>
 You need to reach for the fork.

[Assistant] <point>[[440, 19], [449, 127], [449, 270], [458, 425]]</point>

[User]
Image-2:<image>
 You need to reach for the red pepper.

[Assistant] <point>[[843, 139], [854, 259], [846, 390], [811, 568]]</point>


[System]
You are InternVL, a robotic entity agent.

You are given one observation of the scene and a task to perform. Based on the task, You should return a set of points as the trajectory to execute the task. The point trajectory format should be "<point>[[x1, y1], [x2, y2], [x3, y3],...]</point>". The point coordinates are normalized to integers between 0 and 1000. Please return the point trajectory directly.

[User]
Image-1:<image>
 You need to reach for the carrot.

[Assistant] <point>[[403, 220], [449, 293], [518, 398], [565, 548], [623, 772]]</point>

[User]
Image-2:<image>
 You need to reach for the carrot.

[Assistant] <point>[[353, 274], [437, 398], [481, 479], [527, 560], [573, 633]]</point>


[System]
You are InternVL, a robotic entity agent.

You are given one observation of the scene and a task to perform. Based on the task, You should return a set of points as the trajectory to execute the task. The point trajectory format should be "<point>[[x1, y1], [x2, y2], [x3, y3],...]</point>". The point coordinates are normalized to integers between 0 and 1000. Please return the point trajectory directly.

[User]
Image-1:<image>
 You need to pick up the cauliflower head.

[Assistant] <point>[[854, 351], [837, 456], [817, 575], [805, 695]]</point>

[User]
Image-2:<image>
 You need to move the pot with the cauliflower to the stove.

[Assistant] <point>[[709, 104], [709, 201], [701, 282], [657, 274], [568, 274], [510, 266], [440, 266]]</point>


[System]
You are InternVL, a robotic entity agent.

You are given one observation of the scene and a task to perform. Based on the task, You should return a set of points as the trajectory to execute the task. The point trajectory format should be "<point>[[x1, y1], [x2, y2], [x3, y3],...]</point>". The point coordinates are normalized to integers between 0 and 1000. Please return the point trajectory directly.

[User]
Image-1:<image>
 You need to reach for the spatula.

[Assistant] <point>[[330, 320], [469, 266], [539, 270], [634, 344]]</point>

[User]
Image-2:<image>
 You need to move the spatula towards the orange cloth.

[Assistant] <point>[[594, 332], [489, 293], [431, 274], [362, 270], [287, 270]]</point>


[System]
You are InternVL, a robotic entity agent.

You are given one observation of the scene and a task to perform. Based on the task, You should return a set of points as the trajectory to execute the task. The point trajectory format should be "<point>[[x1, y1], [x2, y2], [x3, y3],...]</point>". The point coordinates are normalized to integers between 0 and 1000. Please return the point trajectory directly.

[User]
Image-1:<image>
 You need to move the pot over the table.

[Assistant] <point>[[78, 444], [168, 421], [313, 448], [429, 506], [533, 595], [599, 664]]</point>

[User]
Image-2:<image>
 You need to move towards the carrot on the plate.

[Assistant] <point>[[261, 602], [394, 587], [501, 598], [672, 645]]</point>


[System]
You are InternVL, a robotic entity agent.

You are given one observation of the scene and a task to perform. Based on the task, You should return a set of points as the trajectory to execute the task. The point trajectory format should be "<point>[[x1, y1], [x2, y2], [x3, y3],...]</point>". The point coordinates are normalized to integers between 0 and 1000. Please return the point trajectory directly.

[User]
Image-1:<image>
 You need to reach for the pineapple.

[Assistant] <point>[[371, 243], [446, 232], [510, 239], [625, 278]]</point>

[User]
Image-2:<image>
 You need to reach for the carrot.

[Assistant] <point>[[423, 181], [304, 293], [246, 394], [165, 525]]</point>


[System]
You are InternVL, a robotic entity agent.

You are given one observation of the scene and a task to perform. Based on the task, You should return a set of points as the trajectory to execute the task. The point trajectory format should be "<point>[[x1, y1], [x2, y2], [x3, y3],...]</point>". The point coordinates are normalized to integers between 0 and 1000. Please return the point trajectory directly.

[User]
Image-1:<image>
 You need to move towards the basil container.

[Assistant] <point>[[206, 174], [391, 232], [492, 313], [614, 452]]</point>

[User]
Image-2:<image>
 You need to reach for the spatula.

[Assistant] <point>[[295, 687], [376, 606], [446, 587], [539, 583]]</point>


[System]
You are InternVL, a robotic entity agent.

You are given one observation of the scene and a task to perform. Based on the task, You should return a set of points as the trajectory to execute the task. The point trajectory format should be "<point>[[x1, y1], [x2, y2], [x3, y3],...]</point>". The point coordinates are normalized to integers between 0 and 1000. Please return the point trajectory directly.

[User]
Image-1:<image>
 You need to pick up the knife.

[Assistant] <point>[[388, 328], [307, 355], [240, 398], [200, 432]]</point>

[User]
Image-2:<image>
 You need to move the knife towards the cloth.

[Assistant] <point>[[347, 386], [527, 409], [672, 444], [782, 483]]</point>


[System]
You are InternVL, a robotic entity agent.

You are given one observation of the scene and a task to perform. Based on the task, You should return a set of points as the trajectory to execute the task. The point trajectory format should be "<point>[[x1, y1], [x2, y2], [x3, y3],...]</point>". The point coordinates are normalized to integers between 0 and 1000. Please return the point trajectory directly.

[User]
Image-1:<image>
 You need to reach for the green vegetable.

[Assistant] <point>[[347, 293], [359, 425], [376, 525], [397, 610]]</point>

[User]
Image-2:<image>
 You need to pick up the stuffed duck.

[Assistant] <point>[[261, 62], [261, 201], [261, 320], [275, 432]]</point>


[System]
You are InternVL, a robotic entity agent.

You are given one observation of the scene and a task to perform. Based on the task, You should return a set of points as the trajectory to execute the task. The point trajectory format should be "<point>[[x1, y1], [x2, y2], [x3, y3],...]</point>". The point coordinates are normalized to integers between 0 and 1000. Please return the point trajectory directly.

[User]
Image-1:<image>
 You need to reach for the bowl.

[Assistant] <point>[[281, 212], [310, 309], [330, 405], [333, 486]]</point>

[User]
Image-2:<image>
 You need to place the bowl on the right corner of the table.

[Assistant] <point>[[605, 263], [675, 456], [707, 568], [750, 707]]</point>


[System]
You are InternVL, a robotic entity agent.

You are given one observation of the scene and a task to perform. Based on the task, You should return a set of points as the trajectory to execute the task. The point trajectory format should be "<point>[[x1, y1], [x2, y2], [x3, y3],...]</point>". The point coordinates are normalized to integers between 0 and 1000. Please return the point trajectory directly.

[User]
Image-1:<image>
 You need to reach for the knife.

[Assistant] <point>[[290, 197], [330, 239], [388, 301], [417, 336]]</point>

[User]
Image-2:<image>
 You need to reach for the spoon.

[Assistant] <point>[[151, 104], [217, 170], [290, 255], [359, 324]]</point>


[System]
You are InternVL, a robotic entity agent.

You are given one observation of the scene and a task to perform. Based on the task, You should return a set of points as the trajectory to execute the task. The point trajectory format should be "<point>[[x1, y1], [x2, y2], [x3, y3],...]</point>". The point coordinates are normalized to integers between 0 and 1000. Please return the point trajectory directly.

[User]
Image-1:<image>
 You need to move the sushi roll towards the orange cloth.

[Assistant] <point>[[359, 255], [339, 340], [330, 436], [319, 525]]</point>

[User]
Image-2:<image>
 You need to reach towards the blue block.

[Assistant] <point>[[266, 239], [371, 417], [469, 568], [611, 749]]</point>


[System]
You are InternVL, a robotic entity agent.

You are given one observation of the scene and a task to perform. Based on the task, You should return a set of points as the trajectory to execute the task. The point trajectory format should be "<point>[[x1, y1], [x2, y2], [x3, y3],...]</point>". The point coordinates are normalized to integers between 0 and 1000. Please return the point trajectory directly.

[User]
Image-1:<image>
 You need to reach for the towel.

[Assistant] <point>[[345, 290], [449, 375], [550, 483], [654, 660]]</point>

[User]
Image-2:<image>
 You need to move the carrot towards the plate.

[Assistant] <point>[[426, 340], [518, 440], [539, 506], [550, 564]]</point>


[System]
You are InternVL, a robotic entity agent.

You are given one observation of the scene and a task to perform. Based on the task, You should return a set of points as the trajectory to execute the task. The point trajectory format should be "<point>[[x1, y1], [x2, y2], [x3, y3],...]</point>". The point coordinates are normalized to integers between 0 and 1000. Please return the point trajectory directly.

[User]
Image-1:<image>
 You need to move towards the hot sauce bottle.

[Assistant] <point>[[458, 405], [394, 463], [356, 525], [319, 625]]</point>

[User]
Image-2:<image>
 You need to move towards the microwave handle.

[Assistant] <point>[[382, 89], [489, 154], [620, 224], [785, 305]]</point>


[System]
You are InternVL, a robotic entity agent.

You are given one observation of the scene and a task to perform. Based on the task, You should return a set of points as the trajectory to execute the task. The point trajectory format should be "<point>[[x1, y1], [x2, y2], [x3, y3],...]</point>". The point coordinates are normalized to integers between 0 and 1000. Please return the point trajectory directly.

[User]
Image-1:<image>
 You need to open the microwave door.

[Assistant] <point>[[736, 309], [698, 390], [660, 448], [597, 525]]</point>

[User]
Image-2:<image>
 You need to pick up the fork.

[Assistant] <point>[[264, 127], [295, 205], [350, 324], [382, 421], [408, 514]]</point>


[System]
You are InternVL, a robotic entity agent.

You are given one observation of the scene and a task to perform. Based on the task, You should return a set of points as the trajectory to execute the task. The point trajectory format should be "<point>[[x1, y1], [x2, y2], [x3, y3],...]</point>". The point coordinates are normalized to integers between 0 and 1000. Please return the point trajectory directly.

[User]
Image-1:<image>
 You need to move the fork towards the cloth.

[Assistant] <point>[[556, 351], [628, 452], [660, 544], [681, 598]]</point>

[User]
Image-2:<image>
 You need to pick up the spoon.

[Assistant] <point>[[527, 263], [405, 297], [266, 363], [211, 517]]</point>


[System]
You are InternVL, a robotic entity agent.

You are given one observation of the scene and a task to perform. Based on the task, You should return a set of points as the trajectory to execute the task. The point trajectory format should be "<point>[[x1, y1], [x2, y2], [x3, y3],...]</point>". The point coordinates are normalized to integers between 0 and 1000. Please return the point trajectory directly.

[User]
Image-1:<image>
 You need to place the spoon on the table.

[Assistant] <point>[[232, 390], [385, 429], [605, 490], [724, 529]]</point>

[User]
Image-2:<image>
 You need to move towards the microwave handle.

[Assistant] <point>[[429, 201], [530, 220], [623, 239], [727, 263]]</point>


[System]
You are InternVL, a robotic entity agent.

You are given one observation of the scene and a task to perform. Based on the task, You should return a set of points as the trajectory to execute the task. The point trajectory format should be "<point>[[x1, y1], [x2, y2], [x3, y3],...]</point>". The point coordinates are normalized to integers between 0 and 1000. Please return the point trajectory directly.

[User]
Image-1:<image>
 You need to reach for the pan.

[Assistant] <point>[[162, 344], [382, 305], [527, 340], [628, 378], [698, 475]]</point>

[User]
Image-2:<image>
 You need to move towards the fridge door.

[Assistant] <point>[[750, 494], [631, 390], [484, 324], [295, 270], [159, 274], [101, 297], [64, 320]]</point>


[System]
You are InternVL, a robotic entity agent.

You are given one observation of the scene and a task to perform. Based on the task, You should return a set of points as the trajectory to execute the task. The point trajectory format should be "<point>[[x1, y1], [x2, y2], [x3, y3],...]</point>". The point coordinates are normalized to integers between 0 and 1000. Please return the point trajectory directly.

[User]
Image-1:<image>
 You need to move towards the pot.

[Assistant] <point>[[217, 347], [434, 351], [568, 367], [678, 421]]</point>

[User]
Image-2:<image>
 You need to reach for the pot.

[Assistant] <point>[[759, 212], [698, 347], [597, 502], [507, 633]]</point>


[System]
You are InternVL, a robotic entity agent.

You are given one observation of the scene and a task to perform. Based on the task, You should return a set of points as the trajectory to execute the task. The point trajectory format should be "<point>[[x1, y1], [x2, y2], [x3, y3],...]</point>". The point coordinates are normalized to integers between 0 and 1000. Please return the point trajectory directly.

[User]
Image-1:<image>
 You need to turn on the stove.

[Assistant] <point>[[304, 247], [327, 317], [347, 375], [374, 425]]</point>

[User]
Image-2:<image>
 You need to reach for the can.

[Assistant] <point>[[712, 205], [634, 201], [495, 208], [371, 236], [229, 282]]</point>


[System]
You are InternVL, a robotic entity agent.

You are given one observation of the scene and a task to perform. Based on the task, You should return a set of points as the trajectory to execute the task. The point trajectory format should be "<point>[[x1, y1], [x2, y2], [x3, y3],...]</point>". The point coordinates are normalized to integers between 0 and 1000. Please return the point trajectory directly.

[User]
Image-1:<image>
 You need to reach for the brush.

[Assistant] <point>[[394, 201], [443, 301], [492, 429], [533, 687]]</point>

[User]
Image-2:<image>
 You need to reach for the pot.

[Assistant] <point>[[295, 185], [411, 239], [556, 301], [669, 355], [793, 425]]</point>


[System]
You are InternVL, a robotic entity agent.

You are given one observation of the scene and a task to perform. Based on the task, You should return a set of points as the trajectory to execute the task. The point trajectory format should be "<point>[[x1, y1], [x2, y2], [x3, y3],...]</point>". The point coordinates are normalized to integers between 0 and 1000. Please return the point trajectory directly.

[User]
Image-1:<image>
 You need to reach for the saucepan.

[Assistant] <point>[[266, 104], [278, 236], [298, 363], [298, 459]]</point>

[User]
Image-2:<image>
 You need to reach for the carrot in the pan.

[Assistant] <point>[[429, 197], [452, 324], [486, 471], [518, 645]]</point>


[System]
You are InternVL, a robotic entity agent.

You are given one observation of the scene and a task to perform. Based on the task, You should return a set of points as the trajectory to execute the task. The point trajectory format should be "<point>[[x1, y1], [x2, y2], [x3, y3],...]</point>". The point coordinates are normalized to integers between 0 and 1000. Please return the point trajectory directly.

[User]
Image-1:<image>
 You need to reach for the red spoon.

[Assistant] <point>[[168, 220], [252, 320], [336, 417], [417, 529], [539, 707]]</point>

[User]
Image-2:<image>
 You need to open the microwave door.

[Assistant] <point>[[290, 100], [266, 201], [255, 266], [249, 371]]</point>


[System]
You are InternVL, a robotic entity agent.

You are given one observation of the scene and a task to perform. Based on the task, You should return a set of points as the trajectory to execute the task. The point trajectory format should be "<point>[[x1, y1], [x2, y2], [x3, y3],...]</point>". The point coordinates are normalized to integers between 0 and 1000. Please return the point trajectory directly.

[User]
Image-1:<image>
 You need to move towards the pan.

[Assistant] <point>[[550, 85], [481, 205], [458, 274], [440, 347]]</point>

[User]
Image-2:<image>
 You need to place the pan on the green towel.

[Assistant] <point>[[466, 174], [550, 232], [620, 305], [707, 398]]</point>


[System]
You are InternVL, a robotic entity agent.

You are given one observation of the scene and a task to perform. Based on the task, You should return a set of points as the trajectory to execute the task. The point trajectory format should be "<point>[[x1, y1], [x2, y2], [x3, y3],...]</point>". The point coordinates are normalized to integers between 0 and 1000. Please return the point trajectory directly.

[User]
Image-1:<image>
 You need to reach for the blue cloth.

[Assistant] <point>[[434, 89], [539, 201], [599, 293], [657, 421], [692, 552], [707, 625]]</point>

[User]
Image-2:<image>
 You need to reach for the pan.

[Assistant] <point>[[475, 189], [437, 320], [423, 390], [350, 510]]</point>


[System]
You are InternVL, a robotic entity agent.

You are given one observation of the scene and a task to perform. Based on the task, You should return a set of points as the trajectory to execute the task. The point trajectory format should be "<point>[[x1, y1], [x2, y2], [x3, y3],...]</point>". The point coordinates are normalized to integers between 0 and 1000. Please return the point trajectory directly.

[User]
Image-1:<image>
 You need to reach for the mushroom.

[Assistant] <point>[[570, 89], [637, 131], [724, 205], [785, 390]]</point>

[User]
Image-2:<image>
 You need to move the mushroom over the napkin.

[Assistant] <point>[[588, 46], [513, 58], [417, 97], [347, 174]]</point>


[System]
You are InternVL, a robotic entity agent.

You are given one observation of the scene and a task to perform. Based on the task, You should return a set of points as the trajectory to execute the task. The point trajectory format should be "<point>[[x1, y1], [x2, y2], [x3, y3],...]</point>". The point coordinates are normalized to integers between 0 and 1000. Please return the point trajectory directly.

[User]
Image-1:<image>
 You need to reach for the pot.

[Assistant] <point>[[356, 274], [391, 371], [417, 479], [426, 544]]</point>

[User]
Image-2:<image>
 You need to reach for the bowl.

[Assistant] <point>[[533, 247], [460, 263], [385, 301]]</point>


[System]
You are InternVL, a robotic entity agent.

You are given one observation of the scene and a task to perform. Based on the task, You should return a set of points as the trajectory to execute the task. The point trajectory format should be "<point>[[x1, y1], [x2, y2], [x3, y3],...]</point>". The point coordinates are normalized to integers between 0 and 1000. Please return the point trajectory directly.

[User]
Image-1:<image>
 You need to move towards the fridge handle.

[Assistant] <point>[[327, 351], [423, 425], [515, 506], [611, 598]]</point>

[User]
Image-2:<image>
 You need to reach for the orange cloth.

[Assistant] <point>[[458, 205], [486, 320], [504, 471], [521, 656]]</point>


[System]
You are InternVL, a robotic entity agent.

You are given one observation of the scene and a task to perform. Based on the task, You should return a set of points as the trajectory to execute the task. The point trajectory format should be "<point>[[x1, y1], [x2, y2], [x3, y3],...]</point>". The point coordinates are normalized to integers between 0 and 1000. Please return the point trajectory directly.

[User]
Image-1:<image>
 You need to move the spoon above the table.

[Assistant] <point>[[197, 301], [313, 332], [455, 432], [518, 510], [553, 571]]</point>

[User]
Image-2:<image>
 You need to grip the vessel.

[Assistant] <point>[[336, 162], [403, 344], [458, 479], [515, 575]]</point>


[System]
You are InternVL, a robotic entity agent.

You are given one observation of the scene and a task to perform. Based on the task, You should return a set of points as the trajectory to execute the task. The point trajectory format should be "<point>[[x1, y1], [x2, y2], [x3, y3],...]</point>". The point coordinates are normalized to integers between 0 and 1000. Please return the point trajectory directly.

[User]
Image-1:<image>
 You need to move towards the metal pot.

[Assistant] <point>[[214, 336], [336, 320], [417, 313], [544, 336]]</point>

[User]
Image-2:<image>
 You need to reach for the pot.

[Assistant] <point>[[403, 205], [460, 282], [550, 398], [614, 494]]</point>


[System]
You are InternVL, a robotic entity agent.

You are given one observation of the scene and a task to perform. Based on the task, You should return a set of points as the trajectory to execute the task. The point trajectory format should be "<point>[[x1, y1], [x2, y2], [x3, y3],...]</point>". The point coordinates are normalized to integers between 0 and 1000. Please return the point trajectory directly.

[User]
Image-1:<image>
 You need to move towards the yellow capsicum.

[Assistant] <point>[[472, 216], [539, 347], [591, 479], [663, 660]]</point>

[User]
Image-2:<image>
 You need to move towards the microwave.

[Assistant] <point>[[333, 676], [347, 359], [292, 89]]</point>


[System]
You are InternVL, a robotic entity agent.

You are given one observation of the scene and a task to perform. Based on the task, You should return a set of points as the trajectory to execute the task. The point trajectory format should be "<point>[[x1, y1], [x2, y2], [x3, y3],...]</point>". The point coordinates are normalized to integers between 0 and 1000. Please return the point trajectory directly.

[User]
Image-1:<image>
 You need to approach the pot.

[Assistant] <point>[[237, 278], [368, 336], [452, 382], [542, 444], [625, 517], [709, 633]]</point>

[User]
Image-2:<image>
 You need to reach for the grapes.

[Assistant] <point>[[350, 205], [544, 286], [637, 340], [738, 452], [796, 564], [840, 668]]</point>


[System]
You are InternVL, a robotic entity agent.

You are given one observation of the scene and a task to perform. Based on the task, You should return a set of points as the trajectory to execute the task. The point trajectory format should be "<point>[[x1, y1], [x2, y2], [x3, y3],...]</point>". The point coordinates are normalized to integers between 0 and 1000. Please return the point trajectory directly.

[User]
Image-1:<image>
 You need to reach for the bowl.

[Assistant] <point>[[281, 62], [330, 139], [397, 263], [452, 355], [536, 579]]</point>

[User]
Image-2:<image>
 You need to move towards the cup.

[Assistant] <point>[[107, 301], [240, 251], [313, 205]]</point>


[System]
You are InternVL, a robotic entity agent.

You are given one observation of the scene and a task to perform. Based on the task, You should return a set of points as the trajectory to execute the task. The point trajectory format should be "<point>[[x1, y1], [x2, y2], [x3, y3],...]</point>". The point coordinates are normalized to integers between 0 and 1000. Please return the point trajectory directly.

[User]
Image-1:<image>
 You need to reach for the pot.

[Assistant] <point>[[171, 81], [217, 193], [278, 336], [368, 471]]</point>

[User]
Image-2:<image>
 You need to reach for the pot.

[Assistant] <point>[[75, 232], [197, 251], [333, 309], [437, 355], [513, 402], [669, 490]]</point>


[System]
You are InternVL, a robotic entity agent.

You are given one observation of the scene and a task to perform. Based on the task, You should return a set of points as the trajectory to execute the task. The point trajectory format should be "<point>[[x1, y1], [x2, y2], [x3, y3],...]</point>". The point coordinates are normalized to integers between 0 and 1000. Please return the point trajectory directly.

[User]
Image-1:<image>
 You need to approach the broccoli.

[Assistant] <point>[[599, 58], [472, 120], [411, 208], [368, 297]]</point>

[User]
Image-2:<image>
 You need to reach for the broccoli in the pan.

[Assistant] <point>[[707, 483], [617, 444], [518, 471], [417, 517], [347, 587]]</point>


[System]
You are InternVL, a robotic entity agent.

You are given one observation of the scene and a task to perform. Based on the task, You should return a set of points as the trajectory to execute the task. The point trajectory format should be "<point>[[x1, y1], [x2, y2], [x3, y3],...]</point>". The point coordinates are normalized to integers between 0 and 1000. Please return the point trajectory directly.

[User]
Image-1:<image>
 You need to reach for the microwave handle.

[Assistant] <point>[[429, 170], [582, 220], [654, 255], [747, 309]]</point>

[User]
Image-2:<image>
 You need to move towards the spoon.

[Assistant] <point>[[440, 120], [510, 201], [568, 282], [623, 359], [672, 440], [724, 541]]</point>


[System]
You are InternVL, a robotic entity agent.

You are given one observation of the scene and a task to perform. Based on the task, You should return a set of points as the trajectory to execute the task. The point trajectory format should be "<point>[[x1, y1], [x2, y2], [x3, y3],...]</point>". The point coordinates are normalized to integers between 0 and 1000. Please return the point trajectory directly.

[User]
Image-1:<image>
 You need to reach for the spoon.

[Assistant] <point>[[414, 124], [353, 185], [290, 259], [232, 324], [177, 398]]</point>

[User]
Image-2:<image>
 You need to approach the bottle.

[Assistant] <point>[[573, 320], [492, 270], [374, 243], [281, 266], [229, 309]]</point>


[System]
You are InternVL, a robotic entity agent.

You are given one observation of the scene and a task to perform. Based on the task, You should return a set of points as the trajectory to execute the task. The point trajectory format should be "<point>[[x1, y1], [x2, y2], [x3, y3],...]</point>". The point coordinates are normalized to integers between 0 and 1000. Please return the point trajectory directly.

[User]
Image-1:<image>
 You need to raise away from the plate and sink.

[Assistant] <point>[[481, 440], [527, 429], [594, 479], [634, 552]]</point>

[User]
Image-2:<image>
 You need to move towards the eggplant.

[Assistant] <point>[[327, 108], [400, 154], [431, 197], [478, 293]]</point>


[System]
You are InternVL, a robotic entity agent.

You are given one observation of the scene and a task to perform. Based on the task, You should return a set of points as the trajectory to execute the task. The point trajectory format should be "<point>[[x1, y1], [x2, y2], [x3, y3],...]</point>". The point coordinates are normalized to integers between 0 and 1000. Please return the point trajectory directly.

[User]
Image-1:<image>
 You need to reach for the yellow sponge in the bowl.

[Assistant] <point>[[463, 124], [365, 232], [275, 405]]</point>

[User]
Image-2:<image>
 You need to move the sponge away from the bowl.

[Assistant] <point>[[319, 93], [443, 154], [565, 232], [683, 320], [791, 413]]</point>


[System]
You are InternVL, a robotic entity agent.

You are given one observation of the scene and a task to perform. Based on the task, You should return a set of points as the trajectory to execute the task. The point trajectory format should be "<point>[[x1, y1], [x2, y2], [x3, y3],...]</point>". The point coordinates are normalized to integers between 0 and 1000. Please return the point trajectory directly.

[User]
Image-1:<image>
 You need to move towards the towel.

[Assistant] <point>[[683, 394], [582, 328], [489, 286], [376, 263]]</point>

[User]
Image-2:<image>
 You need to move the towel.

[Assistant] <point>[[391, 251], [434, 378], [452, 494], [469, 571]]</point>


[System]
You are InternVL, a robotic entity agent.

You are given one observation of the scene and a task to perform. Based on the task, You should return a set of points as the trajectory to execute the task. The point trajectory format should be "<point>[[x1, y1], [x2, y2], [x3, y3],...]</point>". The point coordinates are normalized to integers between 0 and 1000. Please return the point trajectory directly.

[User]
Image-1:<image>
 You need to reach for the cloth.

[Assistant] <point>[[672, 440], [539, 371], [397, 386], [217, 409]]</point>

[User]
Image-2:<image>
 You need to reach for the spoon.

[Assistant] <point>[[484, 382], [510, 459], [527, 533], [542, 649]]</point>


[System]
You are InternVL, a robotic entity agent.

You are given one observation of the scene and a task to perform. Based on the task, You should return a set of points as the trajectory to execute the task. The point trajectory format should be "<point>[[x1, y1], [x2, y2], [x3, y3],...]</point>". The point coordinates are normalized to integers between 0 and 1000. Please return the point trajectory directly.

[User]
Image-1:<image>
 You need to pull open the oven door.

[Assistant] <point>[[492, 637], [559, 722], [588, 768], [663, 888]]</point>

[User]
Image-2:<image>
 You need to place the strawberry on the right corner of the table.

[Assistant] <point>[[339, 236], [469, 378], [550, 548], [623, 745]]</point>


[System]
You are InternVL, a robotic entity agent.

You are given one observation of the scene and a task to perform. Based on the task, You should return a set of points as the trajectory to execute the task. The point trajectory format should be "<point>[[x1, y1], [x2, y2], [x3, y3],...]</point>". The point coordinates are normalized to integers between 0 and 1000. Please return the point trajectory directly.

[User]
Image-1:<image>
 You need to reach for the spatula.

[Assistant] <point>[[446, 305], [356, 266], [275, 293]]</point>

[User]
Image-2:<image>
 You need to move the spatula towards the front edge of the table.

[Assistant] <point>[[321, 239], [405, 382], [458, 506], [524, 672]]</point>


[System]
You are InternVL, a robotic entity agent.

You are given one observation of the scene and a task to perform. Based on the task, You should return a set of points as the trajectory to execute the task. The point trajectory format should be "<point>[[x1, y1], [x2, y2], [x3, y3],...]</point>". The point coordinates are normalized to integers between 0 and 1000. Please return the point trajectory directly.

[User]
Image-1:<image>
 You need to move towards the beet in the pot.

[Assistant] <point>[[414, 255], [472, 359], [501, 475], [518, 583]]</point>

[User]
Image-2:<image>
 You need to move towards the cheese wedge.

[Assistant] <point>[[336, 170], [475, 201], [565, 270], [689, 413]]</point>


[System]
You are InternVL, a robotic entity agent.

You are given one observation of the scene and a task to perform. Based on the task, You should return a set of points as the trajectory to execute the task. The point trajectory format should be "<point>[[x1, y1], [x2, y2], [x3, y3],...]</point>". The point coordinates are normalized to integers between 0 and 1000. Please return the point trajectory directly.

[User]
Image-1:<image>
 You need to reach for the bowl.

[Assistant] <point>[[182, 340], [264, 317], [333, 309], [434, 297]]</point>

[User]
Image-2:<image>
 You need to move towards the meat.

[Assistant] <point>[[405, 178], [356, 290], [266, 537]]</point>


[System]
You are InternVL, a robotic entity agent.

You are given one observation of the scene and a task to perform. Based on the task, You should return a set of points as the trajectory to execute the task. The point trajectory format should be "<point>[[x1, y1], [x2, y2], [x3, y3],...]</point>". The point coordinates are normalized to integers between 0 and 1000. Please return the point trajectory directly.

[User]
Image-1:<image>
 You need to reach for the spatula.

[Assistant] <point>[[510, 185], [501, 309], [495, 394], [498, 494]]</point>

[User]
Image-2:<image>
 You need to reach for the bowl.

[Assistant] <point>[[313, 85], [458, 220], [513, 340], [565, 444]]</point>


[System]
You are InternVL, a robotic entity agent.

You are given one observation of the scene and a task to perform. Based on the task, You should return a set of points as the trajectory to execute the task. The point trajectory format should be "<point>[[x1, y1], [x2, y2], [x3, y3],...]</point>". The point coordinates are normalized to integers between 0 and 1000. Please return the point trajectory directly.

[User]
Image-1:<image>
 You need to move the bowl towards the drumstick.

[Assistant] <point>[[431, 139], [492, 274], [556, 479], [588, 633]]</point>

[User]
Image-2:<image>
 You need to reach for the vegetable.

[Assistant] <point>[[249, 120], [371, 147], [501, 201], [585, 255], [657, 363]]</point>


[System]
You are InternVL, a robotic entity agent.

You are given one observation of the scene and a task to perform. Based on the task, You should return a set of points as the trajectory to execute the task. The point trajectory format should be "<point>[[x1, y1], [x2, y2], [x3, y3],...]</point>". The point coordinates are normalized to integers between 0 and 1000. Please return the point trajectory directly.

[User]
Image-1:<image>
 You need to reach for the knife.

[Assistant] <point>[[174, 216], [278, 282], [394, 359], [599, 517], [698, 610]]</point>

[User]
Image-2:<image>
 You need to reach for the knife.

[Assistant] <point>[[712, 587], [634, 529], [550, 490], [455, 459], [391, 436]]</point>


[System]
You are InternVL, a robotic entity agent.

You are given one observation of the scene and a task to perform. Based on the task, You should return a set of points as the trajectory to execute the task. The point trajectory format should be "<point>[[x1, y1], [x2, y2], [x3, y3],...]</point>". The point coordinates are normalized to integers between 0 and 1000. Please return the point trajectory directly.

[User]
Image-1:<image>
 You need to move towards the bowl.

[Assistant] <point>[[394, 73], [449, 151], [492, 224], [544, 301], [573, 390]]</point>

[User]
Image-2:<image>
 You need to position above the chicken wing in the pot.

[Assistant] <point>[[374, 255], [388, 340], [394, 429], [411, 556]]</point>


[System]
You are InternVL, a robotic entity agent.

You are given one observation of the scene and a task to perform. Based on the task, You should return a set of points as the trajectory to execute the task. The point trajectory format should be "<point>[[x1, y1], [x2, y2], [x3, y3],...]</point>". The point coordinates are normalized to integers between 0 and 1000. Please return the point trajectory directly.

[User]
Image-1:<image>
 You need to reach for the object in the pot.

[Assistant] <point>[[261, 236], [356, 309], [469, 417], [631, 602]]</point>

[User]
Image-2:<image>
 You need to move towards the refrigerator door handle.

[Assistant] <point>[[307, 212], [417, 255], [521, 297], [672, 340], [724, 355]]</point>


[System]
You are InternVL, a robotic entity agent.

You are given one observation of the scene and a task to perform. Based on the task, You should return a set of points as the trajectory to execute the task. The point trajectory format should be "<point>[[x1, y1], [x2, y2], [x3, y3],...]</point>". The point coordinates are normalized to integers between 0 and 1000. Please return the point trajectory directly.

[User]
Image-1:<image>
 You need to reach for the towel.

[Assistant] <point>[[423, 371], [313, 378], [240, 413], [206, 429]]</point>

[User]
Image-2:<image>
 You need to reach for the spoon.

[Assistant] <point>[[553, 367], [437, 367], [362, 413], [287, 471], [237, 544]]</point>


[System]
You are InternVL, a robotic entity agent.

You are given one observation of the scene and a task to perform. Based on the task, You should return a set of points as the trajectory to execute the task. The point trajectory format should be "<point>[[x1, y1], [x2, y2], [x3, y3],...]</point>". The point coordinates are normalized to integers between 0 and 1000. Please return the point trajectory directly.

[User]
Image-1:<image>
 You need to reach for the banana in the pot.

[Assistant] <point>[[145, 185], [310, 224], [437, 259], [536, 297], [652, 363]]</point>

[User]
Image-2:<image>
 You need to place the banana to the left of a pot.

[Assistant] <point>[[654, 239], [585, 243], [475, 266], [379, 305]]</point>


[System]
You are InternVL, a robotic entity agent.

You are given one observation of the scene and a task to perform. Based on the task, You should return a set of points as the trajectory to execute the task. The point trajectory format should be "<point>[[x1, y1], [x2, y2], [x3, y3],...]</point>". The point coordinates are normalized to integers between 0 and 1000. Please return the point trajectory directly.

[User]
Image-1:<image>
 You need to reach for the green pepper.

[Assistant] <point>[[692, 232], [617, 178], [562, 162], [452, 208]]</point>

[User]
Image-2:<image>
 You need to move towards the stuffed duck.

[Assistant] <point>[[646, 54], [501, 93], [420, 193], [342, 332], [330, 394]]</point>


[System]
You are InternVL, a robotic entity agent.

You are given one observation of the scene and a task to perform. Based on the task, You should return a set of points as the trajectory to execute the task. The point trajectory format should be "<point>[[x1, y1], [x2, y2], [x3, y3],...]</point>". The point coordinates are normalized to integers between 0 and 1000. Please return the point trajectory directly.

[User]
Image-1:<image>
 You need to pick up the spoon.

[Assistant] <point>[[206, 320], [290, 270], [353, 263], [429, 266]]</point>

[User]
Image-2:<image>
 You need to move the spoon towards the bottom right corner.

[Assistant] <point>[[440, 151], [547, 305], [628, 463], [666, 583]]</point>


[System]
You are InternVL, a robotic entity agent.

You are given one observation of the scene and a task to perform. Based on the task, You should return a set of points as the trajectory to execute the task. The point trajectory format should be "<point>[[x1, y1], [x2, y2], [x3, y3],...]</point>". The point coordinates are normalized to integers between 0 and 1000. Please return the point trajectory directly.

[User]
Image-1:<image>
 You need to reach for the small pan.

[Assistant] <point>[[255, 317], [356, 293], [458, 301], [597, 336]]</point>

[User]
Image-2:<image>
 You need to reach for the spoon.

[Assistant] <point>[[762, 251], [692, 317], [652, 359], [608, 398]]</point>


[System]
You are InternVL, a robotic entity agent.

You are given one observation of the scene and a task to perform. Based on the task, You should return a set of points as the trajectory to execute the task. The point trajectory format should be "<point>[[x1, y1], [x2, y2], [x3, y3],...]</point>". The point coordinates are normalized to integers between 0 and 1000. Please return the point trajectory directly.

[User]
Image-1:<image>
 You need to reach for the pear.

[Assistant] <point>[[116, 73], [165, 224], [226, 371], [269, 479]]</point>

[User]
Image-2:<image>
 You need to reach for the microwave handle.

[Assistant] <point>[[556, 413], [481, 278], [394, 236], [278, 247]]</point>


[System]
You are InternVL, a robotic entity agent.

You are given one observation of the scene and a task to perform. Based on the task, You should return a set of points as the trajectory to execute the task. The point trajectory format should be "<point>[[x1, y1], [x2, y2], [x3, y3],...]</point>". The point coordinates are normalized to integers between 0 and 1000. Please return the point trajectory directly.

[User]
Image-1:<image>
 You need to reach for the knife.

[Assistant] <point>[[313, 382], [440, 359], [582, 386], [721, 456]]</point>

[User]
Image-2:<image>
 You need to move the knife towards the left of the bowl.

[Assistant] <point>[[620, 185], [423, 193], [376, 216], [301, 251]]</point>


[System]
You are InternVL, a robotic entity agent.

You are given one observation of the scene and a task to perform. Based on the task, You should return a set of points as the trajectory to execute the task. The point trajectory format should be "<point>[[x1, y1], [x2, y2], [x3, y3],...]</point>". The point coordinates are normalized to integers between 0 and 1000. Please return the point trajectory directly.

[User]
Image-1:<image>
 You need to place the pan on the stove.

[Assistant] <point>[[408, 112], [371, 197], [336, 290], [321, 402]]</point>

[User]
Image-2:<image>
 You need to move towards the scissors.

[Assistant] <point>[[90, 170], [237, 255], [391, 328], [544, 494]]</point>


[System]
You are InternVL, a robotic entity agent.

You are given one observation of the scene and a task to perform. Based on the task, You should return a set of points as the trajectory to execute the task. The point trajectory format should be "<point>[[x1, y1], [x2, y2], [x3, y3],...]</point>". The point coordinates are normalized to integers between 0 and 1000. Please return the point trajectory directly.

[User]
Image-1:<image>
 You need to pick up the sushi from a bowl.

[Assistant] <point>[[582, 208], [515, 286], [431, 417], [379, 552]]</point>

[User]
Image-2:<image>
 You need to place the sushi on the table.

[Assistant] <point>[[556, 185], [646, 328], [675, 375], [698, 421]]</point>


[System]
You are InternVL, a robotic entity agent.

You are given one observation of the scene and a task to perform. Based on the task, You should return a set of points as the trajectory to execute the task. The point trajectory format should be "<point>[[x1, y1], [x2, y2], [x3, y3],...]</point>". The point coordinates are normalized to integers between 0 and 1000. Please return the point trajectory directly.

[User]
Image-1:<image>
 You need to move the mushroom over the table.

[Assistant] <point>[[55, 174], [122, 351], [197, 483], [304, 595]]</point>

[User]
Image-2:<image>
 You need to place the pot on the stove.

[Assistant] <point>[[640, 216], [562, 324], [544, 402], [524, 525]]</point>


[System]
You are InternVL, a robotic entity agent.

You are given one observation of the scene and a task to perform. Based on the task, You should return a set of points as the trajectory to execute the task. The point trajectory format should be "<point>[[x1, y1], [x2, y2], [x3, y3],...]</point>". The point coordinates are normalized to integers between 0 and 1000. Please return the point trajectory directly.

[User]
Image-1:<image>
 You need to move the spoon towards the vessel.

[Assistant] <point>[[220, 185], [339, 193], [429, 282], [495, 355], [542, 394]]</point>

[User]
Image-2:<image>
 You need to reach for the cucumber.

[Assistant] <point>[[666, 212], [539, 290], [458, 363], [359, 490], [327, 571]]</point>


[System]
You are InternVL, a robotic entity agent.

You are given one observation of the scene and a task to perform. Based on the task, You should return a set of points as the trajectory to execute the task. The point trajectory format should be "<point>[[x1, y1], [x2, y2], [x3, y3],...]</point>". The point coordinates are normalized to integers between 0 and 1000. Please return the point trajectory directly.

[User]
Image-1:<image>
 You need to reach for the spatula in the sink.

[Assistant] <point>[[750, 429], [724, 514], [689, 656]]</point>

[User]
Image-2:<image>
 You need to lift the pan.

[Assistant] <point>[[463, 475], [559, 459], [669, 506], [721, 525]]</point>


[System]
You are InternVL, a robotic entity agent.

You are given one observation of the scene and a task to perform. Based on the task, You should return a set of points as the trajectory to execute the task. The point trajectory format should be "<point>[[x1, y1], [x2, y2], [x3, y3],...]</point>". The point coordinates are normalized to integers between 0 and 1000. Please return the point trajectory directly.

[User]
Image-1:<image>
 You need to reach for the mushroom.

[Assistant] <point>[[298, 116], [333, 247], [350, 359], [379, 571]]</point>

[User]
Image-2:<image>
 You need to move towards the bowl.

[Assistant] <point>[[594, 286], [547, 293], [486, 317], [446, 344]]</point>


[System]
You are InternVL, a robotic entity agent.

You are given one observation of the scene and a task to perform. Based on the task, You should return a set of points as the trajectory to execute the task. The point trajectory format should be "<point>[[x1, y1], [x2, y2], [x3, y3],...]</point>". The point coordinates are normalized to integers between 0 and 1000. Please return the point trajectory directly.

[User]
Image-1:<image>
 You need to reach for the fork.

[Assistant] <point>[[368, 77], [455, 263], [527, 402], [599, 583], [623, 656]]</point>

[User]
Image-2:<image>
 You need to reach for the vessel.

[Assistant] <point>[[379, 243], [440, 347], [504, 475], [539, 541]]</point>


[System]
You are InternVL, a robotic entity agent.

You are given one observation of the scene and a task to perform. Based on the task, You should return a set of points as the trajectory to execute the task. The point trajectory format should be "<point>[[x1, y1], [x2, y2], [x3, y3],...]</point>". The point coordinates are normalized to integers between 0 and 1000. Please return the point trajectory directly.

[User]
Image-1:<image>
 You need to reach for the spoon.

[Assistant] <point>[[468, 244], [433, 300], [419, 347], [440, 423]]</point>

[User]
Image-2:<image>
 You need to reach for the napkin.

[Assistant] <point>[[637, 333], [511, 291], [387, 305], [338, 357]]</point>


[System]
You are InternVL, a robotic entity agent.

You are given one observation of the scene and a task to perform. Based on the task, You should return a set of points as the trajectory to execute the task. The point trajectory format should be "<point>[[x1, y1], [x2, y2], [x3, y3],...]</point>". The point coordinates are normalized to integers between 0 and 1000. Please return the point trajectory directly.

[User]
Image-1:<image>
 You need to move the napkin over the pot.

[Assistant] <point>[[423, 394], [518, 371], [616, 385], [673, 474]]</point>

[User]
Image-2:<image>
 You need to reach for the beet in the pot.

[Assistant] <point>[[824, 460], [736, 432], [658, 427], [581, 488]]</point>


[System]
You are InternVL, a robotic entity agent.

You are given one observation of the scene and a task to perform. Based on the task, You should return a set of points as the trajectory to execute the task. The point trajectory format should be "<point>[[x1, y1], [x2, y2], [x3, y3],...]</point>". The point coordinates are normalized to integers between 0 and 1000. Please return the point trajectory directly.

[User]
Image-1:<image>
 You need to reach for the sauce pot.

[Assistant] <point>[[285, 216], [299, 305], [292, 385], [250, 460]]</point>

[User]
Image-2:<image>
 You need to reach for the refrigerator handle.

[Assistant] <point>[[356, 385], [426, 437], [504, 474], [616, 446]]</point>


[System]
You are InternVL, a robotic entity agent.

You are given one observation of the scene and a task to perform. Based on the task, You should return a set of points as the trajectory to execute the task. The point trajectory format should be "<point>[[x1, y1], [x2, y2], [x3, y3],...]</point>". The point coordinates are normalized to integers between 0 and 1000. Please return the point trajectory directly.

[User]
Image-1:<image>
 You need to reach for the spoon.

[Assistant] <point>[[363, 300], [482, 371], [556, 474], [599, 700]]</point>

[User]
Image-2:<image>
 You need to move the spoon towards the left edge of the counter.

[Assistant] <point>[[620, 676], [521, 554], [384, 488], [222, 460]]</point>


[System]
You are InternVL, a robotic entity agent.

You are given one observation of the scene and a task to perform. Based on the task, You should return a set of points as the trajectory to execute the task. The point trajectory format should be "<point>[[x1, y1], [x2, y2], [x3, y3],...]</point>". The point coordinates are normalized to integers between 0 and 1000. Please return the point trajectory directly.

[User]
Image-1:<image>
 You need to reach for the brush.

[Assistant] <point>[[440, 174], [454, 249], [461, 319], [433, 427]]</point>

[User]
Image-2:<image>
 You need to move the brush towards the napkin.

[Assistant] <point>[[352, 366], [465, 404], [574, 469], [687, 718]]</point>


[System]
You are InternVL, a robotic entity agent.

You are given one observation of the scene and a task to perform. Based on the task, You should return a set of points as the trajectory to execute the task. The point trajectory format should be "<point>[[x1, y1], [x2, y2], [x3, y3],...]</point>". The point coordinates are normalized to integers between 0 and 1000. Please return the point trajectory directly.

[User]
Image-1:<image>
 You need to lower towards the bowl.

[Assistant] <point>[[718, 239], [546, 239], [444, 315], [415, 413]]</point>

[User]
Image-2:<image>
 You need to reach for the spatula.

[Assistant] <point>[[542, 146], [408, 155], [356, 202], [303, 268]]</point>


[System]
You are InternVL, a robotic entity agent.

You are given one observation of the scene and a task to perform. Based on the task, You should return a set of points as the trajectory to execute the task. The point trajectory format should be "<point>[[x1, y1], [x2, y2], [x3, y3],...]</point>". The point coordinates are normalized to integers between 0 and 1000. Please return the point trajectory directly.

[User]
Image-1:<image>
 You need to pick up the red object.

[Assistant] <point>[[468, 413], [356, 333], [236, 315], [162, 385]]</point>

[User]
Image-2:<image>
 You need to place the red pepper to the right of the towel.

[Assistant] <point>[[303, 249], [479, 244], [585, 286], [732, 451]]</point>


[System]
You are InternVL, a robotic entity agent.

You are given one observation of the scene and a task to perform. Based on the task, You should return a set of points as the trajectory to execute the task. The point trajectory format should be "<point>[[x1, y1], [x2, y2], [x3, y3],...]</point>". The point coordinates are normalized to integers between 0 and 1000. Please return the point trajectory directly.

[User]
Image-1:<image>
 You need to pick up the bowl.

[Assistant] <point>[[511, 272], [482, 329], [482, 413], [518, 474]]</point>

[User]
Image-2:<image>
 You need to reach for the potato.

[Assistant] <point>[[401, 268], [264, 291], [194, 362], [173, 446]]</point>


[System]
You are InternVL, a robotic entity agent.

You are given one observation of the scene and a task to perform. Based on the task, You should return a set of points as the trajectory to execute the task. The point trajectory format should be "<point>[[x1, y1], [x2, y2], [x3, y3],...]</point>". The point coordinates are normalized to integers between 0 and 1000. Please return the point trajectory directly.

[User]
Image-1:<image>
 You need to move the potato towards the pot.

[Assistant] <point>[[194, 545], [264, 488], [327, 484], [444, 535]]</point>

[User]
Image-2:<image>
 You need to reach for the spice container.

[Assistant] <point>[[602, 399], [486, 385], [405, 394], [349, 432]]</point>


[System]
You are InternVL, a robotic entity agent.

You are given one observation of the scene and a task to perform. Based on the task, You should return a set of points as the trajectory to execute the task. The point trajectory format should be "<point>[[x1, y1], [x2, y2], [x3, y3],...]</point>". The point coordinates are normalized to integers between 0 and 1000. Please return the point trajectory directly.

[User]
Image-1:<image>
 You need to reach for the spoon.

[Assistant] <point>[[437, 347], [493, 338], [546, 366], [616, 479]]</point>

[User]
Image-2:<image>
 You need to reach for the pepper in the pot.

[Assistant] <point>[[412, 207], [482, 178], [553, 211], [630, 333]]</point>


[System]
You are InternVL, a robotic entity agent.

You are given one observation of the scene and a task to perform. Based on the task, You should return a set of points as the trajectory to execute the task. The point trajectory format should be "<point>[[x1, y1], [x2, y2], [x3, y3],...]</point>". The point coordinates are normalized to integers between 0 and 1000. Please return the point trajectory directly.

[User]
Image-1:<image>
 You need to move towards the fork.

[Assistant] <point>[[433, 329], [535, 418], [606, 535], [602, 704]]</point>

[User]
Image-2:<image>
 You need to reach for the blue object.

[Assistant] <point>[[539, 197], [405, 197], [292, 258], [208, 423]]</point>


[System]
You are InternVL, a robotic entity agent.

You are given one observation of the scene and a task to perform. Based on the task, You should return a set of points as the trajectory to execute the task. The point trajectory format should be "<point>[[x1, y1], [x2, y2], [x3, y3],...]</point>". The point coordinates are normalized to integers between 0 and 1000. Please return the point trajectory directly.

[User]
Image-1:<image>
 You need to reach for the bowl.

[Assistant] <point>[[447, 272], [475, 362], [518, 385], [581, 371]]</point>

[User]
Image-2:<image>
 You need to reach for the spoon.

[Assistant] <point>[[320, 141], [313, 315], [356, 432], [525, 596]]</point>


[System]
You are InternVL, a robotic entity agent.

You are given one observation of the scene and a task to perform. Based on the task, You should return a set of points as the trajectory to execute the task. The point trajectory format should be "<point>[[x1, y1], [x2, y2], [x3, y3],...]</point>". The point coordinates are normalized to integers between 0 and 1000. Please return the point trajectory directly.

[User]
Image-1:<image>
 You need to pick up the pot.

[Assistant] <point>[[894, 554], [820, 559], [775, 601], [771, 685]]</point>

[User]
Image-2:<image>
 You need to reach for the mushroom.

[Assistant] <point>[[229, 277], [204, 324], [208, 376], [232, 432]]</point>


[System]
You are InternVL, a robotic entity agent.

You are given one observation of the scene and a task to perform. Based on the task, You should return a set of points as the trajectory to execute the task. The point trajectory format should be "<point>[[x1, y1], [x2, y2], [x3, y3],...]</point>". The point coordinates are normalized to integers between 0 and 1000. Please return the point trajectory directly.

[User]
Image-1:<image>
 You need to move towards the orange object.

[Assistant] <point>[[458, 61], [391, 164], [373, 296], [391, 488]]</point>

[User]
Image-2:<image>
 You need to move towards the pot.

[Assistant] <point>[[468, 211], [433, 329], [440, 451], [496, 549]]</point>


[System]
You are InternVL, a robotic entity agent.

You are given one observation of the scene and a task to perform. Based on the task, You should return a set of points as the trajectory to execute the task. The point trajectory format should be "<point>[[x1, y1], [x2, y2], [x3, y3],...]</point>". The point coordinates are normalized to integers between 0 and 1000. Please return the point trajectory directly.

[User]
Image-1:<image>
 You need to move towards the red pepper.

[Assistant] <point>[[595, 423], [468, 357], [324, 329], [201, 399]]</point>

[User]
Image-2:<image>
 You need to reach for the bowl.

[Assistant] <point>[[391, 122], [472, 263], [482, 423], [468, 714]]</point>


[System]
You are InternVL, a robotic entity agent.

You are given one observation of the scene and a task to perform. Based on the task, You should return a set of points as the trajectory to execute the task. The point trajectory format should be "<point>[[x1, y1], [x2, y2], [x3, y3],...]</point>". The point coordinates are normalized to integers between 0 and 1000. Please return the point trajectory directly.

[User]
Image-1:<image>
 You need to pick up the knife.

[Assistant] <point>[[363, 352], [468, 432], [532, 488], [609, 737]]</point>

[User]
Image-2:<image>
 You need to move the knife towards the bottom left corner.

[Assistant] <point>[[282, 310], [222, 357], [197, 418], [201, 474]]</point>


[System]
You are InternVL, a robotic entity agent.

You are given one observation of the scene and a task to perform. Based on the task, You should return a set of points as the trajectory to execute the task. The point trajectory format should be "<point>[[x1, y1], [x2, y2], [x3, y3],...]</point>". The point coordinates are normalized to integers between 0 and 1000. Please return the point trajectory directly.

[User]
Image-1:<image>
 You need to reach for the pot.

[Assistant] <point>[[271, 150], [387, 254], [454, 357], [496, 507]]</point>

[User]
Image-2:<image>
 You need to reach for the blue object.

[Assistant] <point>[[521, 272], [588, 347], [644, 474], [673, 728]]</point>


[System]
You are InternVL, a robotic entity agent.

You are given one observation of the scene and a task to perform. Based on the task, You should return a set of points as the trajectory to execute the task. The point trajectory format should be "<point>[[x1, y1], [x2, y2], [x3, y3],...]</point>". The point coordinates are normalized to integers between 0 and 1000. Please return the point trajectory directly.

[User]
Image-1:<image>
 You need to move the blue object towards the purple cloth.

[Assistant] <point>[[394, 282], [317, 282], [261, 315], [222, 376]]</point>

[User]
Image-2:<image>
 You need to move towards the bowl.

[Assistant] <point>[[204, 216], [296, 282], [356, 366], [384, 526]]</point>


[System]
You are InternVL, a robotic entity agent.

You are given one observation of the scene and a task to perform. Based on the task, You should return a set of points as the trajectory to execute the task. The point trajectory format should be "<point>[[x1, y1], [x2, y2], [x3, y3],...]</point>". The point coordinates are normalized to integers between 0 and 1000. Please return the point trajectory directly.

[User]
Image-1:<image>
 You need to reach towards the measuring cup.

[Assistant] <point>[[482, 42], [447, 103], [419, 174], [398, 272]]</point>

[User]
Image-2:<image>
 You need to reach towards the towel.

[Assistant] <point>[[180, 122], [250, 211], [299, 310], [306, 460]]</point>


[System]
You are InternVL, a robotic entity agent.

You are given one observation of the scene and a task to perform. Based on the task, You should return a set of points as the trajectory to execute the task. The point trajectory format should be "<point>[[x1, y1], [x2, y2], [x3, y3],...]</point>". The point coordinates are normalized to integers between 0 and 1000. Please return the point trajectory directly.

[User]
Image-1:<image>
 You need to reach for the pot.

[Assistant] <point>[[401, 352], [468, 324], [511, 315], [542, 338]]</point>

[User]
Image-2:<image>
 You need to move towards the bowl.

[Assistant] <point>[[465, 85], [546, 254], [570, 390], [567, 545]]</point>


[System]
You are InternVL, a robotic entity agent.

You are given one observation of the scene and a task to perform. Based on the task, You should return a set of points as the trajectory to execute the task. The point trajectory format should be "<point>[[x1, y1], [x2, y2], [x3, y3],...]</point>". The point coordinates are normalized to integers between 0 and 1000. Please return the point trajectory directly.

[User]
Image-1:<image>
 You need to reach for the mushroom.

[Assistant] <point>[[680, 221], [708, 272], [722, 366], [704, 526]]</point>

[User]
Image-2:<image>
 You need to move the mushroom towards the microwave.

[Assistant] <point>[[641, 296], [570, 254], [486, 225], [405, 239]]</point>


[System]
You are InternVL, a robotic entity agent.

You are given one observation of the scene and a task to perform. Based on the task, You should return a set of points as the trajectory to execute the task. The point trajectory format should be "<point>[[x1, y1], [x2, y2], [x3, y3],...]</point>". The point coordinates are normalized to integers between 0 and 1000. Please return the point trajectory directly.

[User]
Image-1:<image>
 You need to pick up clothes from a basket.

[Assistant] <point>[[535, 408], [616, 469], [651, 545], [704, 695]]</point>

[User]
Image-2:<image>
 You need to pick up the spatula.

[Assistant] <point>[[366, 174], [486, 272], [574, 413], [676, 685]]</point>


[System]
You are InternVL, a robotic entity agent.

You are given one observation of the scene and a task to perform. Based on the task, You should return a set of points as the trajectory to execute the task. The point trajectory format should be "<point>[[x1, y1], [x2, y2], [x3, y3],...]</point>". The point coordinates are normalized to integers between 0 and 1000. Please return the point trajectory directly.

[User]
Image-1:<image>
 You need to move the spatula towards the cloth.

[Assistant] <point>[[641, 667], [585, 535], [507, 423], [408, 324], [616, 638]]</point>

[User]
Image-2:<image>
 You need to move towards the bowl with corn.

[Assistant] <point>[[461, 263], [542, 333], [577, 404], [606, 545]]</point>


[System]
You are InternVL, a robotic entity agent.

You are given one observation of the scene and a task to perform. Based on the task, You should return a set of points as the trajectory to execute the task. The point trajectory format should be "<point>[[x1, y1], [x2, y2], [x3, y3],...]</point>". The point coordinates are normalized to integers between 0 and 1000. Please return the point trajectory directly.

[User]
Image-1:<image>
 You need to reach for the cabinet handle.

[Assistant] <point>[[384, 526], [475, 535], [563, 573], [662, 676]]</point>

[User]
Image-2:<image>
 You need to reach for the green towel.

[Assistant] <point>[[176, 385], [275, 352], [349, 343], [444, 366]]</point>


[System]
You are InternVL, a robotic entity agent.

You are given one observation of the scene and a task to perform. Based on the task, You should return a set of points as the trajectory to execute the task. The point trajectory format should be "<point>[[x1, y1], [x2, y2], [x3, y3],...]</point>". The point coordinates are normalized to integers between 0 and 1000. Please return the point trajectory directly.

[User]
Image-1:<image>
 You need to pick up the spoon.

[Assistant] <point>[[588, 404], [511, 324], [447, 272], [387, 272]]</point>

[User]
Image-2:<image>
 You need to move the orange towards the purple rag.

[Assistant] <point>[[468, 268], [511, 376], [528, 479], [528, 620]]</point>


[System]
You are InternVL, a robotic entity agent.

You are given one observation of the scene and a task to perform. Based on the task, You should return a set of points as the trajectory to execute the task. The point trajectory format should be "<point>[[x1, y1], [x2, y2], [x3, y3],...]</point>". The point coordinates are normalized to integers between 0 and 1000. Please return the point trajectory directly.

[User]
Image-1:<image>
 You need to approach the spatula.

[Assistant] <point>[[574, 160], [528, 319], [546, 451], [602, 723]]</point>

[User]
Image-2:<image>
 You need to reach for the can.

[Assistant] <point>[[261, 300], [380, 272], [486, 286], [609, 333]]</point>


[System]
You are InternVL, a robotic entity agent.

You are given one observation of the scene and a task to perform. Based on the task, You should return a set of points as the trajectory to execute the task. The point trajectory format should be "<point>[[x1, y1], [x2, y2], [x3, y3],...]</point>". The point coordinates are normalized to integers between 0 and 1000. Please return the point trajectory directly.

[User]
Image-1:<image>
 You need to reach for the refrigerator handle.

[Assistant] <point>[[243, 315], [345, 300], [472, 296], [687, 366]]</point>

[User]
Image-2:<image>
 You need to reach for the pot.

[Assistant] <point>[[363, 268], [437, 347], [489, 451], [496, 592]]</point>


[System]
You are InternVL, a robotic entity agent.

You are given one observation of the scene and a task to perform. Based on the task, You should return a set of points as the trajectory to execute the task. The point trajectory format should be "<point>[[x1, y1], [x2, y2], [x3, y3],...]</point>". The point coordinates are normalized to integers between 0 and 1000. Please return the point trajectory directly.

[User]
Image-1:<image>
 You need to reach for the fork.

[Assistant] <point>[[669, 169], [475, 211], [342, 329], [222, 516]]</point>

[User]
Image-2:<image>
 You need to reach for the spatula on the plate.

[Assistant] <point>[[391, 362], [461, 380], [504, 404], [539, 451]]</point>


[System]
You are InternVL, a robotic entity agent.

You are given one observation of the scene and a task to perform. Based on the task, You should return a set of points as the trajectory to execute the task. The point trajectory format should be "<point>[[x1, y1], [x2, y2], [x3, y3],...]</point>". The point coordinates are normalized to integers between 0 and 1000. Please return the point trajectory directly.

[User]
Image-1:<image>
 You need to reach for the small metal pan.

[Assistant] <point>[[250, 235], [338, 230], [412, 239], [546, 319]]</point>

[User]
Image-2:<image>
 You need to reach for the pan.

[Assistant] <point>[[412, 347], [451, 394], [468, 469], [489, 592]]</point>


[System]
You are InternVL, a robotic entity agent.

You are given one observation of the scene and a task to perform. Based on the task, You should return a set of points as the trajectory to execute the task. The point trajectory format should be "<point>[[x1, y1], [x2, y2], [x3, y3],...]</point>". The point coordinates are normalized to integers between 0 and 1000. Please return the point trajectory directly.

[User]
Image-1:<image>
 You need to reach towards the cheese.

[Assistant] <point>[[609, 484], [493, 488], [426, 526], [401, 582]]</point>

[User]
Image-2:<image>
 You need to reach for the green spatula.

[Assistant] <point>[[218, 197], [458, 300], [581, 455], [665, 695]]</point>


[System]
You are InternVL, a robotic entity agent.

You are given one observation of the scene and a task to perform. Based on the task, You should return a set of points as the trajectory to execute the task. The point trajectory format should be "<point>[[x1, y1], [x2, y2], [x3, y3],...]</point>". The point coordinates are normalized to integers between 0 and 1000. Please return the point trajectory directly.

[User]
Image-1:<image>
 You need to reach for the strawberry in the bowl.

[Assistant] <point>[[613, 385], [662, 432], [665, 484], [665, 554]]</point>

[User]
Image-2:<image>
 You need to reach for the pan.

[Assistant] <point>[[461, 296], [525, 362], [539, 441], [507, 568]]</point>


[System]
You are InternVL, a robotic entity agent.

You are given one observation of the scene and a task to perform. Based on the task, You should return a set of points as the trajectory to execute the task. The point trajectory format should be "<point>[[x1, y1], [x2, y2], [x3, y3],...]</point>". The point coordinates are normalized to integers between 0 and 1000. Please return the point trajectory directly.

[User]
Image-1:<image>
 You need to reach for the eggplant.

[Assistant] <point>[[299, 164], [275, 235], [254, 343], [285, 526]]</point>

[User]
Image-2:<image>
 You need to reach for the pan.

[Assistant] <point>[[363, 244], [489, 263], [585, 282], [764, 465]]</point>


[System]
You are InternVL, a robotic entity agent.

You are given one observation of the scene and a task to perform. Based on the task, You should return a set of points as the trajectory to execute the task. The point trajectory format should be "<point>[[x1, y1], [x2, y2], [x3, y3],...]</point>". The point coordinates are normalized to integers between 0 and 1000. Please return the point trajectory directly.

[User]
Image-1:<image>
 You need to reach for the pot.

[Assistant] <point>[[423, 254], [384, 286], [345, 352], [338, 437]]</point>

[User]
Image-2:<image>
 You need to reach for the fork.

[Assistant] <point>[[521, 131], [574, 211], [609, 319], [602, 535]]</point>


[System]
You are InternVL, a robotic entity agent.

You are given one observation of the scene and a task to perform. Based on the task, You should return a set of points as the trajectory to execute the task. The point trajectory format should be "<point>[[x1, y1], [x2, y2], [x3, y3],...]</point>". The point coordinates are normalized to integers between 0 and 1000. Please return the point trajectory directly.

[User]
Image-1:<image>
 You need to reach for the spatula on the plate.

[Assistant] <point>[[739, 296], [690, 376], [676, 465], [669, 606]]</point>

[User]
Image-2:<image>
 You need to reach for the knife.

[Assistant] <point>[[246, 160], [306, 225], [352, 286], [412, 465]]</point>


[System]
You are InternVL, a robotic entity agent.

You are given one observation of the scene and a task to perform. Based on the task, You should return a set of points as the trajectory to execute the task. The point trajectory format should be "<point>[[x1, y1], [x2, y2], [x3, y3],...]</point>". The point coordinates are normalized to integers between 0 and 1000. Please return the point trajectory directly.

[User]
Image-1:<image>
 You need to reach for the pot.

[Assistant] <point>[[359, 70], [398, 188], [412, 324], [419, 545]]</point>

[User]
Image-2:<image>
 You need to reach for the bowl.

[Assistant] <point>[[521, 131], [482, 202], [475, 300], [504, 399]]</point>


[System]
You are InternVL, a robotic entity agent.

You are given one observation of the scene and a task to perform. Based on the task, You should return a set of points as the trajectory to execute the task. The point trajectory format should be "<point>[[x1, y1], [x2, y2], [x3, y3],...]</point>". The point coordinates are normalized to integers between 0 and 1000. Please return the point trajectory directly.

[User]
Image-1:<image>
 You need to reach for the spoon.

[Assistant] <point>[[669, 376], [609, 329], [525, 272], [384, 268]]</point>

[User]
Image-2:<image>
 You need to reach for the spoon.

[Assistant] <point>[[349, 235], [468, 347], [570, 516], [644, 704], [359, 282]]</point>


[System]
You are InternVL, a robotic entity agent.

You are given one observation of the scene and a task to perform. Based on the task, You should return a set of points as the trajectory to execute the task. The point trajectory format should be "<point>[[x1, y1], [x2, y2], [x3, y3],...]</point>". The point coordinates are normalized to integers between 0 and 1000. Please return the point trajectory directly.

[User]
Image-1:<image>
 You need to move the spoon over the pot.

[Assistant] <point>[[637, 676], [514, 526], [387, 451], [183, 451]]</point>

[User]
Image-2:<image>
 You need to reach for the bowl.

[Assistant] <point>[[419, 221], [486, 282], [532, 310], [560, 427]]</point>


[System]
You are InternVL, a robotic entity agent.

You are given one observation of the scene and a task to perform. Based on the task, You should return a set of points as the trajectory to execute the task. The point trajectory format should be "<point>[[x1, y1], [x2, y2], [x3, y3],...]</point>". The point coordinates are normalized to integers between 0 and 1000. Please return the point trajectory directly.

[User]
Image-1:<image>
 You need to reach for the carrot.

[Assistant] <point>[[229, 324], [324, 277], [415, 291], [574, 380]]</point>

[User]
Image-2:<image>
 You need to lower towards the cloth.

[Assistant] <point>[[398, 300], [370, 366], [377, 460], [423, 573]]</point>


[System]
You are InternVL, a robotic entity agent.

You are given one observation of the scene and a task to perform. Based on the task, You should return a set of points as the trajectory to execute the task. The point trajectory format should be "<point>[[x1, y1], [x2, y2], [x3, y3],...]</point>". The point coordinates are normalized to integers between 0 and 1000. Please return the point trajectory directly.

[User]
Image-1:<image>
 You need to reach for the blue spoon.

[Assistant] <point>[[430, 169], [539, 282], [585, 399], [655, 662]]</point>

[User]
Image-2:<image>
 You need to reach for the pan.

[Assistant] <point>[[500, 254], [623, 268], [690, 310], [810, 446]]</point>


[System]
You are InternVL, a robotic entity agent.

You are given one observation of the scene and a task to perform. Based on the task, You should return a set of points as the trajectory to execute the task. The point trajectory format should be "<point>[[x1, y1], [x2, y2], [x3, y3],...]</point>". The point coordinates are normalized to integers between 0 and 1000. Please return the point trajectory directly.

[User]
Image-1:<image>
 You need to reach for the orange vessel.

[Assistant] <point>[[482, 127], [588, 272], [620, 446], [602, 582]]</point>

[User]
Image-2:<image>
 You need to reach for the spatula.

[Assistant] <point>[[496, 131], [542, 282], [532, 404], [504, 596]]</point>


[System]
You are InternVL, a robotic entity agent.

You are given one observation of the scene and a task to perform. Based on the task, You should return a set of points as the trajectory to execute the task. The point trajectory format should be "<point>[[x1, y1], [x2, y2], [x3, y3],...]</point>". The point coordinates are normalized to integers between 0 and 1000. Please return the point trajectory directly.

[User]
Image-1:<image>
 You need to reach for the pot.

[Assistant] <point>[[451, 235], [518, 239], [609, 258], [711, 347]]</point>

[User]
Image-2:<image>
 You need to reach for the mushroom.

[Assistant] <point>[[380, 296], [278, 277], [204, 319], [169, 380]]</point>


[System]
You are InternVL, a robotic entity agent.

You are given one observation of the scene and a task to perform. Based on the task, You should return a set of points as the trajectory to execute the task. The point trajectory format should be "<point>[[x1, y1], [x2, y2], [x3, y3],...]</point>". The point coordinates are normalized to integers between 0 and 1000. Please return the point trajectory directly.

[User]
Image-1:<image>
 You need to reach for the refrigerator handle.

[Assistant] <point>[[271, 507], [430, 432], [567, 460], [683, 559]]</point>

[User]
Image-2:<image>
 You need to reach for the object.

[Assistant] <point>[[669, 286], [722, 329], [743, 366], [743, 432]]</point>


[System]
You are InternVL, a robotic entity agent.

You are given one observation of the scene and a task to perform. Based on the task, You should return a set of points as the trajectory to execute the task. The point trajectory format should be "<point>[[x1, y1], [x2, y2], [x3, y3],...]</point>". The point coordinates are normalized to integers between 0 and 1000. Please return the point trajectory directly.

[User]
Image-1:<image>
 You need to move the object across the surface.

[Assistant] <point>[[662, 423], [683, 516], [676, 624], [662, 737]]</point>

[User]
Image-2:<image>
 You need to reach for the spatula.

[Assistant] <point>[[398, 277], [433, 347], [437, 423], [419, 563]]</point>


[System]
You are InternVL, a robotic entity agent.

You are given one observation of the scene and a task to perform. Based on the task, You should return a set of points as the trajectory to execute the task. The point trajectory format should be "<point>[[x1, y1], [x2, y2], [x3, y3],...]</point>". The point coordinates are normalized to integers between 0 and 1000. Please return the point trajectory directly.

[User]
Image-1:<image>
 You need to reach for the corn.

[Assistant] <point>[[489, 244], [486, 300], [496, 352], [546, 362]]</point>

[User]
Image-2:<image>
 You need to reach for the mushroom.

[Assistant] <point>[[532, 99], [595, 188], [606, 263], [641, 446]]</point>


[System]
You are InternVL, a robotic entity agent.

You are given one observation of the scene and a task to perform. Based on the task, You should return a set of points as the trajectory to execute the task. The point trajectory format should be "<point>[[x1, y1], [x2, y2], [x3, y3],...]</point>". The point coordinates are normalized to integers between 0 and 1000. Please return the point trajectory directly.

[User]
Image-1:<image>
 You need to move the mushroom towards the pot.

[Assistant] <point>[[697, 559], [648, 427], [563, 362], [423, 347]]</point>

[User]
Image-2:<image>
 You need to reach for the pan.

[Assistant] <point>[[384, 319], [430, 366], [433, 427], [426, 507]]</point>


[System]
You are InternVL, a robotic entity agent.

You are given one observation of the scene and a task to perform. Based on the task, You should return a set of points as the trajectory to execute the task. The point trajectory format should be "<point>[[x1, y1], [x2, y2], [x3, y3],...]</point>". The point coordinates are normalized to integers between 0 and 1000. Please return the point trajectory directly.

[User]
Image-1:<image>
 You need to reach for the pan.

[Assistant] <point>[[549, 136], [482, 155], [433, 202], [405, 291]]</point>

[User]
Image-2:<image>
 You need to reach for the towel.

[Assistant] <point>[[306, 244], [387, 300], [415, 413], [419, 606]]</point>


[System]
You are InternVL, a robotic entity agent.

You are given one observation of the scene and a task to perform. Based on the task, You should return a set of points as the trajectory to execute the task. The point trajectory format should be "<point>[[x1, y1], [x2, y2], [x3, y3],...]</point>". The point coordinates are normalized to integers between 0 and 1000. Please return the point trajectory directly.

[User]
Image-1:<image>
 You need to move towards the stuffed animal.

[Assistant] <point>[[835, 554], [704, 423], [546, 380], [320, 418]]</point>

[User]
Image-2:<image>
 You need to move towards the cardboard fence.

[Assistant] <point>[[405, 244], [306, 197], [215, 207], [109, 305]]</point>


[System]
You are InternVL, a robotic entity agent.

You are given one observation of the scene and a task to perform. Based on the task, You should return a set of points as the trajectory to execute the task. The point trajectory format should be "<point>[[x1, y1], [x2, y2], [x3, y3],...]</point>". The point coordinates are normalized to integers between 0 and 1000. Please return the point trajectory directly.

[User]
Image-1:<image>
 You need to move towards the cardboard fence.

[Assistant] <point>[[127, 366], [246, 376], [324, 418], [401, 535]]</point>

[User]
Image-2:<image>
 You need to reach for the pot.

[Assistant] <point>[[352, 131], [271, 207], [229, 272], [194, 413]]</point>


[System]
You are InternVL, a robotic entity agent.

You are given one observation of the scene and a task to perform. Based on the task, You should return a set of points as the trajectory to execute the task. The point trajectory format should be "<point>[[x1, y1], [x2, y2], [x3, y3],...]</point>". The point coordinates are normalized to integers between 0 and 1000. Please return the point trajectory directly.

[User]
Image-1:<image>
 You need to reach for the spoon.

[Assistant] <point>[[454, 291], [577, 366], [658, 469], [680, 667]]</point>

[User]
Image-2:<image>
 You need to reach for the carrot on the stove top.

[Assistant] <point>[[342, 296], [444, 338], [521, 404], [570, 516]]</point>


[System]
You are InternVL, a robotic entity agent.

You are given one observation of the scene and a task to perform. Based on the task, You should return a set of points as the trajectory to execute the task. The point trajectory format should be "<point>[[x1, y1], [x2, y2], [x3, y3],...]</point>". The point coordinates are normalized to integers between 0 and 1000. Please return the point trajectory directly.

[User]
Image-1:<image>
 You need to reach towards the oven door.

[Assistant] <point>[[187, 737], [349, 737], [479, 770], [546, 892]]</point>

[User]
Image-2:<image>
 You need to pick up the knife.

[Assistant] <point>[[201, 305], [335, 310], [444, 343], [577, 451]]</point>


[System]
You are InternVL, a robotic entity agent.

You are given one observation of the scene and a task to perform. Based on the task, You should return a set of points as the trajectory to execute the task. The point trajectory format should be "<point>[[x1, y1], [x2, y2], [x3, y3],...]</point>". The point coordinates are normalized to integers between 0 and 1000. Please return the point trajectory directly.

[User]
Image-1:<image>
 You need to move the knife towards the pot.

[Assistant] <point>[[535, 418], [430, 423], [303, 437], [250, 507]]</point>

[User]
Image-2:<image>
 You need to reach for the cloth.

[Assistant] <point>[[704, 211], [546, 188], [391, 221], [264, 305]]</point>