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

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

[Assistant] <point>[[358, 275], [489, 320], [611, 343], [725, 354]]</point>

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

[Assistant] <point>[[678, 410], [577, 287], [463, 174], [324, 39]]</point>


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

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

[User]
Image-1:<image>
 You need to place the blue spoon to the right of the red spoon.

[Assistant] <point>[[346, 197], [489, 292], [662, 365], [801, 500]]</point>

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

[Assistant] <point>[[691, 725], [649, 539], [581, 388], [514, 225]]</point>


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

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

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

[Assistant] <point>[[447, 433], [295, 388], [194, 320], [84, 208]]</point>

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

[Assistant] <point>[[628, 551], [573, 444], [506, 281], [472, 112]]</point>


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

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

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

[Assistant] <point>[[615, 399], [514, 365], [404, 348], [337, 354]]</point>


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

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

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

[Assistant] <point>[[463, 820], [497, 624], [514, 404], [480, 135]]</point>

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

[Assistant] <point>[[615, 489], [531, 388], [413, 287], [312, 185]]</point>


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

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

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

[Assistant] <point>[[362, 404], [480, 399], [607, 388], [716, 365]]</point>


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

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

[Assistant] <point>[[691, 691], [624, 511], [565, 360], [489, 146]]</point>

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

[Assistant] <point>[[497, 433], [421, 376], [350, 298], [228, 219]]</point>


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

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

[Assistant] <point>[[640, 646], [594, 489], [565, 360], [463, 169]]</point>

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

[Assistant] <point>[[544, 444], [413, 416], [282, 360], [135, 264]]</point>


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

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

[User]
Image-2:<image>
 You need to pull out the red cloth from the machine.

[Assistant] <point>[[312, 579], [421, 511], [497, 360], [565, 180]]</point>


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

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

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

[Assistant] <point>[[468, 225], [368, 151], [288, 196]]</point>


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

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

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

[Assistant] <point>[[324, 70], [615, 251], [726, 377]]</point>

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

[Assistant] <point>[[388, 299], [524, 288], [593, 380]]</point>


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

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

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

[Assistant] <point>[[329, 162], [579, 611], [592, 705]]</point>

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

[Assistant] <point>[[446, 214], [543, 443], [501, 554]]</point>


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

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

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

[Assistant] <point>[[78, 425], [213, 181], [349, 122]]</point>

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

[Assistant] <point>[[341, 103], [183, 340], [127, 643]]</point>


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

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

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

[Assistant] <point>[[476, 41], [460, 451], [557, 528]]</point>

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

[Assistant] <point>[[562, 565], [482, 244], [407, 207]]</point>


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

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

[Assistant] <point>[[341, 199], [194, 380], [144, 521]]</point>

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

[Assistant] <point>[[410, 336], [191, 392], [150, 499]]</point>


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

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

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

[Assistant] <point>[[565, 85], [706, 702], [737, 801]]</point>

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

