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

You are given one observation of the scene and a task to perform. Based on the task, You should return a set of points as the trajectory to execute the task. The point trajectory format should be "<point>[[x1, y1], [x2, y2], [x3, y3],...]</point>". 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 cabinet door.

[Assistant] <point>[[452, 834], [460, 161], [510, 111]]</point>

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

[Assistant] <point>[[490, 817], [363, 432], [382, 382]]</point>


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

You are given one observation of the scene and a task to perform. Based on the task, You should return a set of points as the trajectory to execute the task. The point trajectory format should be "<point>[[x1, y1], [x2, y2], [x3, y3],...]</point>". 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 door handle.

[Assistant] <point>[[465, 892], [485, 202], [512, 144]]</point>

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

[Assistant] <point>[[454, 906], [402, 551], [102, 562], [28, 510], [105, 482]]</point>


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

You are given one observation of the scene and a task to perform. Based on the task, You should return a set of points as the trajectory to execute the task. The point trajectory format should be "<point>[[x1, y1], [x2, y2], [x3, y3],...]</point>". 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 refrigerator door.

[Assistant] <point>[[468, 917], [476, 554], [410, 510]]</point>

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

[Assistant] <point>[[454, 825], [537, 587], [607, 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 approach the door.

[Assistant] <point>[[474, 945], [418, 762], [388, 737]]</point>

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

[Assistant] <point>[[452, 837], [479, 424], [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 approach the light switch.

[Assistant] <point>[[410, 820], [460, 249], [490, 199]]</point>

[User]
Image-2:<image>
 You need to press the light switch.

[Assistant] <point>[[463, 884], [421, 507], [449, 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 approach the cube.

[Assistant] <point>[[438, 798], [307, 521], [321, 479]]</point>

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

[Assistant] <point>[[438, 853], [385, 443], [407, 391]]</point>


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

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

[User]
Image-1:<image>
 You need to grab both door handles.

[Assistant] <point>[[476, 864], [424, 388], [457, 263]]</point>

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

[Assistant] <point>[[499, 925], [512, 615], [548, 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 cabinet door handles.

[Assistant] <point>[[471, 820], [568, 449], [537, 404]]</point>

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

[Assistant] <point>[[435, 878], [357, 551], [377, 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 object.

[Assistant] <point>[[413, 864], [438, 554], [471, 496]]</point>

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

[Assistant] <point>[[438, 892], [363, 695], [380, 637]]</point>


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

You are given one observation of the scene and a task to perform. Based on the task, You should return a set of points as the trajectory to execute the task. The point trajectory format should be "<point>[[x1, y1], [x2, y2], [x3, y3],...]</point>". 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 bottle.

[Assistant] <point>[[438, 911], [399, 654], [443, 604]]</point>

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

[Assistant] <point>[[471, 895], [355, 512], [380, 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 approach the cabinet door.

[Assistant] <point>[[454, 892], [457, 706], [493, 651]]</point>

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

[Assistant] <point>[[488, 881], [349, 512], [316, 479]]</point>


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

You are given one observation of the scene and a task to perform. Based on the task, You should return a set of points as the trajectory to execute the task. The point trajectory format should be "<point>[[x1, y1], [x2, y2], [x3, y3],...]</point>". 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 sliding door.

[Assistant] <point>[[493, 820], [413, 349], [446, 313]]</point>

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

[Assistant] <point>[[496, 925], [366, 463], [368, 407]]</point>


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

You are given one observation of the scene and a task to perform. Based on the task, You should return a set of points as the trajectory to execute the task. The point trajectory format should be "<point>[[x1, y1], [x2, y2], [x3, y3],...]</point>". 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 button.

[Assistant] <point>[[454, 806], [471, 524], [493, 493]]</point>

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

[Assistant] <point>[[463, 848], [302, 332], [335, 269]]</point>


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

You are given one observation of the scene and a task to perform. Based on the task, You should return a set of points as the trajectory to execute the task. The point trajectory format should be "<point>[[x1, y1], [x2, y2], [x3, y3],...]</point>". 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 door handle.

[Assistant] <point>[[446, 820], [427, 313], [377, 252]]</point>

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

[Assistant] <point>[[468, 817], [263, 299], [166, 249]]</point>


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

You are given one observation of the scene and a task to perform. Based on the task, You should return a set of points as the trajectory to execute the task. The point trajectory format should be "<point>[[x1, y1], [x2, y2], [x3, y3],...]</point>". 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 door.

[Assistant] <point>[[515, 900], [616, 314], [605, 292]]</point>

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

[Assistant] <point>[[438, 848], [418, 380], [457, 313]]</point>


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

You are given one observation of the scene and a task to perform. Based on the task, You should return a set of points as the trajectory to execute the task. The point trajectory format should be "<point>[[x1, y1], [x2, y2], [x3, y3],...]</point>". 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 drawer.

[Assistant] <point>[[474, 856], [421, 493], [460, 432]]</point>

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

[Assistant] <point>[[471, 798], [601, 571], [825, 540], [875, 568], [842, 598]]</point>


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

You are given one observation of the scene and a task to perform. Based on the task, You should return a set of points as the trajectory to execute the task. The point trajectory format should be "<point>[[x1, y1], [x2, y2], [x3, y3],...]</point>". 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 cabinet door.

[Assistant] <point>[[427, 831], [446, 402], [479, 352]]</point>

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

[Assistant] <point>[[454, 859], [443, 632], [499, 565]]</point>


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

You are given one observation of the scene and a task to perform. Based on the task, You should return a set of points as the trajectory to execute the task. The point trajectory format should be "<point>[[x1, y1], [x2, y2], [x3, y3],...]</point>". 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 drawer handle.

[Assistant] <point>[[452, 839], [471, 532], [524, 468]]</point>

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

[Assistant] <point>[[501, 789], [457, 620], [471, 562]]</point>


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

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

[User]
Image-1:<image>
 You need to press the light switch.

[Assistant] <point>[[482, 864], [463, 609], [490, 535]]</point>

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

[Assistant] <point>[[413, 850], [385, 540], [319, 468]]</point>


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

You are given one observation of the scene and a task to perform. Based on the task, You should return a set of points as the trajectory to execute the task. The point trajectory format should be "<point>[[x1, y1], [x2, y2], [x3, y3],...]</point>". 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 drawer.

[Assistant] <point>[[452, 850], [404, 584], [421, 499]]</point>

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

[Assistant] <point>[[457, 881], [496, 546], [598, 418]]</point>


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

You are given one observation of the scene and a task to perform. Based on the task, You should return a set of points as the trajectory to execute the task. The point trajectory format should be "<point>[[x1, y1], [x2, y2], [x3, y3],...]</point>". 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 cabinet.

[Assistant] <point>[[435, 878], [510, 410], [476, 355]]</point>

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

[Assistant] <point>[[443, 886], [501, 501], [543, 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 approach the door handles.

[Assistant] <point>[[382, 889], [598, 856], [651, 814]]</point>

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

[Assistant] <point>[[449, 878], [787, 784], [784, 715]]</point>


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

You are given one observation of the scene and a task to perform. Based on the task, You should return a set of points as the trajectory to execute the task. The point trajectory format should be "<point>[[x1, y1], [x2, y2], [x3, y3],...]</point>". 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 air fryer drawer.

[Assistant] <point>[[404, 861], [357, 443], [399, 371]]</point>

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

[Assistant] <point>[[385, 906], [402, 391], [468, 291]]</point>


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

You are given one observation of the scene and a task to perform. Based on the task, You should return a set of points as the trajectory to execute the task. The point trajectory format should be "<point>[[x1, y1], [x2, y2], [x3, y3],...]</point>". 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 door handle.

[Assistant] <point>[[457, 903], [449, 720], [416, 687]]</point>

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

[Assistant] <point>[[443, 903], [363, 726], [391, 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 towards the paper bag.

[Assistant] <point>[[449, 842], [349, 435], [457, 468]]</point>

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

[Assistant] <point>[[468, 906], [529, 898], [512, 623]]</point>


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

You are given one observation of the scene and a task to perform. Based on the task, You should return a set of points as the trajectory to execute the task. The point trajectory format should be "<point>[[x1, y1], [x2, y2], [x3, y3],...]</point>". 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 door handle.

[Assistant] <point>[[338, 895], [360, 584], [410, 540]]</point>

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

[Assistant] <point>[[468, 900], [407, 391], [446, 346]]</point>


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

You are given one observation of the scene and a task to perform. Based on the task, You should return a set of points as the trajectory to execute the task. The point trajectory format should be "<point>[[x1, y1], [x2, y2], [x3, y3],...]</point>". 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 handle.

[Assistant] <point>[[465, 964], [410, 806], [363, 789]]</point>

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

[Assistant] <point>[[443, 842], [338, 263], [396, 183]]</point>


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

You are given one observation of the scene and a task to perform. Based on the task, You should return a set of points as the trajectory to execute the task. The point trajectory format should be "<point>[[x1, y1], [x2, y2], [x3, y3],...]</point>". 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 eye drop bottle.

[Assistant] <point>[[452, 873], [421, 609], [452, 526]]</point>

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

[Assistant] <point>[[413, 889], [429, 651], [485, 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 approach the drawer.

[Assistant] <point>[[463, 958], [385, 817], [399, 759]]</point>

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

[Assistant] <point>[[446, 856], [438, 471], [493, 399]]</point>


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

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

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

[Assistant] <point>[[429, 953], [321, 759], [371, 637], [543, 626]]</point>

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

[Assistant] <point>[[443, 889], [522, 461], [544, 431]]</point>


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

You are given one observation of the scene and a task to perform. Based on the task, You should return a set of points as the trajectory to execute the task. The point trajectory format should be "<point>[[x1, y1], [x2, y2], [x3, y3],...]</point>". 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 drawer.

[Assistant] <point>[[476, 906], [343, 540], [374, 438]]</point>

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

[Assistant] <point>[[452, 870], [349, 620], [393, 546]]</point>


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

You are given one observation of the scene and a task to perform. Based on the task, You should return a set of points as the trajectory to execute the task. The point trajectory format should be "<point>[[x1, y1], [x2, y2], [x3, y3],...]</point>". 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 cabinet door.

[Assistant] <point>[[440, 892], [526, 496], [623, 382]]</point>

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

[Assistant] <point>[[496, 895], [479, 457], [529, 327]]</point>


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

You are given one observation of the scene and a task to perform. Based on the task, You should return a set of points as the trajectory to execute the task. The point trajectory format should be "<point>[[x1, y1], [x2, y2], [x3, y3],...]</point>". 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 open drawer.

[Assistant] <point>[[449, 936], [421, 792], [471, 723]]</point>

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

[Assistant] <point>[[457, 853], [310, 357], [346, 238]]</point>


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

You are given one observation of the scene and a task to perform. Based on the task, You should return a set of points as the trajectory to execute the task. The point trajectory format should be "<point>[[x1, y1], [x2, y2], [x3, y3],...]</point>". 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 drawer handle.

[Assistant] <point>[[366, 842], [388, 501], [416, 360]]</point>

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

[Assistant] <point>[[463, 889], [551, 388], [596, 302]]</point>


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

You are given one observation of the scene and a task to perform. Based on the task, You should return a set of points as the trajectory to execute the task. The point trajectory format should be "<point>[[x1, y1], [x2, y2], [x3, y3],...]</point>". 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 cabinet door.

[Assistant] <point>[[452, 875], [449, 706], [490, 665]]</point>

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

[Assistant] <point>[[485, 900], [327, 562], [355, 490]]</point>


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

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

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

[Assistant] <point>[[471, 889], [366, 687], [346, 607]]</point>

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

[Assistant] <point>[[421, 920], [524, 693], [565, 535]]</point>


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

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

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

[Assistant] <point>[[499, 911], [474, 529], [526, 418]]</point>

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

[Assistant] <point>[[463, 881], [410, 546], [488, 410]]</point>


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

You are given one observation of the scene and a task to perform. Based on the task, You should return a set of points as the trajectory to execute the task. The point trajectory format should be "<point>[[x1, y1], [x2, y2], [x3, y3],...]</point>". 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 open drawer.

[Assistant] <point>[[277, 920], [393, 609], [471, 560]]</point>

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

[Assistant] <point>[[410, 886], [637, 510], [759, 512]]</point>


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

You are given one observation of the scene and a task to perform. Based on the task, You should return a set of points as the trajectory to execute the task. The point trajectory format should be "<point>[[x1, y1], [x2, y2], [x3, y3],...]</point>". 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 handle.

[Assistant] <point>[[427, 850], [583, 148], [664, 94]]</point>

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

[Assistant] <point>[[446, 873], [421, 560], [482, 482]]</point>


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

You are given one observation of the scene and a task to perform. Based on the task, You should return a set of points as the trajectory to execute the task. The point trajectory format should be "<point>[[x1, y1], [x2, y2], [x3, y3],...]</point>". 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 door handles.

[Assistant] <point>[[380, 917], [313, 640], [352, 571]]</point>

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

[Assistant] <point>[[471, 834], [615, 504], [756, 474]]</point>


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

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

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

[Assistant] <point>[[440, 867], [413, 598], [452, 543]]</point>

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

[Assistant] <point>[[465, 789], [573, 355], [673, 283]]</point>


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

You are given one observation of the scene and a task to perform. Based on the task, You should return a set of points as the trajectory to execute the task. The point trajectory format should be "<point>[[x1, y1], [x2, y2], [x3, y3],...]</point>". 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 light switch.

[Assistant] <point>[[465, 859], [355, 568], [343, 485]]</point>

[User]
Image-2:<image>
 You need to press the light switch.

[Assistant] <point>[[454, 828], [476, 548], [399, 510]]</point>


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

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

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

[Assistant] <point>[[454, 875], [476, 690], [604, 598]]</point>

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

[Assistant] <point>[[446, 864], [432, 471], [540, 330]]</point>


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

You are given one observation of the scene and a task to perform. Based on the task, You should return a set of points as the trajectory to execute the task. The point trajectory format should be "<point>[[x1, y1], [x2, y2], [x3, y3],...]</point>". 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 button.

[Assistant] <point>[[438, 845], [427, 640], [493, 579]]</point>

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

[Assistant] <point>[[512, 906], [485, 593], [507, 535]]</point>


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

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

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

[Assistant] <point>[[449, 820], [429, 413], [471, 343]]</point>

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

[Assistant] <point>[[452, 884], [388, 479], [418, 363]]</point>


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

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

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

[Assistant] <point>[[343, 898], [371, 584], [446, 529]]</point>

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

[Assistant] <point>[[452, 834], [416, 607], [446, 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 approach the closet door.

[Assistant] <point>[[440, 903], [402, 742], [435, 693]]</point>

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

[Assistant] <point>[[413, 834], [457, 576], [521, 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 approach the light switch.

[Assistant] <point>[[526, 781], [490, 468], [446, 429]]</point>

[User]
Image-2:<image>
 You need to press the light switch.

[Assistant] <point>[[476, 814], [501, 632], [471, 590], [476, 645]]</point>


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

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

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

[Assistant] <point>[[440, 853], [371, 670], [463, 479]]</point>

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

[Assistant] <point>[[352, 817], [349, 446], [399, 305]]</point>


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

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

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

[Assistant] <point>[[452, 848], [343, 601], [360, 554]]</point>

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

[Assistant] <point>[[332, 828], [296, 565], [349, 507]]</point>


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

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

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

[Assistant] <point>[[452, 895], [551, 584], [618, 532]]</point>

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

[Assistant] <point>[[501, 898], [374, 568], [407, 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 drawer handle.

[Assistant] <point>[[460, 751], [501, 291], [432, 197]]</point>

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

[Assistant] <point>[[424, 809], [413, 407], [452, 357]]</point>


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

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

[User]
Image-1:<image>
 You need to press the light switch.

[Assistant] <point>[[471, 864], [407, 493], [438, 402]]</point>

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

[Assistant] <point>[[482, 861], [604, 440], [643, 368]]</point>


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

You are given one observation of the scene and a task to perform. Based on the task, You should return a set of points as the trajectory to execute the task. The point trajectory format should be "<point>[[x1, y1], [x2, y2], [x3, y3],...]</point>". 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 door.

[Assistant] <point>[[440, 842], [717, 299], [698, 244]]</point>

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

[Assistant] <point>[[446, 900], [399, 659], [438, 562]]</point>


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

You are given one observation of the scene and a task to perform. Based on the task, You should return a set of points as the trajectory to execute the task. The point trajectory format should be "<point>[[x1, y1], [x2, y2], [x3, y3],...]</point>". 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 faucet.

[Assistant] <point>[[454, 867], [501, 349], [460, 269]]</point>

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

[Assistant] <point>[[454, 884], [510, 601], [565, 557]]</point>


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

You are given one observation of the scene and a task to perform. Based on the task, You should return a set of points as the trajectory to execute the task. The point trajectory format should be "<point>[[x1, y1], [x2, y2], [x3, y3],...]</point>". 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 microwave.

[Assistant] <point>[[429, 864], [598, 543], [646, 502]]</point>

[User]
Image-2:<image>
 You need to press the stop button.

[Assistant] <point>[[457, 839], [435, 695], [518, 601]]</point>


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

You are given one observation of the scene and a task to perform. Based on the task, You should return a set of points as the trajectory to execute the task. The point trajectory format should be "<point>[[x1, y1], [x2, y2], [x3, y3],...]</point>". 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 light switch.

[Assistant] <point>[[449, 814], [382, 460], [440, 371]]</point>

[User]
Image-2:<image>
 You need to flip the light switch up.

[Assistant] <point>[[443, 886], [343, 753], [366, 654]]</point>


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

You are given one observation of the scene and a task to perform. Based on the task, You should return a set of points as the trajectory to execute the task. The point trajectory format should be "<point>[[x1, y1], [x2, y2], [x3, y3],...]</point>". 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 cabinet door.

[Assistant] <point>[[449, 867], [485, 573], [524, 479]]</point>

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

[Assistant] <point>[[440, 853], [402, 543], [457, 460]]</point>


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

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

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

[Assistant] <point>[[465, 848], [490, 407], [557, 321]]</point>

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

[Assistant] <point>[[482, 817], [399, 573], [432, 482]]</point>


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

You are given one observation of the scene and a task to perform. Based on the task, You should return a set of points as the trajectory to execute the task. The point trajectory format should be "<point>[[x1, y1], [x2, y2], [x3, y3],...]</point>". 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 drawer.

[Assistant] <point>[[446, 881], [449, 695], [507, 643]]</point>

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

[Assistant] <point>[[440, 825], [482, 565], [438, 493]]</point>


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

You are given one observation of the scene and a task to perform. Based on the task, You should return a set of points as the trajectory to execute the task. The point trajectory format should be "<point>[[x1, y1], [x2, y2], [x3, y3],...]</point>". 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 sunscreen bottle.

[Assistant] <point>[[443, 881], [440, 537], [385, 452]]</point>

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

[Assistant] <point>[[424, 850], [435, 543], [377, 382]]</point>


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

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

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

[Assistant] <point>[[457, 837], [490, 587], [346, 515]]</point>

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

[Assistant] <point>[[452, 837], [388, 493], [416, 416]]</point>


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

You are given one observation of the scene and a task to perform. Based on the task, You should return a set of points as the trajectory to execute the task. The point trajectory format should be "<point>[[x1, y1], [x2, y2], [x3, y3],...]</point>". 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 open drawer.

[Assistant] <point>[[493, 895], [715, 501], [704, 368]]</point>

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

[Assistant] <point>[[346, 842], [427, 560], [382, 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 approach the drawer.

[Assistant] <point>[[377, 842], [529, 615], [499, 548]]</point>

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

[Assistant] <point>[[454, 825], [452, 429], [521, 355]]</point>


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

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

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

[Assistant] <point>[[438, 895], [535, 690], [440, 607]]</point>

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

[Assistant] <point>[[468, 829], [465, 725], [451, 673], [445, 555]]</point>


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

You are given one observation of the scene and a task to perform. Based on the task, You should return a set of points as the trajectory to execute the task. The point trajectory format should be "<point>[[x1, y1], [x2, y2], [x3, y3],...]</point>". 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 refrigerator.

[Assistant] <point>[[441, 958], [445, 845], [445, 735], [450, 580]]</point>

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

[Assistant] <point>[[433, 954], [433, 786], [429, 651], [412, 340]]</point>


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

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

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

[Assistant] <point>[[437, 975], [466, 878], [525, 786], [592, 655]]</point>

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

[Assistant] <point>[[429, 987], [454, 891], [479, 769], [450, 618], [454, 954]]</point>


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

You are given one observation of the scene and a task to perform. Based on the task, You should return a set of points as the trajectory to execute the task. The point trajectory format should be "<point>[[x1, y1], [x2, y2], [x3, y3],...]</point>". 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 door handle.

[Assistant] <point>[[441, 962], [429, 807], [395, 592], [261, 231]]</point>

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

[Assistant] <point>[[448, 815], [503, 734], [488, 598]]</point>


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

You are given one observation of the scene and a task to perform. Based on the task, You should return a set of points as the trajectory to execute the task. The point trajectory format should be "<point>[[x1, y1], [x2, y2], [x3, y3],...]</point>". 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 drawer handles.

[Assistant] <point>[[471, 775], [474, 601], [410, 431], [338, 208]]</point>

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

[Assistant] <point>[[448, 832], [460, 708], [512, 636], [581, 592], [673, 569]]</point>


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

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

[User]
Image-1:<image>
 You need to grab both door handles.

[Assistant] <point>[[431, 832], [494, 783], [552, 702]]</point>

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

[Assistant] <point>[[480, 737], [460, 592], [445, 500], [428, 376]]</point>


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

You are given one observation of the scene and a task to perform. Based on the task, You should return a set of points as the trajectory to execute the task. The point trajectory format should be "<point>[[x1, y1], [x2, y2], [x3, y3],...]</point>". 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 drawer handle.

[Assistant] <point>[[442, 740], [442, 662], [410, 584], [353, 462]]</point>

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

[Assistant] <point>[[462, 887], [488, 835], [491, 757], [448, 697]]</point>


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

You are given one observation of the scene and a task to perform. Based on the task, You should return a set of points as the trajectory to execute the task. The point trajectory format should be "<point>[[x1, y1], [x2, y2], [x3, y3],...]</point>". 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 button.

[Assistant] <point>[[436, 818], [494, 691], [526, 581], [566, 465]]</point>

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

[Assistant] <point>[[462, 815], [491, 711], [509, 561]]</point>


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

You are given one observation of the scene and a task to perform. Based on the task, You should return a set of points as the trajectory to execute the task. The point trajectory format should be "<point>[[x1, y1], [x2, y2], [x3, y3],...]</point>". 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 cabinet door.

[Assistant] <point>[[436, 786], [486, 601], [503, 434], [497, 217]]</point>

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

[Assistant] <point>[[387, 809], [436, 685], [488, 601]]</point>


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

You are given one observation of the scene and a task to perform. Based on the task, You should return a set of points as the trajectory to execute the task. The point trajectory format should be "<point>[[x1, y1], [x2, y2], [x3, y3],...]</point>". 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 tissue box.

[Assistant] <point>[[420, 958], [416, 840], [424, 723], [437, 542]]</point>

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

[Assistant] <point>[[429, 941], [437, 811], [445, 685], [454, 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 approach the orange.

[Assistant] <point>[[462, 941], [450, 832], [445, 685], [441, 534]]</point>

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

[Assistant] <point>[[420, 962], [412, 832], [412, 676], [387, 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 door handle.

[Assistant] <point>[[424, 979], [445, 866], [471, 744], [500, 559]]</point>

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

[Assistant] <point>[[492, 950], [492, 790], [483, 643], [462, 424]]</point>


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

You are given one observation of the scene and a task to perform. Based on the task, You should return a set of points as the trajectory to execute the task. The point trajectory format should be "<point>[[x1, y1], [x2, y2], [x3, y3],...]</point>". 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 door.

[Assistant] <point>[[475, 950], [521, 807], [546, 647], [571, 437]]</point>

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

[Assistant] <point>[[479, 954], [487, 756], [500, 584], [529, 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 handle.

[Assistant] <point>[[496, 941], [462, 761], [429, 567], [399, 332]]</point>

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

[Assistant] <point>[[429, 950], [462, 794], [517, 630], [609, 433]]</point>


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

You are given one observation of the scene and a task to perform. Based on the task, You should return a set of points as the trajectory to execute the task. The point trajectory format should be "<point>[[x1, y1], [x2, y2], [x3, y3],...]</point>". 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 partially opened drawer.

[Assistant] <point>[[433, 954], [429, 752], [441, 588], [571, 349], [445, 908]]</point>

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

[Assistant] <point>[[391, 937], [416, 807], [441, 693], [462, 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 grab the handles of the door.

[Assistant] <point>[[445, 962], [454, 887], [479, 836], [487, 786]]</point>

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

[Assistant] <point>[[382, 979], [382, 895], [378, 807], [378, 601]]</point>


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

You are given one observation of the scene and a task to perform. Based on the task, You should return a set of points as the trajectory to execute the task. The point trajectory format should be "<point>[[x1, y1], [x2, y2], [x3, y3],...]</point>". 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 drawer handle.

[Assistant] <point>[[424, 979], [475, 903], [504, 794], [546, 702]]</point>

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

[Assistant] <point>[[433, 929], [420, 718], [378, 517], [319, 286]]</point>


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

You are given one observation of the scene and a task to perform. Based on the task, You should return a set of points as the trajectory to execute the task. The point trajectory format should be "<point>[[x1, y1], [x2, y2], [x3, y3],...]</point>". 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 rubik's cube.

[Assistant] <point>[[454, 971], [458, 845], [487, 689], [487, 429]]</point>

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

[Assistant] <point>[[420, 971], [429, 832], [437, 693], [441, 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 approach the door.

[Assistant] <point>[[471, 971], [471, 882], [471, 794], [496, 651]]</point>

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

[Assistant] <point>[[420, 971], [462, 878], [504, 773], [542, 643]]</point>


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

You are given one observation of the scene and a task to perform. Based on the task, You should return a set of points as the trajectory to execute the task. The point trajectory format should be "<point>[[x1, y1], [x2, y2], [x3, y3],...]</point>". 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 cabinet door.

[Assistant] <point>[[403, 962], [416, 807], [420, 647], [445, 403]]</point>

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

[Assistant] <point>[[445, 954], [437, 748], [429, 563], [424, 332]]</point>


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

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

[User]
Image-1:<image>
 You need to press the light switch.

[Assistant] <point>[[487, 664], [529, 496], [550, 357], [563, 206]]</point>

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

[Assistant] <point>[[450, 962], [521, 811], [559, 681], [639, 538]]</point>


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

You are given one observation of the scene and a task to perform. Based on the task, You should return a set of points as the trajectory to execute the task. The point trajectory format should be "<point>[[x1, y1], [x2, y2], [x3, y3],...]</point>". 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 cabinet.

[Assistant] <point>[[412, 966], [370, 861], [336, 782], [345, 660]]</point>

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

[Assistant] <point>[[424, 941], [466, 761], [538, 592], [655, 298]]</point>


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

You are given one observation of the scene and a task to perform. Based on the task, You should return a set of points as the trajectory to execute the task. The point trajectory format should be "<point>[[x1, y1], [x2, y2], [x3, y3],...]</point>". 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 drawer handle.

[Assistant] <point>[[403, 937], [416, 786], [416, 639], [416, 529]]</point>

[User]
Image-2:<image>
 You need to grasp the drawer handle.

[Assistant] <point>[[403, 975], [454, 866], [479, 786], [546, 706]]</point>


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

You are given one observation of the scene and a task to perform. Based on the task, You should return a set of points as the trajectory to execute the task. The point trajectory format should be "<point>[[x1, y1], [x2, y2], [x3, y3],...]</point>". 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 door handle.

[Assistant] <point>[[454, 945], [534, 786], [546, 676], [592, 521]]</point>

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

[Assistant] <point>[[420, 954], [395, 794], [370, 647], [328, 437]]</point>


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

You are given one observation of the scene and a task to perform. Based on the task, You should return a set of points as the trajectory to execute the task. The point trajectory format should be "<point>[[x1, y1], [x2, y2], [x3, y3],...]</point>". 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 door handle.

[Assistant] <point>[[429, 958], [466, 828], [525, 735], [605, 609]]</point>

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

[Assistant] <point>[[429, 971], [441, 811], [445, 693], [462, 567]]</point>


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

You are given one observation of the scene and a task to perform. Based on the task, You should return a set of points as the trajectory to execute the task. The point trajectory format should be "<point>[[x1, y1], [x2, y2], [x3, y3],...]</point>". 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 sunscreen bottle.

[Assistant] <point>[[462, 958], [496, 815], [534, 676], [555, 571]]</point>

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

[Assistant] <point>[[349, 975], [412, 845], [479, 685], [529, 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 door handle.

[Assistant] <point>[[445, 937], [454, 773], [466, 571], [471, 416]]</point>

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

[Assistant] <point>[[445, 945], [462, 794], [412, 634], [412, 513]]</point>


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

You are given one observation of the scene and a task to perform. Based on the task, You should return a set of points as the trajectory to execute the task. The point trajectory format should be "<point>[[x1, y1], [x2, y2], [x3, y3],...]</point>". 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 light switch.

[Assistant] <point>[[437, 987], [479, 845], [496, 702], [504, 538]]</point>

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

[Assistant] <point>[[445, 979], [445, 870], [458, 765], [513, 647]]</point>


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

You are given one observation of the scene and a task to perform. Based on the task, You should return a set of points as the trajectory to execute the task. The point trajectory format should be "<point>[[x1, y1], [x2, y2], [x3, y3],...]</point>". 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 rubik's cube.

[Assistant] <point>[[468, 783], [514, 702], [535, 590], [543, 480]]</point>

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

[Assistant] <point>[[379, 873], [367, 780], [408, 662], [474, 535]]</point>


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

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

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

[Assistant] <point>[[434, 908], [436, 803], [379, 636]]</point>

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

[Assistant] <point>[[428, 801], [402, 639], [434, 497], [494, 312]]</point>


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

You are given one observation of the scene and a task to perform. Based on the task, You should return a set of points as the trajectory to execute the task. The point trajectory format should be "<point>[[x1, y1], [x2, y2], [x3, y3],...]</point>". 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 electric kettle.

[Assistant] <point>[[454, 861], [483, 751], [509, 656], [506, 575]]</point>

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

[Assistant] <point>[[422, 806], [514, 659], [566, 552], [561, 301]]</point>


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

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

[User]
Image-1:<image>
 You need to flip the light switch down.

[Assistant] <point>[[451, 792], [500, 564], [468, 425]]</point>

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

[Assistant] <point>[[465, 827], [436, 737], [436, 642], [509, 434]]</point>


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

You are given one observation of the scene and a task to perform. Based on the task, You should return a set of points as the trajectory to execute the task. The point trajectory format should be "<point>[[x1, y1], [x2, y2], [x3, y3],...]</point>". 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 door handles.

[Assistant] <point>[[402, 905], [465, 806], [451, 711]]</point>

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

[Assistant] <point>[[439, 795], [402, 685], [405, 535], [471, 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 approach the drawer.

[Assistant] <point>[[422, 809], [428, 601], [474, 405]]</point>

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

[Assistant] <point>[[419, 841], [552, 647], [682, 384]]</point>


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

You are given one observation of the scene and a task to perform. Based on the task, You should return a set of points as the trajectory to execute the task. The point trajectory format should be "<point>[[x1, y1], [x2, y2], [x3, y3],...]</point>". 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 drawer handle.

[Assistant] <point>[[436, 798], [431, 702], [451, 607], [512, 462]]</point>

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

[Assistant] <point>[[309, 798], [295, 682], [318, 578], [416, 520]]</point>


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

You are given one observation of the scene and a task to perform. Based on the task, You should return a set of points as the trajectory to execute the task. The point trajectory format should be "<point>[[x1, y1], [x2, y2], [x3, y3],...]</point>". 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 handle of the cabinet door.

[Assistant] <point>[[462, 841], [460, 662], [434, 578], [358, 451]]</point>

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

[Assistant] <point>[[419, 766], [425, 613], [480, 460], [561, 405], [682, 329]]</point>


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

You are given one observation of the scene and a task to perform. Based on the task, You should return a set of points as the trajectory to execute the task. The point trajectory format should be "<point>[[x1, y1], [x2, y2], [x3, y3],...]</point>". 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 drawer.

[Assistant] <point>[[315, 803], [318, 694], [387, 621], [535, 578]]</point>

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

[Assistant] <point>[[462, 772], [509, 676], [506, 584], [477, 462]]</point>


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

You are given one observation of the scene and a task to perform. Based on the task, You should return a set of points as the trajectory to execute the task. The point trajectory format should be "<point>[[x1, y1], [x2, y2], [x3, y3],...]</point>". 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 door handle.

[Assistant] <point>[[344, 780], [329, 645], [367, 520], [460, 373]]</point>

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

[Assistant] <point>[[457, 884], [500, 749], [497, 618], [462, 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 door handle.

[Assistant] <point>[[402, 827], [382, 685], [399, 569], [442, 434], [517, 315]]</point>

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

[Assistant] <point>[[303, 777], [408, 714], [506, 601], [503, 509]]</point>


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

You are given one observation of the scene and a task to perform. Based on the task, You should return a set of points as the trajectory to execute the task. The point trajectory format should be "<point>[[x1, y1], [x2, y2], [x3, y3],...]</point>". 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 cabinet door.

[Assistant] <point>[[422, 783], [384, 659], [416, 512], [535, 373], [601, 332]]</point>

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

[Assistant] <point>[[442, 803], [445, 671], [434, 590], [471, 491]]</point>


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

You are given one observation of the scene and a task to perform. Based on the task, You should return a set of points as the trajectory to execute the task. The point trajectory format should be "<point>[[x1, y1], [x2, y2], [x3, y3],...]</point>". 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 cabinet doors.

[Assistant] <point>[[393, 795], [399, 598], [465, 497], [590, 367]]</point>

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

[Assistant] <point>[[416, 777], [422, 676], [419, 592], [413, 500]]</point>


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

You are given one observation of the scene and a task to perform. Based on the task, You should return a set of points as the trajectory to execute the task. The point trajectory format should be "<point>[[x1, y1], [x2, y2], [x3, y3],...]</point>". 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 door.

[Assistant] <point>[[373, 792], [373, 676], [373, 572], [419, 413]]</point>

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

[Assistant] <point>[[379, 798], [462, 682], [514, 566], [552, 364]]</point>


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

You are given one observation of the scene and a task to perform. Based on the task, You should return a set of points as the trajectory to execute the task. The point trajectory format should be "<point>[[x1, y1], [x2, y2], [x3, y3],...]</point>". 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 fire extinguisher cabinet.

[Assistant] <point>[[454, 835], [509, 760], [512, 682]]</point>

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

[Assistant] <point>[[491, 835], [555, 725], [578, 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 reach for the cabinet door.

[Assistant] <point>[[431, 777], [416, 659], [457, 526], [558, 431]]</point>

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

[Assistant] <point>[[465, 795], [497, 691], [439, 514]]</point>


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

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

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

[Assistant] <point>[[445, 772], [500, 633], [618, 474], [769, 318], [887, 269]]</point>

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

[Assistant] <point>[[468, 809], [500, 705], [569, 575], [616, 361]]</point>


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

You are given one observation of the scene and a task to perform. Based on the task, You should return a set of points as the trajectory to execute the task. The point trajectory format should be "<point>[[x1, y1], [x2, y2], [x3, y3],...]</point>". 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 button.

[Assistant] <point>[[480, 786], [477, 717], [486, 584]]</point>

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

[Assistant] <point>[[442, 751], [506, 645], [543, 613], [711, 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 approach the tennis ball.

[Assistant] <point>[[488, 853], [486, 783], [486, 731], [483, 627]]</point>

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

[Assistant] <point>[[436, 832], [477, 630], [514, 529], [613, 410]]</point>


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

You are given one observation of the scene and a task to perform. Based on the task, You should return a set of points as the trajectory to execute the task. The point trajectory format should be "<point>[[x1, y1], [x2, y2], [x3, y3],...]</point>". 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 cabinet door handles.

[Assistant] <point>[[425, 803], [436, 665], [480, 578], [520, 497], [642, 393]]</point>

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

[Assistant] <point>[[341, 855], [384, 783], [413, 708], [387, 538]]</point>


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

You are given one observation of the scene and a task to perform. Based on the task, You should return a set of points as the trajectory to execute the task. The point trajectory format should be "<point>[[x1, y1], [x2, y2], [x3, y3],...]</point>". 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 microwave.

[Assistant] <point>[[428, 809], [428, 728], [448, 656], [581, 520]]</point>

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

[Assistant] <point>[[445, 798], [497, 647], [434, 483], [303, 350]]</point>


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

You are given one observation of the scene and a task to perform. Based on the task, You should return a set of points as the trajectory to execute the task. The point trajectory format should be "<point>[[x1, y1], [x2, y2], [x3, y3],...]</point>". 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 open drawer.

[Assistant] <point>[[436, 760], [460, 671], [480, 598]]</point>

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

[Assistant] <point>[[474, 801], [442, 705], [405, 679], [358, 633]]</point>


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

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

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

[Assistant] <point>[[442, 795], [445, 720], [448, 656], [486, 590]]</point>

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

[Assistant] <point>[[486, 801], [486, 723], [445, 645], [396, 595], [309, 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 approach the cabinet door.

[Assistant] <point>[[514, 829], [503, 725], [497, 575], [509, 376]]</point>

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

[Assistant] <point>[[321, 847], [364, 763], [413, 679], [434, 618], [448, 509]]</point>


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

You are given one observation of the scene and a task to perform. Based on the task, You should return a set of points as the trajectory to execute the task. The point trajectory format should be "<point>[[x1, y1], [x2, y2], [x3, y3],...]</point>". 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 cabinet door.

[Assistant] <point>[[451, 844], [506, 769], [555, 682], [555, 569]]</point>

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

[Assistant] <point>[[367, 792], [367, 717], [399, 618], [488, 555]]</point>


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

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

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

[Assistant] <point>[[402, 789], [405, 676], [445, 572], [552, 457]]</point>

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

[Assistant] <point>[[457, 818], [488, 728], [451, 656], [402, 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 pull the drawer inwards.

[Assistant] <point>[[416, 786], [468, 616], [520, 526], [613, 353]]</point>

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

[Assistant] <point>[[439, 798], [491, 685], [460, 575]]</point>


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

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

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

[Assistant] <point>[[460, 798], [457, 699], [451, 627], [442, 468]]</point>

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

[Assistant] <point>[[329, 812], [315, 688], [344, 592], [439, 497]]</point>


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

You are given one observation of the scene and a task to perform. Based on the task, You should return a set of points as the trajectory to execute the task. The point trajectory format should be "<point>[[x1, y1], [x2, y2], [x3, y3],...]</point>". 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 light switch.

[Assistant] <point>[[416, 835], [408, 734], [425, 653], [488, 578]]</point>

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

[Assistant] <point>[[434, 832], [448, 754], [468, 668], [532, 587]]</point>


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

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

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

[Assistant] <point>[[439, 850], [439, 763], [494, 639], [595, 543], [720, 494]]</point>

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

[Assistant] <point>[[367, 786], [373, 668], [370, 598], [393, 500]]</point>


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

You are given one observation of the scene and a task to perform. Based on the task, You should return a set of points as the trajectory to execute the task. The point trajectory format should be "<point>[[x1, y1], [x2, y2], [x3, y3],...]</point>". 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 cabinet door.

[Assistant] <point>[[454, 792], [434, 702], [382, 595], [350, 486]]</point>

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

[Assistant] <point>[[451, 838], [442, 737], [483, 618], [584, 578]]</point>


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

You are given one observation of the scene and a task to perform. Based on the task, You should return a set of points as the trajectory to execute the task. The point trajectory format should be "<point>[[x1, y1], [x2, y2], [x3, y3],...]</point>". 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 cabinet door.

[Assistant] <point>[[428, 803], [445, 691], [480, 604], [590, 529], [656, 514]]</point>

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

[Assistant] <point>[[419, 806], [529, 639], [564, 561], [581, 434], [540, 321]]</point>


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

You are given one observation of the scene and a task to perform. Based on the task, You should return a set of points as the trajectory to execute the task. The point trajectory format should be "<point>[[x1, y1], [x2, y2], [x3, y3],...]</point>". 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 light switch.

[Assistant] <point>[[460, 798], [477, 630], [488, 535], [488, 410]]</point>

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

[Assistant] <point>[[419, 876], [448, 789], [483, 679], [465, 549]]</point>


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

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

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

[Assistant] <point>[[486, 769], [480, 656], [419, 546], [309, 431]]</point>

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

[Assistant] <point>[[526, 861], [497, 749], [520, 639], [538, 512], [561, 405], [624, 298]]</point>


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

You are given one observation of the scene and a task to perform. Based on the task, You should return a set of points as the trajectory to execute the task. The point trajectory format should be "<point>[[x1, y1], [x2, y2], [x3, y3],...]</point>". 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 handle.

[Assistant] <point>[[393, 786], [379, 685], [393, 561], [428, 468]]</point>

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

[Assistant] <point>[[439, 754], [416, 645], [416, 529], [448, 387], [491, 338], [610, 231]]</point>


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

You are given one observation of the scene and a task to perform. Based on the task, You should return a set of points as the trajectory to execute the task. The point trajectory format should be "<point>[[x1, y1], [x2, y2], [x3, y3],...]</point>". 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 open cabinet door.

[Assistant] <point>[[448, 812], [462, 659], [471, 564], [457, 442]]</point>

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

[Assistant] <point>[[460, 795], [526, 671], [538, 561], [543, 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 water bottle.

[Assistant] <point>[[477, 838], [477, 746], [442, 668], [402, 572], [382, 491]]</point>

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

[Assistant] <point>[[439, 783], [448, 720], [460, 665]]</point>


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

You are given one observation of the scene and a task to perform. Based on the task, You should return a set of points as the trajectory to execute the task. The point trajectory format should be "<point>[[x1, y1], [x2, y2], [x3, y3],...]</point>". 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 drawer handle.

[Assistant] <point>[[376, 821], [405, 746], [442, 653], [486, 601]]</point>

[User]
Image-2:<image>
 You need to grab the handle of the air fryer drawer.

[Assistant] <point>[[402, 763], [436, 685], [451, 639], [483, 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 approach the drawer.

[Assistant] <point>[[454, 772], [462, 691], [468, 645], [465, 618]]</point>

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

[Assistant] <point>[[405, 798], [451, 711], [488, 618]]</point>


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

You are given one observation of the scene and a task to perform. Based on the task, You should return a set of points as the trajectory to execute the task. The point trajectory format should be "<point>[[x1, y1], [x2, y2], [x3, y3],...]</point>". 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 door handle.

[Assistant] <point>[[451, 725], [462, 590], [529, 465]]</point>

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

[Assistant] <point>[[454, 780], [474, 668], [462, 578], [439, 497]]</point>


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

You are given one observation of the scene and a task to perform. Based on the task, You should return a set of points as the trajectory to execute the task. The point trajectory format should be "<point>[[x1, y1], [x2, y2], [x3, y3],...]</point>". 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 handle.

[Assistant] <point>[[457, 806], [462, 679], [480, 561], [506, 428]]</point>

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

[Assistant] <point>[[462, 699], [512, 595], [610, 497]]</point>


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

You are given one observation of the scene and a task to perform. Based on the task, You should return a set of points as the trajectory to execute the task. The point trajectory format should be "<point>[[x1, y1], [x2, y2], [x3, y3],...]</point>". 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 button.

[Assistant] <point>[[462, 821], [448, 731], [439, 630]]</point>

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

[Assistant] <point>[[436, 763], [457, 682], [494, 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 approach the cabinet door handles.

[Assistant] <point>[[471, 792], [457, 702], [442, 601], [462, 468]]</point>

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

[Assistant] <point>[[408, 760], [422, 665], [434, 538], [474, 379]]</point>


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

You are given one observation of the scene and a task to perform. Based on the task, You should return a set of points as the trajectory to execute the task. The point trajectory format should be "<point>[[x1, y1], [x2, y2], [x3, y3],...]</point>". 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 drawer handle.

[Assistant] <point>[[431, 777], [457, 630], [480, 540], [506, 439]]</point>

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

[Assistant] <point>[[306, 792], [338, 633], [361, 532], [425, 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 approach the door.

[Assistant] <point>[[442, 803], [483, 656], [543, 520], [679, 434]]</point>

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

[Assistant] <point>[[434, 780], [468, 639], [494, 509], [532, 341]]</point>


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

You are given one observation of the scene and a task to perform. Based on the task, You should return a set of points as the trajectory to execute the task. The point trajectory format should be "<point>[[x1, y1], [x2, y2], [x3, y3],...]</point>". 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 drawer.

[Assistant] <point>[[413, 818], [457, 662], [462, 543], [471, 390]]</point>

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

[Assistant] <point>[[448, 783], [529, 682], [595, 517], [653, 301]]</point>


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

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

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

[Assistant] <point>[[474, 829], [465, 734], [454, 607], [408, 413]]</point>

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

[Assistant] <point>[[460, 824], [460, 714], [436, 621], [353, 491]]</point>


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

You are given one observation of the scene and a task to perform. Based on the task, You should return a set of points as the trajectory to execute the task. The point trajectory format should be "<point>[[x1, y1], [x2, y2], [x3, y3],...]</point>". 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 button.

[Assistant] <point>[[419, 772], [439, 618], [454, 540], [477, 436]]</point>

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

[Assistant] <point>[[422, 841], [468, 679], [465, 503], [465, 416]]</point>


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

You are given one observation of the scene and a task to perform. Based on the task, You should return a set of points as the trajectory to execute the task. The point trajectory format should be "<point>[[x1, y1], [x2, y2], [x3, y3],...]</point>". 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 hand sanitizer bottle.

[Assistant] <point>[[460, 801], [497, 671], [494, 546], [434, 379]]</point>

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

[Assistant] <point>[[431, 887], [488, 763], [540, 624], [561, 465], [540, 283]]</point>


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

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

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

[Assistant] <point>[[382, 835], [387, 671], [428, 546], [468, 457]]</point>

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

[Assistant] <point>[[448, 815], [457, 688], [468, 604]]</point>


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

You are given one observation of the scene and a task to perform. Based on the task, You should return a set of points as the trajectory to execute the task. The point trajectory format should be "<point>[[x1, y1], [x2, y2], [x3, y3],...]</point>". 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 oven door.

[Assistant] <point>[[448, 844], [462, 708], [462, 595], [457, 555]]</point>

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

[Assistant] <point>[[439, 792], [442, 717], [451, 561]]</point>


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

You are given one observation of the scene and a task to perform. Based on the task, You should return a set of points as the trajectory to execute the task. The point trajectory format should be "<point>[[x1, y1], [x2, y2], [x3, y3],...]</point>". 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 power strip.

[Assistant] <point>[[399, 890], [355, 757], [329, 613], [350, 422]]</point>

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

[Assistant] <point>[[419, 948], [367, 792], [344, 659], [358, 460]]</point>


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

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

[User]
Image-1:<image>
 You need to grab the handles of the double door cabinet.

[Assistant] <point>[[422, 922], [370, 829], [286, 633], [240, 332]]</point>

[User]
Image-2:<image>
 You need to grasp the cabinet door handles.

[Assistant] <point>[[416, 965], [442, 902], [448, 841], [431, 697]]</point>