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

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

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

[Assistant] <point>[[352, 282], [292, 300], [254, 347], [225, 394]]</point>

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

[Assistant] <point>[[518, 239], [377, 291], [278, 347], [208, 498]]</point>


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

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

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

[Assistant] <point>[[567, 296], [475, 413], [451, 512], [472, 681]]</point>

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

[Assistant] <point>[[542, 305], [482, 362], [451, 432], [426, 507]]</point>


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

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

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

[Assistant] <point>[[722, 333], [560, 329], [405, 376], [225, 469]]</point>

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

[Assistant] <point>[[306, 103], [387, 254], [465, 329], [588, 343]]</point>


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

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

[Assistant] <point>[[602, 413], [627, 469], [634, 526], [623, 620]]</point>

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

[Assistant] <point>[[408, 141], [356, 174], [313, 221], [278, 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 place the knife down.

[Assistant] <point>[[239, 404], [366, 413], [532, 465], [637, 592]]</point>

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

[Assistant] <point>[[370, 211], [384, 300], [426, 366], [511, 385]]</point>


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

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

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

[Assistant] <point>[[405, 451], [482, 343], [574, 291], [725, 268]]</point>

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

[Assistant] <point>[[493, 394], [451, 437], [437, 507], [440, 629]]</point>


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

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

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

[Assistant] <point>[[701, 197], [651, 338], [655, 507], [708, 648]]</point>

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

[Assistant] <point>[[634, 282], [532, 404], [472, 554], [475, 770]]</point>


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

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

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

[Assistant] <point>[[197, 498], [285, 413], [440, 371], [658, 376]]</point>

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

[Assistant] <point>[[419, 338], [447, 451], [521, 507], [641, 540]]</point>


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

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

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

[Assistant] <point>[[644, 413], [592, 376], [556, 376], [496, 404]]</point>

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

[Assistant] <point>[[606, 75], [644, 150], [662, 239], [637, 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 mushroom.

[Assistant] <point>[[518, 94], [468, 230], [454, 376], [486, 573]]</point>

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

[Assistant] <point>[[331, 197], [370, 300], [447, 376], [577, 404]]</point>


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

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

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

[Assistant] <point>[[437, 164], [581, 291], [673, 441], [694, 601]]</point>

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

[Assistant] <point>[[539, 300], [465, 286], [391, 319], [345, 366]]</point>


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

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

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

[Assistant] <point>[[539, 469], [440, 432], [320, 432], [243, 469]]</point>

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

[Assistant] <point>[[278, 460], [415, 366], [542, 333], [676, 343]]</point>


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

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

[User]
Image-1:<image>
 You need to move towards the metal bowl containing the ear of corn.

[Assistant] <point>[[415, 239], [317, 272], [278, 329], [236, 479]]</point>

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

[Assistant] <point>[[197, 315], [370, 488], [567, 568], [736, 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 move towards the spoon.

[Assistant] <point>[[521, 418], [430, 390], [310, 390], [176, 451]]</point>

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

[Assistant] <point>[[444, 277], [525, 333], [623, 366], [754, 371]]</point>


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

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

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

[Assistant] <point>[[549, 338], [658, 390], [704, 432], [739, 521]]</point>

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

[Assistant] <point>[[401, 178], [352, 258], [320, 347], [320, 516]]</point>


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

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

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

[Assistant] <point>[[232, 404], [331, 479], [458, 554], [651, 573]]</point>

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

[Assistant] <point>[[356, 135], [411, 212], [475, 324], [544, 440], [643, 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 spatula.

[Assistant] <point>[[353, 77], [376, 197], [394, 290], [408, 402]]</point>

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

[Assistant] <point>[[350, 259], [521, 293], [582, 344], [649, 421]]</point>


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

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

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

[Assistant] <point>[[188, 351], [298, 328], [376, 351], [458, 363]]</point>

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

[Assistant] <point>[[264, 185], [319, 278], [391, 386], [466, 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 reach for the green towel.

[Assistant] <point>[[417, 120], [374, 181], [307, 278], [220, 417]]</point>

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

[Assistant] <point>[[426, 290], [359, 297], [313, 332], [243, 398]]</point>


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

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

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

[Assistant] <point>[[449, 116], [423, 212], [403, 320], [391, 417]]</point>

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

[Assistant] <point>[[570, 193], [547, 274], [524, 371], [492, 533]]</point>


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

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

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

[Assistant] <point>[[347, 120], [321, 205], [327, 301]]</point>

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

[Assistant] <point>[[530, 703], [597, 575], [666, 471], [796, 317]]</point>


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

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

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

[Assistant] <point>[[194, 251], [321, 274], [414, 336], [472, 398]]</point>

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

[Assistant] <point>[[290, 351], [403, 417], [504, 486], [588, 579]]</point>


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

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

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

[Assistant] <point>[[182, 154], [272, 201], [353, 297], [452, 402], [539, 490], [614, 548]]</point>

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

[Assistant] <point>[[197, 290], [319, 266], [446, 259], [539, 274], [602, 290]]</point>


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

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

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

[Assistant] <point>[[640, 274], [588, 232], [533, 193], [446, 162], [353, 189]]</point>

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

[Assistant] <point>[[796, 386], [707, 425], [631, 479], [582, 541], [562, 595]]</point>


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

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

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

[Assistant] <point>[[356, 205], [394, 278], [420, 359], [434, 429]]</point>

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

[Assistant] <point>[[449, 278], [426, 398], [414, 568]]</point>


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

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

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

[Assistant] <point>[[405, 552], [498, 517], [579, 506]]</point>

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

[Assistant] <point>[[188, 386], [281, 378], [397, 402], [507, 432], [634, 475], [782, 568]]</point>


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

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

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

[Assistant] <point>[[324, 73], [388, 174], [443, 266], [495, 347], [570, 475]]</point>

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

[Assistant] <point>[[437, 216], [437, 320], [434, 444], [440, 571], [440, 707]]</point>


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

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

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

[Assistant] <point>[[489, 139], [434, 259], [365, 363], [313, 517]]</point>

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

[Assistant] <point>[[295, 170], [359, 239], [408, 320]]</point>


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

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

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

[Assistant] <point>[[385, 266], [486, 355], [585, 448], [660, 533]]</point>

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

[Assistant] <point>[[417, 46], [420, 108], [426, 174], [443, 278]]</point>


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

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

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

[Assistant] <point>[[365, 278], [403, 394], [452, 595]]</point>

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

[Assistant] <point>[[759, 324], [712, 347], [625, 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 cleaning tool on the table.

[Assistant] <point>[[405, 89], [475, 151], [536, 251], [588, 398]]</point>

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

[Assistant] <point>[[188, 359], [261, 382], [365, 390], [486, 378]]</point>


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

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

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

[Assistant] <point>[[599, 598], [550, 533], [452, 429], [376, 359], [292, 305], [188, 251]]</point>

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

[Assistant] <point>[[429, 382], [553, 328], [649, 297], [721, 263]]</point>


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

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

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

[Assistant] <point>[[313, 112], [411, 290], [495, 490], [559, 749]]</point>

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

[Assistant] <point>[[203, 429], [290, 375], [347, 317]]</point>


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

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

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

[Assistant] <point>[[449, 328], [376, 382], [292, 425], [240, 452]]</point>

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

[Assistant] <point>[[715, 116], [588, 124], [486, 166], [408, 205], [266, 301]]</point>


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

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

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

[Assistant] <point>[[301, 274], [391, 367], [463, 483], [513, 602]]</point>

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

[Assistant] <point>[[417, 286], [319, 324], [214, 378], [110, 456], [58, 502]]</point>


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

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

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

[Assistant] <point>[[58, 521], [133, 529], [252, 548], [339, 575], [446, 614]]</point>

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

[Assistant] <point>[[582, 429], [547, 405], [466, 367], [345, 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 green spatula.

[Assistant] <point>[[252, 324], [394, 340], [539, 375], [695, 479]]</point>

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

[Assistant] <point>[[264, 143], [261, 224], [278, 351]]</point>


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

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

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

[Assistant] <point>[[507, 278], [568, 371], [620, 444], [654, 506]]</point>

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

[Assistant] <point>[[692, 216], [623, 336], [585, 471], [553, 622]]</point>


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

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

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

[Assistant] <point>[[501, 286], [443, 320], [333, 386], [269, 459]]</point>

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

[Assistant] <point>[[417, 112], [362, 170], [275, 293], [177, 405]]</point>


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

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

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

[Assistant] <point>[[101, 471], [252, 429], [356, 386], [394, 367]]</point>

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

[Assistant] <point>[[617, 247], [576, 255], [429, 301], [310, 347]]</point>


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

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

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

[Assistant] <point>[[180, 243], [194, 375], [200, 440]]</point>

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

[Assistant] <point>[[698, 386], [568, 386], [452, 425], [298, 486]]</point>


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

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

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

[Assistant] <point>[[284, 405], [400, 402], [510, 402], [573, 425]]</point>

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

[Assistant] <point>[[292, 417], [426, 398], [599, 382], [762, 421]]</point>


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

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

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

[Assistant] <point>[[319, 205], [423, 239], [507, 293], [608, 363]]</point>

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

[Assistant] <point>[[206, 201], [298, 293], [374, 378], [466, 502], [556, 695]]</point>


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

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

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

[Assistant] <point>[[559, 548], [434, 413], [362, 317], [321, 255]]</point>

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

[Assistant] <point>[[669, 332], [637, 417], [608, 537]]</point>


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

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

[User]
Image-1:<image>
 You need to pick up a stuffed elephant.

[Assistant] <point>[[819, 193], [727, 255], [602, 371], [458, 506]]</point>

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

[Assistant] <point>[[507, 320], [431, 313], [382, 328], [307, 378]]</point>


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

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

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

[Assistant] <point>[[17, 290], [133, 290], [220, 290], [368, 320], [478, 332]]</point>

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

[Assistant] <point>[[359, 201], [449, 317], [568, 452], [701, 610]]</point>


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

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

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

[Assistant] <point>[[533, 232], [414, 344], [353, 463]]</point>

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

[Assistant] <point>[[550, 205], [527, 278], [481, 417], [452, 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 reach for the spoon.

[Assistant] <point>[[440, 181], [397, 224], [330, 324], [304, 371]]</point>

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

[Assistant] <point>[[319, 143], [374, 270], [452, 429], [565, 641]]</point>


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

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

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

[Assistant] <point>[[675, 54], [559, 154], [484, 232], [394, 324], [235, 471]]</point>

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

[Assistant] <point>[[284, 212], [379, 282], [495, 355], [573, 390], [649, 444]]</point>


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

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

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

[Assistant] <point>[[206, 93], [310, 174], [446, 297], [562, 432], [582, 517]]</point>

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

[Assistant] <point>[[484, 355], [475, 448], [475, 583], [481, 699]]</point>


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

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

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

[Assistant] <point>[[510, 382], [594, 402], [672, 475], [721, 544]]</point>

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

[Assistant] <point>[[417, 147], [458, 297], [481, 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 brush.

[Assistant] <point>[[484, 290], [507, 440], [547, 548], [597, 703]]</point>

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

[Assistant] <point>[[243, 263], [385, 270], [507, 293], [623, 324]]</point>


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

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

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

[Assistant] <point>[[177, 301], [316, 309], [388, 340], [510, 375]]</point>

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

[Assistant] <point>[[394, 131], [319, 181], [264, 274], [214, 344], [188, 425]]</point>


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

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

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

[Assistant] <point>[[634, 112], [643, 228], [660, 390], [675, 610]]</point>

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

[Assistant] <point>[[142, 266], [185, 332], [226, 402], [261, 448]]</point>


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

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

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

[Assistant] <point>[[405, 181], [460, 239], [515, 324], [591, 463]]</point>

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

[Assistant] <point>[[368, 270], [463, 332], [495, 378], [513, 440]]</point>


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

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

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

[Assistant] <point>[[533, 178], [414, 274], [362, 363], [330, 448]]</point>

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

[Assistant] <point>[[466, 162], [527, 224], [597, 309], [669, 413], [738, 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 cheese.

[Assistant] <point>[[359, 154], [478, 239], [553, 359], [620, 502], [724, 695]]</point>

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

[Assistant] <point>[[275, 185], [431, 255], [530, 293], [637, 367], [712, 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 fork.

[Assistant] <point>[[481, 174], [507, 324], [533, 467], [556, 629]]</point>

[User]
Image-2:<image>
 You need to move the yellow cloth to the right corner.

[Assistant] <point>[[319, 502], [469, 552], [559, 598], [654, 656]]</point>


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

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

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

[Assistant] <point>[[582, 425], [472, 367], [356, 336], [310, 336]]</point>

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

[Assistant] <point>[[617, 699], [524, 637], [429, 633], [347, 622]]</point>


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

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

[Assistant] <point>[[356, 637], [434, 544], [498, 463], [597, 278]]</point>

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

[Assistant] <point>[[281, 143], [356, 178], [426, 247], [530, 355]]</point>


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

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

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

[Assistant] <point>[[542, 158], [484, 239], [443, 317], [417, 390]]</point>

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

[Assistant] <point>[[605, 629], [559, 660], [513, 699], [397, 761]]</point>


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

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

[Assistant] <point>[[156, 162], [197, 239], [217, 305], [232, 355]]</point>

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

[Assistant] <point>[[481, 301], [414, 278], [356, 297], [313, 328]]</point>


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

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

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

[Assistant] <point>[[788, 363], [649, 336], [576, 340], [420, 355]]</point>

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

[Assistant] <point>[[206, 85], [266, 185], [333, 263], [385, 324]]</point>


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

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

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

[Assistant] <point>[[159, 371], [290, 432], [362, 475], [426, 525]]</point>

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

[Assistant] <point>[[469, 328], [362, 344], [269, 394], [223, 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 reach for the oven door handle.

[Assistant] <point>[[507, 502], [539, 568], [582, 691], [591, 842]]</point>

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

[Assistant] <point>[[484, 185], [559, 251], [608, 305], [707, 436]]</point>


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

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

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

[Assistant] <point>[[365, 143], [420, 216], [481, 355], [530, 456], [611, 653]]</point>

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

[Assistant] <point>[[504, 39], [475, 178], [443, 293], [417, 429]]</point>


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

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

[Assistant] <point>[[513, 208], [458, 232], [368, 324], [310, 375]]</point>

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

[Assistant] <point>[[220, 425], [336, 402], [478, 359], [675, 317]]</point>


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

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

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

[Assistant] <point>[[489, 208], [446, 251], [359, 297], [272, 429]]</point>

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

[Assistant] <point>[[411, 324], [394, 394], [374, 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 move the spoon towards the bowl.

[Assistant] <point>[[217, 336], [359, 371], [492, 398], [631, 452]]</point>

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

[Assistant] <point>[[718, 266], [637, 301], [547, 371], [472, 448], [397, 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 pick up the spoon.

[Assistant] <point>[[469, 181], [417, 274], [382, 332], [313, 459]]</point>

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

[Assistant] <point>[[414, 452], [542, 560], [591, 625], [637, 680]]</point>


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

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

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

[Assistant] <point>[[310, 429], [469, 417], [585, 444], [770, 479]]</point>

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

[Assistant] <point>[[301, 328], [356, 444], [371, 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 approach the blue arch.

[Assistant] <point>[[429, 39], [365, 124], [301, 259], [237, 452]]</point>

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

[Assistant] <point>[[148, 174], [261, 205], [359, 278], [446, 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 place the knief on the orange towel.

[Assistant] <point>[[130, 259], [272, 355], [374, 440], [530, 598]]</point>

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

[Assistant] <point>[[391, 355], [542, 355], [654, 375], [730, 413]]</point>


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

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

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

[Assistant] <point>[[507, 143], [599, 197], [666, 309], [727, 537]]</point>

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

[Assistant] <point>[[628, 568], [582, 440], [530, 332], [472, 201]]</point>


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

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

[Assistant] <point>[[455, 328], [376, 336], [272, 355], [240, 378]]</point>

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

[Assistant] <point>[[434, 189], [472, 293], [527, 429], [597, 660]]</point>


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

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

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

[Assistant] <point>[[550, 313], [440, 355], [301, 386], [194, 425]]</point>

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

[Assistant] <point>[[125, 456], [266, 510], [397, 571], [573, 641]]</point>


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

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

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

[Assistant] <point>[[191, 232], [284, 317], [382, 394], [466, 479], [559, 598], [625, 683]]</point>

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

[Assistant] <point>[[640, 197], [672, 293], [698, 425], [718, 525]]</point>


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

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

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

[Assistant] <point>[[498, 224], [458, 266], [405, 359], [368, 456]]</point>

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

[Assistant] <point>[[385, 193], [362, 290], [342, 409], [345, 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 open the microwave door.

[Assistant] <point>[[573, 448], [472, 525], [382, 571]]</point>

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

[Assistant] <point>[[559, 205], [608, 270], [652, 336], [698, 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 place the banana next to the bottle.

[Assistant] <point>[[278, 208], [333, 363], [374, 517], [426, 649]]</point>

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

[Assistant] <point>[[559, 255], [553, 340], [576, 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 pick up the tomato.

[Assistant] <point>[[264, 174], [278, 243], [290, 305], [298, 413]]</point>

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

[Assistant] <point>[[324, 239], [408, 317], [458, 413], [504, 544]]</point>


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

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

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

[Assistant] <point>[[764, 324], [712, 402], [643, 471], [576, 541]]</point>

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

[Assistant] <point>[[261, 371], [379, 390], [513, 413], [669, 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 reach for the cloth.

[Assistant] <point>[[333, 224], [379, 359], [437, 510], [501, 668]]</point>

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

[Assistant] <point>[[611, 93], [646, 197], [672, 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 move towards the pot.

[Assistant] <point>[[313, 81], [388, 232], [466, 402], [495, 533]]</point>

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

[Assistant] <point>[[324, 147], [295, 278], [290, 390], [264, 475]]</point>


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

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

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

[Assistant] <point>[[620, 185], [495, 193], [362, 208], [266, 263]]</point>

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

[Assistant] <point>[[180, 270], [327, 290], [524, 328], [657, 382], [770, 456]]</point>


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

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

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

[Assistant] <point>[[168, 359], [281, 363], [368, 394]]</point>

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

[Assistant] <point>[[405, 336], [403, 417], [394, 537]]</point>


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

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

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

[Assistant] <point>[[220, 201], [301, 290], [374, 402], [434, 506]]</point>

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

[Assistant] <point>[[582, 62], [628, 232], [663, 371], [683, 502], [707, 672]]</point>


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

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

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

[Assistant] <point>[[330, 263], [460, 340], [536, 432], [568, 494]]</point>

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

[Assistant] <point>[[466, 344], [368, 413], [295, 486], [237, 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 bowl.

[Assistant] <point>[[371, 178], [452, 239], [565, 320], [625, 432]]</point>

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

[Assistant] <point>[[562, 483], [501, 486], [403, 506], [255, 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 place the carrot on the plate.

[Assistant] <point>[[258, 583], [362, 502], [431, 459], [533, 444]]</point>

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

[Assistant] <point>[[420, 50], [469, 154], [521, 266], [559, 375], [579, 506]]</point>


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

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

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

[Assistant] <point>[[527, 622], [475, 517], [431, 467]]</point>

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

[Assistant] <point>[[411, 336], [501, 351], [559, 367], [620, 398]]</point>


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

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

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

[Assistant] <point>[[408, 236], [316, 286], [255, 332], [171, 425]]</point>

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

[Assistant] <point>[[310, 517], [382, 421], [429, 398], [498, 371]]</point>


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

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

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

[Assistant] <point>[[495, 320], [599, 471], [672, 560], [727, 695]]</point>

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

[Assistant] <point>[[119, 224], [208, 236], [330, 317], [420, 378], [498, 432]]</point>


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

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

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

[Assistant] <point>[[281, 259], [394, 297], [513, 347], [620, 386], [704, 425]]</point>

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

[Assistant] <point>[[582, 340], [495, 371], [382, 405], [298, 425], [240, 440]]</point>


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

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

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

[Assistant] <point>[[246, 471], [356, 463], [504, 494], [594, 575], [663, 664]]</point>

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

[Assistant] <point>[[791, 432], [620, 425], [498, 417], [379, 413], [307, 413], [235, 417]]</point>


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

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

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

[Assistant] <point>[[660, 208], [614, 208], [556, 239], [518, 270], [458, 336]]</point>

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

[Assistant] <point>[[379, 23], [368, 139], [382, 332], [394, 429]]</point>


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

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

[Assistant] <point>[[180, 251], [243, 255], [327, 259], [403, 278]]</point>

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

[Assistant] <point>[[489, 208], [504, 320], [542, 402], [576, 494]]</point>


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

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

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

[Assistant] <point>[[197, 143], [226, 251], [246, 336], [272, 444], [295, 587]]</point>

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

[Assistant] <point>[[631, 309], [565, 359], [486, 421], [446, 475]]</point>


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

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

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

[Assistant] <point>[[307, 324], [385, 371], [475, 417], [553, 475]]</point>

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

[Assistant] <point>[[180, 286], [232, 340], [316, 429], [356, 486]]</point>


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

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

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

[Assistant] <point>[[463, 100], [434, 181], [411, 243], [394, 324]]</point>

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

[Assistant] <point>[[701, 293], [599, 336], [501, 371], [423, 421], [382, 475]]</point>


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

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

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

[Assistant] <point>[[229, 131], [324, 208], [455, 313], [542, 375], [701, 517]]</point>

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

[Assistant] <point>[[562, 62], [498, 97], [426, 170], [371, 239], [330, 363]]</point>


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

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

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

[Assistant] <point>[[287, 355], [345, 367], [420, 340], [495, 263]]</point>

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

[Assistant] <point>[[229, 274], [316, 305], [405, 351], [455, 425]]</point>


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

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

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

[Assistant] <point>[[290, 232], [420, 220], [527, 259], [663, 382]]</point>

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

[Assistant] <point>[[591, 475], [492, 525], [458, 579], [434, 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 reach for the cloth.

[Assistant] <point>[[550, 320], [446, 320], [278, 371], [145, 463]]</point>

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

[Assistant] <point>[[130, 490], [240, 463], [333, 444], [458, 390]]</point>


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

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

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

[Assistant] <point>[[258, 162], [388, 189], [492, 243], [599, 359]]</point>

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

[Assistant] <point>[[678, 139], [585, 185], [495, 224], [417, 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 move towards the scissors.

[Assistant] <point>[[290, 371], [495, 371], [599, 378], [701, 413], [791, 498]]</point>

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

[Assistant] <point>[[657, 139], [625, 208], [605, 324], [602, 402], [620, 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 lower towards the bowl.

[Assistant] <point>[[614, 212], [565, 259], [515, 332], [472, 409], [405, 552]]</point>

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

[Assistant] <point>[[692, 475], [608, 463], [521, 436], [455, 320]]</point>


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

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

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

[Assistant] <point>[[542, 475], [452, 425], [356, 436], [249, 475]]</point>

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

[Assistant] <point>[[96, 154], [211, 116], [290, 120], [388, 139], [458, 181], [498, 239], [550, 359]]</point>


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

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

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

[Assistant] <point>[[628, 139], [542, 162], [423, 232], [319, 417]]</point>

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

[Assistant] <point>[[365, 154], [319, 313], [307, 413], [310, 656]]</point>


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

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

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

[Assistant] <point>[[486, 340], [405, 324], [307, 344], [208, 413]]</point>

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

[Assistant] <point>[[258, 355], [304, 301], [400, 274], [481, 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 reach for the cloth.

[Assistant] <point>[[478, 8], [400, 131], [365, 255], [368, 444]]</point>

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

[Assistant] <point>[[397, 189], [513, 216], [585, 309], [657, 475]]</point>


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

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

[User]
Image-1:<image>
 You need to hold the carrot above the container.

[Assistant] <point>[[388, 448], [515, 479], [617, 541], [709, 645]]</point>

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

[Assistant] <point>[[510, 220], [565, 317], [614, 429], [643, 649]]</point>


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

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

[User]
Image-1:<image>
 You need to position the gripper above the carrot.

[Assistant] <point>[[472, 297], [492, 409], [481, 498], [446, 625]]</point>

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

[Assistant] <point>[[266, 243], [417, 266], [585, 320], [759, 432]]</point>


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

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

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

[Assistant] <point>[[559, 212], [504, 216], [449, 259], [408, 317]]</point>

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

[Assistant] <point>[[788, 290], [773, 405], [776, 521], [796, 710]]</point>


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

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

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

[Assistant] <point>[[602, 201], [568, 274], [550, 340], [573, 456]]</point>

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

[Assistant] <point>[[324, 0], [353, 85], [411, 181], [446, 332], [469, 502]]</point>


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

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

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

[Assistant] <point>[[269, 81], [371, 143], [455, 297], [495, 417], [515, 722]]</point>

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

[Assistant] <point>[[330, 131], [304, 290], [327, 421], [374, 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 fork.

[Assistant] <point>[[608, 166], [672, 259], [704, 363], [715, 568]]</point>

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

[Assistant] <point>[[327, 270], [316, 344], [301, 448], [350, 533]]</point>


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

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

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

[Assistant] <point>[[284, 50], [310, 151], [336, 270], [339, 510]]</point>

[User]
Image-2:<image>
 You need to place the clothes into the washing machine.

[Assistant] <point>[[278, 560], [426, 475], [527, 355], [617, 151]]</point>


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

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

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

[Assistant] <point>[[654, 193], [643, 255], [611, 328], [542, 413], [478, 475]]</point>

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

[Assistant] <point>[[562, 332], [463, 436], [400, 537], [391, 680]]</point>


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

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

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

[Assistant] <point>[[426, 290], [533, 359], [579, 452], [625, 691]]</point>

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

[Assistant] <point>[[620, 15], [573, 127], [521, 282], [518, 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 lower towards the pot.

[Assistant] <point>[[597, 212], [530, 297], [463, 398], [417, 537]]</point>

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

[Assistant] <point>[[316, 58], [359, 143], [385, 293], [391, 595]]</point>


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

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

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

[Assistant] <point>[[362, 425], [510, 506], [611, 506], [741, 456]]</point>

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

[Assistant] <point>[[374, 170], [298, 208], [214, 301], [148, 429]]</point>


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

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

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

[Assistant] <point>[[492, 139], [397, 151], [327, 228], [266, 371]]</point>

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

[Assistant] <point>[[513, 166], [582, 236], [620, 347], [631, 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 reach for the vegetable.

[Assistant] <point>[[469, 266], [530, 309], [562, 367], [585, 444]]</point>

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

[Assistant] <point>[[423, 247], [507, 278], [556, 344], [597, 448]]</point>


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

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

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

[Assistant] <point>[[643, 293], [582, 278], [463, 278], [368, 290], [237, 344]]</point>

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

[Assistant] <point>[[588, 297], [536, 266], [489, 251], [400, 224]]</point>


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

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

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

[Assistant] <point>[[614, 328], [634, 413], [628, 525], [582, 664]]</point>

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

[Assistant] <point>[[403, 259], [504, 320], [565, 425], [597, 541], [666, 734]]</point>


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

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

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

[Assistant] <point>[[475, 54], [542, 120], [608, 193], [666, 297], [715, 537]]</point>

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

[Assistant] <point>[[643, 452], [504, 405], [353, 409], [208, 452]]</point>


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

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

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

[Assistant] <point>[[258, 351], [405, 371], [559, 429], [709, 521]]</point>

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

[Assistant] <point>[[287, 108], [350, 151], [385, 208], [397, 328]]</point>


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

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

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

[Assistant] <point>[[362, 124], [460, 158], [556, 224], [611, 309], [681, 475]]</point>

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

[Assistant] <point>[[423, 313], [353, 324], [261, 359], [194, 463]]</point>


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

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

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

[Assistant] <point>[[469, 147], [431, 239], [411, 317], [394, 405], [379, 537]]</point>

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

[Assistant] <point>[[220, 135], [275, 205], [319, 324], [330, 552]]</point>


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

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

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

[Assistant] <point>[[226, 459], [330, 452], [501, 425], [692, 340]]</point>

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

[Assistant] <point>[[298, 270], [371, 290], [414, 340], [469, 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 scoop.

[Assistant] <point>[[608, 247], [530, 243], [431, 247], [295, 286], [214, 351]]</point>

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

[Assistant] <point>[[437, 224], [345, 270], [298, 386]]</point>


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

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

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

[Assistant] <point>[[559, 479], [652, 571], [707, 764]]</point>

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

[Assistant] <point>[[307, 270], [446, 290], [588, 290], [701, 378]]</point>


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

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

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

[Assistant] <point>[[498, 483], [431, 571], [336, 606], [223, 637]]</point>

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

[Assistant] <point>[[345, 297], [400, 413], [426, 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 pick up the spatula.

[Assistant] <point>[[235, 143], [414, 224], [533, 347], [715, 625]]</point>

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

[Assistant] <point>[[411, 197], [342, 243], [295, 332]]</point>


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

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

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

[Assistant] <point>[[429, 181], [356, 201], [313, 263], [264, 367]]</point>

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

[Assistant] <point>[[153, 444], [272, 463], [388, 479], [515, 521], [623, 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 move the pan with the red cube.

[Assistant] <point>[[678, 347], [594, 301], [533, 278], [455, 282]]</point>

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

[Assistant] <point>[[246, 174], [350, 193], [397, 278], [443, 413], [466, 606]]</point>


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

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

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

[Assistant] <point>[[177, 197], [287, 224], [431, 274], [559, 340], [689, 459]]</point>

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

[Assistant] <point>[[539, 498], [458, 471], [403, 421], [371, 317]]</point>


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

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

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

[Assistant] <point>[[298, 178], [423, 243], [527, 328], [588, 463], [620, 598]]</point>

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

[Assistant] <point>[[423, 228], [350, 205], [295, 236], [258, 328]]</point>


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

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

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

[Assistant] <point>[[246, 135], [226, 232], [235, 375], [243, 479], [281, 649]]</point>

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

[Assistant] <point>[[284, 205], [388, 205], [472, 243], [542, 290], [605, 371]]</point>


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

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

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

[Assistant] <point>[[226, 363], [339, 347], [484, 347], [625, 382], [753, 494]]</point>

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

[Assistant] <point>[[301, 112], [397, 135], [429, 189], [458, 259], [458, 305]]</point>


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

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

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

[Assistant] <point>[[637, 224], [625, 313], [631, 456], [646, 683]]</point>

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

[Assistant] <point>[[313, 247], [426, 247], [542, 274], [707, 432]]</point>