[Assistant] <point>[[474, 698], [338, 417], [208, 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 pull the door to close it.

[Assistant] <point>[[258, 347], [510, 491], [587, 292]]</point>

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

[Assistant] <point>[[327, 377], [524, 395], [612, 440]]</point>


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

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

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

[Assistant] <point>[[338, 196], [230, 288], [205, 421]]</point>

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

[Assistant] <point>[[645, 151], [510, 595], [554, 735]]</point>


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

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

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

[Assistant] <point>[[388, 229], [349, 417], [421, 517]]</point>

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

[Assistant] <point>[[529, 240], [476, 277], [435, 314]]</point>


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

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

[Assistant] <point>[[515, 240], [576, 325], [659, 425]]</point>

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

[Assistant] <point>[[499, 199], [302, 332], [202, 447]]</point>


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

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

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

[Assistant] <point>[[402, 163], [288, 222], [238, 303]]</point>

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

[Assistant] <point>[[263, 299], [402, 270], [515, 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 spatula.

[Assistant] <point>[[565, 270], [252, 358], [152, 462]]</point>

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

[Assistant] <point>[[668, 277], [496, 495], [488, 591]]</point>


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

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

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

[Assistant] <point>[[371, 465], [454, 351], [537, 366]]</point>

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

[Assistant] <point>[[651, 288], [532, 318], [499, 410]]</point>


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

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

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

[Assistant] <point>[[532, 355], [679, 513], [695, 620]]</point>

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

[Assistant] <point>[[285, 214], [601, 550], [684, 687]]</point>


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

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

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

[Assistant] <point>[[341, 170], [568, 572], [684, 539]]</point>


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

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

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

[Assistant] <point>[[742, 462], [468, 355], [368, 380]]</point>

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

[Assistant] <point>[[260, 15], [607, 617], [698, 805]]</point>


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

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

[Assistant] <point>[[360, 299], [291, 399], [294, 524]]</point>

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

[Assistant] <point>[[512, 273], [382, 347], [296, 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 green towel.

[Assistant] <point>[[352, 129], [643, 480], [720, 705]]</point>

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

[Assistant] <point>[[499, 288], [670, 358], [745, 510]]</point>


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

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

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

[Assistant] <point>[[587, 355], [460, 432], [416, 569]]</point>

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

[Assistant] <point>[[596, 52], [355, 447], [346, 517]]</point>


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

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

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

[Assistant] <point>[[518, 192], [230, 443], [158, 561]]</point>

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

[Assistant] <point>[[197, 561], [310, 521], [404, 613]]</point>


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

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

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

[Assistant] <point>[[493, 266], [618, 288], [687, 377]]</point>

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

[Assistant] <point>[[313, 476], [543, 395], [643, 473]]</point>


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

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

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

[Assistant] <point>[[283, 107], [116, 366], [105, 495]]</point>

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

[Assistant] <point>[[288, 177], [515, 351], [560, 458]]</point>


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

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

[User]
Image-1:<image>
 You need to place a carrot to the right of the pot.

[Assistant] <point>[[457, 225], [573, 325], [579, 403]]</point>

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

[Assistant] <point>[[596, 262], [543, 524], [507, 654]]</point>


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

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

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

[Assistant] <point>[[432, 251], [307, 432], [327, 569]]</point>

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

[Assistant] <point>[[499, 196], [593, 395], [615, 491]]</point>


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

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

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

[Assistant] <point>[[717, 421], [623, 406], [573, 436]]</point>

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

[Assistant] <point>[[476, 222], [579, 591], [526, 691]]</point>


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

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

[Assistant] <point>[[321, 207], [238, 229], [205, 321]]</point>

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

[Assistant] <point>[[776, 410], [382, 432], [271, 558]]</point>


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

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

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

[Assistant] <point>[[452, 114], [601, 369], [662, 502]]</point>

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

[Assistant] <point>[[460, 262], [307, 329], [247, 465]]</point>


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

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

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

[Assistant] <point>[[507, 554], [424, 536], [416, 410]]</point>

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

[Assistant] <point>[[468, 299], [377, 251], [285, 318]]</point>


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

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

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

[Assistant] <point>[[307, 321], [230, 524], [283, 606]]</point>

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

[Assistant] <point>[[479, 126], [643, 536], [618, 669]]</point>


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

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

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

[Assistant] <point>[[565, 469], [382, 421], [335, 325]]</point>

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

[Assistant] <point>[[341, 199], [446, 251], [496, 388]]</point>


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

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

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

[Assistant] <point>[[546, 561], [717, 395], [704, 270]]</point>

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

[Assistant] <point>[[479, 163], [429, 447], [313, 561], [338, 362]]</point>


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

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

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

[Assistant] <point>[[393, 314], [598, 410], [657, 550]]</point>

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

[Assistant] <point>[[399, 181], [526, 591], [629, 639]]</point>


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

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

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

[Assistant] <point>[[380, 63], [432, 129], [404, 203]]</point>

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

[Assistant] <point>[[352, 78], [216, 229], [241, 410]]</point>


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

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

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

[Assistant] <point>[[565, 288], [402, 281], [341, 299]]</point>

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

[Assistant] <point>[[526, 48], [499, 480], [438, 635]]</point>


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

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

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

[Assistant] <point>[[524, 188], [584, 366], [562, 513]]</point>

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

[Assistant] <point>[[601, 410], [463, 421], [438, 303]]</point>


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

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

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

[Assistant] <point>[[546, 421], [432, 458], [388, 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 reach for the pan.

[Assistant] <point>[[654, 192], [454, 266], [330, 373]]</point>

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

[Assistant] <point>[[391, 303], [693, 654], [765, 827]]</point>


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

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

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

[Assistant] <point>[[100, 543], [324, 465], [355, 362]]</point>


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

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

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

[Assistant] <point>[[341, 392], [247, 421], [155, 517]]</point>

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

[Assistant] <point>[[501, 188], [485, 414], [380, 554]]</point>


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

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

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

[Assistant] <point>[[191, 48], [482, 554], [645, 565]]</point>

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

[Assistant] <point>[[321, 266], [288, 465], [399, 558]]</point>


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

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

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

[Assistant] <point>[[551, 244], [238, 369], [127, 473]]</point>

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

[Assistant] <point>[[541, 180], [458, 203], [391, 220], [334, 293]]</point>


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

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

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

[Assistant] <point>[[167, 259], [404, 403], [587, 642], [678, 868]]</point>

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

[Assistant] <point>[[551, 592], [389, 473], [277, 434], [116, 468]]</point>


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

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

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

[Assistant] <point>[[518, 33], [657, 240], [709, 366]]</point>

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

[Assistant] <point>[[626, 388], [416, 321], [299, 406]]</point>


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

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

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

[Assistant] <point>[[274, 318], [518, 399], [670, 528]]</point>


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

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

[Assistant] <point>[[302, 270], [435, 332], [546, 480]]</point>

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

[Assistant] <point>[[380, 140], [568, 476], [560, 650]]</point>


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

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

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

[Assistant] <point>[[413, 299], [294, 325], [211, 443]]</point>

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

[Assistant] <point>[[319, 295], [535, 295], [740, 392]]</point>


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

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

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

[Assistant] <point>[[391, 259], [321, 392], [219, 388]]</point>

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

[Assistant] <point>[[562, 137], [452, 284], [463, 395]]</point>


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

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

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

[Assistant] <point>[[512, 351], [596, 528], [681, 510]]</point>

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

[Assistant] <point>[[404, 181], [396, 325], [507, 432]]</point>


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

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

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

[Assistant] <point>[[438, 358], [582, 602], [604, 739]]</point>

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

[Assistant] <point>[[310, 211], [582, 440], [690, 691]]</point>


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

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

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

[Assistant] <point>[[224, 89], [427, 606], [537, 661]]</point>

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

[Assistant] <point>[[191, 417], [418, 270], [576, 229]]</point>


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

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

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

[Assistant] <point>[[535, 244], [363, 565], [402, 731]]</point>

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

[Assistant] <point>[[316, 410], [391, 343], [432, 292]]</point>


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

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

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

[Assistant] <point>[[424, 292], [590, 524], [579, 669]]</point>

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

[Assistant] <point>[[801, 454], [643, 499], [612, 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 cloth.

[Assistant] <point>[[402, 236], [269, 281], [205, 380]]</point>

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

[Assistant] <point>[[643, 85], [319, 303], [266, 403]]</point>


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

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

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

[Assistant] <point>[[382, 347], [529, 443], [568, 547]]</point>

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

[Assistant] <point>[[601, 550], [438, 480], [327, 517]]</point>


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

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

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

[Assistant] <point>[[676, 473], [540, 543], [501, 495]]</point>

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

[Assistant] <point>[[324, 380], [260, 480], [219, 451]]</point>


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

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

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

[Assistant] <point>[[244, 440], [363, 299], [357, 207], [316, 203], [330, 247]]</point>

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

[Assistant] <point>[[529, 465], [679, 414], [731, 506]]</point>


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

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

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

[Assistant] <point>[[463, 233], [687, 484], [773, 606]]</point>

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

[Assistant] <point>[[468, 170], [363, 244], [313, 325]]</point>


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

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

[Assistant] <point>[[313, 321], [355, 510], [432, 628], [465, 565]]</point>

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

[Assistant] <point>[[371, 270], [543, 340], [618, 458]]</point>


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

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

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

[Assistant] <point>[[294, 329], [363, 318], [429, 421]]</point>

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

[Assistant] <point>[[471, 277], [501, 635], [626, 709]]</point>


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

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

[Assistant] <point>[[499, 262], [496, 362], [568, 399]]</point>

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

[Assistant] <point>[[504, 111], [529, 314], [476, 458]]</point>


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

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

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

[Assistant] <point>[[587, 199], [681, 513], [643, 728]]</point>

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

[Assistant] <point>[[252, 222], [449, 295], [540, 417]]</point>


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

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

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

[Assistant] <point>[[399, 288], [551, 325], [670, 432]]</point>

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

[Assistant] <point>[[701, 177], [748, 687], [601, 750]]</point>


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

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

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

[Assistant] <point>[[274, 295], [463, 465], [518, 687]]</point>


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

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

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

[Assistant] <point>[[393, 170], [537, 572], [554, 702]]</point>


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

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

[Assistant] <point>[[576, 196], [446, 314], [368, 288]]</point>

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

[Assistant] <point>[[341, 199], [618, 576], [609, 709]]</point>


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

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

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

[Assistant] <point>[[449, 92], [310, 114], [247, 273], [316, 262]]</point>


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

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

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

[Assistant] <point>[[632, 343], [277, 451], [213, 547]]</point>


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

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

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

[Assistant] <point>[[438, 78], [504, 233], [435, 310]]</point>

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

[Assistant] <point>[[316, 244], [632, 473], [681, 624]]</point>


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

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

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

[Assistant] <point>[[296, 347], [576, 318], [668, 388]]</point>

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

[Assistant] <point>[[573, 443], [432, 480], [388, 602]]</point>


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

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

[User]
Image-1:<image>
 You need to move the cheese to the upper right corner of the table.

[Assistant] <point>[[557, 539], [609, 661], [695, 639], [767, 513], [665, 595]]</point>

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

[Assistant] <point>[[319, 321], [457, 476], [518, 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 avocado towards the pot.

[Assistant] <point>[[454, 310], [332, 425], [269, 369]]</point>

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

[Assistant] <point>[[416, 476], [598, 425], [748, 513]]</point>


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

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

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

[Assistant] <point>[[410, 458], [607, 325], [742, 380]]</point>

[User]
Image-2:<image>
 You need to pick up a piece of clothing from the basket.

[Assistant] <point>[[537, 569], [435, 713], [335, 728]]</point>


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

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

[User]
Image-1:<image>
 You need to place the clothing inside the washing machine.

[Assistant] <point>[[324, 731], [449, 739], [540, 502], [548, 351], [482, 462]]</point>

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

[Assistant] <point>[[693, 307], [562, 436], [479, 410]]</point>


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

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

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

[Assistant] <point>[[355, 336], [460, 469], [440, 584]]</point>

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

[Assistant] <point>[[446, 247], [493, 436], [393, 521]]</point>


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

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

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

[Assistant] <point>[[255, 233], [161, 314], [202, 425]]</point>

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

[Assistant] <point>[[452, 151], [598, 539], [687, 536]]</point>


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

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

[Assistant] <point>[[440, 358], [271, 395], [199, 502]]</point>

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

[Assistant] <point>[[659, 214], [501, 244], [377, 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 the spoon towards the towel.

[Assistant] <point>[[432, 273], [626, 521], [609, 724]]</point>

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

[Assistant] <point>[[416, 284], [551, 451], [579, 598]]</point>


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

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

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

[Assistant] <point>[[551, 613], [452, 624], [440, 510]]</point>

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

[Assistant] <point>[[413, 620], [535, 598], [551, 473]]</point>


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

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

[User]
Image-2:<image>
 You need to approach the pan containing a mushroom.

[Assistant] <point>[[432, 609], [573, 484], [596, 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 move towards the container.

[Assistant] <point>[[418, 355], [360, 591], [263, 628]]</point>

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

[Assistant] <point>[[640, 81], [571, 484], [690, 635]]</point>


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

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

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

[Assistant] <point>[[410, 635], [535, 484], [618, 502]]</point>

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

[Assistant] <point>[[515, 281], [449, 395], [368, 406]]</point>


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

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

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

[Assistant] <point>[[576, 465], [440, 392], [360, 403]]</point>


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

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

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

[Assistant] <point>[[693, 236], [712, 380], [604, 462]]</point>

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

[Assistant] <point>[[609, 421], [427, 336], [349, 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 pot.

[Assistant] <point>[[432, 303], [515, 436], [537, 584]]</point>

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

[Assistant] <point>[[280, 177], [449, 440], [479, 602]]</point>


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

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

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

[Assistant] <point>[[330, 277], [449, 462], [488, 617]]</point>

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

[Assistant] <point>[[504, 454], [482, 676], [560, 720]]</point>


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

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

[Assistant] <point>[[432, 295], [562, 447], [590, 602]]</point>

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

[Assistant] <point>[[227, 318], [532, 325], [687, 428]]</point>


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

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

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

[Assistant] <point>[[302, 332], [418, 255], [499, 251]]</point>

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

[Assistant] <point>[[288, 181], [188, 380], [133, 414]]</point>


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

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

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

[Assistant] <point>[[590, 177], [366, 325], [271, 406]]</point>

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

[Assistant] <point>[[706, 137], [579, 565], [662, 672]]</point>


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

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

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

[Assistant] <point>[[341, 247], [657, 617], [693, 768]]</point>

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

[Assistant] <point>[[734, 436], [604, 329], [612, 229]]</point>


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

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

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

[Assistant] <point>[[839, 521], [717, 661], [659, 643]]</point>


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

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

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

[Assistant] <point>[[474, 436], [319, 495], [183, 428]]</point>

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

[Assistant] <point>[[562, 307], [765, 284], [798, 166]]</point>


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

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

[Assistant] <point>[[673, 325], [562, 532], [598, 694]]</point>

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

[Assistant] <point>[[410, 181], [374, 414], [399, 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 the pot.

[Assistant] <point>[[380, 384], [562, 458], [623, 399]]</point>

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

[Assistant] <point>[[607, 233], [607, 332], [673, 392]]</point>


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

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

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

[Assistant] <point>[[355, 122], [449, 657], [579, 698]]</point>


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

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

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

[Assistant] <point>[[632, 358], [488, 458], [521, 628]]</point>


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

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

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

[Assistant] <point>[[573, 211], [482, 266], [427, 406]]</point>

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

[Assistant] <point>[[377, 488], [499, 373], [573, 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 place the bowl on the blue towel.

[Assistant] <point>[[296, 325], [352, 454], [296, 561]]</point>

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

[Assistant] <point>[[413, 244], [399, 436], [449, 528]]</point>


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

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

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

[Assistant] <point>[[568, 369], [382, 384], [310, 295]]</point>


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

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

[Assistant] <point>[[371, 307], [435, 343], [518, 499]]</point>

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

[Assistant] <point>[[499, 118], [524, 443], [435, 628]]</point>


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

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

[User]
Image-1:<image>
 You need to pick up a piece of clothing from the basket.

[Assistant] <point>[[427, 281], [393, 532], [316, 650]]</point>

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

[Assistant] <point>[[343, 705], [584, 447], [618, 277]]</point>


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

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

[Assistant] <point>[[294, 159], [294, 244], [363, 266]]</point>

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

[Assistant] <point>[[357, 129], [299, 403], [172, 476]]</point>


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

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

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

[Assistant] <point>[[227, 207], [579, 524], [645, 709]]</point>

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

[Assistant] <point>[[914, 174], [565, 185], [501, 277]]</point>


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

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

[Assistant] <point>[[357, 303], [537, 513], [607, 665]]</point>

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

[Assistant] <point>[[817, 166], [740, 332], [839, 469]]</point>


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

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

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

[Assistant] <point>[[476, 211], [227, 332], [144, 462]]</point>


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

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

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

[Assistant] <point>[[150, 432], [565, 624], [662, 794]]</point>

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

[Assistant] <point>[[435, 211], [512, 273], [524, 380]]</point>


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

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

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

[Assistant] <point>[[488, 587], [593, 314], [745, 251]]</point>

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

[Assistant] <point>[[413, 207], [615, 680], [742, 702]]</point>


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

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

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

[Assistant] <point>[[438, 114], [587, 366], [670, 499]]</point>

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

[Assistant] <point>[[524, 369], [399, 373], [391, 318]]</point>


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

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

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

[Assistant] <point>[[261, 70], [284, 248], [323, 436], [378, 624]]</point>


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

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

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

[Assistant] <point>[[367, 591], [485, 602], [598, 596], [705, 564]]</point>

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

[Assistant] <point>[[145, 331], [301, 401], [432, 489], [562, 591]]</point>


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

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

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

[Assistant] <point>[[647, 393], [662, 454], [682, 519], [709, 561]]</point>

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

[Assistant] <point>[[430, 185], [523, 288], [615, 401], [695, 521]]</point>


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

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

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

[Assistant] <point>[[515, 308], [442, 311], [363, 331], [297, 373]]</point>

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

[Assistant] <point>[[273, 358], [383, 404], [479, 459], [588, 541]]</point>


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

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

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

[Assistant] <point>[[239, 368], [383, 445], [503, 555], [602, 670]]</point>

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

[Assistant] <point>[[486, 319], [379, 291], [247, 341], [165, 456]]</point>


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

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

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

[Assistant] <point>[[198, 418], [284, 423], [338, 489], [375, 621]]</point>

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

[Assistant] <point>[[222, 402], [343, 432], [489, 437], [636, 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 refrigerator handle.

[Assistant] <point>[[203, 540], [369, 606], [517, 646], [676, 667]]</point>

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

[Assistant] <point>[[210, 366], [366, 379], [523, 409], [688, 462]]</point>


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

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

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

[Assistant] <point>[[463, 178], [371, 228], [261, 317], [200, 494]]</point>

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

[Assistant] <point>[[53, 216], [256, 343], [438, 516], [553, 704]]</point>


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

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

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

[Assistant] <point>[[523, 316], [611, 361], [679, 419], [724, 474]]</point>


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

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

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

[Assistant] <point>[[660, 336], [549, 341], [438, 368], [306, 421]]</point>

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

[Assistant] <point>[[419, 158], [491, 221], [555, 301], [607, 383]]</point>


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

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

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

[Assistant] <point>[[414, 596], [320, 571], [233, 561], [143, 561]]</point>


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

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

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

[Assistant] <point>[[643, 411], [560, 461], [485, 519], [427, 594]]</point>

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

[Assistant] <point>[[376, 93], [327, 221], [273, 378], [231, 531]]</point>


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

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

[Assistant] <point>[[370, 30], [305, 125], [212, 301], [156, 461]]</point>

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

[Assistant] <point>[[410, 5], [477, 195], [528, 386], [568, 586]]</point>


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

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

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

[Assistant] <point>[[111, 486], [254, 529], [408, 594], [556, 677]]</point>


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

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

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

[Assistant] <point>[[216, 153], [382, 203], [568, 278], [763, 371]]</point>

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

[Assistant] <point>[[461, 291], [483, 459], [496, 669], [500, 857]]</point>


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

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

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

[Assistant] <point>[[656, 108], [489, 201], [368, 291], [211, 436]]</point>

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

[Assistant] <point>[[267, 135], [331, 228], [387, 326], [445, 439]]</point>


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

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

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

[Assistant] <point>[[466, 175], [414, 281], [342, 381], [276, 436]]</point>

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

[Assistant] <point>[[466, 228], [370, 263], [286, 313], [192, 396]]</point>


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

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

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

[Assistant] <point>[[378, 193], [444, 343], [519, 556], [562, 747]]</point>


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

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

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

[Assistant] <point>[[222, 120], [271, 246], [303, 376], [331, 499]]</point>


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

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

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

[Assistant] <point>[[673, 208], [600, 266], [543, 333], [485, 429]]</point>

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

[Assistant] <point>[[423, 70], [368, 165], [301, 253], [212, 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 microwave handle.

[Assistant] <point>[[410, 5], [506, 130], [641, 256], [782, 333]]</point>

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

[Assistant] <point>[[301, 286], [318, 414], [321, 494], [314, 591]]</point>


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

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

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

[Assistant] <point>[[321, 288], [457, 456], [553, 602], [650, 777]]</point>

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

[Assistant] <point>[[628, 33], [682, 243], [727, 464], [769, 737]]</point>


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

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

[Assistant] <point>[[684, 426], [592, 489], [519, 554], [451, 642]]</point>

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

[Assistant] <point>[[720, 138], [703, 213], [673, 306], [632, 381]]</point>


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

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

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

[Assistant] <point>[[560, 667], [577, 602], [605, 544], [647, 499]]</point>

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

[Assistant] <point>[[447, 201], [393, 276], [353, 361], [323, 466]]</point>


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

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

[Assistant] <point>[[306, 446], [398, 449], [504, 494], [594, 566]]</point>

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

[Assistant] <point>[[425, 298], [549, 343], [639, 391], [739, 469]]</point>


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

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

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

[Assistant] <point>[[746, 416], [643, 391], [558, 378], [461, 378]]</point>

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

[Assistant] <point>[[479, 5], [427, 85], [393, 170], [374, 268]]</point>


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

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

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

[Assistant] <point>[[357, 175], [361, 293], [376, 421], [402, 531]]</point>

[User]
Image-2:<image>
 You need to position above the hotdog bun.

[Assistant] <point>[[372, 213], [494, 288], [615, 398], [703, 511]]</point>


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

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

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

[Assistant] <point>[[639, 211], [583, 356], [539, 541], [517, 709]]</point>


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

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

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

[Assistant] <point>[[372, 501], [410, 429], [451, 383], [515, 356]]</point>

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

[Assistant] <point>[[462, 343], [534, 341], [598, 343], [658, 371]]</point>