[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>[[404, 351], [657, 451], [748, 580]]</point>

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

[Assistant] <point>[[429, 321], [404, 513], [346, 547]]</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 right side of the table.

[Assistant] <point>[[374, 229], [560, 495], [648, 528]]</point>

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

[Assistant] <point>[[158, 107], [155, 399], [219, 458]]</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>[[258, 222], [684, 277], [742, 384]]</point>

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

[Assistant] <point>[[219, 203], [371, 318], [407, 388]]</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>[[241, 107], [576, 543], [670, 576]]</point>

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

[Assistant] <point>[[374, 366], [623, 624], [726, 591]]</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.

[Assistant] <point>[[172, 351], [607, 281], [698, 347]]</point>

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

[Assistant] <point>[[479, 295], [330, 325], [271, 403]]</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 corn on the stove.

[Assistant] <point>[[288, 377], [596, 395], [659, 451]]</point>

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

[Assistant] <point>[[368, 185], [335, 284], [380, 347]]</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 bowl.

[Assistant] <point>[[341, 140], [302, 480], [380, 550]]</point>

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

[Assistant] <point>[[435, 388], [554, 539], [645, 558]]</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>[[474, 406], [665, 380], [715, 425]]</point>

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

[Assistant] <point>[[357, 569], [596, 561], [676, 613]]</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>[[86, 100], [416, 447], [524, 410]]</point>

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

[Assistant] <point>[[360, 244], [551, 661], [665, 735]]</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>[[418, 59], [582, 332], [587, 428]]</point>

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

[Assistant] <point>[[235, 318], [410, 561], [391, 632]]</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>[[305, 170], [460, 646], [529, 694]]</point>

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

[Assistant] <point>[[717, 126], [809, 395], [801, 495]]</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>[[175, 292], [371, 632], [515, 624]]</point>

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

[Assistant] <point>[[175, 262], [615, 362], [701, 440]]</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>[[601, 222], [449, 362], [371, 321]]</point>

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

[Assistant] <point>[[269, 81], [219, 380], [269, 484]]</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 the broccoli.

[Assistant] <point>[[393, 140], [488, 717], [562, 798]]</point>

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

[Assistant] <point>[[377, 310], [355, 561], [424, 609]]</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 pear.

[Assistant] <point>[[407, 281], [449, 358], [515, 369]]</point>

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

[Assistant] <point>[[340, 120], [471, 546], [549, 590]]</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 ear of corn across the table.

[Assistant] <point>[[343, 183], [512, 602], [601, 640]]</point>

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

[Assistant] <point>[[217, 251], [480, 459], [582, 454]]</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 spice jar.

[Assistant] <point>[[359, 155], [365, 667], [430, 754]]</point>

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

[Assistant] <point>[[343, 38], [444, 280], [452, 360]]</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 metal bowl.

[Assistant] <point>[[427, 360], [242, 376], [185, 441]]</point>

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

[Assistant] <point>[[508, 392], [593, 457], [669, 403]]</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 blue spoon on the left of the towel.

[Assistant] <point>[[629, 215], [274, 414], [165, 495]]</point>

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

[Assistant] <point>[[452, 237], [556, 586], [633, 624]]</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 pot of the table.

[Assistant] <point>[[371, 285], [270, 446], [266, 548]]</point>

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

[Assistant] <point>[[500, 382], [403, 387], [351, 441]]</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>[[471, 281], [299, 425], [277, 524]]</point>

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

[Assistant] <point>[[604, 155], [521, 284], [446, 310]]</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>[[435, 155], [399, 310], [418, 377]]</point>

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

[Assistant] <point>[[468, 425], [360, 539], [357, 617]]</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 with the broccoli.

[Assistant] <point>[[352, 628], [479, 462], [482, 399]]</point>

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

[Assistant] <point>[[385, 225], [496, 414], [571, 443]]</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>[[407, 329], [413, 613], [468, 676]]</point>

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

[Assistant] <point>[[224, 129], [432, 680], [604, 717]]</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 cheese wedge.

[Assistant] <point>[[296, 403], [150, 392], [83, 458]]</point>

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

[Assistant] <point>[[385, 192], [402, 561], [488, 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 move the corn towards the pot.

[Assistant] <point>[[499, 639], [709, 484], [679, 421], [643, 377]]</point>

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

[Assistant] <point>[[676, 362], [421, 321], [360, 358]]</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 pan towards the upper right corner.

[Assistant] <point>[[380, 288], [695, 513], [809, 513]]</point>

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

[Assistant] <point>[[416, 314], [535, 318], [535, 377]]</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>[[648, 30], [291, 307], [222, 303]]</point>

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

[Assistant] <point>[[393, 225], [321, 465], [255, 480]]</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 broccoli towards the pot.

[Assistant] <point>[[346, 355], [191, 373], [144, 458]]</point>

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

[Assistant] <point>[[537, 255], [457, 332], [465, 428]]</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 can.

[Assistant] <point>[[258, 273], [681, 506], [762, 451]]</point>

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

[Assistant] <point>[[543, 351], [371, 347], [324, 273]]</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 sushi.

[Assistant] <point>[[562, 266], [665, 580], [756, 639]]</point>

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

[Assistant] <point>[[260, 22], [263, 528], [332, 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 approach the fork.

[Assistant] <point>[[352, 78], [645, 403], [715, 506]]</point>

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

[Assistant] <point>[[715, 244], [338, 303], [288, 362]]</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.

[Assistant] <point>[[496, 288], [607, 632], [695, 654]]</point>

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

[Assistant] <point>[[305, 244], [208, 343], [202, 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 blue object.

[Assistant] <point>[[573, 251], [607, 657], [676, 776]]</point>

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

[Assistant] <point>[[294, 236], [366, 347], [443, 388]]</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.

[Assistant] <point>[[388, 288], [471, 469], [548, 532]]</point>

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

[Assistant] <point>[[493, 196], [271, 403], [213, 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 carrot.

[Assistant] <point>[[546, 192], [233, 447], [125, 417]]</point>

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

[Assistant] <point>[[571, 347], [474, 351], [468, 447]]</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 metal pot.

[Assistant] <point>[[357, 358], [504, 321], [579, 399]]</point>

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

[Assistant] <point>[[288, 343], [332, 506], [399, 554]]</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 pickle.

[Assistant] <point>[[454, 639], [668, 532], [648, 443]]</point>

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

[Assistant] <point>[[421, 497], [559, 379], [599, 430]]</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 the broccoli.

[Assistant] <point>[[632, 432], [529, 547], [476, 513]]</point>

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

[Assistant] <point>[[393, 399], [596, 414], [723, 499]]</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>[[343, 218], [327, 484], [391, 558]]</point>

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

[Assistant] <point>[[496, 199], [327, 528], [258, 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 move towards the cup on the plate.

[Assistant] <point>[[460, 270], [291, 314], [233, 266]]</point>

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

[Assistant] <point>[[637, 369], [440, 432], [402, 499]]</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 metal vessel.

[Assistant] <point>[[438, 303], [537, 561], [593, 609]]</point>

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

[Assistant] <point>[[590, 222], [654, 432], [740, 414]]</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 cheese.

[Assistant] <point>[[695, 366], [571, 661], [626, 813]]</point>

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

[Assistant] <point>[[629, 602], [233, 469], [183, 373]]</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 can.

[Assistant] <point>[[388, 377], [604, 425], [681, 377]]</point>

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

[Assistant] <point>[[271, 369], [609, 469], [704, 543]]</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 eggplant from the pan.

[Assistant] <point>[[429, 295], [626, 362], [695, 440]]</point>

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

[Assistant] <point>[[632, 406], [596, 646], [623, 724]]</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 lemon in the pot.

[Assistant] <point>[[510, 288], [659, 742], [731, 798]]</point>

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

[Assistant] <point>[[452, 458], [640, 414], [690, 476]]</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 vessel to another location on the table.

[Assistant] <point>[[512, 347], [277, 440], [216, 521]]</point>

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

[Assistant] <point>[[302, 255], [565, 513], [607, 628]]</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 scoop.

[Assistant] <point>[[543, 236], [313, 499], [230, 524]]</point>

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

[Assistant] <point>[[241, 377], [471, 329], [571, 377]]</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 blue towel.

[Assistant] <point>[[551, 44], [413, 380], [307, 417]]</point>

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

[Assistant] <point>[[294, 358], [485, 484], [529, 550]]</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>[[391, 203], [343, 495], [377, 580]]</point>

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

[Assistant] <point>[[61, 151], [327, 425], [399, 417]]</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>[[551, 536], [130, 329], [64, 340]]</point>

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

[Assistant] <point>[[371, 251], [471, 196], [479, 140]]</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>[[266, 211], [371, 447], [446, 495]]</point>

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

[Assistant] <point>[[249, 196], [543, 502], [618, 476]]</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 sushi.

[Assistant] <point>[[668, 325], [668, 495], [720, 558]]</point>

[User]
Image-2:<image>
 You need to move the sushi to the other side of the table.

[Assistant] <point>[[706, 447], [499, 384], [438, 403]]</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 overturned pot.

[Assistant] <point>[[526, 233], [485, 458], [521, 521]]</point>

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

[Assistant] <point>[[457, 244], [548, 510], [632, 576]]</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 object.

[Assistant] <point>[[665, 207], [460, 528], [490, 598]]</point>

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

[Assistant] <point>[[156, 278], [243, 320], [313, 351], [371, 402]]</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 pan.

[Assistant] <point>[[443, 124], [429, 239], [423, 367], [414, 514]]</point>

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

[Assistant] <point>[[886, 622], [819, 571], [715, 568], [591, 568], [469, 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 towel.

[Assistant] <point>[[307, 81], [403, 212], [469, 351], [550, 583]]</point>

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

[Assistant] <point>[[136, 375], [385, 324], [521, 363], [712, 456]]</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 knife.

[Assistant] <point>[[171, 270], [240, 355], [330, 417], [429, 467], [478, 490]]</point>

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

[Assistant] <point>[[652, 317], [582, 290], [472, 263], [391, 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 towel.

[Assistant] <point>[[724, 336], [721, 471], [738, 548]]</point>

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

[Assistant] <point>[[704, 402], [683, 521], [660, 664]]</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>[[449, 270], [475, 390], [489, 506], [498, 629]]</point>

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

[Assistant] <point>[[550, 286], [625, 347], [709, 479], [773, 772]]</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>[[460, 313], [527, 398], [582, 444], [669, 490]]</point>

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

[Assistant] <point>[[420, 313], [330, 378], [252, 429], [162, 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 spoon.

[Assistant] <point>[[324, 255], [255, 305], [211, 355], [182, 421]]</point>

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

[Assistant] <point>[[130, 421], [217, 425], [330, 413], [431, 336]]</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>[[582, 69], [582, 135], [585, 236], [576, 351], [559, 448], [515, 633]]</point>

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

[Assistant] <point>[[492, 46], [443, 139], [397, 236], [394, 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 the potato away.

[Assistant] <point>[[489, 602], [420, 533], [371, 475], [321, 402]]</point>

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

[Assistant] <point>[[81, 205], [243, 181], [374, 193], [507, 216], [718, 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 metal pot.

[Assistant] <point>[[449, 247], [411, 290], [330, 344], [272, 382]]</point>

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

[Assistant] <point>[[611, 23], [565, 100], [481, 162], [408, 224], [353, 255]]</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 position over the spatula.

[Assistant] <point>[[434, 174], [420, 236], [449, 293], [486, 351]]</point>

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

[Assistant] <point>[[365, 193], [449, 274], [518, 328], [539, 402]]</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>[[510, 266], [539, 347], [576, 425], [588, 517], [597, 726]]</point>

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

[Assistant] <point>[[359, 390], [301, 402], [258, 390], [235, 347]]</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>[[229, 205], [298, 239], [420, 270], [504, 317], [539, 432]]</point>

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

[Assistant] <point>[[562, 147], [495, 228], [475, 336], [469, 448], [472, 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 pick up the mushroom.

[Assistant] <point>[[521, 525], [347, 452], [258, 417], [96, 386]]</point>

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

[Assistant] <point>[[122, 347], [208, 336], [292, 409], [359, 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 pot.

[Assistant] <point>[[264, 170], [278, 228], [301, 309], [298, 382], [266, 440]]</point>

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

[Assistant] <point>[[446, 162], [492, 251], [568, 355], [628, 421], [695, 486], [744, 579]]</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>[[324, 243], [388, 247], [475, 286], [513, 332]]</point>

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

[Assistant] <point>[[359, 166], [452, 220], [515, 270], [550, 328], [579, 382], [599, 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 move towards the blue spoon.

[Assistant] <point>[[562, 224], [484, 208], [385, 228], [304, 255], [206, 313]]</point>

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

[Assistant] <point>[[683, 432], [614, 452], [550, 475], [504, 560]]</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 broccoli.

[Assistant] <point>[[556, 421], [605, 440], [652, 471], [724, 541]]</point>

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

[Assistant] <point>[[681, 521], [605, 486], [539, 486], [437, 490], [342, 552]]</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 broccoli.

[Assistant] <point>[[223, 340], [347, 305], [417, 320], [489, 378]]</point>

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

[Assistant] <point>[[460, 336], [408, 328], [330, 336], [232, 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 pick up the plush toy from the table.

[Assistant] <point>[[565, 390], [521, 336], [472, 282], [414, 263]]</point>

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

[Assistant] <point>[[333, 181], [301, 247], [290, 347], [292, 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 pick up the knife from the stove.

[Assistant] <point>[[510, 263], [449, 270], [339, 309], [249, 378], [188, 463]]</point>

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

[Assistant] <point>[[194, 405], [281, 448], [336, 467], [443, 417]]</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 spatula.

[Assistant] <point>[[472, 81], [556, 89], [620, 170], [654, 243], [681, 359], [698, 483]]</point>

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

[Assistant] <point>[[498, 479], [397, 479], [350, 475], [321, 521]]</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 lid.

[Assistant] <point>[[814, 448], [738, 440], [634, 456], [568, 506]]</point>

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

[Assistant] <point>[[356, 286], [440, 305], [466, 347], [489, 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 move towards the red object.

[Assistant] <point>[[327, 517], [466, 533], [573, 552], [672, 672]]</point>

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

[Assistant] <point>[[750, 386], [654, 320], [550, 313], [426, 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 pick up the brush.

[Assistant] <point>[[376, 185], [319, 228], [237, 317], [208, 483]]</point>

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

[Assistant] <point>[[226, 456], [290, 479], [382, 490], [536, 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 cup.

[Assistant] <point>[[0, 290], [98, 243], [252, 232], [397, 247], [573, 293]]</point>

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

[Assistant] <point>[[553, 510], [486, 459], [368, 440], [284, 448], [200, 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 spoon.

[Assistant] <point>[[785, 413], [652, 525], [559, 595], [481, 718]]</point>

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

[Assistant] <point>[[582, 548], [666, 533], [727, 479], [782, 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 spoon.

[Assistant] <point>[[704, 151], [579, 193], [472, 255], [431, 340], [400, 448]]</point>

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

[Assistant] <point>[[269, 127], [359, 170], [414, 216], [455, 290], [481, 347]]</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>[[266, 66], [365, 127], [507, 228], [669, 471]]</point>

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

[Assistant] <point>[[539, 139], [429, 205], [327, 297], [264, 552]]</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 across the table.

[Assistant] <point>[[223, 506], [403, 560], [539, 602], [666, 707]]</point>

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

[Assistant] <point>[[347, 193], [405, 243], [469, 324], [513, 398], [550, 533], [562, 629]]</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 in the pot.

[Assistant] <point>[[307, 208], [379, 220], [452, 247], [533, 344]]</point>

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

[Assistant] <point>[[536, 232], [504, 259], [492, 324], [513, 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 move towards the corn.

[Assistant] <point>[[313, 378], [391, 425], [484, 432], [614, 417], [692, 363]]</point>

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

[Assistant] <point>[[556, 402], [481, 436], [397, 467], [287, 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 move towards the metal pot.

[Assistant] <point>[[301, 124], [290, 224], [278, 367], [281, 467], [304, 641]]</point>

[User]
Image-2:<image>
 You need to release the spatula and pipe.

[Assistant] <point>[[440, 429], [542, 432], [594, 479], [640, 602]]</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 pepper in the pot.

[Assistant] <point>[[657, 521], [498, 444], [397, 448], [321, 502]]</point>

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

[Assistant] <point>[[599, 475], [466, 521], [391, 537], [284, 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 can on the table.

[Assistant] <point>[[336, 471], [449, 452], [542, 432], [663, 402]]</point>

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

[Assistant] <point>[[301, 50], [304, 116], [304, 185], [321, 255]]</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 orange toy animal towards the right side of the purple cloth.

[Assistant] <point>[[313, 166], [414, 247], [536, 390], [649, 718]]</point>

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

[Assistant] <point>[[67, 58], [208, 69], [310, 131], [368, 197], [440, 328]]</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 can.

[Assistant] <point>[[762, 699], [599, 660], [513, 533], [434, 386], [440, 301]]</point>

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

[Assistant] <point>[[324, 147], [394, 205], [423, 290], [449, 429], [475, 680]]</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 towel.

[Assistant] <point>[[492, 139], [365, 189], [243, 263], [177, 382]]</point>

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

[Assistant] <point>[[597, 556], [481, 514], [376, 471], [243, 417], [127, 417]]</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 towel.

[Assistant] <point>[[93, 448], [200, 402], [362, 359], [475, 359], [597, 394]]</point>

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

[Assistant] <point>[[489, 154], [437, 263], [385, 344], [356, 529], [356, 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 red object.

[Assistant] <point>[[49, 193], [87, 239], [133, 324], [177, 456]]</point>

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

[Assistant] <point>[[597, 143], [559, 297], [533, 425], [475, 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 reach for the carrot.

[Assistant] <point>[[576, 533], [478, 486], [359, 486], [290, 517]]</point>

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

[Assistant] <point>[[738, 301], [625, 290], [495, 328], [434, 378], [359, 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 reach for the spatula.

[Assistant] <point>[[463, 12], [510, 81], [576, 181], [628, 282], [669, 417], [695, 610]]</point>

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

[Assistant] <point>[[489, 340], [611, 336], [695, 371], [782, 498]]</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 oven door handle.

[Assistant] <point>[[258, 355], [324, 429], [405, 521], [469, 653], [521, 849]]</point>

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

[Assistant] <point>[[258, 263], [379, 320], [486, 402], [559, 510], [591, 629]]</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 handle.

[Assistant] <point>[[443, 301], [481, 347], [579, 355], [738, 305]]</point>

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

[Assistant] <point>[[617, 301], [527, 297], [414, 301], [301, 340], [206, 440]]</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>[[585, 205], [527, 259], [489, 328], [463, 394], [440, 467], [434, 544], [429, 649]]</point>

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

[Assistant] <point>[[67, 120], [127, 162], [174, 247], [214, 402]]</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>[[235, 154], [295, 162], [394, 193], [492, 243], [582, 309], [614, 363]]</point>

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

[Assistant] <point>[[510, 606], [527, 703], [568, 780], [637, 884]]</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>[[371, 139], [423, 185], [449, 220], [484, 324]]</point>

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

[Assistant] <point>[[501, 290], [553, 301], [602, 336], [631, 367]]</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>[[197, 386], [353, 363], [469, 351], [597, 378], [753, 452]]</point>

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

[Assistant] <point>[[226, 402], [194, 440], [148, 421], [136, 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 place the spoon between the napkin and the stove.

[Assistant] <point>[[133, 320], [237, 324], [394, 390], [510, 463], [611, 633]]</point>

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

[Assistant] <point>[[481, 93], [437, 162], [382, 228], [339, 297], [301, 417]]</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>[[235, 309], [214, 386], [217, 448], [240, 510]]</point>

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

[Assistant] <point>[[391, 313], [356, 367], [330, 394], [278, 459]]</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>[[533, 228], [510, 278], [466, 375], [460, 564]]</point>

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

[Assistant] <point>[[837, 255], [793, 286], [736, 324], [660, 336]]</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 pot on the stove.

[Assistant] <point>[[374, 228], [359, 317], [374, 413], [417, 494]]</point>

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

[Assistant] <point>[[458, 270], [484, 320], [518, 328], [542, 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 reach for the spoon.

[Assistant] <point>[[403, 236], [486, 301], [576, 405], [654, 533], [675, 629]]</point>

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

[Assistant] <point>[[709, 575], [625, 591], [492, 579], [359, 521], [290, 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 reach for the pot.

[Assistant] <point>[[515, 162], [481, 224], [440, 324], [437, 398], [443, 498]]</point>

[User]
Image-2:<image>
 You need to move the jar of almonds over the pot.

[Assistant] <point>[[400, 452], [455, 425], [515, 432], [568, 452], [599, 506]]</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>[[194, 205], [261, 247], [356, 328], [420, 417], [515, 668]]</point>

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

[Assistant] <point>[[174, 444], [301, 471], [466, 448], [579, 367], [657, 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 pull open the oven door.

[Assistant] <point>[[510, 320], [495, 386], [429, 444], [336, 494], [217, 502]]</point>

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

[Assistant] <point>[[307, 27], [353, 73], [388, 127], [405, 216]]</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 pepper in the pot.

[Assistant] <point>[[339, 77], [292, 166], [266, 247], [264, 390]]</point>

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

[Assistant] <point>[[278, 93], [255, 154], [232, 243], [235, 359], [240, 471]]</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>[[408, 147], [475, 224], [550, 328], [617, 425], [669, 560], [678, 710]]</point>

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

[Assistant] <point>[[443, 278], [379, 340], [342, 378], [281, 367]]</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>[[782, 394], [753, 421], [704, 448], [649, 452]]</point>

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

[Assistant] <point>[[652, 409], [585, 394], [544, 405], [515, 448]]</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 in the pan.

[Assistant] <point>[[168, 239], [266, 305], [359, 367], [423, 456], [530, 629]]</point>

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

[Assistant] <point>[[513, 239], [440, 266], [362, 305], [319, 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 move towards the basket of clothes.

[Assistant] <point>[[507, 429], [547, 521], [582, 598], [608, 745]]</point>

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

[Assistant] <point>[[501, 429], [617, 479], [715, 525], [805, 741]]</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>[[246, 208], [350, 232], [420, 270], [495, 328], [588, 452]]</point>

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

[Assistant] <point>[[371, 243], [478, 278], [562, 313], [681, 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 move towards the cloth.

[Assistant] <point>[[162, 309], [362, 347], [472, 440], [582, 560]]</point>

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

[Assistant] <point>[[701, 440], [614, 471], [513, 479], [423, 483], [307, 463], [208, 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 microwave handle.

[Assistant] <point>[[408, 502], [507, 475], [614, 440], [764, 375]]</point>

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

[Assistant] <point>[[753, 332], [701, 402], [625, 463], [565, 486], [443, 506]]</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>[[313, 85], [261, 170], [223, 259], [197, 413]]</point>

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

[Assistant] <point>[[136, 371], [284, 398], [434, 417], [608, 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 reach for the yellow towel.

[Assistant] <point>[[426, 328], [542, 344], [628, 386], [663, 432]]</point>

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

[Assistant] <point>[[542, 394], [597, 452], [643, 529], [666, 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 down towards the microwave.

[Assistant] <point>[[408, 270], [521, 332], [605, 386], [733, 490]]</point>

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

[Assistant] <point>[[368, 483], [295, 452], [180, 425], [96, 456]]</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>[[310, 236], [295, 297], [295, 386], [327, 525]]</point>

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

[Assistant] <point>[[269, 405], [330, 467], [385, 514], [501, 660]]</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 door.

[Assistant] <point>[[43, 266], [168, 278], [292, 301], [423, 359], [544, 533]]</point>

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

[Assistant] <point>[[469, 15], [446, 66], [434, 143], [423, 259], [434, 452]]</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 cucumber.

[Assistant] <point>[[681, 378], [585, 371], [475, 386], [382, 394], [223, 432]]</point>

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

[Assistant] <point>[[206, 351], [307, 336], [368, 344], [501, 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 spoon.

[Assistant] <point>[[405, 108], [350, 178], [301, 266], [290, 394]]</point>

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

[Assistant] <point>[[675, 494], [660, 579], [663, 656], [689, 710]]</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 pepper.

[Assistant] <point>[[492, 143], [533, 162], [620, 224], [698, 328], [744, 440], [767, 568]]</point>

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

[Assistant] <point>[[646, 212], [625, 266], [579, 355], [515, 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 purple cloth.

[Assistant] <point>[[374, 228], [475, 243], [550, 293], [605, 390]]</point>

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

[Assistant] <point>[[405, 286], [405, 371], [420, 444], [452, 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 move the corn towards the middle right of the table.

[Assistant] <point>[[924, 166], [869, 205], [814, 278], [773, 367], [759, 444], [759, 544], [759, 614]]</point>

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

[Assistant] <point>[[411, 189], [513, 208], [625, 236], [724, 286], [808, 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 reach for the pot.

[Assistant] <point>[[423, 170], [385, 208], [353, 263], [321, 320], [292, 402]]</point>

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

[Assistant] <point>[[339, 69], [287, 162], [269, 270], [275, 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 place the mushroom in the pot.

[Assistant] <point>[[266, 394], [333, 375], [417, 394], [504, 436], [623, 633]]</point>

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

[Assistant] <point>[[301, 116], [362, 170], [405, 263], [446, 347], [469, 421], [489, 533], [486, 660]]</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>[[394, 645], [429, 533], [452, 440], [463, 332]]</point>

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

[Assistant] <point>[[759, 440], [698, 421], [637, 367], [582, 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 move the cup towards the plate.

[Assistant] <point>[[602, 243], [518, 251], [408, 263], [339, 305]]</point>

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

[Assistant] <point>[[617, 305], [553, 293], [449, 320], [423, 452]]</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 sushi.

[Assistant] <point>[[521, 243], [431, 247], [330, 263], [252, 324], [156, 463]]</point>

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

[Assistant] <point>[[423, 243], [400, 336], [359, 386], [278, 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 pot to the right side of the table.

[Assistant] <point>[[738, 382], [724, 440], [718, 486], [733, 571]]</point>

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

[Assistant] <point>[[347, 147], [400, 201], [429, 270], [469, 351], [486, 425], [489, 529]]</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 bowl on the towel.

[Assistant] <point>[[521, 456], [446, 425], [388, 378], [359, 274]]</point>

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

[Assistant] <point>[[730, 672], [675, 672], [582, 649], [486, 571], [385, 467], [290, 324], [191, 135]]</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 door closed.

[Assistant] <point>[[185, 382], [272, 413], [484, 440], [707, 371]]</point>

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

[Assistant] <point>[[510, 266], [544, 313], [579, 390], [611, 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 pot.

[Assistant] <point>[[203, 286], [290, 317], [356, 359], [397, 425], [446, 544]]</point>

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

[Assistant] <point>[[460, 162], [429, 243], [408, 293], [400, 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 the bowl above the cloth.

[Assistant] <point>[[553, 266], [620, 305], [689, 371], [727, 479], [744, 544]]</point>

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

[Assistant] <point>[[295, 320], [417, 320], [504, 332], [582, 405]]</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, 475], [307, 471], [400, 517], [440, 552]]</point>

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

[Assistant] <point>[[156, 46], [252, 85], [324, 166], [400, 255], [452, 332], [504, 425], [559, 521], [585, 583], [599, 699]]</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 towards the lid.

[Assistant] <point>[[579, 676], [452, 625], [411, 517], [455, 359]]</point>

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

[Assistant] <point>[[142, 263], [243, 266], [374, 344], [446, 398], [521, 475], [559, 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 pick up the salmon.

[Assistant] <point>[[240, 228], [269, 290], [307, 413], [304, 537]]</point>

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

[Assistant] <point>[[550, 216], [550, 293], [582, 371], [646, 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 move the spoon towards the pot.

[Assistant] <point>[[542, 185], [452, 247], [362, 293], [249, 394]]</point>

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

[Assistant] <point>[[443, 46], [429, 127], [423, 212], [440, 328], [486, 490]]</point>