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

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

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

[Assistant] <point>[[615, 434], [492, 298], [368, 288], [291, 424]]</point>


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

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

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

[Assistant] <point>[[709, 140], [633, 193], [617, 273], [695, 368], [763, 321]]</point>

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

[Assistant] <point>[[344, 258], [367, 353], [378, 459], [376, 564]]</point>


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

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

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

[Assistant] <point>[[203, 291], [355, 368], [496, 539], [583, 722]]</point>

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

[Assistant] <point>[[583, 657], [496, 569], [427, 436], [383, 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 move towards the bottle.

[Assistant] <point>[[746, 454], [630, 459], [523, 494], [417, 551]]</point>

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

[Assistant] <point>[[718, 346], [660, 366], [626, 386], [575, 449]]</point>


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

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

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

[Assistant] <point>[[331, 150], [414, 303], [515, 561], [564, 729]]</point>


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

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

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

[Assistant] <point>[[581, 591], [470, 544], [310, 491], [201, 479], [199, 341]]</point>

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

[Assistant] <point>[[342, 170], [372, 231], [387, 291], [387, 356]]</point>


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

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

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

[Assistant] <point>[[434, 221], [436, 268], [425, 318], [383, 203]]</point>


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

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

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

[Assistant] <point>[[333, 328], [470, 301], [598, 306], [748, 338]]</point>


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

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

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

[Assistant] <point>[[147, 3], [242, 95], [333, 276], [378, 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 hover over the sushi.

[Assistant] <point>[[502, 343], [483, 301], [414, 293], [372, 326]]</point>

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

[Assistant] <point>[[53, 424], [135, 416], [220, 393], [276, 333]]</point>


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

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

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

[Assistant] <point>[[335, 135], [305, 288], [289, 409], [289, 571]]</point>

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

[Assistant] <point>[[276, 140], [400, 273], [481, 409], [549, 596]]</point>


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

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

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

[Assistant] <point>[[218, 168], [359, 248], [536, 371], [650, 471]]</point>

[User]
Image-2:<image>
 You need to slide the pan closer to the sushi roll.

[Assistant] <point>[[652, 361], [555, 318], [427, 301], [344, 308], [327, 241]]</point>


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

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

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

[Assistant] <point>[[263, 236], [363, 273], [483, 361], [517, 414]]</point>

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

[Assistant] <point>[[532, 351], [483, 421], [432, 524], [406, 629]]</point>


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

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

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

[Assistant] <point>[[393, 576], [489, 637], [586, 689], [684, 722], [729, 612]]</point>

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

[Assistant] <point>[[214, 291], [372, 346], [506, 439], [652, 576]]</point>


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

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

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

[Assistant] <point>[[357, 228], [462, 323], [558, 454], [630, 589]]</point>

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

[Assistant] <point>[[233, 311], [342, 333], [449, 446], [483, 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 move towards the pan containing broccoli.

[Assistant] <point>[[280, 303], [380, 308], [492, 343], [568, 393]]</point>

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

[Assistant] <point>[[566, 5], [643, 65], [692, 140], [731, 286]]</point>


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

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

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

[Assistant] <point>[[105, 243], [301, 383], [502, 556], [673, 747]]</point>

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

[Assistant] <point>[[310, 85], [382, 316], [419, 494], [440, 707]]</point>


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

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

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

[Assistant] <point>[[286, 133], [348, 221], [421, 361], [472, 494]]</point>

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

[Assistant] <point>[[297, 63], [374, 241], [447, 446], [492, 622]]</point>


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

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

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

[Assistant] <point>[[241, 281], [289, 236], [338, 155], [370, 93]]</point>

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

[Assistant] <point>[[459, 313], [444, 441], [447, 574], [457, 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 towards the pan containing broccoli.

[Assistant] <point>[[383, 246], [444, 444], [479, 622], [513, 832]]</point>

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

[Assistant] <point>[[549, 363], [462, 343], [385, 336], [291, 346]]</point>


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

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

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

[Assistant] <point>[[297, 303], [353, 368], [393, 444], [421, 541]]</point>

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

[Assistant] <point>[[271, 165], [278, 251], [299, 326], [329, 391]]</point>


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

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

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

[Assistant] <point>[[374, 456], [308, 469], [250, 459], [205, 431]]</point>

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

[Assistant] <point>[[558, 236], [502, 338], [451, 486], [402, 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 move the brush over the middle left of the table.

[Assistant] <point>[[297, 211], [237, 286], [186, 381], [152, 471]]</point>

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

[Assistant] <point>[[485, 261], [459, 401], [445, 509], [440, 622]]</point>


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

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

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

[Assistant] <point>[[380, 221], [430, 281], [466, 361], [492, 426]]</point>

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

[Assistant] <point>[[506, 105], [609, 271], [699, 436], [756, 576]]</point>


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

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

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

[Assistant] <point>[[541, 211], [468, 263], [391, 351], [335, 436]]</point>

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

[Assistant] <point>[[707, 411], [624, 411], [570, 398], [506, 371]]</point>


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

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

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

[Assistant] <point>[[192, 243], [338, 331], [489, 436], [622, 566]]</point>

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

[Assistant] <point>[[271, 10], [355, 153], [445, 373], [530, 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 hover over the mushroom.

[Assistant] <point>[[519, 271], [536, 341], [551, 421], [556, 489]]</point>

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

[Assistant] <point>[[588, 434], [513, 363], [440, 306], [336, 241]]</point>


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

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

[User]
Image-1:<image>
 You need to lift the bowl containing corn.

[Assistant] <point>[[628, 481], [491, 454], [344, 436], [195, 441]]</point>

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

[Assistant] <point>[[190, 404], [335, 396], [483, 416], [628, 461]]</point>


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

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

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

[Assistant] <point>[[605, 296], [523, 381], [442, 514], [387, 614]]</point>


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

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

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

[Assistant] <point>[[380, 496], [461, 576], [526, 682], [575, 805]]</point>

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

[Assistant] <point>[[551, 376], [444, 398], [323, 434], [218, 471]]</point>


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

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

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

[Assistant] <point>[[541, 311], [487, 313], [432, 301], [382, 271]]</point>

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

[Assistant] <point>[[523, 120], [536, 248], [534, 381], [523, 516]]</point>


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

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

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

[Assistant] <point>[[564, 288], [459, 291], [355, 311], [263, 351]]</point>

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

[Assistant] <point>[[282, 140], [218, 231], [165, 331], [128, 436]]</point>


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

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

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

[Assistant] <point>[[568, 496], [481, 464], [397, 446], [305, 436]]</point>

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

[Assistant] <point>[[284, 356], [415, 456], [508, 539], [622, 657]]</point>


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

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

[Assistant] <point>[[652, 431], [508, 501], [367, 586], [248, 674]]</point>

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

[Assistant] <point>[[391, 83], [398, 296], [436, 509], [481, 697]]</point>


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

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

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

[Assistant] <point>[[184, 195], [342, 263], [519, 361], [645, 461]]</point>

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

[Assistant] <point>[[521, 268], [400, 386], [280, 489], [164, 576]]</point>


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

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

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

[Assistant] <point>[[179, 273], [291, 286], [376, 303], [472, 331]]</point>

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

[Assistant] <point>[[502, 125], [609, 258], [684, 368], [767, 496]]</point>


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

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

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

[Assistant] <point>[[402, 188], [481, 251], [543, 328], [583, 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 mushroom.

[Assistant] <point>[[226, 216], [203, 283], [192, 368], [188, 456]]</point>

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

[Assistant] <point>[[199, 371], [346, 378], [492, 396], [639, 436]]</point>


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

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

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

[Assistant] <point>[[758, 83], [652, 145], [555, 216], [447, 303]]</point>

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

[Assistant] <point>[[258, 446], [209, 416], [150, 398], [88, 391]]</point>


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

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

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

[Assistant] <point>[[55, 351], [120, 398], [182, 449], [233, 499]]</point>

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

[Assistant] <point>[[759, 130], [641, 293], [558, 439], [461, 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 move towards the blueberries in the sink.

[Assistant] <point>[[372, 188], [459, 251], [530, 313], [603, 386]]</point>

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

[Assistant] <point>[[492, 98], [470, 216], [464, 313], [466, 444]]</point>


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

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

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

[Assistant] <point>[[489, 180], [380, 221], [273, 281], [158, 353]]</point>

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

[Assistant] <point>[[383, 5], [376, 140], [387, 296], [421, 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 the pan towards the cans and cloth.

[Assistant] <point>[[506, 271], [596, 331], [673, 409], [754, 496]]</point>

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

[Assistant] <point>[[180, 100], [359, 206], [524, 321], [680, 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 bowl.

[Assistant] <point>[[352, 3], [389, 128], [451, 258], [523, 378]]</point>

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

[Assistant] <point>[[111, 123], [327, 211], [521, 308], [709, 424]]</point>


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

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

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

[Assistant] <point>[[259, 138], [237, 221], [218, 336], [212, 421]]</point>

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

[Assistant] <point>[[509, 293], [400, 326], [295, 368], [182, 421]]</point>


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

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

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

[Assistant] <point>[[479, 251], [440, 301], [378, 351], [316, 381]]</point>

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

[Assistant] <point>[[553, 391], [617, 414], [695, 424], [758, 416]]</point>


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

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

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

[Assistant] <point>[[436, 246], [404, 333], [363, 419], [310, 489]]</point>

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

[Assistant] <point>[[515, 135], [464, 195], [408, 246], [331, 291]]</point>


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

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

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

[Assistant] <point>[[395, 85], [508, 183], [626, 313], [712, 426]]</point>

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

[Assistant] <point>[[645, 263], [643, 366], [637, 501], [622, 612]]</point>


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

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

[Assistant] <point>[[312, 328], [414, 353], [485, 381], [555, 426]]</point>

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

[Assistant] <point>[[64, 135], [209, 251], [301, 348], [406, 486]]</point>


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

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

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

[Assistant] <point>[[206, 107], [320, 213], [489, 303], [695, 399]]</point>

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

[Assistant] <point>[[320, 118], [379, 225], [434, 320], [463, 472]]</point>


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

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

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

[Assistant] <point>[[771, 275], [725, 433], [657, 584], [577, 725]]</point>

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

[Assistant] <point>[[565, 253], [438, 298], [350, 320], [215, 404]]</point>


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

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

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

[Assistant] <point>[[426, 28], [426, 180], [426, 320], [417, 489]]</point>

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

[Assistant] <point>[[459, 96], [455, 253], [455, 365], [430, 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 can.

[Assistant] <point>[[93, 73], [228, 264], [362, 404], [489, 528]]</point>

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

[Assistant] <point>[[624, 320], [476, 337], [362, 326], [253, 326]]</point>


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

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

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

[Assistant] <point>[[240, 298], [295, 382], [346, 461], [417, 567]]</point>

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

[Assistant] <point>[[362, 410], [295, 388], [249, 360], [177, 315]]</point>


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

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

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

[Assistant] <point>[[367, 404], [472, 528], [560, 624], [649, 753]]</point>

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

[Assistant] <point>[[312, 230], [413, 303], [522, 399], [632, 500]]</point>


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

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

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

[Assistant] <point>[[194, 152], [316, 191], [421, 208], [581, 236]]</point>

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

[Assistant] <point>[[636, 253], [573, 309], [506, 331], [426, 360]]</point>


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

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

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

[Assistant] <point>[[362, 264], [362, 376], [303, 388], [228, 472]]</point>

[User]
Image-2:<image>
 You need to place the sushi roll to the right of the spatula.

[Assistant] <point>[[308, 326], [409, 365], [485, 410], [573, 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 reach for the spatula.

[Assistant] <point>[[400, 62], [392, 140], [358, 197], [308, 247]]</point>

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

[Assistant] <point>[[362, 140], [442, 258], [480, 354], [510, 494]]</point>


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

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

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

[Assistant] <point>[[442, 567], [396, 433], [350, 287], [295, 129]]</point>

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

[Assistant] <point>[[303, 388], [232, 275], [202, 169], [126, 28]]</point>


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

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

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

[Assistant] <point>[[451, 208], [548, 258], [636, 303], [775, 399]]</point>

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

[Assistant] <point>[[729, 376], [691, 478], [666, 567], [666, 685]]</point>


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

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

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

[Assistant] <point>[[421, 225], [371, 275], [295, 320], [223, 410]]</point>

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

[Assistant] <point>[[265, 146], [371, 225], [489, 343], [624, 601]]</point>


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

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

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

[Assistant] <point>[[640, 315], [535, 247], [430, 174], [265, 84]]</point>

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

[Assistant] <point>[[396, 208], [438, 331], [497, 494], [619, 730]]</point>


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

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

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

[Assistant] <point>[[253, 73], [278, 157], [287, 230], [287, 320]]</point>


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

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

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

[Assistant] <point>[[742, 124], [695, 275], [645, 444], [590, 629]]</point>

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

[Assistant] <point>[[611, 39], [598, 174], [548, 348], [518, 545]]</point>


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

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

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

[Assistant] <point>[[253, 281], [404, 382], [527, 421], [649, 466]]</point>

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

[Assistant] <point>[[750, 292], [598, 360], [463, 433], [291, 522]]</point>


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

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

[Assistant] <point>[[105, 230], [303, 303], [480, 354], [674, 365]]</point>

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

[Assistant] <point>[[754, 39], [590, 152], [396, 320], [228, 478]]</point>


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

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

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

[Assistant] <point>[[472, 258], [421, 298], [371, 320], [303, 331]]</point>

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

[Assistant] <point>[[438, 140], [438, 258], [480, 421], [493, 612]]</point>


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

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

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

[Assistant] <point>[[417, 303], [367, 343], [299, 360], [232, 410]]</point>

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

[Assistant] <point>[[548, 230], [586, 399], [615, 590], [581, 843]]</point>


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

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

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

[Assistant] <point>[[463, 73], [472, 174], [472, 275], [468, 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 broccoli.

[Assistant] <point>[[202, 253], [303, 343], [421, 478], [518, 669]]</point>

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

[Assistant] <point>[[544, 230], [506, 337], [455, 438], [421, 556]]</point>


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

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

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

[Assistant] <point>[[228, 258], [274, 326], [312, 388], [341, 494]]</point>

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

[Assistant] <point>[[379, 494], [472, 494], [552, 478], [657, 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 reach for the green object.

[Assistant] <point>[[746, 107], [716, 202], [683, 287], [632, 449]]</point>

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

[Assistant] <point>[[362, 275], [438, 343], [506, 438], [577, 573]]</point>


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

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

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

[Assistant] <point>[[670, 230], [624, 298], [573, 354], [497, 444]]</point>

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

[Assistant] <point>[[371, 96], [371, 236], [346, 343], [312, 478]]</point>


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

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

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

[Assistant] <point>[[303, 410], [392, 388], [447, 320], [514, 287]]</point>

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

[Assistant] <point>[[497, 51], [455, 163], [421, 258], [400, 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 orange.

[Assistant] <point>[[565, 500], [438, 506], [316, 511], [126, 444]]</point>

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

[Assistant] <point>[[169, 421], [312, 466], [438, 522], [569, 567]]</point>


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

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

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

[Assistant] <point>[[392, 84], [472, 202], [577, 331], [662, 489]]</point>

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

[Assistant] <point>[[455, 270], [522, 320], [603, 365], [699, 444]]</point>


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

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

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

[Assistant] <point>[[388, 287], [463, 354], [565, 466], [712, 646]]</point>

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

[Assistant] <point>[[708, 545], [552, 494], [430, 410], [282, 326]]</point>


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

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

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

[Assistant] <point>[[430, 163], [362, 230], [278, 303], [143, 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 reach for the spoon.

[Assistant] <point>[[160, 309], [278, 326], [388, 343], [493, 331]]</point>

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

[Assistant] <point>[[506, 236], [569, 303], [640, 343], [695, 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 pan.

[Assistant] <point>[[531, 118], [506, 270], [480, 388], [447, 601]]</point>

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

[Assistant] <point>[[518, 208], [531, 331], [573, 483], [619, 736]]</point>


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

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

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

[Assistant] <point>[[303, 281], [438, 298], [590, 337], [754, 393]]</point>

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

[Assistant] <point>[[341, 320], [434, 444], [581, 596], [771, 787]]</point>


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

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

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

[Assistant] <point>[[388, 343], [379, 455], [337, 539], [282, 612]]</point>


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

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

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

[Assistant] <point>[[371, 96], [320, 208], [274, 298], [219, 433]]</point>


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

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

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

[Assistant] <point>[[147, 376], [228, 382], [282, 393], [337, 433]]</point>

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

[Assistant] <point>[[362, 84], [489, 197], [590, 309], [683, 494]]</point>


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

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

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

[Assistant] <point>[[674, 315], [544, 320], [421, 365], [303, 433]]</point>

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

[Assistant] <point>[[438, 17], [539, 174], [628, 343], [695, 579]]</point>


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

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

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

[Assistant] <point>[[581, 163], [497, 287], [400, 337], [223, 427]]</point>

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

[Assistant] <point>[[472, 163], [451, 275], [413, 399], [354, 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 green object.

[Assistant] <point>[[388, 152], [535, 242], [615, 343], [721, 376]]</point>

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

[Assistant] <point>[[261, 337], [388, 365], [480, 343], [573, 376]]</point>


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

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

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

[Assistant] <point>[[244, 298], [375, 382], [480, 438], [607, 466]]</point>

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

[Assistant] <point>[[126, 292], [236, 309], [350, 360], [438, 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 move towards the bowl containing the corn.

[Assistant] <point>[[362, 34], [362, 174], [367, 337], [362, 528]]</point>

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

[Assistant] <point>[[598, 140], [573, 388], [573, 528], [565, 713]]</point>


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

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

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

[Assistant] <point>[[371, 163], [421, 236], [514, 315], [611, 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 spatula.

[Assistant] <point>[[514, 208], [527, 320], [565, 461], [721, 702]]</point>

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

[Assistant] <point>[[754, 140], [754, 281], [729, 388], [657, 478]]</point>


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

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

[Assistant] <point>[[202, 275], [346, 331], [497, 404], [628, 478]]</point>

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

[Assistant] <point>[[223, 118], [303, 163], [388, 298], [426, 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 towards the fork.

[Assistant] <point>[[362, 135], [396, 253], [442, 410], [468, 556]]</point>

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

[Assistant] <point>[[547, 35], [618, 224], [701, 429], [732, 647]]</point>


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

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

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

[Assistant] <point>[[732, 412], [649, 371], [574, 335], [543, 400]]</point>

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

[Assistant] <point>[[202, 416], [371, 483], [501, 567], [666, 680]]</point>


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

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

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

[Assistant] <point>[[324, 129], [316, 242], [312, 343], [278, 506]]</point>

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

[Assistant] <point>[[152, 174], [308, 247], [493, 410], [539, 646]]</point>


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

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

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

[Assistant] <point>[[430, 118], [346, 213], [253, 298], [173, 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 spatula in the sink.

[Assistant] <point>[[687, 292], [662, 376], [628, 433], [535, 551]]</point>

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

[Assistant] <point>[[662, 73], [531, 202], [421, 287], [270, 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 pick up the cheese.

[Assistant] <point>[[392, 51], [371, 174], [329, 247], [274, 393]]</point>

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

[Assistant] <point>[[333, 174], [354, 292], [383, 410], [404, 590]]</point>


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

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

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

[Assistant] <point>[[261, 112], [383, 213], [506, 298], [674, 399]]</point>

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

[Assistant] <point>[[560, 421], [459, 472], [354, 500], [211, 517]]</point>


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

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

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

[Assistant] <point>[[754, 315], [632, 365], [480, 404], [278, 410]]</point>

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

[Assistant] <point>[[346, 371], [463, 399], [611, 416], [750, 433]]</point>


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

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

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

[Assistant] <point>[[337, 112], [430, 219], [506, 331], [611, 534]]</point>

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

[Assistant] <point>[[101, 230], [244, 253], [350, 275], [472, 287]]</point>


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

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

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

[Assistant] <point>[[409, 96], [371, 230], [295, 309], [236, 416]]</point>

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

[Assistant] <point>[[194, 253], [320, 360], [455, 522], [581, 725]]</point>


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

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

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

[Assistant] <point>[[885, 124], [855, 208], [843, 281], [792, 382]]</point>


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

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

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

[Assistant] <point>[[388, 51], [400, 219], [400, 337], [413, 511]]</point>

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

[Assistant] <point>[[565, 112], [539, 230], [480, 365], [417, 522]]</point>


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

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

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

[Assistant] <point>[[493, 17], [489, 174], [451, 298], [438, 416]]</point>


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

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

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

[Assistant] <point>[[455, 169], [573, 275], [670, 309], [729, 449]]</point>

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

[Assistant] <point>[[417, 6], [506, 140], [577, 253], [603, 382]]</point>


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

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

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

[Assistant] <point>[[426, 17], [535, 140], [615, 247], [670, 376]]</point>

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

[Assistant] <point>[[649, 500], [430, 416], [274, 309], [114, 242]]</point>


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

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

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

[Assistant] <point>[[287, 107], [253, 213], [198, 275], [131, 421]]</point>


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

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

[User]
Image-1:<image>
 You need to move the pot towards the bottom left corner of the table.

[Assistant] <point>[[615, 67], [426, 185], [278, 264], [131, 337]]</point>

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

[Assistant] <point>[[417, 247], [346, 315], [287, 410], [287, 489]]</point>


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

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

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

[Assistant] <point>[[160, 62], [177, 197], [177, 343], [169, 522]]</point>

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

[Assistant] <point>[[413, 197], [522, 343], [590, 489], [645, 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 for the potato in the pan.

[Assistant] <point>[[421, 56], [485, 140], [514, 208], [535, 343]]</point>

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

[Assistant] <point>[[506, 287], [611, 399], [699, 472], [775, 551]]</point>


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

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

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

[Assistant] <point>[[388, 107], [447, 230], [480, 376], [463, 534]]</point>


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

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

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

[Assistant] <point>[[497, 34], [527, 219], [514, 393], [514, 590]]</point>

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

[Assistant] <point>[[518, 416], [400, 399], [354, 337], [219, 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 reach for the spoon.

[Assistant] <point>[[261, 67], [379, 197], [497, 298], [649, 348]]</point>

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

[Assistant] <point>[[493, 152], [404, 185], [346, 242], [333, 331]]</point>


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

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

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

[Assistant] <point>[[447, 0], [447, 118], [447, 275], [413, 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 lime.

[Assistant] <point>[[80, 84], [316, 208], [518, 287], [674, 438]]</point>

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

[Assistant] <point>[[421, 444], [522, 478], [569, 494], [636, 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 microwave handle.

[Assistant] <point>[[413, 320], [548, 303], [657, 309], [737, 275]]</point>

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

[Assistant] <point>[[261, 202], [337, 253], [430, 281], [539, 320]]</point>


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

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

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

[Assistant] <point>[[404, 6], [451, 174], [560, 275], [581, 478]]</point>

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

[Assistant] <point>[[632, 208], [645, 337], [649, 449], [649, 590]]</point>


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

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

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

[Assistant] <point>[[489, 73], [489, 213], [472, 287], [421, 360]]</point>

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

[Assistant] <point>[[228, 157], [350, 298], [463, 472], [556, 843]]</point>


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

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

[Assistant] <point>[[493, 84], [548, 270], [598, 472], [640, 691]]</point>

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

[Assistant] <point>[[539, 185], [628, 292], [683, 416], [674, 590]]</point>


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

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

[User]
Image-1:<image>
 You need to move the croissant towards the lower right corner near the spoon.

[Assistant] <point>[[421, 197], [531, 410], [573, 562], [657, 747]]</point>

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

[Assistant] <point>[[581, 281], [581, 404], [581, 522], [586, 663]]</point>


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

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

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

[Assistant] <point>[[160, 101], [236, 163], [295, 242], [341, 320]]</point>


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

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

[User]
Image-1:<image>
 You need to place the cup on the front left side of the stove.

[Assistant] <point>[[270, 157], [232, 225], [198, 309], [118, 444]]</point>

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

[Assistant] <point>[[434, 320], [371, 275], [308, 264], [223, 281]]</point>


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

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

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

[Assistant] <point>[[413, 140], [497, 202], [590, 287], [691, 399]]</point>


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

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

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

[Assistant] <point>[[308, 62], [409, 163], [455, 348], [590, 640]]</point>

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

[Assistant] <point>[[135, 309], [282, 360], [480, 399], [725, 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 spoon towards the cloth.

[Assistant] <point>[[619, 399], [493, 444], [362, 466], [194, 478]]</point>

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

[Assistant] <point>[[489, 376], [615, 483], [733, 584], [860, 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 move towards the pan containing the broccoli.

[Assistant] <point>[[552, 292], [556, 449], [565, 669], [539, 843]]</point>

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

[Assistant] <point>[[522, 264], [472, 365], [417, 455], [312, 579]]</point>


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

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

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

[Assistant] <point>[[143, 230], [219, 242], [270, 258], [324, 331]]</point>

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

[Assistant] <point>[[581, 270], [581, 421], [531, 562], [438, 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 pick up the pot.

[Assistant] <point>[[624, 39], [729, 140], [813, 213], [838, 298]]</point>

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

[Assistant] <point>[[851, 135], [851, 270], [826, 466], [792, 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 pan.

[Assistant] <point>[[303, 219], [476, 275], [577, 365], [683, 421]]</point>

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

[Assistant] <point>[[413, 253], [346, 275], [257, 326], [177, 455]]</point>


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

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

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

[Assistant] <point>[[413, 275], [371, 275], [324, 275], [270, 287]]</point>


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

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

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

[Assistant] <point>[[548, 163], [548, 225], [539, 309], [522, 410]]</point>

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

[Assistant] <point>[[164, 90], [278, 275], [367, 433], [442, 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 reach for the potato.

[Assistant] <point>[[754, 112], [754, 253], [779, 348], [817, 466]]</point>

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

[Assistant] <point>[[421, 213], [362, 320], [303, 376], [198, 449]]</point>


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

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

[User]
Image-1:<image>
 You need to lift a small metal pot.

[Assistant] <point>[[430, 399], [341, 416], [244, 399], [122, 376]]</point>

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

[Assistant] <point>[[59, 382], [244, 433], [413, 438], [590, 371]]</point>


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

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

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

[Assistant] <point>[[426, 275], [426, 365], [430, 433], [434, 534]]</point>

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

[Assistant] <point>[[472, 79], [548, 107], [640, 202], [767, 275]]</point>


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

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

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

[Assistant] <point>[[261, 354], [371, 393], [455, 438], [539, 483]]</point>


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

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

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

[Assistant] <point>[[598, 242], [514, 309], [413, 343], [282, 444]]</point>

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

[Assistant] <point>[[569, 843], [628, 781], [640, 680], [649, 562]]</point>


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

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

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

[Assistant] <point>[[649, 6], [649, 51], [556, 163], [489, 230], [350, 354]]</point>

[User]
Image-2:<image>
 You need to move the cleaning brush to the left side of the countertop.

[Assistant] <point>[[295, 28], [337, 309], [350, 444], [371, 618]]</point>


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

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

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

[Assistant] <point>[[581, 331], [611, 522], [628, 618], [628, 764]]</point>

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

[Assistant] <point>[[556, 163], [518, 242], [468, 264], [421, 320]]</point>


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

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

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

[Assistant] <point>[[581, 669], [463, 438], [388, 242], [337, 56]]</point>

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

[Assistant] <point>[[687, 376], [704, 522], [674, 674], [674, 753]]</point>


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

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

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

[Assistant] <point>[[615, 118], [581, 219], [539, 309], [480, 416]]</point>


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

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

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

[Assistant] <point>[[750, 584], [792, 444], [826, 287], [872, 73]]</point>

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

[Assistant] <point>[[270, 371], [396, 371], [539, 371], [657, 315]]</point>