TSPTW/TSPTW_M_context.json

[
  {
    "task_name": "TSPTW",
    "problem_type": "TSPTW",
    "instruction": "Someone on the morning shift needs to draw up a delivery route that leaves from the depot, goes to every customer exactly one time during that customer’s allowed delivery window, and comes back to the depot; it’s okay to pause and wait if a place isn’t open yet. The deciding factor is how few miles the whole circuit uses — simply add up the distances between consecutive stops to see which plan uses less driving. Every customer must be visited once, and the exact stops and time windows are shown below.\n\nThere are 11 locations (including depot 0); list each stop with coordinates and its allowed arrival window:\nStop 0 at (0, 0), available from 0 to 1067.\nStop 1 at (7, 3), available from 145 to 431.\nStop 2 at (13, 28), available from 284 to 536.\nStop 3 at (12, 72), available from 60 to 269.\nStop 4 at (4, 84), available from 22 to 300.\nStop 5 at (28, 59), available from 233 to 495.\nStop 6 at (56, 100), available from 7 to 296.\nStop 7 at (68, 100), available from 322 to 537.\nStop 8 at (68, 27), available from 70 to 282.\nStop 9 at (83, 100), available from 118 to 362.\nStop 10 at (100, 82), available from 167 to 389.\nThe route must start and end at 0 and visit every location within its time window.\n\nOh, and when you reply with a candidate route, please use this simple JSON shape so it's easy to read and check:\n\n{\n  \"solution\": [depot_id, location_id, ..., depot_id]\n}\n\nHere \"solution\" is just the ordered list of stops: start at the depot, visit every customer once (in the order shown in the array), and finish back at the depot. Think of the bits in brackets as a form where you list the stop identifiers in travel order — it's just a sketch of the shape I need, not the actual route.\n\nPlease be sure to use the exact identifiers from the instance input — do not rename them or invent new labels. \n- for example: \"Valid identifiers look like plain numbers such as “1” or “23”, single capital letters like “A” or “B”, or a capital letter followed by digits like “A1” or “X7”.\"",
    "instance": {
      "coordinates": [
        [
          0,
          0
        ],
        [
          7,
          3
        ],
        [
          13,
          28
        ],
        [
          12,
          72
        ],
        [
          4,
          84
        ],
        [
          28,
          59
        ],
        [
          56,
          100
        ],
        [
          68,
          100
        ],
        [
          68,
          27
        ],
        [
          83,
          100
        ],
        [
          100,
          82
        ]
      ],
      "depot": 0,
      "num_nodes": 11,
      "time_windows": [
        [
          0,
          1067
        ],
        [
          145,
          431
        ],
        [
          284,
          536
        ],
        [
          60,
          269
        ],
        [
          22,
          300
        ],
        [
          233,
          495
        ],
        [
          7,
          296
        ],
        [
          322,
          537
        ],
        [
          70,
          282
        ],
        [
          118,
          362
        ],
        [
          167,
          389
        ]
      ],
      "tour_length": 469.37699024953946,
      "objective": 469.37699024953946
    },
    "solution": [
      0,
      8,
      1,
      3,
      4,
      6,
      7,
      9,
      10,
      5,
      2,
      0
    ],
    "obj": 469.37699024953946,
    "instance_variant": {
      "problem_type": "TSPTW",
      "num_nodes": 11,
      "nodes": [
        {
          "id": 0,
          "x": 0,
          "y": 0,
          "tw_start": 0,
          "tw_end": 1067
        },
        {
          "id": 1,
          "x": 7,
          "y": 3,
          "tw_start": 145,
          "tw_end": 431
        },
        {
          "id": 2,
          "x": 13,
          "y": 28,
          "tw_start": 284,
          "tw_end": 536
        },
        {
          "id": 3,
          "x": 12,
          "y": 72,
          "tw_start": 60,
          "tw_end": 269
        },
        {
          "id": 4,
          "x": 4,
          "y": 84,
          "tw_start": 22,
          "tw_end": 300
        },
        {
          "id": 5,
          "x": 28,
          "y": 59,
          "tw_start": 233,
          "tw_end": 495
        },
        {
          "id": 6,
          "x": 56,
          "y": 100,
          "tw_start": 7,
          "tw_end": 296
        },
        {
          "id": 7,
          "x": 68,
          "y": 100,
          "tw_start": 322,
          "tw_end": 537
        },
        {
          "id": 8,
          "x": 68,
          "y": 27,
          "tw_start": 70,
          "tw_end": 282
        },
        {
          "id": 9,
          "x": 83,
          "y": 100,
          "tw_start": 118,
          "tw_end": 362
        },
        {
          "id": 10,
          "x": 100,
          "y": 82,
          "tw_start": 167,
          "tw_end": 389
        }
      ],
      "depot": 0,
      "objective": 469.37699024953946
    },
    "solution_variant": [
      0,
      8,
      1,
      3,
      4,
      6,
      7,
      9,
      10,
      5,
      2,
      0
    ],
    "context_index": 1,
    "input_format": "nl",
    "input_index_base": 0
  },
  {
    "task_name": "TSPTW",
    "problem_type": "TSPTW",
    "instruction": "We have a supervisor who needs one round trip from the depot that hits every piece of equipment exactly once, arriving to each site only during its allowed arrival period, and then returns to the depot. The decision is which route and sequence to follow so those arrival intervals are met. What makes one route better than another is simple: the one with the smallest total travel distance wins — calculate that by summing the distances between each stop in the trip (including leaving from and returning to the garage). Waiting at a site until its window opens is allowed, but it doesn’t reduce the miles driven. The concrete details are listed below.\n\n# total_locations_including_garage=11\n# depot_node_id=A\n# time windows are listed per node in the table\nsite_id,x_coord,y_coord,earliest_arrival_time,latest_arrival_time\nA,76,66,0,1067\nB,0,25,237,444\nC,12,54,113,342\nD,53,10,176,447\nE,43,64,77,321\nF,71,0,229,428\nG,98,90,235,446\nH,100,100,25,311\nI,93,8,374,647\nJ,28,0,118,321\nK,88,46,265,502\n\nOh, and when you send the route back, please put it in this simple JSON shape so I can read it easily:\n\n{\n  \"solution\": [garage_id, site_id, ..., garage_id]\n}\n\nThis just means \"solution\" should be an ordered list showing the trip: start at the garage_id, visit each site_id once in the order you choose, and finish back at the garage_id. It's just a sketch of the shape I need, not your actual answer.\n\nPlease be careful to use the exact identifiers from the instance input — don't rename them or invent new labels. \n- for example: \"Valid identifiers look like plain numbers such as “1” or “23”, single capital letters like “A” or “B”, or a capital letter followed by digits like “A1” or “X7”.\"",
    "instance": {
      "coordinates": [
        [
          76,
          66
        ],
        [
          0,
          25
        ],
        [
          12,
          54
        ],
        [
          53,
          10
        ],
        [
          43,
          64
        ],
        [
          71,
          0
        ],
        [
          98,
          90
        ],
        [
          100,
          100
        ],
        [
          93,
          8
        ],
        [
          28,
          0
        ],
        [
          88,
          46
        ]
      ],
      "depot": 0,
      "num_nodes": 11,
      "time_windows": [
        [
          0,
          1067
        ],
        [
          237,
          444
        ],
        [
          113,
          342
        ],
        [
          176,
          447
        ],
        [
          77,
          321
        ],
        [
          229,
          428
        ],
        [
          235,
          446
        ],
        [
          25,
          311
        ],
        [
          374,
          647
        ],
        [
          118,
          321
        ],
        [
          265,
          502
        ]
      ],
      "tour_length": 494.8005635056315,
      "objective": 494.8005635056315
    },
    "solution": [
      0,
      7,
      4,
      2,
      1,
      9,
      3,
      5,
      10,
      6,
      8,
      0
    ],
    "obj": 494.8005635056315,
    "instance_variant": {
      "problem_type": "TSPTW",
      "num_nodes": 11,
      "nodes": [
        {
          "id": "A",
          "x": 76,
          "y": 66,
          "tw_start": 0,
          "tw_end": 1067
        },
        {
          "id": "B",
          "x": 0,
          "y": 25,
          "tw_start": 237,
          "tw_end": 444
        },
        {
          "id": "C",
          "x": 12,
          "y": 54,
          "tw_start": 113,
          "tw_end": 342
        },
        {
          "id": "D",
          "x": 53,
          "y": 10,
          "tw_start": 176,
          "tw_end": 447
        },
        {
          "id": "E",
          "x": 43,
          "y": 64,
          "tw_start": 77,
          "tw_end": 321
        },
        {
          "id": "F",
          "x": 71,
          "y": 0,
          "tw_start": 229,
          "tw_end": 428
        },
        {
          "id": "G",
          "x": 98,
          "y": 90,
          "tw_start": 235,
          "tw_end": 446
        },
        {
          "id": "H",
          "x": 100,
          "y": 100,
          "tw_start": 25,
          "tw_end": 311
        },
        {
          "id": "I",
          "x": 93,
          "y": 8,
          "tw_start": 374,
          "tw_end": 647
        },
        {
          "id": "J",
          "x": 28,
          "y": 0,
          "tw_start": 118,
          "tw_end": 321
        },
        {
          "id": "K",
          "x": 88,
          "y": 46,
          "tw_start": 265,
          "tw_end": 502
        }
      ],
      "depot": "A",
      "objective": 494.8005635056315
    },
    "solution_variant": [
      "A",
      "H",
      "E",
      "C",
      "B",
      "J",
      "D",
      "F",
      "K",
      "G",
      "I",
      "A"
    ],
    "context_index": 2,
    "input_format": "csv",
    "input_index_base": "names"
  },
  {
    "task_name": "TSPTW",
    "problem_type": "TSPTW",
    "instruction": "Early on weekday mornings a routine takes shape: start at the house, drop off at school, stop at scheduled activities, and end back at the house, making sure each stop is visited once and only during its permitted time range. The choice is the order of stops — different orders change arrival times and miles driven, and the best order is the one that produces the smallest total miles driven. To get that number, add up the miles between each successive stop in the plan and include the final leg home; pausing to wait for a place to open is allowed. The concrete schedule and locations are shown below.\n\n{\n  \"total_stops_including_home\": 14,\n  \"nodes\": [\n    {\n      \"stop_id\": 1,\n      \"map_x_coordinate\": 4,\n      \"map_y_coordinate\": 89,\n      \"earliest_allowed_arrival\": 0,\n      \"latest_allowed_arrival\": 1067\n    },\n    {\n      \"stop_id\": 2,\n      \"map_x_coordinate\": 4,\n      \"map_y_coordinate\": 100,\n      \"earliest_allowed_arrival\": 47,\n      \"latest_allowed_arrival\": 289\n    },\n    {\n      \"stop_id\": 3,\n      \"map_x_coordinate\": 0,\n      \"map_y_coordinate\": 89,\n      \"earliest_allowed_arrival\": 13,\n      \"latest_allowed_arrival\": 295\n    },\n    {\n      \"stop_id\": 4,\n      \"map_x_coordinate\": 0,\n      \"map_y_coordinate\": 14,\n      \"earliest_allowed_arrival\": 100,\n      \"latest_allowed_arrival\": 358\n    },\n    {\n      \"stop_id\": 5,\n      \"map_x_coordinate\": 0,\n      \"map_y_coordinate\": 24,\n      \"earliest_allowed_arrival\": 120,\n      \"latest_allowed_arrival\": 365\n    },\n    {\n      \"stop_id\": 6,\n      \"map_x_coordinate\": 12,\n      \"map_y_coordinate\": 30,\n      \"earliest_allowed_arrival\": 212,\n      \"latest_allowed_arrival\": 424\n    },\n    {\n      \"stop_id\": 7,\n      \"map_x_coordinate\": 71,\n      \"map_y_coordinate\": 59,\n      \"earliest_allowed_arrival\": 376,\n      \"latest_allowed_arrival\": 645\n    },\n    {\n      \"stop_id\": 8,\n      \"map_x_coordinate\": 76,\n      \"map_y_coordinate\": 27,\n      \"earliest_allowed_arrival\": 364,\n      \"latest_allowed_arrival\": 645\n    },\n    {\n      \"stop_id\": 9,\n      \"map_x_coordinate\": 24,\n      \"map_y_coordinate\": 14,\n      \"earliest_allowed_arrival\": 231,\n      \"latest_allowed_arrival\": 515\n    },\n    {\n      \"stop_id\": 10,\n      \"map_x_coordinate\": 37,\n      \"map_y_coordinate\": 24,\n      \"earliest_allowed_arrival\": 34,\n      \"latest_allowed_arrival\": 247\n    },\n    {\n      \"stop_id\": 11,\n      \"map_x_coordinate\": 47,\n      \"map_y_coordinate\": 38,\n      \"earliest_allowed_arrival\": 17,\n      \"latest_allowed_arrival\": 243\n    },\n    {\n      \"stop_id\": 12,\n      \"map_x_coordinate\": 47,\n      \"map_y_coordinate\": 11,\n      \"earliest_allowed_arrival\": 150,\n      \"latest_allowed_arrival\": 371\n    },\n    {\n      \"stop_id\": 13,\n      \"map_x_coordinate\": 76,\n      \"map_y_coordinate\": 0,\n      \"earliest_allowed_arrival\": 321,\n      \"latest_allowed_arrival\": 550\n    },\n    {\n      \"stop_id\": 14,\n      \"map_x_coordinate\": 100,\n      \"map_y_coordinate\": 11,\n      \"earliest_allowed_arrival\": 109,\n      \"latest_allowed_arrival\": 355\n    }\n  ],\n  \"home_node_id\": 1\n}\n\nIf you want the plan in a simple machine-friendly form, just give it in this little JSON shape so it's easy to read and check:\n\n{\n  \"solution\": [\"home_id\", \"stop_id\", \"...\", \"home_id\"]\n}\n\nHere \"solution\" is the ordered list of place IDs — start at home, list each stop once in the order you'll visit them, and finish back at home. Think of it like filling in the blanks on a form: the first and last entry are your home/depot, and the items in between are the stops in visit order. This is just a sketch of the shape I expect, not the actual route.\n\nPlease make sure to use the exact identifiers from the instance input — don't rename them or add new labels.\n- for example: \"Valid identifiers look like plain numbers such as “1” or “23”, single capital letters like “A” or “B”, or a capital letter followed by digits like “A1” or “X7”.\"",
    "instance": {
      "coordinates": [
        [
          4,
          89
        ],
        [
          4,
          100
        ],
        [
          0,
          89
        ],
        [
          0,
          14
        ],
        [
          0,
          24
        ],
        [
          12,
          30
        ],
        [
          71,
          59
        ],
        [
          76,
          27
        ],
        [
          24,
          14
        ],
        [
          37,
          24
        ],
        [
          47,
          38
        ],
        [
          47,
          11
        ],
        [
          76,
          0
        ],
        [
          100,
          11
        ]
      ],
      "depot": 0,
      "num_nodes": 14,
      "time_windows": [
        [
          0,
          1067
        ],
        [
          47,
          289
        ],
        [
          13,
          295
        ],
        [
          100,
          358
        ],
        [
          120,
          365
        ],
        [
          212,
          424
        ],
        [
          376,
          645
        ],
        [
          364,
          645
        ],
        [
          231,
          515
        ],
        [
          34,
          247
        ],
        [
          17,
          243
        ],
        [
          150,
          371
        ],
        [
          321,
          550
        ],
        [
          109,
          355
        ]
      ],
      "tour_length": 396.7418477596823,
      "objective": 396.7418477596823
    },
    "solution": [
      0,
      2,
      1,
      10,
      9,
      5,
      4,
      3,
      8,
      11,
      12,
      13,
      7,
      6,
      0
    ],
    "obj": 396.7418477596823,
    "instance_variant": {
      "problem_type": "TSPTW",
      "num_nodes": 14,
      "nodes": [
        {
          "id": 1,
          "x": 4,
          "y": 89,
          "tw_start": 0,
          "tw_end": 1067
        },
        {
          "id": 2,
          "x": 4,
          "y": 100,
          "tw_start": 47,
          "tw_end": 289
        },
        {
          "id": 3,
          "x": 0,
          "y": 89,
          "tw_start": 13,
          "tw_end": 295
        },
        {
          "id": 4,
          "x": 0,
          "y": 14,
          "tw_start": 100,
          "tw_end": 358
        },
        {
          "id": 5,
          "x": 0,
          "y": 24,
          "tw_start": 120,
          "tw_end": 365
        },
        {
          "id": 6,
          "x": 12,
          "y": 30,
          "tw_start": 212,
          "tw_end": 424
        },
        {
          "id": 7,
          "x": 71,
          "y": 59,
          "tw_start": 376,
          "tw_end": 645
        },
        {
          "id": 8,
          "x": 76,
          "y": 27,
          "tw_start": 364,
          "tw_end": 645
        },
        {
          "id": 9,
          "x": 24,
          "y": 14,
          "tw_start": 231,
          "tw_end": 515
        },
        {
          "id": 10,
          "x": 37,
          "y": 24,
          "tw_start": 34,
          "tw_end": 247
        },
        {
          "id": 11,
          "x": 47,
          "y": 38,
          "tw_start": 17,
          "tw_end": 243
        },
        {
          "id": 12,
          "x": 47,
          "y": 11,
          "tw_start": 150,
          "tw_end": 371
        },
        {
          "id": 13,
          "x": 76,
          "y": 0,
          "tw_start": 321,
          "tw_end": 550
        },
        {
          "id": 14,
          "x": 100,
          "y": 11,
          "tw_start": 109,
          "tw_end": 355
        }
      ],
      "depot": 1,
      "objective": 396.7418477596823
    },
    "solution_variant": [
      1,
      3,
      2,
      11,
      10,
      6,
      5,
      4,
      9,
      12,
      13,
      14,
      8,
      7,
      1
    ],
    "context_index": 3,
    "input_format": "json",
    "input_index_base": 1
  },
  {
    "task_name": "TSPTW",
    "problem_type": "TSPTW",
    "instruction": "At the flower shop the planner’s job is to arrange the same-day delivery run: start and finish at the shop, visit each address one time only, arrive within each recipient’s specified time period (it’s okay to pause and wait if arriving early), and keep the overall driving down. A wiser choice of order is the one that produces the smallest total kilometers driven — you work that out by summing the distances between each leg of the trip, including coming back to the shop. Nothing can be skipped or repeated, and every delivery must fit its time window. The specific stops, distances and time windows are listed below.\n\nThere are 11 stops including the shop A; each stop's coordinates and allowed arrival window are listed one per line below.\nStop A: coordinates (0, 38), arrival window 0 - 1067.\nStop B: coordinates (9, 97), arrival window 54 - 326.\nStop C: coordinates (12, 90), arrival window 28 - 318.\nStop D: coordinates (12, 37), arrival window 299 - 512.\nStop E: coordinates (26, 90), arrival window 2 - 275.\nStop F: coordinates (46, 100), arrival window 274 - 538.\nStop G: coordinates (56, 0), arrival window 299 - 500.\nStop H: coordinates (74, 35), arrival window 139 - 344.\nStop I: coordinates (75, 35), arrival window 334 - 589.\nStop J: coordinates (95, 41), arrival window 128 - 328.\nStop K: coordinates (100, 3), arrival window 120 - 346.\nVisit every stop once, start and finish at A, and make the route for all 11 stops fit their time windows while keeping total kilometers minimal.\n\nWhen you hand over the final delivery order, just pop it into this simple JSON layout so it's easy to read and process:\n\n{\n  \"solution\": [depot_id, location_id, ..., depot_id]\n}\n\nThink of \"solution\" as the ordered list of stops — start at the shop (depot), visit every address once, and come back to the shop at the end. The placeholders in the array are where you put the exact stop identifiers from the instance. This JSON is only a sketch of the shape I expect, not the actual route.\n\nPlease make sure you use the identifiers exactly as they appear in the instance input — no renaming and no new labels. For example: \"Valid identifiers look like plain numbers such as “1” or “23”, single capital letters like “A” or “B”, or a capital letter followed by digits like “A1” or “X7”.\"",
    "instance": {
      "coordinates": [
        [
          0,
          38
        ],
        [
          9,
          97
        ],
        [
          12,
          90
        ],
        [
          12,
          37
        ],
        [
          26,
          90
        ],
        [
          46,
          100
        ],
        [
          56,
          0
        ],
        [
          74,
          35
        ],
        [
          75,
          35
        ],
        [
          95,
          41
        ],
        [
          100,
          3
        ]
      ],
      "depot": 0,
      "num_nodes": 11,
      "time_windows": [
        [
          0,
          1067
        ],
        [
          54,
          326
        ],
        [
          28,
          318
        ],
        [
          299,
          512
        ],
        [
          2,
          275
        ],
        [
          274,
          538
        ],
        [
          299,
          500
        ],
        [
          139,
          344
        ],
        [
          334,
          589
        ],
        [
          128,
          328
        ],
        [
          120,
          346
        ]
      ],
      "tour_length": 441.5893717762156,
      "objective": 441.5893717762156
    },
    "solution": [
      0,
      2,
      1,
      4,
      9,
      10,
      6,
      7,
      8,
      5,
      3,
      0
    ],
    "obj": 441.5893717762156,
    "instance_variant": {
      "problem_type": "TSPTW",
      "num_nodes": 11,
      "nodes": [
        {
          "id": "A",
          "x": 0,
          "y": 38,
          "tw_start": 0,
          "tw_end": 1067
        },
        {
          "id": "B",
          "x": 9,
          "y": 97,
          "tw_start": 54,
          "tw_end": 326
        },
        {
          "id": "C",
          "x": 12,
          "y": 90,
          "tw_start": 28,
          "tw_end": 318
        },
        {
          "id": "D",
          "x": 12,
          "y": 37,
          "tw_start": 299,
          "tw_end": 512
        },
        {
          "id": "E",
          "x": 26,
          "y": 90,
          "tw_start": 2,
          "tw_end": 275
        },
        {
          "id": "F",
          "x": 46,
          "y": 100,
          "tw_start": 274,
          "tw_end": 538
        },
        {
          "id": "G",
          "x": 56,
          "y": 0,
          "tw_start": 299,
          "tw_end": 500
        },
        {
          "id": "H",
          "x": 74,
          "y": 35,
          "tw_start": 139,
          "tw_end": 344
        },
        {
          "id": "I",
          "x": 75,
          "y": 35,
          "tw_start": 334,
          "tw_end": 589
        },
        {
          "id": "J",
          "x": 95,
          "y": 41,
          "tw_start": 128,
          "tw_end": 328
        },
        {
          "id": "K",
          "x": 100,
          "y": 3,
          "tw_start": 120,
          "tw_end": 346
        }
      ],
      "depot": "A",
      "objective": 441.5893717762156
    },
    "solution_variant": [
      "A",
      "C",
      "B",
      "E",
      "J",
      "K",
      "G",
      "H",
      "I",
      "F",
      "D",
      "A"
    ],
    "context_index": 4,
    "input_format": "nl",
    "input_index_base": "names"
  },
  {
    "task_name": "TSPTW",
    "problem_type": "TSPTW",
    "instruction": "There’s an inspector route to plan: leave the office, visit every property one time, respect each property’s allowed inspection period, and return to the same office at the end. The only leeway is waiting until a property’s window opens, and the better route is the one with the smallest total travel distance — calculated by summing the distances between all the successive stops on the loop — and the specific stops and windows are shown below.\n\nThe plan covers 12 locations, with the office as 1:\n\n| location_id | x_coordinate | y_coordinate | earliest_arrival_time | latest_arrival_time |\n|---|---|---|---|---|\n| 1 | 71 | 0 | 0 | 1067 |\n| 2 | 0 | 9 | 283 | 538 |\n| 3 | 20 | 19 | 344 | 584 |\n| 4 | 100 | 21 | 46 | 309 |\n| 5 | 66 | 36 | 295 | 543 |\n| 6 | 92 | 37 | 299 | 541 |\n| 7 | 56 | 38 | 202 | 438 |\n| 8 | 75 | 55 | 9 | 214 |\n| 9 | 50 | 88 | 12 | 267 |\n| 10 | 93 | 94 | 121 | 365 |\n| 11 | 58 | 97 | 352 | 570 |\n| 12 | 41 | 100 | 159 | 426 |\n\nReturn to the office 1 after visiting all 12 locations; wait if necessary until windows open, and prefer the route with the smallest total travel distance.\n\nWhen you send the planned route back, just use this simple JSON layout so it's easy to check automatically:\n\n{\n  \"solution\": [office_id, property_id, ..., office_id]\n}\n\nThis just says: \"solution\" is the ordered loop — start at the office_id, list each property_id in the order you visit them, and come back to the same office_id at the end. The \"...\" means all the other stops go in between. It's just a sketch of the shape I need, not the actual route.\n\nPlease use the exact identifiers from the instance input — don't rename them or invent new labels.  \n- for example: \"Valid identifiers look like plain numbers such as “1” or “23”, single capital letters like “A” or “B”, or a capital letter followed by digits like “A1” or “X7”.\"",
    "instance": {
      "coordinates": [
        [
          71,
          0
        ],
        [
          0,
          9
        ],
        [
          20,
          19
        ],
        [
          100,
          21
        ],
        [
          66,
          36
        ],
        [
          92,
          37
        ],
        [
          56,
          38
        ],
        [
          75,
          55
        ],
        [
          50,
          88
        ],
        [
          93,
          94
        ],
        [
          58,
          97
        ],
        [
          41,
          100
        ]
      ],
      "depot": 0,
      "num_nodes": 12,
      "time_windows": [
        [
          0,
          1067
        ],
        [
          283,
          538
        ],
        [
          344,
          584
        ],
        [
          46,
          309
        ],
        [
          295,
          543
        ],
        [
          299,
          541
        ],
        [
          202,
          438
        ],
        [
          9,
          214
        ],
        [
          12,
          267
        ],
        [
          121,
          365
        ],
        [
          352,
          570
        ],
        [
          159,
          426
        ]
      ],
      "tour_length": 494.28669025875394,
      "objective": 494.28669025875394
    },
    "solution": [
      0,
      3,
      7,
      6,
      8,
      11,
      9,
      10,
      5,
      4,
      2,
      1,
      0
    ],
    "obj": 494.28669025875394,
    "instance_variant": {
      "problem_type": "TSPTW",
      "num_nodes": 12,
      "nodes": [
        {
          "id": 1,
          "x": 71,
          "y": 0,
          "tw_start": 0,
          "tw_end": 1067
        },
        {
          "id": 2,
          "x": 0,
          "y": 9,
          "tw_start": 283,
          "tw_end": 538
        },
        {
          "id": 3,
          "x": 20,
          "y": 19,
          "tw_start": 344,
          "tw_end": 584
        },
        {
          "id": 4,
          "x": 100,
          "y": 21,
          "tw_start": 46,
          "tw_end": 309
        },
        {
          "id": 5,
          "x": 66,
          "y": 36,
          "tw_start": 295,
          "tw_end": 543
        },
        {
          "id": 6,
          "x": 92,
          "y": 37,
          "tw_start": 299,
          "tw_end": 541
        },
        {
          "id": 7,
          "x": 56,
          "y": 38,
          "tw_start": 202,
          "tw_end": 438
        },
        {
          "id": 8,
          "x": 75,
          "y": 55,
          "tw_start": 9,
          "tw_end": 214
        },
        {
          "id": 9,
          "x": 50,
          "y": 88,
          "tw_start": 12,
          "tw_end": 267
        },
        {
          "id": 10,
          "x": 93,
          "y": 94,
          "tw_start": 121,
          "tw_end": 365
        },
        {
          "id": 11,
          "x": 58,
          "y": 97,
          "tw_start": 352,
          "tw_end": 570
        },
        {
          "id": 12,
          "x": 41,
          "y": 100,
          "tw_start": 159,
          "tw_end": 426
        }
      ],
      "depot": 1,
      "objective": 494.28669025875394
    },
    "solution_variant": [
      1,
      4,
      8,
      7,
      9,
      12,
      10,
      11,
      6,
      5,
      3,
      2,
      1
    ],
    "context_index": 5,
    "input_format": "markdown_table",
    "input_index_base": 1
  },
  {
    "task_name": "TSPTW",
    "problem_type": "TSPTW",
    "instruction": "There’s a vaccination team leader sketching out a route that leaves the clinic, goes to each community stop once within its assigned access window, and then comes back to base — arriving early and waiting for a site to open is okay. What makes a route preferable is how short the total drive is: add up the distance between each pair of consecutive stops (and the return to the clinic) and the smallest total wins. No site can be skipped or revisited, and the specific locations and windows are listed below.\n\nThey number 11, with clinic 0 as the tour start and end.\nStop 0 is at (0, 9), with access window 0 to 1067.\nStop 1 is at (7, 4), with access window 88 to 290.\nStop 2 is at (33, 84), with access window 112 to 322.\nStop 3 is at (45, 0), with access window 360 to 633.\nStop 4 is at (47, 26), with access window 245 to 524.\nStop 5 is at (51, 100), with access window 311 to 523.\nStop 6 is at (56, 41), with access window 346 to 592.\nStop 7 is at (66, 25), with access window 313 to 594.\nStop 8 is at (68, 41), with access window 123 to 328.\nStop 9 is at (80, 94), with access window 88 to 323.\nStop 10 is at (100, 61), with access window 317 to 594.\nThe leader will plan a loop visiting all 11 sites and returning to 0.\n\nOh, and when you send back the planned route, a casual little JSON shape like this is perfect — just a list that starts at the clinic, visits each stop once, and comes back to the clinic.\n\n{\n  \"solution\": [clinic_id, stop_id, ..., clinic_id]\n}\n\nHere \"solution\" is the tour: the sequence of place identifiers you plan to visit in order, starting and ending at the clinic and including every community stop exactly once. Think of it like filling out a short form: just drop the sequence of IDs in the array in the order the team will drive them. This example is only a sketch of the expected shape — not the actual answer.\n\nPlease be sure to use the identifiers exactly as they appear in the instance input — do not rename them or invent new labels.\n- for example: \"Valid identifiers look like plain numbers such as “1” or “23”, single capital letters like “A” or “B”, or a capital letter followed by digits like “A1” or “X7”.\"",
    "instance": {
      "coordinates": [
        [
          0,
          9
        ],
        [
          7,
          4
        ],
        [
          33,
          84
        ],
        [
          45,
          0
        ],
        [
          47,
          26
        ],
        [
          51,
          100
        ],
        [
          56,
          41
        ],
        [
          66,
          25
        ],
        [
          68,
          41
        ],
        [
          80,
          94
        ],
        [
          100,
          61
        ]
      ],
      "depot": 0,
      "num_nodes": 11,
      "time_windows": [
        [
          0,
          1067
        ],
        [
          88,
          290
        ],
        [
          112,
          322
        ],
        [
          360,
          633
        ],
        [
          245,
          524
        ],
        [
          311,
          523
        ],
        [
          346,
          592
        ],
        [
          313,
          594
        ],
        [
          123,
          328
        ],
        [
          88,
          323
        ],
        [
          317,
          594
        ]
      ],
      "tour_length": 426.89566818704435,
      "objective": 426.89566818704435
    },
    "solution": [
      0,
      1,
      8,
      9,
      2,
      5,
      10,
      7,
      6,
      4,
      3,
      0
    ],
    "obj": 426.89566818704435,
    "instance_variant": {
      "problem_type": "TSPTW",
      "num_nodes": 11,
      "nodes": [
        {
          "id": 0,
          "x": 0,
          "y": 9,
          "tw_start": 0,
          "tw_end": 1067
        },
        {
          "id": 1,
          "x": 7,
          "y": 4,
          "tw_start": 88,
          "tw_end": 290
        },
        {
          "id": 2,
          "x": 33,
          "y": 84,
          "tw_start": 112,
          "tw_end": 322
        },
        {
          "id": 3,
          "x": 45,
          "y": 0,
          "tw_start": 360,
          "tw_end": 633
        },
        {
          "id": 4,
          "x": 47,
          "y": 26,
          "tw_start": 245,
          "tw_end": 524
        },
        {
          "id": 5,
          "x": 51,
          "y": 100,
          "tw_start": 311,
          "tw_end": 523
        },
        {
          "id": 6,
          "x": 56,
          "y": 41,
          "tw_start": 346,
          "tw_end": 592
        },
        {
          "id": 7,
          "x": 66,
          "y": 25,
          "tw_start": 313,
          "tw_end": 594
        },
        {
          "id": 8,
          "x": 68,
          "y": 41,
          "tw_start": 123,
          "tw_end": 328
        },
        {
          "id": 9,
          "x": 80,
          "y": 94,
          "tw_start": 88,
          "tw_end": 323
        },
        {
          "id": 10,
          "x": 100,
          "y": 61,
          "tw_start": 317,
          "tw_end": 594
        }
      ],
      "depot": 0,
      "objective": 426.89566818704435
    },
    "solution_variant": [
      0,
      1,
      8,
      9,
      2,
      5,
      10,
      7,
      6,
      4,
      3,
      0
    ],
    "context_index": 6,
    "input_format": "nl",
    "input_index_base": 0
  },
  {
    "task_name": "TSPTW",
    "problem_type": "TSPTW",
    "instruction": "Someone juggling portrait sessions must plan a one-day loop: leave the studio, visit every client location once and during its booked time window, and finish back at the studio. What makes one plan better than another is simply how little driving it requires — add up all the travel legs (including the final leg back) and pick the route with the smallest total — and arriving early is okay since waiting for the slot to start is allowed. The concrete schedule and distances are shown below.\n\n# total_locations_including_studio=14\n# studio_node_id=A\n# time windows are listed per node in the table\nlocation_id,location_x_coord,location_y_coord,booking_start_time,booking_end_time\nA,24,0,0,1067\nB,31,0,2,246\nC,19,15,161,377\nD,8,15,46,273\nE,0,25,365,591\nF,16,29,201,463\nG,32,29,141,429\nH,48,43,373,591\nI,59,56,192,416\nJ,16,70,110,308\nK,100,84,236,479\nL,18,95,19,241\nM,11,99,352,569\nN,33,100,56,297\n\nIf you'd like to hand me a proposed route, just pop it into this little JSON shape so it's easy to read and check:\n\n{\n  \"solution\": [studio_id, client_id, ..., studio_id]\n}\n\nThink of it like a short form: \"solution\" is the ordered list of stops — start at the studio, visit each client once in the order shown, and finish back at the studio. The placeholders are just that (a sketch of the shape I want), so replace studio_id and client_id with the actual stop identifiers from the instance when you submit a route.\n\nPlease make sure you use the exact identifiers from the instance input — no renaming and no new labels. Valid identifiers look like plain numbers such as “1” or “23”, single capital letters like “A” or “B”, or a capital letter followed by digits like “A1” or “X7”.",
    "instance": {
      "coordinates": [
        [
          24,
          0
        ],
        [
          31,
          0
        ],
        [
          19,
          15
        ],
        [
          8,
          15
        ],
        [
          0,
          25
        ],
        [
          16,
          29
        ],
        [
          32,
          29
        ],
        [
          48,
          43
        ],
        [
          59,
          56
        ],
        [
          16,
          70
        ],
        [
          100,
          84
        ],
        [
          18,
          95
        ],
        [
          11,
          99
        ],
        [
          33,
          100
        ]
      ],
      "depot": 0,
      "num_nodes": 14,
      "time_windows": [
        [
          0,
          1067
        ],
        [
          2,
          246
        ],
        [
          161,
          377
        ],
        [
          46,
          273
        ],
        [
          365,
          591
        ],
        [
          201,
          463
        ],
        [
          141,
          429
        ],
        [
          373,
          591
        ],
        [
          192,
          416
        ],
        [
          110,
          308
        ],
        [
          236,
          479
        ],
        [
          19,
          241
        ],
        [
          352,
          569
        ],
        [
          56,
          297
        ]
      ],
      "tour_length": 528.7374899856832,
      "objective": 528.7374899856832
    },
    "solution": [
      0,
      1,
      3,
      9,
      11,
      13,
      10,
      8,
      6,
      2,
      5,
      4,
      12,
      7,
      0
    ],
    "obj": 528.7374899856832,
    "instance_variant": {
      "problem_type": "TSPTW",
      "num_nodes": 14,
      "nodes": [
        {
          "id": "A",
          "x": 24,
          "y": 0,
          "tw_start": 0,
          "tw_end": 1067
        },
        {
          "id": "B",
          "x": 31,
          "y": 0,
          "tw_start": 2,
          "tw_end": 246
        },
        {
          "id": "C",
          "x": 19,
          "y": 15,
          "tw_start": 161,
          "tw_end": 377
        },
        {
          "id": "D",
          "x": 8,
          "y": 15,
          "tw_start": 46,
          "tw_end": 273
        },
        {
          "id": "E",
          "x": 0,
          "y": 25,
          "tw_start": 365,
          "tw_end": 591
        },
        {
          "id": "F",
          "x": 16,
          "y": 29,
          "tw_start": 201,
          "tw_end": 463
        },
        {
          "id": "G",
          "x": 32,
          "y": 29,
          "tw_start": 141,
          "tw_end": 429
        },
        {
          "id": "H",
          "x": 48,
          "y": 43,
          "tw_start": 373,
          "tw_end": 591
        },
        {
          "id": "I",
          "x": 59,
          "y": 56,
          "tw_start": 192,
          "tw_end": 416
        },
        {
          "id": "J",
          "x": 16,
          "y": 70,
          "tw_start": 110,
          "tw_end": 308
        },
        {
          "id": "K",
          "x": 100,
          "y": 84,
          "tw_start": 236,
          "tw_end": 479
        },
        {
          "id": "L",
          "x": 18,
          "y": 95,
          "tw_start": 19,
          "tw_end": 241
        },
        {
          "id": "M",
          "x": 11,
          "y": 99,
          "tw_start": 352,
          "tw_end": 569
        },
        {
          "id": "N",
          "x": 33,
          "y": 100,
          "tw_start": 56,
          "tw_end": 297
        }
      ],
      "depot": "A",
      "objective": 528.7374899856832
    },
    "solution_variant": [
      "A",
      "B",
      "D",
      "J",
      "L",
      "N",
      "K",
      "I",
      "G",
      "C",
      "F",
      "E",
      "M",
      "H",
      "A"
    ],
    "context_index": 7,
    "input_format": "csv",
    "input_index_base": "names"
  },
  {
    "task_name": "TSPTW",
    "problem_type": "TSPTW",
    "instruction": "Recently the crew schedule required a single-van tour that starts and ends at the depot, visits each customer property only once during its allowed service period, and avoids unnecessary back-and-forth. The winning route is the one with the smallest total driving distance, which you find by summing the distances of each leg of the trip; arriving early and waiting until a service window opens is allowed. The specific addresses, service windows and travel lengths are shown below.\n\n# total_locations=15\n# depot_node_id=1\n# time windows are listed per node in the table\nlocation_id,coord_x,coord_y,service_window_start,service_window_end\n1,2,76,0,1067\n2,44,50,382,599\n3,54,38,260,528\n4,61,36,92,356\n5,70,74,142,398\n6,100,27,245,491\n7,70,4,35,310\n8,35,2,124,336\n9,64,24,15,267\n10,0,60,262,458\n11,64,9,198,414\n12,69,100,250,461\n13,45,6,268,499\n14,30,51,363,570\n15,85,0,132,337\n\nWhen you send back the chosen tour, just use this simple JSON layout so it's easy to check:\n\n{\n  \"solution\": [depot_id, location_id, ..., depot_id]\n}\n\nThis shows the shape I need: \"solution\" is the ordered list of stops — start at the depot, list each customer once in the order you'll visit them, and finish back at the depot. The snippet above is just a sketch of the format, not the actual route.\n\nPlease use the exact identifiers from the instance input when you fill that array — do not rename them or invent new labels. For example: Valid identifiers look like plain numbers such as “1” or “23”, single capital letters like “A” or “B”, or a capital letter followed by digits like “A1” or “X7”.",
    "instance": {
      "coordinates": [
        [
          2,
          76
        ],
        [
          44,
          50
        ],
        [
          54,
          38
        ],
        [
          61,
          36
        ],
        [
          70,
          74
        ],
        [
          100,
          27
        ],
        [
          70,
          4
        ],
        [
          35,
          2
        ],
        [
          64,
          24
        ],
        [
          0,
          60
        ],
        [
          64,
          9
        ],
        [
          69,
          100
        ],
        [
          45,
          6
        ],
        [
          30,
          51
        ],
        [
          85,
          0
        ]
      ],
      "depot": 0,
      "num_nodes": 15,
      "time_windows": [
        [
          0,
          1067
        ],
        [
          382,
          599
        ],
        [
          260,
          528
        ],
        [
          92,
          356
        ],
        [
          142,
          398
        ],
        [
          245,
          491
        ],
        [
          35,
          310
        ],
        [
          124,
          336
        ],
        [
          15,
          267
        ],
        [
          262,
          458
        ],
        [
          198,
          414
        ],
        [
          250,
          461
        ],
        [
          268,
          499
        ],
        [
          363,
          570
        ],
        [
          132,
          337
        ]
      ],
      "tour_length": 536.36529539223,
      "objective": 536.36529539223
    },
    "solution": [
      0,
      3,
      8,
      7,
      10,
      6,
      14,
      5,
      4,
      11,
      9,
      12,
      2,
      1,
      13,
      0
    ],
    "obj": 536.36529539223,
    "instance_variant": {
      "problem_type": "TSPTW",
      "num_nodes": 15,
      "nodes": [
        {
          "id": 1,
          "x": 2,
          "y": 76,
          "tw_start": 0,
          "tw_end": 1067
        },
        {
          "id": 2,
          "x": 44,
          "y": 50,
          "tw_start": 382,
          "tw_end": 599
        },
        {
          "id": 3,
          "x": 54,
          "y": 38,
          "tw_start": 260,
          "tw_end": 528
        },
        {
          "id": 4,
          "x": 61,
          "y": 36,
          "tw_start": 92,
          "tw_end": 356
        },
        {
          "id": 5,
          "x": 70,
          "y": 74,
          "tw_start": 142,
          "tw_end": 398
        },
        {
          "id": 6,
          "x": 100,
          "y": 27,
          "tw_start": 245,
          "tw_end": 491
        },
        {
          "id": 7,
          "x": 70,
          "y": 4,
          "tw_start": 35,
          "tw_end": 310
        },
        {
          "id": 8,
          "x": 35,
          "y": 2,
          "tw_start": 124,
          "tw_end": 336
        },
        {
          "id": 9,
          "x": 64,
          "y": 24,
          "tw_start": 15,
          "tw_end": 267
        },
        {
          "id": 10,
          "x": 0,
          "y": 60,
          "tw_start": 262,
          "tw_end": 458
        },
        {
          "id": 11,
          "x": 64,
          "y": 9,
          "tw_start": 198,
          "tw_end": 414
        },
        {
          "id": 12,
          "x": 69,
          "y": 100,
          "tw_start": 250,
          "tw_end": 461
        },
        {
          "id": 13,
          "x": 45,
          "y": 6,
          "tw_start": 268,
          "tw_end": 499
        },
        {
          "id": 14,
          "x": 30,
          "y": 51,
          "tw_start": 363,
          "tw_end": 570
        },
        {
          "id": 15,
          "x": 85,
          "y": 0,
          "tw_start": 132,
          "tw_end": 337
        }
      ],
      "depot": 1,
      "objective": 536.36529539223
    },
    "solution_variant": [
      1,
      4,
      9,
      8,
      11,
      7,
      15,
      6,
      5,
      12,
      10,
      13,
      3,
      2,
      14,
      1
    ],
    "context_index": 8,
    "input_format": "csv",
    "input_index_base": 1
  },
  {
    "task_name": "TSPTW",
    "problem_type": "TSPTW",
    "instruction": "Many people on the tour team have wrestled with the same homework: start at headquarters, go to each venue once during its agreed time window, and return to headquarters, all while trying to keep driving to a minimum. The decision is the order of stops; a better choice is the route with the lowest total driving distance — simply add up the distances for all legs of the trip — and it’s allowed to hang around and wait if a venue’s window hasn’t started yet. No stop can be skipped or revisited, and arrival times must respect the windows. The exact itinerary data appears below.\n\nThere are 13 locations in total — the headquarters is node 0.\nNode 0 at (0, 24) must be visited within [0, 1067].\nNode 1 at (6, 24) must be visited within [1, 211].\nNode 2 at (14, 61) must be visited within [212, 474].\nNode 3 at (12, 88) must be visited within [252, 468].\nNode 4 at (35, 41) must be visited within [276, 493].\nNode 5 at (40, 10) must be visited within [126, 392].\nNode 6 at (40, 75) must be visited within [252, 528].\nNode 7 at (60, 83) must be visited within [255, 504].\nNode 8 at (72, 88) must be visited within [36, 266].\nNode 9 at (74, 0) must be visited within [102, 320].\nNode 10 at (96, 100) must be visited within [377, 609].\nNode 11 at (100, 67) must be visited within [346, 601].\nNode 12 at (100, 66) must be visited within [308, 551].\nUse these records to construct a route that starts and ends at node 0 and visits all 13 locations within their time windows.\n\nYou can just send the planned route back in a tiny JSON snippet like this:\n\n{\n  \"solution\": [hq_id, venue_id, ..., hq_id]\n}\n\nThis just means: put the ordered list of stops under \"solution\" — start with the HQ identifier, list each venue once in the visit order, and end with the HQ identifier again. The placeholders above are just showing the shape (hq_id is the depot/headquarters; venue_id stands for each visit location; \"...\" means the rest of the stops in between). Treat it like a simple form, not a full report.\n\nReminder: that JSON is only a sketch of the shape I expect, not the actual route. Use the exact identifiers from the instance input — don't rename them or invent new labels. \n- for example: \"Valid identifiers look like plain numbers such as “1” or “23”, single capital letters like “A” or “B”, or a capital letter followed by digits like “A1” or “X7”.\"",
    "instance": {
      "coordinates": [
        [
          0,
          24
        ],
        [
          6,
          24
        ],
        [
          14,
          61
        ],
        [
          12,
          88
        ],
        [
          35,
          41
        ],
        [
          40,
          10
        ],
        [
          40,
          75
        ],
        [
          60,
          83
        ],
        [
          72,
          88
        ],
        [
          74,
          0
        ],
        [
          96,
          100
        ],
        [
          100,
          67
        ],
        [
          100,
          66
        ]
      ],
      "depot": 0,
      "num_nodes": 13,
      "time_windows": [
        [
          0,
          1067
        ],
        [
          1,
          211
        ],
        [
          212,
          474
        ],
        [
          252,
          468
        ],
        [
          276,
          493
        ],
        [
          126,
          392
        ],
        [
          252,
          528
        ],
        [
          255,
          504
        ],
        [
          36,
          266
        ],
        [
          102,
          320
        ],
        [
          377,
          609
        ],
        [
          346,
          601
        ],
        [
          308,
          551
        ]
      ],
      "tour_length": 514.0430018876883,
      "objective": 514.0430018876883
    },
    "solution": [
      0,
      1,
      5,
      9,
      8,
      7,
      6,
      3,
      2,
      4,
      12,
      11,
      10,
      0
    ],
    "obj": 514.0430018876883,
    "instance_variant": {
      "problem_type": "TSPTW",
      "num_nodes": 13,
      "nodes": [
        {
          "id": 0,
          "x": 0,
          "y": 24,
          "tw_start": 0,
          "tw_end": 1067
        },
        {
          "id": 1,
          "x": 6,
          "y": 24,
          "tw_start": 1,
          "tw_end": 211
        },
        {
          "id": 2,
          "x": 14,
          "y": 61,
          "tw_start": 212,
          "tw_end": 474
        },
        {
          "id": 3,
          "x": 12,
          "y": 88,
          "tw_start": 252,
          "tw_end": 468
        },
        {
          "id": 4,
          "x": 35,
          "y": 41,
          "tw_start": 276,
          "tw_end": 493
        },
        {
          "id": 5,
          "x": 40,
          "y": 10,
          "tw_start": 126,
          "tw_end": 392
        },
        {
          "id": 6,
          "x": 40,
          "y": 75,
          "tw_start": 252,
          "tw_end": 528
        },
        {
          "id": 7,
          "x": 60,
          "y": 83,
          "tw_start": 255,
          "tw_end": 504
        },
        {
          "id": 8,
          "x": 72,
          "y": 88,
          "tw_start": 36,
          "tw_end": 266
        },
        {
          "id": 9,
          "x": 74,
          "y": 0,
          "tw_start": 102,
          "tw_end": 320
        },
        {
          "id": 10,
          "x": 96,
          "y": 100,
          "tw_start": 377,
          "tw_end": 609
        },
        {
          "id": 11,
          "x": 100,
          "y": 67,
          "tw_start": 346,
          "tw_end": 601
        },
        {
          "id": 12,
          "x": 100,
          "y": 66,
          "tw_start": 308,
          "tw_end": 551
        }
      ],
      "depot": 0,
      "objective": 514.0430018876883
    },
    "solution_variant": [
      0,
      1,
      5,
      9,
      8,
      7,
      6,
      3,
      2,
      4,
      12,
      11,
      10,
      0
    ],
    "context_index": 9,
    "input_format": "nl",
    "input_index_base": 0
  },
  {
    "task_name": "TSPTW",
    "problem_type": "TSPTW",
    "instruction": "Many people count on the mobile library, so the planner must lay out a single route that leaves the branch, visits every community stop once within its visiting window, and returns to the branch afterward. The idea is to pick the order that results in the least overall driving — compute that by adding up the distance of each leg from stop to stop and back home — and early arrivals can wait until a place opens. The detailed stops and their hours are listed below.\n\n{\n  \"total_stops_including_branch\": 12,\n  \"nodes\": [\n    {\n      \"stop_id\": 1,\n      \"coordinate_x\": 3,\n      \"coordinate_y\": 1,\n      \"visit_window_start\": 0,\n      \"visit_window_end\": 1067\n    },\n    {\n      \"stop_id\": 2,\n      \"coordinate_x\": 59,\n      \"coordinate_y\": 0,\n      \"visit_window_start\": 223,\n      \"visit_window_end\": 465\n    },\n    {\n      \"stop_id\": 3,\n      \"coordinate_x\": 81,\n      \"coordinate_y\": 0,\n      \"visit_window_start\": 75,\n      \"visit_window_end\": 339\n    },\n    {\n      \"stop_id\": 4,\n      \"coordinate_x\": 87,\n      \"coordinate_y\": 5,\n      \"visit_window_start\": 108,\n      \"visit_window_end\": 305\n    },\n    {\n      \"stop_id\": 5,\n      \"coordinate_x\": 85,\n      \"coordinate_y\": 18,\n      \"visit_window_start\": 250,\n      \"visit_window_end\": 461\n    },\n    {\n      \"stop_id\": 6,\n      \"coordinate_x\": 89,\n      \"coordinate_y\": 41,\n      \"visit_window_start\": 364,\n      \"visit_window_end\": 651\n    },\n    {\n      \"stop_id\": 7,\n      \"coordinate_x\": 94,\n      \"coordinate_y\": 43,\n      \"visit_window_start\": 354,\n      \"visit_window_end\": 584\n    },\n    {\n      \"stop_id\": 8,\n      \"coordinate_x\": 8,\n      \"coordinate_y\": 61,\n      \"visit_window_start\": 5,\n      \"visit_window_end\": 290\n    },\n    {\n      \"stop_id\": 9,\n      \"coordinate_x\": 100,\n      \"coordinate_y\": 76,\n      \"visit_window_start\": 166,\n      \"visit_window_end\": 453\n    },\n    {\n      \"stop_id\": 10,\n      \"coordinate_x\": 85,\n      \"coordinate_y\": 90,\n      \"visit_window_start\": 373,\n      \"visit_window_end\": 650\n    },\n    {\n      \"stop_id\": 11,\n      \"coordinate_x\": 85,\n      \"coordinate_y\": 83,\n      \"visit_window_start\": 114,\n      \"visit_window_end\": 345\n    },\n    {\n      \"stop_id\": 12,\n      \"coordinate_x\": 0,\n      \"coordinate_y\": 100,\n      \"visit_window_start\": 330,\n      \"visit_window_end\": 554\n    }\n  ],\n  \"branch_node_id\": 1\n}\n\nYou can just hand the route back in a tiny JSON snippet like this — an ordered list that starts and ends at the branch:\n\n{\n  \"solution\": [branch_id, stop_id, ..., branch_id]\n}\n\nThis shows the shape I want: \"solution\" is the tour in visit order, the first entry is the branch (depot), the middle entries are the community stops in the order you plan to visit them, and the final entry is the branch again. It’s just a sketch of the expected shape, not the actual answer — please fill it with the exact IDs from the instance when you return the real route.\n\nPlease don’t rename or invent labels; use the identifiers exactly as they appear in the instance input — no renaming and no new labels.\n- for example: \"Valid identifiers look like plain numbers such as “1” or “23”, single capital letters like “A” or “B”, or a capital letter followed by digits like “A1” or “X7”.\"",
    "instance": {
      "coordinates": [
        [
          3,
          1
        ],
        [
          59,
          0
        ],
        [
          81,
          0
        ],
        [
          87,
          5
        ],
        [
          85,
          18
        ],
        [
          89,
          41
        ],
        [
          94,
          43
        ],
        [
          8,
          61
        ],
        [
          100,
          76
        ],
        [
          85,
          90
        ],
        [
          85,
          83
        ],
        [
          0,
          100
        ]
      ],
      "depot": 0,
      "num_nodes": 12,
      "time_windows": [
        [
          0,
          1067
        ],
        [
          223,
          465
        ],
        [
          75,
          339
        ],
        [
          108,
          305
        ],
        [
          250,
          461
        ],
        [
          364,
          651
        ],
        [
          354,
          584
        ],
        [
          5,
          290
        ],
        [
          166,
          453
        ],
        [
          373,
          650
        ],
        [
          114,
          345
        ],
        [
          330,
          554
        ]
      ],
      "tour_length": 519.9522356166823,
      "objective": 519.9522356166823
    },
    "solution": [
      0,
      7,
      1,
      2,
      3,
      4,
      10,
      9,
      8,
      6,
      5,
      11,
      0
    ],
    "obj": 519.9522356166823,
    "instance_variant": {
      "problem_type": "TSPTW",
      "num_nodes": 12,
      "nodes": [
        {
          "id": 1,
          "x": 3,
          "y": 1,
          "tw_start": 0,
          "tw_end": 1067
        },
        {
          "id": 2,
          "x": 59,
          "y": 0,
          "tw_start": 223,
          "tw_end": 465
        },
        {
          "id": 3,
          "x": 81,
          "y": 0,
          "tw_start": 75,
          "tw_end": 339
        },
        {
          "id": 4,
          "x": 87,
          "y": 5,
          "tw_start": 108,
          "tw_end": 305
        },
        {
          "id": 5,
          "x": 85,
          "y": 18,
          "tw_start": 250,
          "tw_end": 461
        },
        {
          "id": 6,
          "x": 89,
          "y": 41,
          "tw_start": 364,
          "tw_end": 651
        },
        {
          "id": 7,
          "x": 94,
          "y": 43,
          "tw_start": 354,
          "tw_end": 584
        },
        {
          "id": 8,
          "x": 8,
          "y": 61,
          "tw_start": 5,
          "tw_end": 290
        },
        {
          "id": 9,
          "x": 100,
          "y": 76,
          "tw_start": 166,
          "tw_end": 453
        },
        {
          "id": 10,
          "x": 85,
          "y": 90,
          "tw_start": 373,
          "tw_end": 650
        },
        {
          "id": 11,
          "x": 85,
          "y": 83,
          "tw_start": 114,
          "tw_end": 345
        },
        {
          "id": 12,
          "x": 0,
          "y": 100,
          "tw_start": 330,
          "tw_end": 554
        }
      ],
      "depot": 1,
      "objective": 519.9522356166823
    },
    "solution_variant": [
      1,
      8,
      2,
      3,
      4,
      5,
      11,
      10,
      9,
      7,
      6,
      12,
      1
    ],
    "context_index": 10,
    "input_format": "json",
    "input_index_base": 1
  },
  {
    "task_name": "TSPTW",
    "problem_type": "TSPTW",
    "instruction": "Imagine organizing a calibration trip where the technician sets off from the lab, calls on each customer exactly once during that customer’s available time window (waiting is permitted if the tech gets there before the window), and finally returns to the lab. The measure of a good plan is straightforward: the total distance of the whole tour — sum every driving leg from start to finish — and the smaller that sum, the better the plan. The detailed instance information is listed below.\n\n{\n  \"total_locations_including_lab\": 11,\n  \"nodes\": [\n    {\n      \"site_id\": 0,\n      \"site_x\": 100,\n      \"site_y\": 70,\n      \"available_from\": 0,\n      \"available_until\": 1067\n    },\n    {\n      \"site_id\": 1,\n      \"site_x\": 99,\n      \"site_y\": 67,\n      \"available_from\": 65,\n      \"available_until\": 313\n    },\n    {\n      \"site_id\": 2,\n      \"site_x\": 73,\n      \"site_y\": 59,\n      \"available_from\": 363,\n      \"available_until\": 624\n    },\n    {\n      \"site_id\": 3,\n      \"site_x\": 0,\n      \"site_y\": 53,\n      \"available_from\": 221,\n      \"available_until\": 424\n    },\n    {\n      \"site_id\": 4,\n      \"site_x\": 63,\n      \"site_y\": 34,\n      \"available_from\": 238,\n      \"available_until\": 528\n    },\n    {\n      \"site_id\": 5,\n      \"site_x\": 60,\n      \"site_y\": 32,\n      \"available_from\": 54,\n      \"available_until\": 298\n    },\n    {\n      \"site_id\": 6,\n      \"site_x\": 30,\n      \"site_y\": 21,\n      \"available_from\": 340,\n      \"available_until\": 606\n    },\n    {\n      \"site_id\": 7,\n      \"site_x\": 48,\n      \"site_y\": 21,\n      \"available_from\": 270,\n      \"available_until\": 532\n    },\n    {\n      \"site_id\": 8,\n      \"site_x\": 23,\n      \"site_y\": 100,\n      \"available_from\": 139,\n      \"available_until\": 361\n    },\n    {\n      \"site_id\": 9,\n      \"site_x\": 24,\n      \"site_y\": 99,\n      \"available_from\": 314,\n      \"available_until\": 586\n    },\n    {\n      \"site_id\": 10,\n      \"site_x\": 26,\n      \"site_y\": 0,\n      \"available_from\": 336,\n      \"available_until\": 619\n    }\n  ],\n  \"lab_node_id\": 0\n}\n\nOh, and when you send back the technician’s plan, please use this simple JSON layout so it’s really clear what the tour looks like:\n\n{\n  \"solution\": [\"lab_id\", \"customer_id\", ..., \"lab_id\"]\n}\n\nHere \"solution\" is just the tour listed in order — who the tech visits, starting and ending at the lab. Each item in the list is the identifier for that stop (the lab or a customer). Think of it like filling out a little itinerary form, not a technical file — just the sequence in plain identifiers.\n\nThis is only a sketch of the expected shape, not the actual answer — please return the real sequence when you’re ready.\n\nAll identifiers in your returned JSON must match exactly how they appear in the instance input — no renaming and no new labels. \n- for example: \"Valid identifiers look like plain numbers such as “1” or “23”, single capital letters like “A” or “B”, or a capital letter followed by digits like “A1” or “X7”.\"",
    "instance": {
      "coordinates": [
        [
          100,
          70
        ],
        [
          99,
          67
        ],
        [
          73,
          59
        ],
        [
          0,
          53
        ],
        [
          63,
          34
        ],
        [
          60,
          32
        ],
        [
          30,
          21
        ],
        [
          48,
          21
        ],
        [
          23,
          100
        ],
        [
          24,
          99
        ],
        [
          26,
          0
        ]
      ],
      "depot": 0,
      "num_nodes": 11,
      "time_windows": [
        [
          0,
          1067
        ],
        [
          65,
          313
        ],
        [
          363,
          624
        ],
        [
          221,
          424
        ],
        [
          238,
          528
        ],
        [
          54,
          298
        ],
        [
          340,
          606
        ],
        [
          270,
          532
        ],
        [
          139,
          361
        ],
        [
          314,
          586
        ],
        [
          336,
          619
        ]
      ],
      "tour_length": 355.69941008658355,
      "objective": 355.69941008658355
    },
    "solution": [
      0,
      1,
      4,
      5,
      9,
      8,
      3,
      6,
      10,
      7,
      2,
      0
    ],
    "obj": 355.69941008658355,
    "instance_variant": {
      "problem_type": "TSPTW",
      "num_nodes": 11,
      "nodes": [
        {
          "id": 0,
          "x": 100,
          "y": 70,
          "tw_start": 0,
          "tw_end": 1067
        },
        {
          "id": 1,
          "x": 99,
          "y": 67,
          "tw_start": 65,
          "tw_end": 313
        },
        {
          "id": 2,
          "x": 73,
          "y": 59,
          "tw_start": 363,
          "tw_end": 624
        },
        {
          "id": 3,
          "x": 0,
          "y": 53,
          "tw_start": 221,
          "tw_end": 424
        },
        {
          "id": 4,
          "x": 63,
          "y": 34,
          "tw_start": 238,
          "tw_end": 528
        },
        {
          "id": 5,
          "x": 60,
          "y": 32,
          "tw_start": 54,
          "tw_end": 298
        },
        {
          "id": 6,
          "x": 30,
          "y": 21,
          "tw_start": 340,
          "tw_end": 606
        },
        {
          "id": 7,
          "x": 48,
          "y": 21,
          "tw_start": 270,
          "tw_end": 532
        },
        {
          "id": 8,
          "x": 23,
          "y": 100,
          "tw_start": 139,
          "tw_end": 361
        },
        {
          "id": 9,
          "x": 24,
          "y": 99,
          "tw_start": 314,
          "tw_end": 586
        },
        {
          "id": 10,
          "x": 26,
          "y": 0,
          "tw_start": 336,
          "tw_end": 619
        }
      ],
      "depot": 0,
      "objective": 355.69941008658355
    },
    "solution_variant": [
      0,
      1,
      4,
      5,
      9,
      8,
      3,
      6,
      10,
      7,
      2,
      0
    ],
    "context_index": 11,
    "input_format": "json",
    "input_index_base": 0
  },
  {
    "task_name": "TSPTW",
    "problem_type": "TSPTW",
    "instruction": "Recently the bakery has started juggling a bunch of morning drop-offs: the driver must start at the bakery, visit each café and shop on the list a single time, and return to the bakery afterward. Every customer has a preferred time frame for deliveries, so the route needs to respect those windows (waiting is allowed if a place isn’t ready yet, but being late isn’t). Which delivery order is preferred comes down to total distance driven — sum up the distance between each stop in the route plus the return trip, and the smaller total is better. The exact stops, their windows and the travel distances are listed below.\n\nThere are 12 locations in total, counting the bakery as node 0.\n\n| stop_id | coord_x | coord_y | earliest_arrival_time | latest_arrival_time |\n|---|---|---|---|---|\n| 0 | 12 | 57 | 0 | 1067 |\n| 1 | 46 | 48 | 198 | 441 |\n| 2 | 29 | 53 | 309 | 566 |\n| 3 | 0 | 51 | 272 | 543 |\n| 4 | 16 | 100 | 345 | 572 |\n| 5 | 59 | 94 | 145 | 348 |\n| 6 | 62 | 74 | 224 | 421 |\n| 7 | 28 | 53 | 180 | 427 |\n| 8 | 1 | 0 | 111 | 362 |\n| 9 | 83 | 12 | 11 | 209 |\n| 10 | 100 | 98 | 319 | 548 |\n| 11 | 32 | 50 | 49 | 293 |\n\nThey list each stop so the driver’s route can respect the time windows while minimizing total distance.\n\nWhen you’re ready to give the route, just pop it into a tiny JSON snippet like this so I can read it programmatically:\n\n{\n  \"solution\": [bakery_id, shop_id, ..., bakery_id]\n}\n\nPretty simple — \"solution\" is the ordered list of stops: start at the bakery, visit each place once, and come back to the bakery. The placeholders (bakery_id, shop_id, etc.) are just showing the shape of the answer — they’re not the real identifiers, just a sketch.\n\nPlease make sure to use the exact identifiers from the instance input — don’t rename them and don’t invent new labels.\n- for example: \"Valid identifiers look like plain numbers such as “1” or “23”, single capital letters like “A” or “B”, or a capital letter followed by digits like “A1” or “X7”.\"",
    "instance": {
      "coordinates": [
        [
          12,
          57
        ],
        [
          46,
          48
        ],
        [
          29,
          53
        ],
        [
          0,
          51
        ],
        [
          16,
          100
        ],
        [
          59,
          94
        ],
        [
          62,
          74
        ],
        [
          28,
          53
        ],
        [
          1,
          0
        ],
        [
          83,
          12
        ],
        [
          100,
          98
        ],
        [
          32,
          50
        ]
      ],
      "depot": 0,
      "num_nodes": 12,
      "time_windows": [
        [
          0,
          1067
        ],
        [
          198,
          441
        ],
        [
          309,
          566
        ],
        [
          272,
          543
        ],
        [
          345,
          572
        ],
        [
          145,
          348
        ],
        [
          224,
          421
        ],
        [
          180,
          427
        ],
        [
          111,
          362
        ],
        [
          11,
          209
        ],
        [
          319,
          548
        ],
        [
          49,
          293
        ]
      ],
      "tour_length": 488.345601888962,
      "objective": 488.345601888962
    },
    "solution": [
      0,
      8,
      9,
      1,
      11,
      7,
      6,
      5,
      10,
      4,
      2,
      3,
      0
    ],
    "obj": 488.345601888962,
    "instance_variant": {
      "problem_type": "TSPTW",
      "num_nodes": 12,
      "nodes": [
        {
          "id": 0,
          "x": 12,
          "y": 57,
          "tw_start": 0,
          "tw_end": 1067
        },
        {
          "id": 1,
          "x": 46,
          "y": 48,
          "tw_start": 198,
          "tw_end": 441
        },
        {
          "id": 2,
          "x": 29,
          "y": 53,
          "tw_start": 309,
          "tw_end": 566
        },
        {
          "id": 3,
          "x": 0,
          "y": 51,
          "tw_start": 272,
          "tw_end": 543
        },
        {
          "id": 4,
          "x": 16,
          "y": 100,
          "tw_start": 345,
          "tw_end": 572
        },
        {
          "id": 5,
          "x": 59,
          "y": 94,
          "tw_start": 145,
          "tw_end": 348
        },
        {
          "id": 6,
          "x": 62,
          "y": 74,
          "tw_start": 224,
          "tw_end": 421
        },
        {
          "id": 7,
          "x": 28,
          "y": 53,
          "tw_start": 180,
          "tw_end": 427
        },
        {
          "id": 8,
          "x": 1,
          "y": 0,
          "tw_start": 111,
          "tw_end": 362
        },
        {
          "id": 9,
          "x": 83,
          "y": 12,
          "tw_start": 11,
          "tw_end": 209
        },
        {
          "id": 10,
          "x": 100,
          "y": 98,
          "tw_start": 319,
          "tw_end": 548
        },
        {
          "id": 11,
          "x": 32,
          "y": 50,
          "tw_start": 49,
          "tw_end": 293
        }
      ],
      "depot": 0,
      "objective": 488.345601888962
    },
    "solution_variant": [
      0,
      8,
      9,
      1,
      11,
      7,
      6,
      5,
      10,
      4,
      2,
      3,
      0
    ],
    "context_index": 12,
    "input_format": "markdown_table",
    "input_index_base": 0
  },
  {
    "task_name": "TSPTW",
    "problem_type": "TSPTW",
    "instruction": "Someone is lining up a route for an art restorer who must leave the studio, work at every gallery on the list once within each gallery’s specific access slot, and end the day back at the studio. The practical choice is picking the order and arrival times; arriving early and waiting is OK, but every gallery has to be visited exactly once. The plan that’s better is simply the one that racks up the fewest total miles — calculated by adding each leg of the trip from studio through all galleries and back — and the detailed schedule and distances are shown below.\n\n{\n  \"total_locations_including_studio\": 12,\n  \"nodes\": [\n    {\n      \"location_id\": 0,\n      \"map_x_coordinate\": 59,\n      \"map_y_coordinate\": 83,\n      \"access_window_start\": 0,\n      \"access_window_end\": 1067\n    },\n    {\n      \"location_id\": 1,\n      \"map_x_coordinate\": 24,\n      \"map_y_coordinate\": 94,\n      \"access_window_start\": 298,\n      \"access_window_end\": 513\n    },\n    {\n      \"location_id\": 2,\n      \"map_x_coordinate\": 4,\n      \"map_y_coordinate\": 92,\n      \"access_window_start\": 241,\n      \"access_window_end\": 443\n    },\n    {\n      \"location_id\": 3,\n      \"map_x_coordinate\": 0,\n      \"map_y_coordinate\": 100,\n      \"access_window_start\": 20,\n      \"access_window_end\": 265\n    },\n    {\n      \"location_id\": 4,\n      \"map_x_coordinate\": 0,\n      \"map_y_coordinate\": 22,\n      \"access_window_start\": 209,\n      \"access_window_end\": 465\n    },\n    {\n      \"location_id\": 5,\n      \"map_x_coordinate\": 0,\n      \"map_y_coordinate\": 50,\n      \"access_window_start\": 281,\n      \"access_window_end\": 570\n    },\n    {\n      \"location_id\": 6,\n      \"map_x_coordinate\": 24,\n      \"map_y_coordinate\": 67,\n      \"access_window_start\": 200,\n      \"access_window_end\": 425\n    },\n    {\n      \"location_id\": 7,\n      \"map_x_coordinate\": 63,\n      \"map_y_coordinate\": 25,\n      \"access_window_start\": 308,\n      \"access_window_end\": 528\n    },\n    {\n      \"location_id\": 8,\n      \"map_x_coordinate\": 8,\n      \"map_y_coordinate\": 0,\n      \"access_window_start\": 170,\n      \"access_window_end\": 371\n    },\n    {\n      \"location_id\": 9,\n      \"map_x_coordinate\": 100,\n      \"map_y_coordinate\": 53,\n      \"access_window_start\": 9,\n      \"access_window_end\": 297\n    },\n    {\n      \"location_id\": 10,\n      \"map_x_coordinate\": 71,\n      \"map_y_coordinate\": 53,\n      \"access_window_start\": 324,\n      \"access_window_end\": 585\n    },\n    {\n      \"location_id\": 11,\n      \"map_x_coordinate\": 97,\n      \"map_y_coordinate\": 81,\n      \"access_window_start\": 158,\n      \"access_window_end\": 369\n    }\n  ],\n  \"studio_node_id\": 0\n}\n\nAnd if you want the route in a tidy, machine-friendly snippet, I usually show it like this:\n\n{\n  \"solution\": [\"studio_id\", \"gallery_id\", ..., \"studio_id\"]\n}\n\nThis just means \"solution\" is a simple ordered list: start at the studio, visit each gallery once (in the order listed), and come back to the studio. Treat the placeholders as labels you would swap for the actual IDs from the instance — it’s just a sketch of the shape I expect, not the real route.\n\nPlease be sure to use the exact identifiers from the instance input — do not rename them or invent new ones.  \nFor example: \"Valid identifiers look like plain numbers such as “1” or “23”, single capital letters like “A” or “B”, or a capital letter followed by digits like “A1” or “X7”.\"",
    "instance": {
      "coordinates": [
        [
          59,
          83
        ],
        [
          24,
          94
        ],
        [
          4,
          92
        ],
        [
          0,
          100
        ],
        [
          0,
          22
        ],
        [
          0,
          50
        ],
        [
          24,
          67
        ],
        [
          63,
          25
        ],
        [
          8,
          0
        ],
        [
          100,
          53
        ],
        [
          71,
          53
        ],
        [
          97,
          81
        ]
      ],
      "depot": 0,
      "num_nodes": 12,
      "time_windows": [
        [
          0,
          1067
        ],
        [
          298,
          513
        ],
        [
          241,
          443
        ],
        [
          20,
          265
        ],
        [
          209,
          465
        ],
        [
          281,
          570
        ],
        [
          200,
          425
        ],
        [
          308,
          528
        ],
        [
          170,
          371
        ],
        [
          9,
          297
        ],
        [
          324,
          585
        ],
        [
          158,
          369
        ]
      ],
      "tour_length": 568.2044284882414,
      "objective": 568.2044284882414
    },
    "solution": [
      0,
      3,
      11,
      9,
      8,
      4,
      5,
      6,
      2,
      1,
      7,
      10,
      0
    ],
    "obj": 568.2044284882414,
    "instance_variant": {
      "problem_type": "TSPTW",
      "num_nodes": 12,
      "nodes": [
        {
          "id": 0,
          "x": 59,
          "y": 83,
          "tw_start": 0,
          "tw_end": 1067
        },
        {
          "id": 1,
          "x": 24,
          "y": 94,
          "tw_start": 298,
          "tw_end": 513
        },
        {
          "id": 2,
          "x": 4,
          "y": 92,
          "tw_start": 241,
          "tw_end": 443
        },
        {
          "id": 3,
          "x": 0,
          "y": 100,
          "tw_start": 20,
          "tw_end": 265
        },
        {
          "id": 4,
          "x": 0,
          "y": 22,
          "tw_start": 209,
          "tw_end": 465
        },
        {
          "id": 5,
          "x": 0,
          "y": 50,
          "tw_start": 281,
          "tw_end": 570
        },
        {
          "id": 6,
          "x": 24,
          "y": 67,
          "tw_start": 200,
          "tw_end": 425
        },
        {
          "id": 7,
          "x": 63,
          "y": 25,
          "tw_start": 308,
          "tw_end": 528
        },
        {
          "id": 8,
          "x": 8,
          "y": 0,
          "tw_start": 170,
          "tw_end": 371
        },
        {
          "id": 9,
          "x": 100,
          "y": 53,
          "tw_start": 9,
          "tw_end": 297
        },
        {
          "id": 10,
          "x": 71,
          "y": 53,
          "tw_start": 324,
          "tw_end": 585
        },
        {
          "id": 11,
          "x": 97,
          "y": 81,
          "tw_start": 158,
          "tw_end": 369
        }
      ],
      "depot": 0,
      "objective": 568.2044284882414
    },
    "solution_variant": [
      0,
      3,
      11,
      9,
      8,
      4,
      5,
      6,
      2,
      1,
      7,
      10,
      0
    ],
    "context_index": 13,
    "input_format": "json",
    "input_index_base": 0
  },
  {
    "task_name": "TSPTW",
    "problem_type": "TSPTW",
    "instruction": "Recently the city asked for a daily route that starts and ends at the maintenance yard, hits every street-tree inspection spot exactly once during its allotted time period, and keeps the miles driven to an absolute minimum. The way to tell which route is better is straightforward — total the distances for each leg of the trip (including leaving and returning to the yard); the route with the smallest total distance wins. Crews are allowed to wait if they get there early, but every point must be visited once and only once. The concrete details are shown below.\n\n{\n  \"total_locations_including_yard\": 14,\n  \"nodes\": [\n    {\n      \"inspection_point_id\": 1,\n      \"x_coordinate\": 87,\n      \"y_coordinate\": 62,\n      \"time_window_start\": 0,\n      \"time_window_end\": 1067\n    },\n    {\n      \"inspection_point_id\": 2,\n      \"x_coordinate\": 100,\n      \"y_coordinate\": 80,\n      \"time_window_start\": 190,\n      \"time_window_end\": 430\n    },\n    {\n      \"inspection_point_id\": 3,\n      \"x_coordinate\": 4,\n      \"y_coordinate\": 79,\n      \"time_window_start\": 67,\n      \"time_window_end\": 303\n    },\n    {\n      \"inspection_point_id\": 4,\n      \"x_coordinate\": 0,\n      \"y_coordinate\": 59,\n      \"time_window_start\": 154,\n      \"time_window_end\": 408\n    },\n    {\n      \"inspection_point_id\": 5,\n      \"x_coordinate\": 18,\n      \"y_coordinate\": 91,\n      \"time_window_start\": 246,\n      \"time_window_end\": 444\n    },\n    {\n      \"inspection_point_id\": 6,\n      \"x_coordinate\": 65,\n      \"y_coordinate\": 33,\n      \"time_window_start\": 145,\n      \"time_window_end\": 400\n    },\n    {\n      \"inspection_point_id\": 7,\n      \"x_coordinate\": 27,\n      \"y_coordinate\": 74,\n      \"time_window_start\": 195,\n      \"time_window_end\": 472\n    },\n    {\n      \"inspection_point_id\": 8,\n      \"x_coordinate\": 85,\n      \"y_coordinate\": 9,\n      \"time_window_start\": 255,\n      \"time_window_end\": 465\n    },\n    {\n      \"inspection_point_id\": 9,\n      \"x_coordinate\": 25,\n      \"y_coordinate\": 67,\n      \"time_window_start\": 27,\n      \"time_window_end\": 283\n    },\n    {\n      \"inspection_point_id\": 10,\n      \"x_coordinate\": 85,\n      \"y_coordinate\": 52,\n      \"time_window_start\": 10,\n      \"time_window_end\": 261\n    },\n    {\n      \"inspection_point_id\": 11,\n      \"x_coordinate\": 5,\n      \"y_coordinate\": 100,\n      \"time_window_start\": 364,\n      \"time_window_end\": 614\n    },\n    {\n      \"inspection_point_id\": 12,\n      \"x_coordinate\": 60,\n      \"y_coordinate\": 85,\n      \"time_window_start\": 150,\n      \"time_window_end\": 407\n    },\n    {\n      \"inspection_point_id\": 13,\n      \"x_coordinate\": 78,\n      \"y_coordinate\": 0,\n      \"time_window_start\": 177,\n      \"time_window_end\": 424\n    },\n    {\n      \"inspection_point_id\": 14,\n      \"x_coordinate\": 95,\n      \"y_coordinate\": 2,\n      \"time_window_start\": 365,\n      \"time_window_end\": 596\n    }\n  ],\n  \"yard_node_identifier\": 1\n}\n\nOh, and one more practical thing — when you give the route back, please put it in a tiny JSON object so it's easy to read and share. Something like this:\n\n{\n  \"solution\": [yard_id, spot_id, ..., yard_id]\n}\n\nThis just means \"solution\" holds the ordered list: start at the maintenance yard, list each inspection spot in the order the crew will visit them, and finish back at the yard. The identifiers in the array are placeholders you would replace with the actual IDs from the instance — this snippet is just a sketch of the shape I expect, not the real route.\n\nPlease make sure you use the exact identifiers from the problem input — do not rename them or invent new labels.\n- for example: \"Valid identifiers look like plain numbers such as “1” or “23”, single capital letters like “A” or “B”, or a capital letter followed by digits like “A1” or “X7”.\"",
    "instance": {
      "coordinates": [
        [
          87,
          62
        ],
        [
          100,
          80
        ],
        [
          4,
          79
        ],
        [
          0,
          59
        ],
        [
          18,
          91
        ],
        [
          65,
          33
        ],
        [
          27,
          74
        ],
        [
          85,
          9
        ],
        [
          25,
          67
        ],
        [
          85,
          52
        ],
        [
          5,
          100
        ],
        [
          60,
          85
        ],
        [
          78,
          0
        ],
        [
          95,
          2
        ]
      ],
      "depot": 0,
      "num_nodes": 14,
      "time_windows": [
        [
          0,
          1067
        ],
        [
          190,
          430
        ],
        [
          67,
          303
        ],
        [
          154,
          408
        ],
        [
          246,
          444
        ],
        [
          145,
          400
        ],
        [
          195,
          472
        ],
        [
          255,
          465
        ],
        [
          27,
          283
        ],
        [
          10,
          261
        ],
        [
          364,
          614
        ],
        [
          150,
          407
        ],
        [
          177,
          424
        ],
        [
          365,
          596
        ]
      ],
      "tour_length": 579.1343953480267,
      "objective": 579.1343953480267
    },
    "solution": [
      0,
      9,
      8,
      3,
      2,
      6,
      4,
      11,
      1,
      5,
      12,
      13,
      7,
      10,
      0
    ],
    "obj": 579.1343953480267,
    "instance_variant": {
      "problem_type": "TSPTW",
      "num_nodes": 14,
      "nodes": [
        {
          "id": 1,
          "x": 87,
          "y": 62,
          "tw_start": 0,
          "tw_end": 1067
        },
        {
          "id": 2,
          "x": 100,
          "y": 80,
          "tw_start": 190,
          "tw_end": 430
        },
        {
          "id": 3,
          "x": 4,
          "y": 79,
          "tw_start": 67,
          "tw_end": 303
        },
        {
          "id": 4,
          "x": 0,
          "y": 59,
          "tw_start": 154,
          "tw_end": 408
        },
        {
          "id": 5,
          "x": 18,
          "y": 91,
          "tw_start": 246,
          "tw_end": 444
        },
        {
          "id": 6,
          "x": 65,
          "y": 33,
          "tw_start": 145,
          "tw_end": 400
        },
        {
          "id": 7,
          "x": 27,
          "y": 74,
          "tw_start": 195,
          "tw_end": 472
        },
        {
          "id": 8,
          "x": 85,
          "y": 9,
          "tw_start": 255,
          "tw_end": 465
        },
        {
          "id": 9,
          "x": 25,
          "y": 67,
          "tw_start": 27,
          "tw_end": 283
        },
        {
          "id": 10,
          "x": 85,
          "y": 52,
          "tw_start": 10,
          "tw_end": 261
        },
        {
          "id": 11,
          "x": 5,
          "y": 100,
          "tw_start": 364,
          "tw_end": 614
        },
        {
          "id": 12,
          "x": 60,
          "y": 85,
          "tw_start": 150,
          "tw_end": 407
        },
        {
          "id": 13,
          "x": 78,
          "y": 0,
          "tw_start": 177,
          "tw_end": 424
        },
        {
          "id": 14,
          "x": 95,
          "y": 2,
          "tw_start": 365,
          "tw_end": 596
        }
      ],
      "depot": 1,
      "objective": 579.1343953480267
    },
    "solution_variant": [
      1,
      10,
      9,
      4,
      3,
      7,
      5,
      12,
      2,
      6,
      13,
      14,
      8,
      11,
      1
    ],
    "context_index": 14,
    "input_format": "json",
    "input_index_base": 1
  },
  {
    "task_name": "TSPTW",
    "problem_type": "TSPTW",
    "instruction": "Many days involve a single catering run: start at the kitchen, hit every event once within its promised arrival slot, and head back to the kitchen. The better the plan, the fewer miles driven overall — which you get by summing the distances for each leg in the route, including the return leg — and arriving early is fine because waiting for the arrival period is allowed. Every stop must be included exactly once. The specific event locations and their time windows are shown below.\n\n# total_locations_including_depot=12\n# kitchen_node_id=0\n# time windows are listed per node in the table\nlocation_id,x_coordinate,y_coordinate,earliest_allowed_arrival,latest_allowed_arrival\n0,0,7,0,1067\n1,5,90,372,654\n2,9,100,75,276\n3,21,100,39,234\n4,100,94,36,296\n5,100,84,27,252\n6,79,66,327,524\n7,24,0,316,537\n8,39,13,45,307\n9,79,100,244,523\n10,54,58,285,557\n11,46,99,109,320\n\nAlso, when you hand back the route, just stick to a simple JSON layout like this:\n\n{\n  \"solution\": [kitchen_id, event_id, ..., kitchen_id]\n}\n\nThink of that as a little route form: \"solution\" is the ordered list of stops (start at the kitchen, visit each event once, and come back to the kitchen). The placeholders there are just showing the shape I expect — replace them with the actual IDs from the instance when you send the real answer.\n\nThis JSON is only a sketch of the shape I want, not the actual route — please use the exact identifiers from the instance input, no renaming and no new labels.\n\n- for example: \"Valid identifiers look like plain numbers such as “1” or “23”, single capital letters like “A” or “B”, or a capital letter followed by digits like “A1” or “X7”\".",
    "instance": {
      "coordinates": [
        [
          0,
          7
        ],
        [
          5,
          90
        ],
        [
          9,
          100
        ],
        [
          21,
          100
        ],
        [
          100,
          94
        ],
        [
          100,
          84
        ],
        [
          79,
          66
        ],
        [
          24,
          0
        ],
        [
          39,
          13
        ],
        [
          79,
          100
        ],
        [
          54,
          58
        ],
        [
          46,
          99
        ]
      ],
      "depot": 0,
      "num_nodes": 12,
      "time_windows": [
        [
          0,
          1067
        ],
        [
          372,
          654
        ],
        [
          75,
          276
        ],
        [
          39,
          234
        ],
        [
          36,
          296
        ],
        [
          27,
          252
        ],
        [
          327,
          524
        ],
        [
          316,
          537
        ],
        [
          45,
          307
        ],
        [
          244,
          523
        ],
        [
          285,
          557
        ],
        [
          109,
          320
        ]
      ],
      "tour_length": 492.1469592236004,
      "objective": 492.1469592236004
    },
    "solution": [
      0,
      8,
      2,
      3,
      11,
      5,
      4,
      9,
      6,
      10,
      1,
      7,
      0
    ],
    "obj": 492.1469592236004,
    "instance_variant": {
      "problem_type": "TSPTW",
      "num_nodes": 12,
      "nodes": [
        {
          "id": 0,
          "x": 0,
          "y": 7,
          "tw_start": 0,
          "tw_end": 1067
        },
        {
          "id": 1,
          "x": 5,
          "y": 90,
          "tw_start": 372,
          "tw_end": 654
        },
        {
          "id": 2,
          "x": 9,
          "y": 100,
          "tw_start": 75,
          "tw_end": 276
        },
        {
          "id": 3,
          "x": 21,
          "y": 100,
          "tw_start": 39,
          "tw_end": 234
        },
        {
          "id": 4,
          "x": 100,
          "y": 94,
          "tw_start": 36,
          "tw_end": 296
        },
        {
          "id": 5,
          "x": 100,
          "y": 84,
          "tw_start": 27,
          "tw_end": 252
        },
        {
          "id": 6,
          "x": 79,
          "y": 66,
          "tw_start": 327,
          "tw_end": 524
        },
        {
          "id": 7,
          "x": 24,
          "y": 0,
          "tw_start": 316,
          "tw_end": 537
        },
        {
          "id": 8,
          "x": 39,
          "y": 13,
          "tw_start": 45,
          "tw_end": 307
        },
        {
          "id": 9,
          "x": 79,
          "y": 100,
          "tw_start": 244,
          "tw_end": 523
        },
        {
          "id": 10,
          "x": 54,
          "y": 58,
          "tw_start": 285,
          "tw_end": 557
        },
        {
          "id": 11,
          "x": 46,
          "y": 99,
          "tw_start": 109,
          "tw_end": 320
        }
      ],
      "depot": 0,
      "objective": 492.1469592236004
    },
    "solution_variant": [
      0,
      8,
      2,
      3,
      11,
      5,
      4,
      9,
      6,
      10,
      1,
      7,
      0
    ],
    "context_index": 15,
    "input_format": "csv",
    "input_index_base": 0
  },
  {
    "task_name": "TSPTW",
    "problem_type": "TSPTW",
    "instruction": "I help plan outreach days for a nonprofit, where the idea is to leave the office, visit every beneficiary address one time only within the time slot each family agreed to, and come back to the office at the end of the day. The trick is to arrange the order of stops so the total driving distance is as small as possible — that total is just the sum of the distances between each stop in the route, including the trip back to the office — and it’s okay to wait at a location if its time window hasn’t opened yet. Concrete details are shown below.\n\n{\n  \"total_locations_including_office\": 12,\n  \"nodes\": [\n    {\n      \"location_id\": 1,\n      \"location_x_coordinate\": 100,\n      \"location_y_coordinate\": 67,\n      \"earliest_arrival_time\": 0,\n      \"latest_arrival_time\": 1067\n    },\n    {\n      \"location_id\": 2,\n      \"location_x_coordinate\": 0,\n      \"location_y_coordinate\": 75,\n      \"earliest_arrival_time\": 291,\n      \"latest_arrival_time\": 563\n    },\n    {\n      \"location_id\": 3,\n      \"location_x_coordinate\": 82,\n      \"location_y_coordinate\": 7,\n      \"earliest_arrival_time\": 384,\n      \"latest_arrival_time\": 618\n    },\n    {\n      \"location_id\": 4,\n      \"location_x_coordinate\": 42,\n      \"location_y_coordinate\": 100,\n      \"earliest_arrival_time\": 144,\n      \"latest_arrival_time\": 413\n    },\n    {\n      \"location_id\": 5,\n      \"location_x_coordinate\": 85,\n      \"location_y_coordinate\": 43,\n      \"earliest_arrival_time\": 132,\n      \"latest_arrival_time\": 416\n    },\n    {\n      \"location_id\": 6,\n      \"location_x_coordinate\": 57,\n      \"location_y_coordinate\": 59,\n      \"earliest_arrival_time\": 333,\n      \"latest_arrival_time\": 568\n    },\n    {\n      \"location_id\": 7,\n      \"location_x_coordinate\": 70,\n      \"location_y_coordinate\": 93,\n      \"earliest_arrival_time\": 291,\n      \"latest_arrival_time\": 558\n    },\n    {\n      \"location_id\": 8,\n      \"location_x_coordinate\": 69,\n      \"location_y_coordinate\": 73,\n      \"earliest_arrival_time\": 40,\n      \"latest_arrival_time\": 321\n    },\n    {\n      \"location_id\": 9,\n      \"location_x_coordinate\": 59,\n      \"location_y_coordinate\": 9,\n      \"earliest_arrival_time\": 196,\n      \"latest_arrival_time\": 470\n    },\n    {\n      \"location_id\": 10,\n      \"location_x_coordinate\": 80,\n      \"location_y_coordinate\": 54,\n      \"earliest_arrival_time\": 124,\n      \"latest_arrival_time\": 405\n    },\n    {\n      \"location_id\": 11,\n      \"location_x_coordinate\": 40,\n      \"location_y_coordinate\": 34,\n      \"earliest_arrival_time\": 151,\n      \"latest_arrival_time\": 346\n    },\n    {\n      \"location_id\": 12,\n      \"location_x_coordinate\": 55,\n      \"location_y_coordinate\": 0,\n      \"earliest_arrival_time\": 351,\n      \"latest_arrival_time\": 554\n    }\n  ],\n  \"office_node_id\": 1\n}\n\nAlso, when you send the route back, please follow this little JSON sketch for the answer format:\n\n{\n  \"solution\": [office_id, family_id, ..., office_id]\n}\n\n\"solution\" is the ordered list of stops — start at the office, visit each family once, and return to the office at the end. The names there are just placeholders: office_id stands for the office/depot and family_id stands for each beneficiary address. The \"...\" is where all the other stops go. This is just the shape I need, not the actual route.\n\nPlease make sure to use the exact identifiers from the instance input — no renaming and no new labels.  \n- for example: \"Valid identifiers look like plain numbers such as “1” or “23”, single capital letters like “A” or “B”, or a capital letter followed by digits like “A1” or “X7”.\"",
    "instance": {
      "coordinates": [
        [
          100,
          67
        ],
        [
          0,
          75
        ],
        [
          82,
          7
        ],
        [
          42,
          100
        ],
        [
          85,
          43
        ],
        [
          57,
          59
        ],
        [
          70,
          93
        ],
        [
          69,
          73
        ],
        [
          59,
          9
        ],
        [
          80,
          54
        ],
        [
          40,
          34
        ],
        [
          55,
          0
        ]
      ],
      "depot": 0,
      "num_nodes": 12,
      "time_windows": [
        [
          0,
          1067
        ],
        [
          291,
          563
        ],
        [
          384,
          618
        ],
        [
          144,
          413
        ],
        [
          132,
          416
        ],
        [
          333,
          568
        ],
        [
          291,
          558
        ],
        [
          40,
          321
        ],
        [
          196,
          470
        ],
        [
          124,
          405
        ],
        [
          151,
          346
        ],
        [
          351,
          554
        ]
      ],
      "tour_length": 432.78293195237,
      "objective": 432.78293195237
    },
    "solution": [
      0,
      4,
      9,
      7,
      10,
      1,
      3,
      6,
      5,
      8,
      11,
      2,
      0
    ],
    "obj": 432.78293195237,
    "instance_variant": {
      "problem_type": "TSPTW",
      "num_nodes": 12,
      "nodes": [
        {
          "id": 1,
          "x": 100,
          "y": 67,
          "tw_start": 0,
          "tw_end": 1067
        },
        {
          "id": 2,
          "x": 0,
          "y": 75,
          "tw_start": 291,
          "tw_end": 563
        },
        {
          "id": 3,
          "x": 82,
          "y": 7,
          "tw_start": 384,
          "tw_end": 618
        },
        {
          "id": 4,
          "x": 42,
          "y": 100,
          "tw_start": 144,
          "tw_end": 413
        },
        {
          "id": 5,
          "x": 85,
          "y": 43,
          "tw_start": 132,
          "tw_end": 416
        },
        {
          "id": 6,
          "x": 57,
          "y": 59,
          "tw_start": 333,
          "tw_end": 568
        },
        {
          "id": 7,
          "x": 70,
          "y": 93,
          "tw_start": 291,
          "tw_end": 558
        },
        {
          "id": 8,
          "x": 69,
          "y": 73,
          "tw_start": 40,
          "tw_end": 321
        },
        {
          "id": 9,
          "x": 59,
          "y": 9,
          "tw_start": 196,
          "tw_end": 470
        },
        {
          "id": 10,
          "x": 80,
          "y": 54,
          "tw_start": 124,
          "tw_end": 405
        },
        {
          "id": 11,
          "x": 40,
          "y": 34,
          "tw_start": 151,
          "tw_end": 346
        },
        {
          "id": 12,
          "x": 55,
          "y": 0,
          "tw_start": 351,
          "tw_end": 554
        }
      ],
      "depot": 1,
      "objective": 432.78293195237
    },
    "solution_variant": [
      1,
      5,
      10,
      8,
      11,
      2,
      4,
      7,
      6,
      9,
      12,
      3,
      1
    ],
    "context_index": 16,
    "input_format": "json",
    "input_index_base": 1
  },
  {
    "task_name": "TSPTW",
    "problem_type": "TSPTW",
    "instruction": "We have a mobile groomer who needs to plan a day that starts and finishes at the shop, visits every booked client one time during that client’s appointment window, and is allowed to hang around if it gets there early. The choice to make is the visiting order; better orders are simply those where the total trip length (calculated by summing the distance between each pair of consecutive locations, including the legs from and back to the home base) is lower than other orders. The specific appointments and distances are listed below.\n\nWe have 14 total locations to consider and the home shop is 1.\nWe must visit location 1 at (49, 61) between 0 and 1067.\nWe must visit location 2 at (89, 100) between 123 and 410.\nWe must visit location 3 at (79, 58) between 368 and 618.\nWe must visit location 4 at (66, 64) between 245 and 482.\nWe must visit location 5 at (97, 99) between 113 and 339.\nWe must visit location 6 at (71, 37) between 260 and 527.\nWe must visit location 7 at (0, 21) between 307 and 577.\nWe must visit location 8 at (83, 0) between 35 and 277.\nWe must visit location 9 at (62, 12) between 22 and 269.\nWe must visit location 10 at (85, 38) between 171 and 451.\nWe must visit location 11 at (100, 21) between 136 and 341.\nWe must visit location 12 at (73, 20) between 55 and 323.\nWe must visit location 13 at (81, 77) between 239 and 443.\nWe must visit location 14 at (8, 10) between 32 and 294.\nWe will select the visiting order that minimizes the total trip length, summing distances between consecutive locations and including the return to the home shop.\n\nAlso, when you send back the visiting order, just stick to a tiny JSON outline like this so it's easy to read and parse:\n\n{\n  \"solution\": [shop_id, client_id, ..., shop_id]\n}\n\nThink of that as a simple form: \"solution\" is the ordered list of stops (start at the shop, visit each client once, and return to the shop). The bits in the array are placeholders showing the shape I need — replace them with the actual identifiers from the instance. This is just a sketch of the expected shape, not the real answer.\n\nPlease make sure to use the exact identifiers from the instance input — no renaming and no new labels. Valid identifiers look like plain numbers such as “1” or “23”, single capital letters like “A” or “B”, or a capital letter followed by digits like “A1” or “X7”.",
    "instance": {
      "coordinates": [
        [
          49,
          61
        ],
        [
          89,
          100
        ],
        [
          79,
          58
        ],
        [
          66,
          64
        ],
        [
          97,
          99
        ],
        [
          71,
          37
        ],
        [
          0,
          21
        ],
        [
          83,
          0
        ],
        [
          62,
          12
        ],
        [
          85,
          38
        ],
        [
          100,
          21
        ],
        [
          73,
          20
        ],
        [
          81,
          77
        ],
        [
          8,
          10
        ]
      ],
      "depot": 0,
      "num_nodes": 14,
      "time_windows": [
        [
          0,
          1067
        ],
        [
          123,
          410
        ],
        [
          368,
          618
        ],
        [
          245,
          482
        ],
        [
          113,
          339
        ],
        [
          260,
          527
        ],
        [
          307,
          577
        ],
        [
          35,
          277
        ],
        [
          22,
          269
        ],
        [
          171,
          451
        ],
        [
          136,
          341
        ],
        [
          55,
          323
        ],
        [
          239,
          443
        ],
        [
          32,
          294
        ]
      ],
      "tour_length": 492.3826303893492,
      "objective": 492.3826303893492
    },
    "solution": [
      0,
      13,
      8,
      11,
      7,
      10,
      9,
      4,
      1,
      12,
      3,
      2,
      5,
      6,
      0
    ],
    "obj": 492.3826303893492,
    "instance_variant": {
      "problem_type": "TSPTW",
      "num_nodes": 14,
      "nodes": [
        {
          "id": 1,
          "x": 49,
          "y": 61,
          "tw_start": 0,
          "tw_end": 1067
        },
        {
          "id": 2,
          "x": 89,
          "y": 100,
          "tw_start": 123,
          "tw_end": 410
        },
        {
          "id": 3,
          "x": 79,
          "y": 58,
          "tw_start": 368,
          "tw_end": 618
        },
        {
          "id": 4,
          "x": 66,
          "y": 64,
          "tw_start": 245,
          "tw_end": 482
        },
        {
          "id": 5,
          "x": 97,
          "y": 99,
          "tw_start": 113,
          "tw_end": 339
        },
        {
          "id": 6,
          "x": 71,
          "y": 37,
          "tw_start": 260,
          "tw_end": 527
        },
        {
          "id": 7,
          "x": 0,
          "y": 21,
          "tw_start": 307,
          "tw_end": 577
        },
        {
          "id": 8,
          "x": 83,
          "y": 0,
          "tw_start": 35,
          "tw_end": 277
        },
        {
          "id": 9,
          "x": 62,
          "y": 12,
          "tw_start": 22,
          "tw_end": 269
        },
        {
          "id": 10,
          "x": 85,
          "y": 38,
          "tw_start": 171,
          "tw_end": 451
        },
        {
          "id": 11,
          "x": 100,
          "y": 21,
          "tw_start": 136,
          "tw_end": 341
        },
        {
          "id": 12,
          "x": 73,
          "y": 20,
          "tw_start": 55,
          "tw_end": 323
        },
        {
          "id": 13,
          "x": 81,
          "y": 77,
          "tw_start": 239,
          "tw_end": 443
        },
        {
          "id": 14,
          "x": 8,
          "y": 10,
          "tw_start": 32,
          "tw_end": 294
        }
      ],
      "depot": 1,
      "objective": 492.3826303893492
    },
    "solution_variant": [
      1,
      14,
      9,
      12,
      8,
      11,
      10,
      5,
      2,
      13,
      4,
      3,
      6,
      7,
      1
    ],
    "context_index": 17,
    "input_format": "nl",
    "input_index_base": 1
  },
  {
    "task_name": "TSPTW",
    "problem_type": "TSPTW",
    "instruction": "On a Monday morning a field rep sets out from the regional office, needs to visit every client one time while each is open for visits, and must end the day back at the office. The simplest way to judge different schedules is by total distance driven — just add up the length of each leg between stops and the trip home, and the plan with the lowest total is preferred. It’s fine to wait until a client’s window opens, but skipping or repeating visits isn’t allowed. The concrete list of stops, windows and distances is provided below.\n\nIt includes 11 locations in total, with the regional office recorded as 0.\n\n| location_id | coordinate_x | coordinate_y | availability_start_time | availability_end_time |\n|---|---|---|---|---|\n| 0 | 28 | 100 | 0 | 1067 |\n| 1 | 1 | 67 | 28 | 301 |\n| 2 | 20 | 93 | 274 | 475 |\n| 3 | 28 | 0 | 32 | 322 |\n| 4 | 59 | 53 | 145 | 375 |\n| 5 | 64 | 14 | 315 | 601 |\n| 6 | 0 | 89 | 382 | 649 |\n| 7 | 53 | 40 | 145 | 348 |\n| 8 | 100 | 11 | 301 | 549 |\n| 9 | 73 | 94 | 164 | 446 |\n| 10 | 60 | 99 | 43 | 284 |\n\nThe field rep must start and finish at 0 and visit all 11 locations within their time windows.\n\nAlso, if you want to hand the route back to me in a machine-friendly way, a little JSON snippet like this is perfect — nothing fancy, just the sequence of stops from the office and back:\n\n{\n  \"solution\": [office_id, client_id, ..., office_id]\n}\n\nPretty straightforward: the solution array is the visit order, starting at the office, listing each client once in the order you’ll visit them, and finishing back at the office. Think of each placeholder as “put the exact ID for that stop here.”\n\nThis is just a sketch of the shape I expect, not the actual route — please fill it in with the real identifiers from the instance.\n\nPlease be careful to use the identifiers exactly as they appear in the instance input — no renaming and no inventing new labels. For example: \"Valid identifiers look like plain numbers such as “1” or “23”, single capital letters like “A” or “B”, or a capital letter followed by digits like “A1” or “X7”.\"",
    "instance": {
      "coordinates": [
        [
          28,
          100
        ],
        [
          1,
          67
        ],
        [
          20,
          93
        ],
        [
          28,
          0
        ],
        [
          59,
          53
        ],
        [
          64,
          14
        ],
        [
          0,
          89
        ],
        [
          53,
          40
        ],
        [
          100,
          11
        ],
        [
          73,
          94
        ],
        [
          60,
          99
        ]
      ],
      "depot": 0,
      "num_nodes": 11,
      "time_windows": [
        [
          0,
          1067
        ],
        [
          28,
          301
        ],
        [
          274,
          475
        ],
        [
          32,
          322
        ],
        [
          145,
          375
        ],
        [
          315,
          601
        ],
        [
          382,
          649
        ],
        [
          145,
          348
        ],
        [
          301,
          549
        ],
        [
          164,
          446
        ],
        [
          43,
          284
        ]
      ],
      "tour_length": 468.28830450281157,
      "objective": 468.28830450281157
    },
    "solution": [
      0,
      1,
      10,
      9,
      4,
      7,
      3,
      5,
      8,
      2,
      6,
      0
    ],
    "obj": 468.28830450281157,
    "instance_variant": {
      "problem_type": "TSPTW",
      "num_nodes": 11,
      "nodes": [
        {
          "id": 0,
          "x": 28,
          "y": 100,
          "tw_start": 0,
          "tw_end": 1067
        },
        {
          "id": 1,
          "x": 1,
          "y": 67,
          "tw_start": 28,
          "tw_end": 301
        },
        {
          "id": 2,
          "x": 20,
          "y": 93,
          "tw_start": 274,
          "tw_end": 475
        },
        {
          "id": 3,
          "x": 28,
          "y": 0,
          "tw_start": 32,
          "tw_end": 322
        },
        {
          "id": 4,
          "x": 59,
          "y": 53,
          "tw_start": 145,
          "tw_end": 375
        },
        {
          "id": 5,
          "x": 64,
          "y": 14,
          "tw_start": 315,
          "tw_end": 601
        },
        {
          "id": 6,
          "x": 0,
          "y": 89,
          "tw_start": 382,
          "tw_end": 649
        },
        {
          "id": 7,
          "x": 53,
          "y": 40,
          "tw_start": 145,
          "tw_end": 348
        },
        {
          "id": 8,
          "x": 100,
          "y": 11,
          "tw_start": 301,
          "tw_end": 549
        },
        {
          "id": 9,
          "x": 73,
          "y": 94,
          "tw_start": 164,
          "tw_end": 446
        },
        {
          "id": 10,
          "x": 60,
          "y": 99,
          "tw_start": 43,
          "tw_end": 284
        }
      ],
      "depot": 0,
      "objective": 468.28830450281157
    },
    "solution_variant": [
      0,
      1,
      10,
      9,
      4,
      7,
      3,
      5,
      8,
      2,
      6,
      0
    ],
    "context_index": 18,
    "input_format": "markdown_table",
    "input_index_base": 0
  },
  {
    "task_name": "TSPTW",
    "problem_type": "TSPTW",
    "instruction": "Many people on the logistics team are focused on one simple problem: build a route that leaves the warehouse, visits every delivery address once during its assigned time slot, and returns to the warehouse while keeping total travel distance as low as possible. You evaluate any candidate route by summing the distances between each pair of consecutive stops (including the start and finish at the warehouse); the smaller that sum, the better. Waiting before a window opens is allowed, but repeating a stop or leaving one out isn’t. The detailed list of stops and windows is shown below.\n\nYou will find 15 locations listed here and the warehouse node id is 1.\nStop 1 at (19, 21) with delivery window [0, 1067].\nStop 2 at (36, 57) with delivery window [4, 243].\nStop 3 at (35, 70) with delivery window [21, 227].\nStop 4 at (23, 92) with delivery window [45, 302].\nStop 5 at (43, 92) with delivery window [289, 540].\nStop 6 at (67, 44) with delivery window [373, 603].\nStop 7 at (51, 58) with delivery window [110, 389].\nStop 8 at (68, 85) with delivery window [86, 374].\nStop 9 at (61, 85) with delivery window [4, 292].\nStop 10 at (67, 100) with delivery window [16, 297].\nStop 11 at (79, 93) with delivery window [204, 495].\nStop 12 at (100, 57) with delivery window [28, 276].\nStop 13 at (87, 92) with delivery window [376, 620].\nStop 14 at (99, 5) with delivery window [244, 505].\nStop 15 at (0, 0) with delivery window [176, 431].\nVisit each of the 15 stops (start/finish at 1), observing every delivery window.\n\nAlso, when you give me the final route, please use this simple JSON shape so it's easy to parse:\n\n{\n  \"solution\": [warehouse_id, address_id, ..., warehouse_id]\n}\n\nThink of that as a little form: the first item is the warehouse where the truck leaves from, the middle items are the delivery addresses in the exact order you visit them, and the last item is the warehouse again (you come back at the end). This is just a sketch of the shape I expect — not the actual route.\n\nPlease be sure to use the identifiers exactly as they appear in the instance input — don't rename them or invent new labels. \n- for example: \"Valid identifiers look like plain numbers such as “1” or “23”, single capital letters like “A” or “B”, or a capital letter followed by digits like “A1” or “X7”.\"",
    "instance": {
      "coordinates": [
        [
          19,
          21
        ],
        [
          36,
          57
        ],
        [
          35,
          70
        ],
        [
          23,
          92
        ],
        [
          43,
          92
        ],
        [
          67,
          44
        ],
        [
          51,
          58
        ],
        [
          68,
          85
        ],
        [
          61,
          85
        ],
        [
          67,
          100
        ],
        [
          79,
          93
        ],
        [
          100,
          57
        ],
        [
          87,
          92
        ],
        [
          99,
          5
        ],
        [
          0,
          0
        ]
      ],
      "depot": 0,
      "num_nodes": 15,
      "time_windows": [
        [
          0,
          1067
        ],
        [
          4,
          243
        ],
        [
          21,
          227
        ],
        [
          45,
          302
        ],
        [
          289,
          540
        ],
        [
          373,
          603
        ],
        [
          110,
          389
        ],
        [
          86,
          374
        ],
        [
          4,
          292
        ],
        [
          16,
          297
        ],
        [
          204,
          495
        ],
        [
          28,
          276
        ],
        [
          376,
          620
        ],
        [
          244,
          505
        ],
        [
          176,
          431
        ]
      ],
      "tour_length": 630.2659270772839,
      "objective": 630.2659270772839
    },
    "solution": [
      0,
      1,
      2,
      3,
      6,
      8,
      7,
      9,
      10,
      11,
      13,
      14,
      4,
      12,
      5,
      0
    ],
    "obj": 630.2659270772839,
    "instance_variant": {
      "problem_type": "TSPTW",
      "num_nodes": 15,
      "nodes": [
        {
          "id": 1,
          "x": 19,
          "y": 21,
          "tw_start": 0,
          "tw_end": 1067
        },
        {
          "id": 2,
          "x": 36,
          "y": 57,
          "tw_start": 4,
          "tw_end": 243
        },
        {
          "id": 3,
          "x": 35,
          "y": 70,
          "tw_start": 21,
          "tw_end": 227
        },
        {
          "id": 4,
          "x": 23,
          "y": 92,
          "tw_start": 45,
          "tw_end": 302
        },
        {
          "id": 5,
          "x": 43,
          "y": 92,
          "tw_start": 289,
          "tw_end": 540
        },
        {
          "id": 6,
          "x": 67,
          "y": 44,
          "tw_start": 373,
          "tw_end": 603
        },
        {
          "id": 7,
          "x": 51,
          "y": 58,
          "tw_start": 110,
          "tw_end": 389
        },
        {
          "id": 8,
          "x": 68,
          "y": 85,
          "tw_start": 86,
          "tw_end": 374
        },
        {
          "id": 9,
          "x": 61,
          "y": 85,
          "tw_start": 4,
          "tw_end": 292
        },
        {
          "id": 10,
          "x": 67,
          "y": 100,
          "tw_start": 16,
          "tw_end": 297
        },
        {
          "id": 11,
          "x": 79,
          "y": 93,
          "tw_start": 204,
          "tw_end": 495
        },
        {
          "id": 12,
          "x": 100,
          "y": 57,
          "tw_start": 28,
          "tw_end": 276
        },
        {
          "id": 13,
          "x": 87,
          "y": 92,
          "tw_start": 376,
          "tw_end": 620
        },
        {
          "id": 14,
          "x": 99,
          "y": 5,
          "tw_start": 244,
          "tw_end": 505
        },
        {
          "id": 15,
          "x": 0,
          "y": 0,
          "tw_start": 176,
          "tw_end": 431
        }
      ],
      "depot": 1,
      "objective": 630.2659270772839
    },
    "solution_variant": [
      1,
      2,
      3,
      4,
      7,
      9,
      8,
      10,
      11,
      12,
      14,
      15,
      5,
      13,
      6,
      1
    ],
    "context_index": 19,
    "input_format": "nl",
    "input_index_base": 1
  },
  {
    "task_name": "TSPTW",
    "problem_type": "TSPTW",
    "instruction": "On a typical morning a community health worker straps on a GPS and a schedule: leave the clinic, visit each household once during its allotted appointment window (it’s acceptable to wait if arriving ahead of time), and return to the clinic at day’s end. The practical question is how to arrange the stops so the total miles driven are as small as possible — calculate that by adding every leg of the trip, from clinic to first house, between houses, and back to the clinic; the route with the lowest sum is preferable. No household can be missed or visited more than once, and every visit must fall inside its planned window. The concrete details will be shown below.\n\nThere are 12 locations including the clinic, which is node 1.\n\n| household_node_id | x_coordinate_map | y_coordinate_map | visit_window_start_time | visit_window_end_time |\n|---|---|---|---|---|\n| 1 | 15 | 84 | 0 | 1067 |\n| 2 | 100 | 70 | 226 | 508 |\n| 3 | 81 | 66 | 17 | 238 |\n| 4 | 66 | 58 | 368 | 649 |\n| 5 | 83 | 57 | 176 | 430 |\n| 6 | 87 | 56 | 107 | 319 |\n| 7 | 53 | 53 | 179 | 408 |\n| 8 | 61 | 52 | 226 | 427 |\n| 9 | 28 | 20 | 378 | 667 |\n| 10 | 0 | 100 | 270 | 516 |\n| 11 | 2 | 99 | 120 | 393 |\n| 12 | 96 | 0 | 265 | 475 |\n\nThese lines enumerate every location the worker must visit once within its allotted window.\n\nWhen you send the route back, just stick to a tiny JSON layout so it's easy to read and machine-friendly. Something like this will do:\n\n{\n  \"solution\": [clinic_id, household_id, ..., clinic_id]\n}\n\nThis shows the visit order: start at the clinic, go to each household in the listed sequence (you can wait if you arrive early), and finish back at the clinic. It's just a sketch of the shape I expect — not the actual route yet.\n\nPlease make sure you use the exact identifiers from the instance input, without renaming or inventing new labels. \nfor example: \"Valid identifiers look like plain numbers such as “1” or “23”, single capital letters like “A” or “B”, or a capital letter followed by digits like “A1” or “X7”.\"",
    "instance": {
      "coordinates": [
        [
          15,
          84
        ],
        [
          100,
          70
        ],
        [
          81,
          66
        ],
        [
          66,
          58
        ],
        [
          83,
          57
        ],
        [
          87,
          56
        ],
        [
          53,
          53
        ],
        [
          61,
          52
        ],
        [
          28,
          20
        ],
        [
          0,
          100
        ],
        [
          2,
          99
        ],
        [
          96,
          0
        ]
      ],
      "depot": 0,
      "num_nodes": 12,
      "time_windows": [
        [
          0,
          1067
        ],
        [
          226,
          508
        ],
        [
          17,
          238
        ],
        [
          368,
          649
        ],
        [
          176,
          430
        ],
        [
          107,
          319
        ],
        [
          179,
          408
        ],
        [
          226,
          427
        ],
        [
          378,
          667
        ],
        [
          270,
          516
        ],
        [
          120,
          393
        ],
        [
          265,
          475
        ]
      ],
      "tour_length": 435.83557696493887,
      "objective": 435.83557696493887
    },
    "solution": [
      0,
      10,
      2,
      1,
      5,
      4,
      11,
      3,
      7,
      6,
      8,
      9,
      0
    ],
    "obj": 435.83557696493887,
    "instance_variant": {
      "problem_type": "TSPTW",
      "num_nodes": 12,
      "nodes": [
        {
          "id": 1,
          "x": 15,
          "y": 84,
          "tw_start": 0,
          "tw_end": 1067
        },
        {
          "id": 2,
          "x": 100,
          "y": 70,
          "tw_start": 226,
          "tw_end": 508
        },
        {
          "id": 3,
          "x": 81,
          "y": 66,
          "tw_start": 17,
          "tw_end": 238
        },
        {
          "id": 4,
          "x": 66,
          "y": 58,
          "tw_start": 368,
          "tw_end": 649
        },
        {
          "id": 5,
          "x": 83,
          "y": 57,
          "tw_start": 176,
          "tw_end": 430
        },
        {
          "id": 6,
          "x": 87,
          "y": 56,
          "tw_start": 107,
          "tw_end": 319
        },
        {
          "id": 7,
          "x": 53,
          "y": 53,
          "tw_start": 179,
          "tw_end": 408
        },
        {
          "id": 8,
          "x": 61,
          "y": 52,
          "tw_start": 226,
          "tw_end": 427
        },
        {
          "id": 9,
          "x": 28,
          "y": 20,
          "tw_start": 378,
          "tw_end": 667
        },
        {
          "id": 10,
          "x": 0,
          "y": 100,
          "tw_start": 270,
          "tw_end": 516
        },
        {
          "id": 11,
          "x": 2,
          "y": 99,
          "tw_start": 120,
          "tw_end": 393
        },
        {
          "id": 12,
          "x": 96,
          "y": 0,
          "tw_start": 265,
          "tw_end": 475
        }
      ],
      "depot": 1,
      "objective": 435.83557696493887
    },
    "solution_variant": [
      1,
      11,
      3,
      2,
      6,
      5,
      12,
      4,
      8,
      7,
      9,
      10,
      1
    ],
    "context_index": 20,
    "input_format": "markdown_table",
    "input_index_base": 1
  },
  {
    "task_name": "TSPTW",
    "problem_type": "TSPTW",
    "instruction": "Many mornings the challenge is the same: leave the oven, pop into every cafe on the list once while they’re open, and return to the oven, all while keeping the odometer reading as low as possible. The best route is the one with the smallest total miles — calculated by summing every driving leg from one stop to the next and including the trips from and back to the oven. It’s okay to wait for an opening, but each cafe must be visited exactly one time. Exact locations, time windows and mileages follow below.\n\nThere are 11 stops in total, with the oven at node A.\nCafe A at (75, 97); open from 0 to 1067.\nCafe B at (67, 40); open from 298 to 584.\nCafe C at (44, 32); open from 329 to 547.\nCafe D at (29, 40); open from 174 to 381.\nCafe E at (92, 95); open from 370 to 622.\nCafe F at (28, 40); open from 88 to 347.\nCafe G at (78, 100); open from 239 to 468.\nCafe H at (49, 30); open from 44 to 303.\nCafe I at (25, 0); open from 201 to 470.\nCafe J at (0, 66); open from 201 to 478.\nCafe K at (100, 95); open from 214 to 462.\nVisit each of the 11 stops exactly once and return to the oven at node A.\n\nOh, and when you send the actual route back, please use a little JSON snippet like this — just a tidy list that starts and ends at the oven:\n\n{\n  \"solution\": [oven_id, cafe_id, ..., oven_id]\n}\n\nThink of \"solution\" as the ordered list of stops: the first item is the oven, then every cafe exactly once in the order you’ll visit them, and then the oven again to finish. It’s just a simple checklist, not the final answer — a sketch of the shape I’m expecting.\n\nPlease use the exact identifiers from the instance input — don’t rename them or invent new ones.  \nValid identifiers look like plain numbers such as “1” or “23”, single capital letters like “A” or “B”, or a capital letter followed by digits like “A1” or “X7”.",
    "instance": {
      "coordinates": [
        [
          75,
          97
        ],
        [
          67,
          40
        ],
        [
          44,
          32
        ],
        [
          29,
          40
        ],
        [
          92,
          95
        ],
        [
          28,
          40
        ],
        [
          78,
          100
        ],
        [
          49,
          30
        ],
        [
          25,
          0
        ],
        [
          0,
          66
        ],
        [
          100,
          95
        ]
      ],
      "depot": 0,
      "num_nodes": 11,
      "time_windows": [
        [
          0,
          1067
        ],
        [
          298,
          584
        ],
        [
          329,
          547
        ],
        [
          174,
          381
        ],
        [
          370,
          622
        ],
        [
          88,
          347
        ],
        [
          239,
          468
        ],
        [
          44,
          303
        ],
        [
          201,
          470
        ],
        [
          201,
          478
        ],
        [
          214,
          462
        ]
      ],
      "tour_length": 333.9599055431392,
      "objective": 333.9599055431392
    },
    "solution": [
      0,
      9,
      5,
      3,
      7,
      8,
      2,
      1,
      10,
      4,
      6,
      0
    ],
    "obj": 333.9599055431392,
    "instance_variant": {
      "problem_type": "TSPTW",
      "num_nodes": 11,
      "nodes": [
        {
          "id": "A",
          "x": 75,
          "y": 97,
          "tw_start": 0,
          "tw_end": 1067
        },
        {
          "id": "B",
          "x": 67,
          "y": 40,
          "tw_start": 298,
          "tw_end": 584
        },
        {
          "id": "C",
          "x": 44,
          "y": 32,
          "tw_start": 329,
          "tw_end": 547
        },
        {
          "id": "D",
          "x": 29,
          "y": 40,
          "tw_start": 174,
          "tw_end": 381
        },
        {
          "id": "E",
          "x": 92,
          "y": 95,
          "tw_start": 370,
          "tw_end": 622
        },
        {
          "id": "F",
          "x": 28,
          "y": 40,
          "tw_start": 88,
          "tw_end": 347
        },
        {
          "id": "G",
          "x": 78,
          "y": 100,
          "tw_start": 239,
          "tw_end": 468
        },
        {
          "id": "H",
          "x": 49,
          "y": 30,
          "tw_start": 44,
          "tw_end": 303
        },
        {
          "id": "I",
          "x": 25,
          "y": 0,
          "tw_start": 201,
          "tw_end": 470
        },
        {
          "id": "J",
          "x": 0,
          "y": 66,
          "tw_start": 201,
          "tw_end": 478
        },
        {
          "id": "K",
          "x": 100,
          "y": 95,
          "tw_start": 214,
          "tw_end": 462
        }
      ],
      "depot": "A",
      "objective": 333.9599055431392
    },
    "solution_variant": [
      "A",
      "J",
      "F",
      "D",
      "H",
      "I",
      "C",
      "B",
      "K",
      "E",
      "G",
      "A"
    ],
    "context_index": 21,
    "input_format": "nl",
    "input_index_base": "names"
  },
  {
    "task_name": "TSPTW",
    "problem_type": "TSPTW",
    "instruction": "Out in the field the situation is straightforward: a technician drives out from the depot, visits a set of ATMs exactly one time each within their service windows, and finishes the loop back at the depot. The question is how to order and time the visits so every ATM is covered once, no visit falls outside its allowed time, and the whole trip is as short as possible — measure that by summing up the distance of every leg of the route. Waiting for a window to open is allowed. The concrete details are below.\n\n{\n  \"total_locations\": 14,\n  \"nodes\": [\n    {\n      \"location_id\": 1,\n      \"x_coordinate\": 36,\n      \"y_coordinate\": 93,\n      \"service_window_start\": 0,\n      \"service_window_end\": 1067\n    },\n    {\n      \"location_id\": 2,\n      \"x_coordinate\": 32,\n      \"y_coordinate\": 93,\n      \"service_window_start\": 340,\n      \"service_window_end\": 573\n    },\n    {\n      \"location_id\": 3,\n      \"x_coordinate\": 47,\n      \"y_coordinate\": 79,\n      \"service_window_start\": 51,\n      \"service_window_end\": 248\n    },\n    {\n      \"location_id\": 4,\n      \"x_coordinate\": 43,\n      \"y_coordinate\": 34,\n      \"service_window_start\": 292,\n      \"service_window_end\": 547\n    },\n    {\n      \"location_id\": 5,\n      \"x_coordinate\": 31,\n      \"y_coordinate\": 33,\n      \"service_window_start\": 273,\n      \"service_window_end\": 487\n    },\n    {\n      \"location_id\": 6,\n      \"x_coordinate\": 51,\n      \"y_coordinate\": 33,\n      \"service_window_start\": 52,\n      \"service_window_end\": 248\n    },\n    {\n      \"location_id\": 7,\n      \"x_coordinate\": 4,\n      \"y_coordinate\": 100,\n      \"service_window_start\": 136,\n      \"service_window_end\": 387\n    },\n    {\n      \"location_id\": 8,\n      \"x_coordinate\": 2,\n      \"y_coordinate\": 99,\n      \"service_window_start\": 152,\n      \"service_window_end\": 388\n    },\n    {\n      \"location_id\": 9,\n      \"x_coordinate\": 0,\n      \"y_coordinate\": 100,\n      \"service_window_start\": 350,\n      \"service_window_end\": 578\n    },\n    {\n      \"location_id\": 10,\n      \"x_coordinate\": 73,\n      \"y_coordinate\": 0,\n      \"service_window_start\": 199,\n      \"service_window_end\": 469\n    },\n    {\n      \"location_id\": 11,\n      \"x_coordinate\": 3,\n      \"y_coordinate\": 1,\n      \"service_window_start\": 153,\n      \"service_window_end\": 408\n    },\n    {\n      \"location_id\": 12,\n      \"x_coordinate\": 2,\n      \"y_coordinate\": 0,\n      \"service_window_start\": 334,\n      \"service_window_end\": 620\n    },\n    {\n      \"location_id\": 13,\n      \"x_coordinate\": 100,\n      \"y_coordinate\": 100,\n      \"service_window_start\": 57,\n      \"service_window_end\": 340\n    },\n    {\n      \"location_id\": 14,\n      \"x_coordinate\": 19,\n      \"y_coordinate\": 99,\n      \"service_window_start\": 190,\n      \"service_window_end\": 409\n    }\n  ],\n  \"depot_node_id\": 1\n}\n\nJust toss the answer back in a tiny JSON object like this so it's easy to parse:\n\n{\n  \"solution\": [depot_id, location_id, ..., depot_id]\n}\n\nThis little block means: the \"solution\" field carries the route as an ordered list that starts at the depot, visits each ATM exactly once (in the order shown), and finishes at the depot again. Think of it as the simple form you fill in with the place IDs — it's just the shape I expect, not the real route.\n\nPlease use the exact identifiers from the instance input — do not rename them or invent new labels. \n- For example: \"Valid identifiers look like plain numbers such as “1” or “23”, single capital letters like “A” or “B”, or a capital letter followed by digits like “A1” or “X7”.\"",
    "instance": {
      "coordinates": [
        [
          36,
          93
        ],
        [
          32,
          93
        ],
        [
          47,
          79
        ],
        [
          43,
          34
        ],
        [
          31,
          33
        ],
        [
          51,
          33
        ],
        [
          4,
          100
        ],
        [
          2,
          99
        ],
        [
          0,
          100
        ],
        [
          73,
          0
        ],
        [
          3,
          1
        ],
        [
          2,
          0
        ],
        [
          100,
          100
        ],
        [
          19,
          99
        ]
      ],
      "depot": 0,
      "num_nodes": 14,
      "time_windows": [
        [
          0,
          1067
        ],
        [
          340,
          573
        ],
        [
          51,
          248
        ],
        [
          292,
          547
        ],
        [
          273,
          487
        ],
        [
          52,
          248
        ],
        [
          136,
          387
        ],
        [
          152,
          388
        ],
        [
          350,
          578
        ],
        [
          199,
          469
        ],
        [
          153,
          408
        ],
        [
          334,
          620
        ],
        [
          57,
          340
        ],
        [
          190,
          409
        ]
      ],
      "tour_length": 602.4832485845818,
      "objective": 602.4832485845818
    },
    "solution": [
      0,
      12,
      5,
      2,
      13,
      6,
      7,
      10,
      11,
      9,
      3,
      4,
      1,
      8,
      0
    ],
    "obj": 602.4832485845818,
    "instance_variant": {
      "problem_type": "TSPTW",
      "num_nodes": 14,
      "nodes": [
        {
          "id": 1,
          "x": 36,
          "y": 93,
          "tw_start": 0,
          "tw_end": 1067
        },
        {
          "id": 2,
          "x": 32,
          "y": 93,
          "tw_start": 340,
          "tw_end": 573
        },
        {
          "id": 3,
          "x": 47,
          "y": 79,
          "tw_start": 51,
          "tw_end": 248
        },
        {
          "id": 4,
          "x": 43,
          "y": 34,
          "tw_start": 292,
          "tw_end": 547
        },
        {
          "id": 5,
          "x": 31,
          "y": 33,
          "tw_start": 273,
          "tw_end": 487
        },
        {
          "id": 6,
          "x": 51,
          "y": 33,
          "tw_start": 52,
          "tw_end": 248
        },
        {
          "id": 7,
          "x": 4,
          "y": 100,
          "tw_start": 136,
          "tw_end": 387
        },
        {
          "id": 8,
          "x": 2,
          "y": 99,
          "tw_start": 152,
          "tw_end": 388
        },
        {
          "id": 9,
          "x": 0,
          "y": 100,
          "tw_start": 350,
          "tw_end": 578
        },
        {
          "id": 10,
          "x": 73,
          "y": 0,
          "tw_start": 199,
          "tw_end": 469
        },
        {
          "id": 11,
          "x": 3,
          "y": 1,
          "tw_start": 153,
          "tw_end": 408
        },
        {
          "id": 12,
          "x": 2,
          "y": 0,
          "tw_start": 334,
          "tw_end": 620
        },
        {
          "id": 13,
          "x": 100,
          "y": 100,
          "tw_start": 57,
          "tw_end": 340
        },
        {
          "id": 14,
          "x": 19,
          "y": 99,
          "tw_start": 190,
          "tw_end": 409
        }
      ],
      "depot": 1,
      "objective": 602.4832485845818
    },
    "solution_variant": [
      1,
      13,
      6,
      3,
      14,
      7,
      8,
      11,
      12,
      10,
      4,
      5,
      2,
      9,
      1
    ],
    "context_index": 22,
    "input_format": "json",
    "input_index_base": 1
  },
  {
    "task_name": "TSPTW",
    "problem_type": "TSPTW",
    "instruction": "We need to plan a route for a visiting nurse who starts and finishes at the clinic, visits each patient’s home one time only during that patient’s availability window, and can wait if she gets there early. The better plan is simply the one with the smallest total driving distance, calculated by summing the distance between each consecutive stop plus the return leg to the clinic. The concrete patient times and locations are shown below.\n\nThere are 11 locations in total and the clinic is node A.\nWe list location A at coordinates (63, 76) with availability window from 0 to 1067.\nWe list location B at coordinates (97, 16) with availability window from 178 to 467.\nWe list location C at coordinates (15, 73) with availability window from 191 to 417.\nWe list location D at coordinates (100, 96) with availability window from 245 to 463.\nWe list location E at coordinates (15, 28) with availability window from 29 to 235.\nWe list location F at coordinates (27, 12) with availability window from 49 to 258.\nWe list location G at coordinates (27, 45) with availability window from 53 to 310.\nWe list location H at coordinates (37, 11) with availability window from 70 to 298.\nWe list location I at coordinates (84, 100) with availability window from 347 to 587.\nWe list location J at coordinates (0, 26) with availability window from 259 to 469.\nWe list location K at coordinates (1, 0) with availability window from 74 to 272.\nWe will minimize total driving distance for a tour that starts and ends at clinic A.\n\nAlso, when you send back the nurse’s route, please use this simple JSON layout so it’s easy to read and parse:\n\n{\n  \"solution\": [clinic_id, patient_id, ..., clinic_id]\n}\n\nThink of that array as the ordered stops: start at the clinic, list each patient’s identifier in the order they should be visited (one time each), and finish back at the clinic. This is just a sketch of the shape I expect — don’t treat the example values as the actual answer.\n\nPlease make sure to use the exact identifiers from the instance input — don’t rename them or invent new ones. \n- Valid identifiers look like plain numbers such as “1” or “23”, single capital letters like “A” or “B”, or a capital letter followed by digits like “A1” or “X7”.",
    "instance": {
      "coordinates": [
        [
          63,
          76
        ],
        [
          97,
          16
        ],
        [
          15,
          73
        ],
        [
          100,
          96
        ],
        [
          15,
          28
        ],
        [
          27,
          12
        ],
        [
          27,
          45
        ],
        [
          37,
          11
        ],
        [
          84,
          100
        ],
        [
          0,
          26
        ],
        [
          1,
          0
        ]
      ],
      "depot": 0,
      "num_nodes": 11,
      "time_windows": [
        [
          0,
          1067
        ],
        [
          178,
          467
        ],
        [
          191,
          417
        ],
        [
          245,
          463
        ],
        [
          29,
          235
        ],
        [
          49,
          258
        ],
        [
          53,
          310
        ],
        [
          70,
          298
        ],
        [
          347,
          587
        ],
        [
          259,
          469
        ],
        [
          74,
          272
        ]
      ],
      "tour_length": 466.5581336532528,
      "objective": 466.5581336532528
    },
    "solution": [
      0,
      7,
      5,
      10,
      4,
      6,
      2,
      9,
      1,
      3,
      8,
      0
    ],
    "obj": 466.5581336532528,
    "instance_variant": {
      "problem_type": "TSPTW",
      "num_nodes": 11,
      "nodes": [
        {
          "id": "A",
          "x": 63,
          "y": 76,
          "tw_start": 0,
          "tw_end": 1067
        },
        {
          "id": "B",
          "x": 97,
          "y": 16,
          "tw_start": 178,
          "tw_end": 467
        },
        {
          "id": "C",
          "x": 15,
          "y": 73,
          "tw_start": 191,
          "tw_end": 417
        },
        {
          "id": "D",
          "x": 100,
          "y": 96,
          "tw_start": 245,
          "tw_end": 463
        },
        {
          "id": "E",
          "x": 15,
          "y": 28,
          "tw_start": 29,
          "tw_end": 235
        },
        {
          "id": "F",
          "x": 27,
          "y": 12,
          "tw_start": 49,
          "tw_end": 258
        },
        {
          "id": "G",
          "x": 27,
          "y": 45,
          "tw_start": 53,
          "tw_end": 310
        },
        {
          "id": "H",
          "x": 37,
          "y": 11,
          "tw_start": 70,
          "tw_end": 298
        },
        {
          "id": "I",
          "x": 84,
          "y": 100,
          "tw_start": 347,
          "tw_end": 587
        },
        {
          "id": "J",
          "x": 0,
          "y": 26,
          "tw_start": 259,
          "tw_end": 469
        },
        {
          "id": "K",
          "x": 1,
          "y": 0,
          "tw_start": 74,
          "tw_end": 272
        }
      ],
      "depot": "A",
      "objective": 466.5581336532528
    },
    "solution_variant": [
      "A",
      "H",
      "F",
      "K",
      "E",
      "G",
      "C",
      "J",
      "B",
      "D",
      "I",
      "A"
    ],
    "context_index": 23,
    "input_format": "nl",
    "input_index_base": "names"
  },
  {
    "task_name": "TSPTW",
    "problem_type": "TSPTW",
    "instruction": "Someone in the studio booked a string of one-off shoots across the city and needs a sensible route: leave the studio, go to each shoot exactly once during its scheduled access period, and return to the studio at the end. It’s okay to arrive early and wait for a location to open, but every location must be visited once and only once. The easy way to compare plans is to add up the travel between stops (and the final trip home) — the plan with the least total distance is the better plan. The exact schedule and location details are provided below.\n\nThere are 12 locations in total, and the studio (depot) is node A.\n\n| location_id | map_x_coordinate | map_y_coordinate | access_open_time | access_close_time |\n|---|---|---|---|---|\n| A | 0 | 88 | 0 | 1067 |\n| B | 78 | 15 | 65 | 286 |\n| C | 99 | 55 | 68 | 271 |\n| D | 93 | 100 | 46 | 285 |\n| E | 98 | 75 | 80 | 309 |\n| F | 84 | 65 | 195 | 456 |\n| G | 20 | 6 | 15 | 286 |\n| H | 81 | 93 | 243 | 445 |\n| I | 0 | 34 | 338 | 622 |\n| J | 22 | 0 | 23 | 244 |\n| K | 44 | 32 | 312 | 579 |\n| L | 100 | 90 | 71 | 285 |\n\nStart and finish the route at the studio (node A); visit every location once within its access window.\n\nOh, and when you send the route back, please use this simple JSON layout so it's easy to read and check:\n\n{\n  \"solution\": [studio_id, shoot_id, ..., studio_id]\n}\n\nThink of this like a little form: the \"solution\" field holds the ordered list of stops starting and ending at the studio. studio_id is the place we leave from and return to, each shoot_id is a shoot location visited once in the order shown, and the ... just means \"all the other stops in between\" — it's a sketch of the shape I need, not the actual route.\n\nPlease use the exact identifiers from the instance input — don't rename them or invent new labels. Valid identifiers look like plain numbers such as \"1\" or \"23\", single capital letters like \"A\" or \"B\", or a capital letter followed by digits like \"A1\" or \"X7\".",
    "instance": {
      "coordinates": [
        [
          0,
          88
        ],
        [
          78,
          15
        ],
        [
          99,
          55
        ],
        [
          93,
          100
        ],
        [
          98,
          75
        ],
        [
          84,
          65
        ],
        [
          20,
          6
        ],
        [
          81,
          93
        ],
        [
          0,
          34
        ],
        [
          22,
          0
        ],
        [
          44,
          32
        ],
        [
          100,
          90
        ]
      ],
      "depot": 0,
      "num_nodes": 12,
      "time_windows": [
        [
          0,
          1067
        ],
        [
          65,
          286
        ],
        [
          68,
          271
        ],
        [
          46,
          285
        ],
        [
          80,
          309
        ],
        [
          195,
          456
        ],
        [
          15,
          286
        ],
        [
          243,
          445
        ],
        [
          338,
          622
        ],
        [
          23,
          244
        ],
        [
          312,
          579
        ],
        [
          71,
          285
        ]
      ],
      "tour_length": 433.197892230933,
      "objective": 433.197892230933
    },
    "solution": [
      0,
      6,
      9,
      1,
      2,
      4,
      11,
      3,
      7,
      5,
      10,
      8,
      0
    ],
    "obj": 433.197892230933,
    "instance_variant": {
      "problem_type": "TSPTW",
      "num_nodes": 12,
      "nodes": [
        {
          "id": "A",
          "x": 0,
          "y": 88,
          "tw_start": 0,
          "tw_end": 1067
        },
        {
          "id": "B",
          "x": 78,
          "y": 15,
          "tw_start": 65,
          "tw_end": 286
        },
        {
          "id": "C",
          "x": 99,
          "y": 55,
          "tw_start": 68,
          "tw_end": 271
        },
        {
          "id": "D",
          "x": 93,
          "y": 100,
          "tw_start": 46,
          "tw_end": 285
        },
        {
          "id": "E",
          "x": 98,
          "y": 75,
          "tw_start": 80,
          "tw_end": 309
        },
        {
          "id": "F",
          "x": 84,
          "y": 65,
          "tw_start": 195,
          "tw_end": 456
        },
        {
          "id": "G",
          "x": 20,
          "y": 6,
          "tw_start": 15,
          "tw_end": 286
        },
        {
          "id": "H",
          "x": 81,
          "y": 93,
          "tw_start": 243,
          "tw_end": 445
        },
        {
          "id": "I",
          "x": 0,
          "y": 34,
          "tw_start": 338,
          "tw_end": 622
        },
        {
          "id": "J",
          "x": 22,
          "y": 0,
          "tw_start": 23,
          "tw_end": 244
        },
        {
          "id": "K",
          "x": 44,
          "y": 32,
          "tw_start": 312,
          "tw_end": 579
        },
        {
          "id": "L",
          "x": 100,
          "y": 90,
          "tw_start": 71,
          "tw_end": 285
        }
      ],
      "depot": "A",
      "objective": 433.197892230933
    },
    "solution_variant": [
      "A",
      "G",
      "J",
      "B",
      "C",
      "E",
      "L",
      "D",
      "H",
      "F",
      "K",
      "I",
      "A"
    ],
    "context_index": 24,
    "input_format": "markdown_table",
    "input_index_base": "names"
  },
  {
    "task_name": "TSPTW",
    "problem_type": "TSPTW",
    "instruction": "At the office there’s a route to plan: dispatch the salesperson, have them visit each retailer exactly once while they’re doing demos, and get them back to base before day’s end. The question is which route and timing will let every visit occur inside its demo slot (it’s acceptable to wait if arriving early), and the route that’s best is the one that minimizes total miles driven — total travel equals the sum of every trip between points plus the trips from and to the office. Every retailer must be visited one time only. The concrete times and places are listed below.\n\n{\n  \"total_locations_including_office\": 11,\n  \"nodes\": [\n    {\n      \"location_id\": 1,\n      \"x_coordinate\": 4,\n      \"y_coordinate\": 34,\n      \"demo_start_time\": 0,\n      \"demo_end_time\": 1067\n    },\n    {\n      \"location_id\": 2,\n      \"x_coordinate\": 97,\n      \"y_coordinate\": 17,\n      \"demo_start_time\": 143,\n      \"demo_end_time\": 384\n    },\n    {\n      \"location_id\": 3,\n      \"x_coordinate\": 9,\n      \"y_coordinate\": 0,\n      \"demo_start_time\": 239,\n      \"demo_end_time\": 469\n    },\n    {\n      \"location_id\": 4,\n      \"x_coordinate\": 0,\n      \"y_coordinate\": 38,\n      \"demo_start_time\": 179,\n      \"demo_end_time\": 445\n    },\n    {\n      \"location_id\": 5,\n      \"x_coordinate\": 3,\n      \"y_coordinate\": 48,\n      \"demo_start_time\": 14,\n      \"demo_end_time\": 232\n    },\n    {\n      \"location_id\": 6,\n      \"x_coordinate\": 31,\n      \"y_coordinate\": 77,\n      \"demo_start_time\": 276,\n      \"demo_end_time\": 557\n    },\n    {\n      \"location_id\": 7,\n      \"x_coordinate\": 42,\n      \"y_coordinate\": 57,\n      \"demo_start_time\": 198,\n      \"demo_end_time\": 444\n    },\n    {\n      \"location_id\": 8,\n      \"x_coordinate\": 65,\n      \"y_coordinate\": 48,\n      \"demo_start_time\": 41,\n      \"demo_end_time\": 278\n    },\n    {\n      \"location_id\": 9,\n      \"x_coordinate\": 74,\n      \"y_coordinate\": 57,\n      \"demo_start_time\": 206,\n      \"demo_end_time\": 424\n    },\n    {\n      \"location_id\": 10,\n      \"x_coordinate\": 100,\n      \"y_coordinate\": 77,\n      \"demo_start_time\": 104,\n      \"demo_end_time\": 335\n    },\n    {\n      \"location_id\": 11,\n      \"x_coordinate\": 13,\n      \"y_coordinate\": 100,\n      \"demo_start_time\": 7,\n      \"demo_end_time\": 233\n    }\n  ],\n  \"office_node_id\": 1\n}\n\nAlso, if you want to give me the route in a tidy, machine-friendly form, here's the little JSON shape I expect — just a simple list that starts and ends at the office.\n\n{\n  \"solution\": [office_id, retailer_id, ..., office_id]\n}\n\nThink of this as a form: \"solution\" is the ordered tour (start at the office, visit each retailer once, come back to the office). The placeholders here stand in for the exact IDs from the instance — you’ll replace them with the real identifiers when you send the actual route. This snippet is only a sketch of the expected shape, not the final answer.\n\nPlease use the identifiers exactly as they appear in the instance input — do not rename them and do not invent new labels.\n\nValid identifiers look like plain numbers such as \"1\" or \"23\", single capital letters like \"A\" or \"B\", or a capital letter followed by digits like \"A1\" or \"X7\".",
    "instance": {
      "coordinates": [
        [
          4,
          34
        ],
        [
          97,
          17
        ],
        [
          9,
          0
        ],
        [
          0,
          38
        ],
        [
          3,
          48
        ],
        [
          31,
          77
        ],
        [
          42,
          57
        ],
        [
          65,
          48
        ],
        [
          74,
          57
        ],
        [
          100,
          77
        ],
        [
          13,
          100
        ]
      ],
      "depot": 0,
      "num_nodes": 11,
      "time_windows": [
        [
          0,
          1067
        ],
        [
          143,
          384
        ],
        [
          239,
          469
        ],
        [
          179,
          445
        ],
        [
          14,
          232
        ],
        [
          276,
          557
        ],
        [
          198,
          444
        ],
        [
          41,
          278
        ],
        [
          206,
          424
        ],
        [
          104,
          335
        ],
        [
          7,
          233
        ]
      ],
      "tour_length": 446.6815357093644,
      "objective": 446.6815357093644
    },
    "solution": [
      0,
      4,
      10,
      9,
      1,
      8,
      7,
      6,
      5,
      3,
      2,
      0
    ],
    "obj": 446.6815357093644,
    "instance_variant": {
      "problem_type": "TSPTW",
      "num_nodes": 11,
      "nodes": [
        {
          "id": 1,
          "x": 4,
          "y": 34,
          "tw_start": 0,
          "tw_end": 1067
        },
        {
          "id": 2,
          "x": 97,
          "y": 17,
          "tw_start": 143,
          "tw_end": 384
        },
        {
          "id": 3,
          "x": 9,
          "y": 0,
          "tw_start": 239,
          "tw_end": 469
        },
        {
          "id": 4,
          "x": 0,
          "y": 38,
          "tw_start": 179,
          "tw_end": 445
        },
        {
          "id": 5,
          "x": 3,
          "y": 48,
          "tw_start": 14,
          "tw_end": 232
        },
        {
          "id": 6,
          "x": 31,
          "y": 77,
          "tw_start": 276,
          "tw_end": 557
        },
        {
          "id": 7,
          "x": 42,
          "y": 57,
          "tw_start": 198,
          "tw_end": 444
        },
        {
          "id": 8,
          "x": 65,
          "y": 48,
          "tw_start": 41,
          "tw_end": 278
        },
        {
          "id": 9,
          "x": 74,
          "y": 57,
          "tw_start": 206,
          "tw_end": 424
        },
        {
          "id": 10,
          "x": 100,
          "y": 77,
          "tw_start": 104,
          "tw_end": 335
        },
        {
          "id": 11,
          "x": 13,
          "y": 100,
          "tw_start": 7,
          "tw_end": 233
        }
      ],
      "depot": 1,
      "objective": 446.6815357093644
    },
    "solution_variant": [
      1,
      5,
      11,
      10,
      2,
      9,
      8,
      7,
      6,
      4,
      3,
      1
    ],
    "context_index": 25,
    "input_format": "json",
    "input_index_base": 1
  },
  {
    "task_name": "TSPTW",
    "problem_type": "TSPTW",
    "instruction": "Recently the branch started planning mobile visits to neighborhood centers, and the challenge is to plan one loop that starts and finishes at the branch, drops by every center once while respecting their allowed visit times, and keeps the driving as low as possible. To tell which loop is best, add up the distance of every leg of the trip — the lowest total distance is the winner. Visits can be delayed by waiting if arriving early, but each center must be visited exactly once. The concrete details are given below.\n\n# total_stops_including_branch=11\n# branch_node_id=A\n# time windows are listed per node in the table\nlocation_node_id,map_x_coordinate,map_y_coordinate,visit_window_start,visit_window_end\nA,100,0,0,1067\nB,70,10,82,307\nC,87,79,46,326\nD,71,100,230,490\nE,61,44,306,548\nF,69,47,33,279\nG,35,10,227,494\nH,25,71,167,373\nI,1,74,110,339\nJ,6,49,250,499\nK,0,8,138,427\n\nWhen you send the route back, just use a tiny JSON layout so it's easy to read and plug into the planner. For example, something in the shape below works nicely:\n\n{\n  \"solution\": [branch_id, center_id, ..., branch_id]\n}\n\n\"solution\" is the ordered loop: the first and last entry are the branch, and everything in between is a center in the order you'll visit them. Think of it as a simple form to fill out — it's just the shape we expect, not the real route itself.\n\nPlease use the exact identifiers from the instance input — don't rename them or invent new labels.\n- for example: \"Valid identifiers look like plain numbers such as “1” or “23”, single capital letters like “A” or “B”, or a capital letter followed by digits like “A1” or “X7”.\"",
    "instance": {
      "coordinates": [
        [
          100,
          0
        ],
        [
          70,
          10
        ],
        [
          87,
          79
        ],
        [
          71,
          100
        ],
        [
          61,
          44
        ],
        [
          69,
          47
        ],
        [
          35,
          10
        ],
        [
          25,
          71
        ],
        [
          1,
          74
        ],
        [
          6,
          49
        ],
        [
          0,
          8
        ]
      ],
      "depot": 0,
      "num_nodes": 11,
      "time_windows": [
        [
          0,
          1067
        ],
        [
          82,
          307
        ],
        [
          46,
          326
        ],
        [
          230,
          490
        ],
        [
          306,
          548
        ],
        [
          33,
          279
        ],
        [
          227,
          494
        ],
        [
          167,
          373
        ],
        [
          110,
          339
        ],
        [
          250,
          499
        ],
        [
          138,
          427
        ]
      ],
      "tour_length": 413.9042625232761,
      "objective": 413.9042625232761
    },
    "solution": [
      0,
      1,
      5,
      2,
      3,
      7,
      8,
      9,
      10,
      6,
      4,
      0
    ],
    "obj": 413.9042625232761,
    "instance_variant": {
      "problem_type": "TSPTW",
      "num_nodes": 11,
      "nodes": [
        {
          "id": "A",
          "x": 100,
          "y": 0,
          "tw_start": 0,
          "tw_end": 1067
        },
        {
          "id": "B",
          "x": 70,
          "y": 10,
          "tw_start": 82,
          "tw_end": 307
        },
        {
          "id": "C",
          "x": 87,
          "y": 79,
          "tw_start": 46,
          "tw_end": 326
        },
        {
          "id": "D",
          "x": 71,
          "y": 100,
          "tw_start": 230,
          "tw_end": 490
        },
        {
          "id": "E",
          "x": 61,
          "y": 44,
          "tw_start": 306,
          "tw_end": 548
        },
        {
          "id": "F",
          "x": 69,
          "y": 47,
          "tw_start": 33,
          "tw_end": 279
        },
        {
          "id": "G",
          "x": 35,
          "y": 10,
          "tw_start": 227,
          "tw_end": 494
        },
        {
          "id": "H",
          "x": 25,
          "y": 71,
          "tw_start": 167,
          "tw_end": 373
        },
        {
          "id": "I",
          "x": 1,
          "y": 74,
          "tw_start": 110,
          "tw_end": 339
        },
        {
          "id": "J",
          "x": 6,
          "y": 49,
          "tw_start": 250,
          "tw_end": 499
        },
        {
          "id": "K",
          "x": 0,
          "y": 8,
          "tw_start": 138,
          "tw_end": 427
        }
      ],
      "depot": "A",
      "objective": 413.9042625232761
    },
    "solution_variant": [
      "A",
      "B",
      "F",
      "C",
      "D",
      "H",
      "I",
      "J",
      "K",
      "G",
      "E",
      "A"
    ],
    "context_index": 26,
    "input_format": "csv",
    "input_index_base": "names"
  },
  {
    "task_name": "TSPTW",
    "problem_type": "TSPTW",
    "instruction": "We have a single truck that must leave the farm, visit every market stall one time to set up during its assigned opening window, and then return to the farm at the end. The decision is simply the order of visits — a good order means the total miles driven (add up all the legs: farm to first, between stalls, and back to farm) is as small as possible. Every stall must be visited exactly once within its time slot, and standing by until a stall’s setup window starts is allowed. The concrete details are listed below.\n\n{\n  \"total_locations_including_farm\": 11,\n  \"nodes\": [\n    {\n      \"location_id\": \"A\",\n      \"x_coordinate\": 11,\n      \"y_coordinate\": 0,\n      \"setup_window_start\": 0,\n      \"setup_window_end\": 1067\n    },\n    {\n      \"location_id\": \"B\",\n      \"x_coordinate\": 97,\n      \"y_coordinate\": 21,\n      \"setup_window_start\": 235,\n      \"setup_window_end\": 452\n    },\n    {\n      \"location_id\": \"C\",\n      \"x_coordinate\": 100,\n      \"y_coordinate\": 77,\n      \"setup_window_start\": 39,\n      \"setup_window_end\": 248\n    },\n    {\n      \"location_id\": \"D\",\n      \"x_coordinate\": 81,\n      \"y_coordinate\": 78,\n      \"setup_window_start\": 95,\n      \"setup_window_end\": 305\n    },\n    {\n      \"location_id\": \"E\",\n      \"x_coordinate\": 66,\n      \"y_coordinate\": 28,\n      \"setup_window_start\": 72,\n      \"setup_window_end\": 294\n    },\n    {\n      \"location_id\": \"F\",\n      \"x_coordinate\": 41,\n      \"y_coordinate\": 12,\n      \"setup_window_start\": 67,\n      \"setup_window_end\": 348\n    },\n    {\n      \"location_id\": \"G\",\n      \"x_coordinate\": 34,\n      \"y_coordinate\": 60,\n      \"setup_window_start\": 31,\n      \"setup_window_end\": 276\n    },\n    {\n      \"location_id\": \"H\",\n      \"x_coordinate\": 57,\n      \"y_coordinate\": 99,\n      \"setup_window_start\": 159,\n      \"setup_window_end\": 448\n    },\n    {\n      \"location_id\": \"I\",\n      \"x_coordinate\": 57,\n      \"y_coordinate\": 100,\n      \"setup_window_start\": 43,\n      \"setup_window_end\": 276\n    },\n    {\n      \"location_id\": \"J\",\n      \"x_coordinate\": 3,\n      \"y_coordinate\": 79,\n      \"setup_window_start\": 376,\n      \"setup_window_end\": 654\n    },\n    {\n      \"location_id\": \"K\",\n      \"x_coordinate\": 0,\n      \"y_coordinate\": 19,\n      \"setup_window_start\": 317,\n      \"setup_window_end\": 536\n    }\n  ],\n  \"farm_depot_id\": \"A\"\n}\n\nYou can return the chosen route in a tiny JSON object like this — nothing fancy, just the order of stops so I know which stall you hit when and that you start and end at the farm:\n\n{\n  \"solution\": [farm_id, stall_id, ..., farm_id]\n}\n\nJust so it’s clear: \"solution\" holds the list of stops in order, beginning and ending with the farm. Each placeholder there stands for the identifier of the farm or a stall (the \"...\" just means all the other stalls in between). This is only a sketch of the shape I expect — don’t treat these placeholders as your actual answer.\n\nPlease use the exact identifiers from the instance input, with no renaming and no new labels. \n- for example: \"Valid identifiers look like plain numbers such as “1” or “23”, single capital letters like “A” or “B”, or a capital letter followed by digits like “A1” or “X7”.\"",
    "instance": {
      "coordinates": [
        [
          11,
          0
        ],
        [
          97,
          21
        ],
        [
          100,
          77
        ],
        [
          81,
          78
        ],
        [
          66,
          28
        ],
        [
          41,
          12
        ],
        [
          34,
          60
        ],
        [
          57,
          99
        ],
        [
          57,
          100
        ],
        [
          3,
          79
        ],
        [
          0,
          19
        ]
      ],
      "depot": 0,
      "num_nodes": 11,
      "time_windows": [
        [
          0,
          1067
        ],
        [
          235,
          452
        ],
        [
          39,
          248
        ],
        [
          95,
          305
        ],
        [
          72,
          294
        ],
        [
          67,
          348
        ],
        [
          31,
          276
        ],
        [
          159,
          448
        ],
        [
          43,
          276
        ],
        [
          376,
          654
        ],
        [
          317,
          536
        ]
      ],
      "tour_length": 453.67169279809957,
      "objective": 453.67169279809957
    },
    "solution": [
      0,
      5,
      4,
      6,
      7,
      8,
      3,
      2,
      1,
      9,
      10,
      0
    ],
    "obj": 453.67169279809957,
    "instance_variant": {
      "problem_type": "TSPTW",
      "num_nodes": 11,
      "nodes": [
        {
          "id": "A",
          "x": 11,
          "y": 0,
          "tw_start": 0,
          "tw_end": 1067
        },
        {
          "id": "B",
          "x": 97,
          "y": 21,
          "tw_start": 235,
          "tw_end": 452
        },
        {
          "id": "C",
          "x": 100,
          "y": 77,
          "tw_start": 39,
          "tw_end": 248
        },
        {
          "id": "D",
          "x": 81,
          "y": 78,
          "tw_start": 95,
          "tw_end": 305
        },
        {
          "id": "E",
          "x": 66,
          "y": 28,
          "tw_start": 72,
          "tw_end": 294
        },
        {
          "id": "F",
          "x": 41,
          "y": 12,
          "tw_start": 67,
          "tw_end": 348
        },
        {
          "id": "G",
          "x": 34,
          "y": 60,
          "tw_start": 31,
          "tw_end": 276
        },
        {
          "id": "H",
          "x": 57,
          "y": 99,
          "tw_start": 159,
          "tw_end": 448
        },
        {
          "id": "I",
          "x": 57,
          "y": 100,
          "tw_start": 43,
          "tw_end": 276
        },
        {
          "id": "J",
          "x": 3,
          "y": 79,
          "tw_start": 376,
          "tw_end": 654
        },
        {
          "id": "K",
          "x": 0,
          "y": 19,
          "tw_start": 317,
          "tw_end": 536
        }
      ],
      "depot": "A",
      "objective": 453.67169279809957
    },
    "solution_variant": [
      "A",
      "F",
      "E",
      "G",
      "H",
      "I",
      "D",
      "C",
      "B",
      "J",
      "K",
      "A"
    ],
    "context_index": 27,
    "input_format": "json",
    "input_index_base": "names"
  },
  {
    "task_name": "TSPTW",
    "problem_type": "TSPTW",
    "instruction": "Back at headquarters the morning plan is simple: the inspector must start here, knock out inspections at all sites exactly once within each site’s specified inspection window (it’s okay to wait until the slot opens), and return here at the end of the run. Routes are judged by how much driving they require — add up each leg from one place to the next, including returning to HQ, and the route with the smallest total distance wins. The full details for each site and its time window are shown below.\n\n# total_locations_count=13\n# hq_node_id=A\n# time windows are listed per node in the table\nsite_id,x_coord,y_coord,inspection_window_open,inspection_window_close\nA,34,100,0,1067\nB,19,9,294,546\nC,73,64,182,416\nD,26,11,135,419\nE,1,83,322,609\nF,86,52,48,313\nG,100,79,364,575\nH,66,63,25,291\nI,90,76,222,498\nJ,80,0,54,325\nK,21,31,78,288\nL,0,63,63,336\nM,70,66,258,502\n\nOh, and when you send the route back, just use a little JSON sketch like this so it's easy to parse:\n\n{\n  \"solution\": [hq_id, site_id, ..., hq_id]\n}\n\nThink of that as a simple form: the solution array is the visit order — start at HQ, list every site once in the order you’ll visit them, and finish back at HQ. It’s just the shape I expect, not the actual route.\n\nPlease make sure to use the exact identifiers from the instance input — don’t rename them or invent new ones.  \nFor example: Valid identifiers look like plain numbers such as “1” or “23”, single capital letters like “A” or “B”, or a capital letter followed by digits like “A1” or “X7”.",
    "instance": {
      "coordinates": [
        [
          34,
          100
        ],
        [
          19,
          9
        ],
        [
          73,
          64
        ],
        [
          26,
          11
        ],
        [
          1,
          83
        ],
        [
          86,
          52
        ],
        [
          100,
          79
        ],
        [
          66,
          63
        ],
        [
          90,
          76
        ],
        [
          80,
          0
        ],
        [
          21,
          31
        ],
        [
          0,
          63
        ],
        [
          70,
          66
        ]
      ],
      "depot": 0,
      "num_nodes": 13,
      "time_windows": [
        [
          0,
          1067
        ],
        [
          294,
          546
        ],
        [
          182,
          416
        ],
        [
          135,
          419
        ],
        [
          322,
          609
        ],
        [
          48,
          313
        ],
        [
          364,
          575
        ],
        [
          25,
          291
        ],
        [
          222,
          498
        ],
        [
          54,
          325
        ],
        [
          78,
          288
        ],
        [
          63,
          336
        ],
        [
          258,
          502
        ]
      ],
      "tour_length": 498.46455416197995,
      "objective": 498.46455416197995
    },
    "solution": [
      0,
      11,
      10,
      3,
      9,
      5,
      7,
      12,
      8,
      6,
      2,
      1,
      4,
      0
    ],
    "obj": 498.46455416197995,
    "instance_variant": {
      "problem_type": "TSPTW",
      "num_nodes": 13,
      "nodes": [
        {
          "id": "A",
          "x": 34,
          "y": 100,
          "tw_start": 0,
          "tw_end": 1067
        },
        {
          "id": "B",
          "x": 19,
          "y": 9,
          "tw_start": 294,
          "tw_end": 546
        },
        {
          "id": "C",
          "x": 73,
          "y": 64,
          "tw_start": 182,
          "tw_end": 416
        },
        {
          "id": "D",
          "x": 26,
          "y": 11,
          "tw_start": 135,
          "tw_end": 419
        },
        {
          "id": "E",
          "x": 1,
          "y": 83,
          "tw_start": 322,
          "tw_end": 609
        },
        {
          "id": "F",
          "x": 86,
          "y": 52,
          "tw_start": 48,
          "tw_end": 313
        },
        {
          "id": "G",
          "x": 100,
          "y": 79,
          "tw_start": 364,
          "tw_end": 575
        },
        {
          "id": "H",
          "x": 66,
          "y": 63,
          "tw_start": 25,
          "tw_end": 291
        },
        {
          "id": "I",
          "x": 90,
          "y": 76,
          "tw_start": 222,
          "tw_end": 498
        },
        {
          "id": "J",
          "x": 80,
          "y": 0,
          "tw_start": 54,
          "tw_end": 325
        },
        {
          "id": "K",
          "x": 21,
          "y": 31,
          "tw_start": 78,
          "tw_end": 288
        },
        {
          "id": "L",
          "x": 0,
          "y": 63,
          "tw_start": 63,
          "tw_end": 336
        },
        {
          "id": "M",
          "x": 70,
          "y": 66,
          "tw_start": 258,
          "tw_end": 502
        }
      ],
      "depot": "A",
      "objective": 498.46455416197995
    },
    "solution_variant": [
      "A",
      "L",
      "K",
      "D",
      "J",
      "F",
      "H",
      "M",
      "I",
      "G",
      "C",
      "B",
      "E",
      "A"
    ],
    "context_index": 28,
    "input_format": "csv",
    "input_index_base": "names"
  },
  {
    "task_name": "TSPTW",
    "problem_type": "TSPTW",
    "instruction": "Recently the gardening company had to sort out a day’s work — a team leaves the depot, must tend each customer’s garden one time during that customer’s scheduled window, and then return to the depot. The job is to pick the sequence of visits so the total driving is as small as possible: for each plan, sum the lengths of the legs between stops (and back home) and choose the smallest total. Every client must be visited exactly once and time windows must be respected; arriving early can be handled by waiting. The full list of appointments and distances is shown below.\n\nThey must handle 14 locations in total, with the depot at 1.\n\n| location_id | x_coordinate | y_coordinate | time_window_start | time_window_end |\n|---|---|---|---|---|\n| 1 | 0 | 100 | 0 | 1067 |\n| 2 | 22 | 16 | 139 | 418 |\n| 3 | 41 | 29 | 152 | 425 |\n| 4 | 45 | 58 | 170 | 400 |\n| 5 | 76 | 16 | 179 | 402 |\n| 6 | 69 | 100 | 290 | 532 |\n| 7 | 76 | 100 | 90 | 371 |\n| 8 | 100 | 81 | 148 | 395 |\n| 9 | 95 | 90 | 351 | 606 |\n| 10 | 83 | 36 | 45 | 330 |\n| 11 | 83 | 26 | 243 | 470 |\n| 12 | 88 | 7 | 54 | 325 |\n| 13 | 45 | 0 | 240 | 486 |\n| 14 | 31 | 100 | 346 | 617 |\n\nEvery plan must visit all 14 locations and return to 1.\n\nWhen you're ready to give the planned route, just hand it back in this simple JSON layout so it's easy to read:\n\n{\n  \"solution\": [\"depot_id\", \"location_id\", \"...\", \"depot_id\"]\n}\n\nThis just means: \"solution\" is the sequence of stops — start at the depot, list each customer once in the order they'll be visited, and end at the depot. The names in the example are placeholders to show the shape; they're not the actual labels from the instance.\n\nThe JSON above is only a sketch of the expected shape, not the final answer.\n\nAll identifiers must be used exactly as they appear in the instance input — no renaming and no new labels.\n- for example: \"Valid identifiers look like plain numbers such as “1” or “23”, single capital letters like “A” or “B”, or a capital letter followed by digits like “A1” or “X7”.\"",
    "instance": {
      "coordinates": [
        [
          0,
          100
        ],
        [
          22,
          16
        ],
        [
          41,
          29
        ],
        [
          45,
          58
        ],
        [
          76,
          16
        ],
        [
          69,
          100
        ],
        [
          76,
          100
        ],
        [
          100,
          81
        ],
        [
          95,
          90
        ],
        [
          83,
          36
        ],
        [
          83,
          26
        ],
        [
          88,
          7
        ],
        [
          45,
          0
        ],
        [
          31,
          100
        ]
      ],
      "depot": 0,
      "num_nodes": 14,
      "time_windows": [
        [
          0,
          1067
        ],
        [
          139,
          418
        ],
        [
          152,
          425
        ],
        [
          170,
          400
        ],
        [
          179,
          402
        ],
        [
          290,
          532
        ],
        [
          90,
          371
        ],
        [
          148,
          395
        ],
        [
          351,
          606
        ],
        [
          45,
          330
        ],
        [
          243,
          470
        ],
        [
          54,
          325
        ],
        [
          240,
          486
        ],
        [
          346,
          617
        ]
      ],
      "tour_length": 443.30454556783945,
      "objective": 443.30454556783945
    },
    "solution": [
      0,
      6,
      3,
      2,
      1,
      12,
      4,
      11,
      10,
      9,
      7,
      8,
      5,
      13,
      0
    ],
    "obj": 443.30454556783945,
    "instance_variant": {
      "problem_type": "TSPTW",
      "num_nodes": 14,
      "nodes": [
        {
          "id": 1,
          "x": 0,
          "y": 100,
          "tw_start": 0,
          "tw_end": 1067
        },
        {
          "id": 2,
          "x": 22,
          "y": 16,
          "tw_start": 139,
          "tw_end": 418
        },
        {
          "id": 3,
          "x": 41,
          "y": 29,
          "tw_start": 152,
          "tw_end": 425
        },
        {
          "id": 4,
          "x": 45,
          "y": 58,
          "tw_start": 170,
          "tw_end": 400
        },
        {
          "id": 5,
          "x": 76,
          "y": 16,
          "tw_start": 179,
          "tw_end": 402
        },
        {
          "id": 6,
          "x": 69,
          "y": 100,
          "tw_start": 290,
          "tw_end": 532
        },
        {
          "id": 7,
          "x": 76,
          "y": 100,
          "tw_start": 90,
          "tw_end": 371
        },
        {
          "id": 8,
          "x": 100,
          "y": 81,
          "tw_start": 148,
          "tw_end": 395
        },
        {
          "id": 9,
          "x": 95,
          "y": 90,
          "tw_start": 351,
          "tw_end": 606
        },
        {
          "id": 10,
          "x": 83,
          "y": 36,
          "tw_start": 45,
          "tw_end": 330
        },
        {
          "id": 11,
          "x": 83,
          "y": 26,
          "tw_start": 243,
          "tw_end": 470
        },
        {
          "id": 12,
          "x": 88,
          "y": 7,
          "tw_start": 54,
          "tw_end": 325
        },
        {
          "id": 13,
          "x": 45,
          "y": 0,
          "tw_start": 240,
          "tw_end": 486
        },
        {
          "id": 14,
          "x": 31,
          "y": 100,
          "tw_start": 346,
          "tw_end": 617
        }
      ],
      "depot": 1,
      "objective": 443.30454556783945
    },
    "solution_variant": [
      1,
      7,
      4,
      3,
      2,
      13,
      5,
      12,
      11,
      10,
      8,
      9,
      6,
      14,
      1
    ],
    "context_index": 29,
    "input_format": "markdown_table",
    "input_index_base": 1
  },
  {
    "task_name": "TSPTW",
    "problem_type": "TSPTW",
    "instruction": "Someone in charge of the ice cream truck schedule has to pick the order of stops so the day starts and ends at the truck yard, every stop gets visited exactly once during its allotted time, and no place is skipped or visited twice. The goal is to keep the total driving to a minimum: tally the distance between each consecutive stop in the route (and include the drive back to base) and prefer the route with the smallest total, with waiting allowed if reaching a stop early. The specific stops, time windows, and distances appear below.\n\n# total_stops_including_depot=15\n# truck_yard_id=0\n# time windows are listed per node in the table\nstop_id,map_x,map_y,active_start_time,active_end_time\n0,2,88,0,1067\n1,32,100,70,352\n2,100,74,226,459\n3,81,5,179,465\n4,46,2,59,310\n5,48,93,196,449\n6,43,26,7,285\n7,13,0,361,610\n8,29,58,270,553\n9,83,24,274,483\n10,100,6,223,476\n11,0,66,164,429\n12,22,86,362,646\n13,58,60,174,379\n14,43,12,382,657\n\nOh, and when you send the route back, you can just use this simple JSON layout:\n\n{\n  \"solution\": [depot_id, location_id, ..., depot_id]\n}\n\nThink of \"solution\" as the ordered list of stops: start at the depot, follow the stops in order, and finish back at the depot. The depot_id and location_id bits are placeholders for the actual stop identifiers from the instance. This is just a sketch of the shape I need — not the real route.\n\nPlease use the identifiers exactly as they appear in the instance input — do not rename them or introduce new labels.\n- for example: \"Valid identifiers look like plain numbers such as “1” or “23”, single capital letters like “A” or “B”, or a capital letter followed by digits like “A1” or “X7”.\"",
    "instance": {
      "coordinates": [
        [
          2,
          88
        ],
        [
          32,
          100
        ],
        [
          100,
          74
        ],
        [
          81,
          5
        ],
        [
          46,
          2
        ],
        [
          48,
          93
        ],
        [
          43,
          26
        ],
        [
          13,
          0
        ],
        [
          29,
          58
        ],
        [
          83,
          24
        ],
        [
          100,
          6
        ],
        [
          0,
          66
        ],
        [
          22,
          86
        ],
        [
          58,
          60
        ],
        [
          43,
          12
        ]
      ],
      "depot": 0,
      "num_nodes": 15,
      "time_windows": [
        [
          0,
          1067
        ],
        [
          70,
          352
        ],
        [
          226,
          459
        ],
        [
          179,
          465
        ],
        [
          59,
          310
        ],
        [
          196,
          449
        ],
        [
          7,
          285
        ],
        [
          361,
          610
        ],
        [
          270,
          553
        ],
        [
          274,
          483
        ],
        [
          223,
          476
        ],
        [
          164,
          429
        ],
        [
          362,
          646
        ],
        [
          174,
          379
        ],
        [
          382,
          657
        ]
      ],
      "tour_length": 596.9162363860437,
      "objective": 596.9162363860437
    },
    "solution": [
      0,
      6,
      4,
      11,
      1,
      5,
      13,
      2,
      9,
      10,
      3,
      14,
      7,
      8,
      12,
      0
    ],
    "obj": 596.9162363860437,
    "instance_variant": {
      "problem_type": "TSPTW",
      "num_nodes": 15,
      "nodes": [
        {
          "id": 0,
          "x": 2,
          "y": 88,
          "tw_start": 0,
          "tw_end": 1067
        },
        {
          "id": 1,
          "x": 32,
          "y": 100,
          "tw_start": 70,
          "tw_end": 352
        },
        {
          "id": 2,
          "x": 100,
          "y": 74,
          "tw_start": 226,
          "tw_end": 459
        },
        {
          "id": 3,
          "x": 81,
          "y": 5,
          "tw_start": 179,
          "tw_end": 465
        },
        {
          "id": 4,
          "x": 46,
          "y": 2,
          "tw_start": 59,
          "tw_end": 310
        },
        {
          "id": 5,
          "x": 48,
          "y": 93,
          "tw_start": 196,
          "tw_end": 449
        },
        {
          "id": 6,
          "x": 43,
          "y": 26,
          "tw_start": 7,
          "tw_end": 285
        },
        {
          "id": 7,
          "x": 13,
          "y": 0,
          "tw_start": 361,
          "tw_end": 610
        },
        {
          "id": 8,
          "x": 29,
          "y": 58,
          "tw_start": 270,
          "tw_end": 553
        },
        {
          "id": 9,
          "x": 83,
          "y": 24,
          "tw_start": 274,
          "tw_end": 483
        },
        {
          "id": 10,
          "x": 100,
          "y": 6,
          "tw_start": 223,
          "tw_end": 476
        },
        {
          "id": 11,
          "x": 0,
          "y": 66,
          "tw_start": 164,
          "tw_end": 429
        },
        {
          "id": 12,
          "x": 22,
          "y": 86,
          "tw_start": 362,
          "tw_end": 646
        },
        {
          "id": 13,
          "x": 58,
          "y": 60,
          "tw_start": 174,
          "tw_end": 379
        },
        {
          "id": 14,
          "x": 43,
          "y": 12,
          "tw_start": 382,
          "tw_end": 657
        }
      ],
      "depot": 0,
      "objective": 596.9162363860437
    },
    "solution_variant": [
      0,
      6,
      4,
      11,
      1,
      5,
      13,
      2,
      9,
      10,
      3,
      14,
      7,
      8,
      12,
      0
    ],
    "context_index": 30,
    "input_format": "csv",
    "input_index_base": 0
  },
  {
    "task_name": "TSPTW",
    "problem_type": "TSPTW",
    "instruction": "On a typical morning the mobile lab team has to craft a route: leave the lab, swing by each clinic once during its designated pickup time (it’s allowed to wait if arriving too early), and return to base at the end. The decision is just the order of stops, and the route that’s better is the one that minimizes how far the van drives overall — total distance is the sum of each leg from one stop to the next, plus the journey back to the lab. No stops can be skipped or repeated, and every pickup must fall inside its window. The specific stops and time windows are listed below.\n\nThere are 15 stops in total (including the lab), with the lab depot labeled A.\nStop A located at (11, 83), pickup allowed between 0 and 1067.\nStop B located at (0, 100), pickup allowed between 48 and 331.\nStop C located at (34, 77), pickup allowed between 337 and 581.\nStop D located at (41, 55), pickup allowed between 229 and 462.\nStop E located at (71, 35), pickup allowed between 21 and 247.\nStop F located at (77, 34), pickup allowed between 311 and 505.\nStop G located at (61, 29), pickup allowed between 129 and 362.\nStop H located at (86, 28), pickup allowed between 208 and 491.\nStop I located at (87, 28), pickup allowed between 134 and 362.\nStop J located at (48, 25), pickup allowed between 286 and 524.\nStop K located at (61, 21), pickup allowed between 87 and 325.\nStop L located at (64, 14), pickup allowed between 54 and 265.\nStop M located at (78, 10), pickup allowed between 193 and 428.\nStop N located at (72, 0), pickup allowed between 354 and 584.\nStop O located at (100, 10), pickup allowed between 225 and 480.\nUse these entries to choose an order that visits every stop once and returns to A, while respecting all pickup windows.\n\nWhen you send back the route, just use this simple JSON shape so it's easy to read and parse:\n\n{\n  \"solution\": [lab_id, clinic_id, ..., lab_id]\n}\n\n\"solution\" is the ordered list of stops — start at the lab (first entry), visit each clinic once in the order shown, and come back to the lab (last entry). The names in the example above are just placeholders to show the shape; replace them with the actual IDs from the instance. This JSON is only a sketch of the expected shape, not the final answer.\n\nPlease use the identifiers exactly as they appear in the instance input — no renaming and no new labels.\n- for example: \"Valid identifiers look like plain numbers such as “1” or “23”, single capital letters like “A” or “B”, or a capital letter followed by digits like “A1” or “X7”.\"",
    "instance": {
      "coordinates": [
        [
          11,
          83
        ],
        [
          0,
          100
        ],
        [
          34,
          77
        ],
        [
          41,
          55
        ],
        [
          71,
          35
        ],
        [
          77,
          34
        ],
        [
          61,
          29
        ],
        [
          86,
          28
        ],
        [
          87,
          28
        ],
        [
          48,
          25
        ],
        [
          61,
          21
        ],
        [
          64,
          14
        ],
        [
          78,
          10
        ],
        [
          72,
          0
        ],
        [
          100,
          10
        ]
      ],
      "depot": 0,
      "num_nodes": 15,
      "time_windows": [
        [
          0,
          1067
        ],
        [
          48,
          331
        ],
        [
          337,
          581
        ],
        [
          229,
          462
        ],
        [
          21,
          247
        ],
        [
          311,
          505
        ],
        [
          129,
          362
        ],
        [
          208,
          491
        ],
        [
          134,
          362
        ],
        [
          286,
          524
        ],
        [
          87,
          325
        ],
        [
          54,
          265
        ],
        [
          193,
          428
        ],
        [
          354,
          584
        ],
        [
          225,
          480
        ]
      ],
      "tour_length": 337.6884642196724,
      "objective": 337.6884642196724
    },
    "solution": [
      0,
      1,
      6,
      10,
      11,
      4,
      5,
      7,
      8,
      14,
      12,
      13,
      9,
      3,
      2,
      0
    ],
    "obj": 337.6884642196724,
    "instance_variant": {
      "problem_type": "TSPTW",
      "num_nodes": 15,
      "nodes": [
        {
          "id": "A",
          "x": 11,
          "y": 83,
          "tw_start": 0,
          "tw_end": 1067
        },
        {
          "id": "B",
          "x": 0,
          "y": 100,
          "tw_start": 48,
          "tw_end": 331
        },
        {
          "id": "C",
          "x": 34,
          "y": 77,
          "tw_start": 337,
          "tw_end": 581
        },
        {
          "id": "D",
          "x": 41,
          "y": 55,
          "tw_start": 229,
          "tw_end": 462
        },
        {
          "id": "E",
          "x": 71,
          "y": 35,
          "tw_start": 21,
          "tw_end": 247
        },
        {
          "id": "F",
          "x": 77,
          "y": 34,
          "tw_start": 311,
          "tw_end": 505
        },
        {
          "id": "G",
          "x": 61,
          "y": 29,
          "tw_start": 129,
          "tw_end": 362
        },
        {
          "id": "H",
          "x": 86,
          "y": 28,
          "tw_start": 208,
          "tw_end": 491
        },
        {
          "id": "I",
          "x": 87,
          "y": 28,
          "tw_start": 134,
          "tw_end": 362
        },
        {
          "id": "J",
          "x": 48,
          "y": 25,
          "tw_start": 286,
          "tw_end": 524
        },
        {
          "id": "K",
          "x": 61,
          "y": 21,
          "tw_start": 87,
          "tw_end": 325
        },
        {
          "id": "L",
          "x": 64,
          "y": 14,
          "tw_start": 54,
          "tw_end": 265
        },
        {
          "id": "M",
          "x": 78,
          "y": 10,
          "tw_start": 193,
          "tw_end": 428
        },
        {
          "id": "N",
          "x": 72,
          "y": 0,
          "tw_start": 354,
          "tw_end": 584
        },
        {
          "id": "O",
          "x": 100,
          "y": 10,
          "tw_start": 225,
          "tw_end": 480
        }
      ],
      "depot": "A",
      "objective": 337.6884642196724
    },
    "solution_variant": [
      "A",
      "B",
      "G",
      "K",
      "L",
      "E",
      "F",
      "H",
      "I",
      "O",
      "M",
      "N",
      "J",
      "D",
      "C",
      "A"
    ],
    "context_index": 31,
    "input_format": "nl",
    "input_index_base": "names"
  },
  {
    "task_name": "TSPTW",
    "problem_type": "TSPTW",
    "instruction": "Recently an agent told a story about a day packed with back-to-back viewings, each with a strict time window, and the need to start and finish at the brokerage. The decision was which order to follow so each flat is shown once at the right time (arriving early and waiting if necessary is okay) and the overall miles driven — calculated by adding every drive between stops, including the return — end up as low as possible. The exact appointments and addresses are listed below.\n\nThere were 14 stops in total, starting and ending at the brokerage office A.\nStop A at coordinates (0, 95) had a viewing window from 0 to 1067.\nStop B at coordinates (36, 51) had a viewing window from 5 to 263.\nStop C at coordinates (100, 100) had a viewing window from 69 to 356.\nStop D at coordinates (100, 92) had a viewing window from 57 to 291.\nStop E at coordinates (100, 82) had a viewing window from 33 to 323.\nStop F at coordinates (100, 74) had a viewing window from 194 to 446.\nStop G at coordinates (100, 67) had a viewing window from 26 to 292.\nStop H at coordinates (100, 64) had a viewing window from 81 to 362.\nStop I at coordinates (85, 64) had a viewing window from 79 to 292.\nStop J at coordinates (45, 5) had a viewing window from 14 to 253.\nStop K at coordinates (53, 21) had a viewing window from 219 to 419.\nStop L at coordinates (49, 36) had a viewing window from 300 to 538.\nStop M at coordinates (19, 0) had a viewing window from 203 to 440.\nStop N at coordinates (28, 46) had a viewing window from 155 to 403.\nThe agent then planned a visiting order that met each viewing window while keeping the total miles driven as low as possible.\n\nOh, and when you hand back the route, a little JSON like this is perfect — just a tiny, predictable shape so it's easy to check automatically:\n\n{\n  \"solution\": [brokerage_id, flat_id, ..., brokerage_id]\n}\n\nThis just shows the shape I need: \"solution\" is the ordered list of stops (start at the brokerage, visit every flat once in the listed order, and return to the brokerage). The placeholder names above are only a sketch of the format — don’t treat them as the real IDs.\n\nPlease make sure to use the exact identifiers from the instance input (no renaming, no new labels). \n\nValid identifiers look like plain numbers such as “1” or “23”, single capital letters like “A” or “B”, or a capital letter followed by digits like “A1” or “X7”.",
    "instance": {
      "coordinates": [
        [
          0,
          95
        ],
        [
          36,
          51
        ],
        [
          100,
          100
        ],
        [
          100,
          92
        ],
        [
          100,
          82
        ],
        [
          100,
          74
        ],
        [
          100,
          67
        ],
        [
          100,
          64
        ],
        [
          85,
          64
        ],
        [
          45,
          5
        ],
        [
          53,
          21
        ],
        [
          49,
          36
        ],
        [
          19,
          0
        ],
        [
          28,
          46
        ]
      ],
      "depot": 0,
      "num_nodes": 14,
      "time_windows": [
        [
          0,
          1067
        ],
        [
          5,
          263
        ],
        [
          69,
          356
        ],
        [
          57,
          291
        ],
        [
          33,
          323
        ],
        [
          194,
          446
        ],
        [
          26,
          292
        ],
        [
          81,
          362
        ],
        [
          79,
          292
        ],
        [
          14,
          253
        ],
        [
          219,
          419
        ],
        [
          300,
          538
        ],
        [
          203,
          440
        ],
        [
          155,
          403
        ]
      ],
      "tour_length": 490.34011769459596,
      "objective": 490.34011769459596
    },
    "solution": [
      0,
      9,
      13,
      1,
      8,
      7,
      6,
      5,
      4,
      3,
      2,
      11,
      10,
      12,
      0
    ],
    "obj": 490.34011769459596,
    "instance_variant": {
      "problem_type": "TSPTW",
      "num_nodes": 14,
      "nodes": [
        {
          "id": "A",
          "x": 0,
          "y": 95,
          "tw_start": 0,
          "tw_end": 1067
        },
        {
          "id": "B",
          "x": 36,
          "y": 51,
          "tw_start": 5,
          "tw_end": 263
        },
        {
          "id": "C",
          "x": 100,
          "y": 100,
          "tw_start": 69,
          "tw_end": 356
        },
        {
          "id": "D",
          "x": 100,
          "y": 92,
          "tw_start": 57,
          "tw_end": 291
        },
        {
          "id": "E",
          "x": 100,
          "y": 82,
          "tw_start": 33,
          "tw_end": 323
        },
        {
          "id": "F",
          "x": 100,
          "y": 74,
          "tw_start": 194,
          "tw_end": 446
        },
        {
          "id": "G",
          "x": 100,
          "y": 67,
          "tw_start": 26,
          "tw_end": 292
        },
        {
          "id": "H",
          "x": 100,
          "y": 64,
          "tw_start": 81,
          "tw_end": 362
        },
        {
          "id": "I",
          "x": 85,
          "y": 64,
          "tw_start": 79,
          "tw_end": 292
        },
        {
          "id": "J",
          "x": 45,
          "y": 5,
          "tw_start": 14,
          "tw_end": 253
        },
        {
          "id": "K",
          "x": 53,
          "y": 21,
          "tw_start": 219,
          "tw_end": 419
        },
        {
          "id": "L",
          "x": 49,
          "y": 36,
          "tw_start": 300,
          "tw_end": 538
        },
        {
          "id": "M",
          "x": 19,
          "y": 0,
          "tw_start": 203,
          "tw_end": 440
        },
        {
          "id": "N",
          "x": 28,
          "y": 46,
          "tw_start": 155,
          "tw_end": 403
        }
      ],
      "depot": "A",
      "objective": 490.34011769459596
    },
    "solution_variant": [
      "A",
      "J",
      "N",
      "B",
      "I",
      "H",
      "G",
      "F",
      "E",
      "D",
      "C",
      "L",
      "K",
      "M",
      "A"
    ],
    "context_index": 32,
    "input_format": "nl",
    "input_index_base": "names"
  },
  {
    "task_name": "TSPTW",
    "problem_type": "TSPTW",
    "instruction": "There’s a tuner with a van, a handful of schools, and a single-day route to sort out: begin at the workshop, visit every school once during its available lesson period, then return to the workshop. What makes one route nicer than another is how little driving it requires — the total distance comes from summing each leg of the trip — and arriving ahead of a lesson to wait is allowed if needed. The specific schools, their time windows, and distances appear below.\n\n{\n  \"total_locations_including_workshop\": 15,\n  \"nodes\": [\n    {\n      \"location_id\": 1,\n      \"coord_x\": 95,\n      \"coord_y\": 100,\n      \"lesson_period_start\": 0,\n      \"lesson_period_end\": 1067\n    },\n    {\n      \"location_id\": 2,\n      \"coord_x\": 27,\n      \"coord_y\": 61,\n      \"lesson_period_start\": 280,\n      \"lesson_period_end\": 557\n    },\n    {\n      \"location_id\": 3,\n      \"coord_x\": 80,\n      \"coord_y\": 57,\n      \"lesson_period_start\": 322,\n      \"lesson_period_end\": 554\n    },\n    {\n      \"location_id\": 4,\n      \"coord_x\": 43,\n      \"coord_y\": 16,\n      \"lesson_period_start\": 259,\n      \"lesson_period_end\": 473\n    },\n    {\n      \"location_id\": 5,\n      \"coord_x\": 63,\n      \"coord_y\": 67,\n      \"lesson_period_start\": 113,\n      \"lesson_period_end\": 394\n    },\n    {\n      \"location_id\": 6,\n      \"coord_x\": 14,\n      \"coord_y\": 50,\n      \"lesson_period_start\": 5,\n      \"lesson_period_end\": 207\n    },\n    {\n      \"location_id\": 7,\n      \"coord_x\": 16,\n      \"coord_y\": 16,\n      \"lesson_period_start\": 80,\n      \"lesson_period_end\": 277\n    },\n    {\n      \"location_id\": 8,\n      \"coord_x\": 36,\n      \"coord_y\": 70,\n      \"lesson_period_start\": 70,\n      \"lesson_period_end\": 320\n    },\n    {\n      \"location_id\": 9,\n      \"coord_x\": 55,\n      \"coord_y\": 56,\n      \"lesson_period_start\": 163,\n      \"lesson_period_end\": 444\n    },\n    {\n      \"location_id\": 10,\n      \"coord_x\": 100,\n      \"coord_y\": 0,\n      \"lesson_period_start\": 317,\n      \"lesson_period_end\": 544\n    },\n    {\n      \"location_id\": 11,\n      \"coord_x\": 81,\n      \"coord_y\": 8,\n      \"lesson_period_start\": 100,\n      \"lesson_period_end\": 331\n    },\n    {\n      \"location_id\": 12,\n      \"coord_x\": 34,\n      \"coord_y\": 22,\n      \"lesson_period_start\": 229,\n      \"lesson_period_end\": 449\n    },\n    {\n      \"location_id\": 13,\n      \"coord_x\": 9,\n      \"coord_y\": 81,\n      \"lesson_period_start\": 242,\n      \"lesson_period_end\": 475\n    },\n    {\n      \"location_id\": 14,\n      \"coord_x\": 89,\n      \"coord_y\": 68,\n      \"lesson_period_start\": 214,\n      \"lesson_period_end\": 450\n    },\n    {\n      \"location_id\": 15,\n      \"coord_x\": 0,\n      \"coord_y\": 100,\n      \"lesson_period_start\": 114,\n      \"lesson_period_end\": 400\n    }\n  ],\n  \"workshop_id\": 1\n}\n\nWhen you send back the route, just paste a tiny JSON snippet that looks like this — nice and simple:\n\n{\n  \"solution\": [workshop_id, school_id, ..., workshop_id]\n}\n\nHere \"solution\" should be the tour: start at the workshop, list each school in the order you'll visit them, and finish back at the workshop. The placeholders (workshop_id and school_id) are just that — placeholders showing the shape I expect, not the real labels.\n\nPlease use the exact identifiers from the problem input when you fill this in — don’t rename them or invent new ones. Valid identifiers look like plain numbers such as “1” or “23”, single capital letters like “A” or “B”, or a capital letter followed by digits like “A1” or “X7”.",
    "instance": {
      "coordinates": [
        [
          95,
          100
        ],
        [
          27,
          61
        ],
        [
          80,
          57
        ],
        [
          43,
          16
        ],
        [
          63,
          67
        ],
        [
          14,
          50
        ],
        [
          16,
          16
        ],
        [
          36,
          70
        ],
        [
          55,
          56
        ],
        [
          100,
          0
        ],
        [
          81,
          8
        ],
        [
          34,
          22
        ],
        [
          9,
          81
        ],
        [
          89,
          68
        ],
        [
          0,
          100
        ]
      ],
      "depot": 0,
      "num_nodes": 15,
      "time_windows": [
        [
          0,
          1067
        ],
        [
          280,
          557
        ],
        [
          322,
          554
        ],
        [
          259,
          473
        ],
        [
          113,
          394
        ],
        [
          5,
          207
        ],
        [
          80,
          277
        ],
        [
          70,
          320
        ],
        [
          163,
          444
        ],
        [
          317,
          544
        ],
        [
          100,
          331
        ],
        [
          229,
          449
        ],
        [
          242,
          475
        ],
        [
          214,
          450
        ],
        [
          114,
          400
        ]
      ],
      "tour_length": 607.7154773387698,
      "objective": 607.7154773387698
    },
    "solution": [
      0,
      10,
      6,
      5,
      14,
      12,
      1,
      7,
      4,
      13,
      2,
      8,
      11,
      3,
      9,
      0
    ],
    "obj": 607.7154773387698,
    "instance_variant": {
      "problem_type": "TSPTW",
      "num_nodes": 15,
      "nodes": [
        {
          "id": 1,
          "x": 95,
          "y": 100,
          "tw_start": 0,
          "tw_end": 1067
        },
        {
          "id": 2,
          "x": 27,
          "y": 61,
          "tw_start": 280,
          "tw_end": 557
        },
        {
          "id": 3,
          "x": 80,
          "y": 57,
          "tw_start": 322,
          "tw_end": 554
        },
        {
          "id": 4,
          "x": 43,
          "y": 16,
          "tw_start": 259,
          "tw_end": 473
        },
        {
          "id": 5,
          "x": 63,
          "y": 67,
          "tw_start": 113,
          "tw_end": 394
        },
        {
          "id": 6,
          "x": 14,
          "y": 50,
          "tw_start": 5,
          "tw_end": 207
        },
        {
          "id": 7,
          "x": 16,
          "y": 16,
          "tw_start": 80,
          "tw_end": 277
        },
        {
          "id": 8,
          "x": 36,
          "y": 70,
          "tw_start": 70,
          "tw_end": 320
        },
        {
          "id": 9,
          "x": 55,
          "y": 56,
          "tw_start": 163,
          "tw_end": 444
        },
        {
          "id": 10,
          "x": 100,
          "y": 0,
          "tw_start": 317,
          "tw_end": 544
        },
        {
          "id": 11,
          "x": 81,
          "y": 8,
          "tw_start": 100,
          "tw_end": 331
        },
        {
          "id": 12,
          "x": 34,
          "y": 22,
          "tw_start": 229,
          "tw_end": 449
        },
        {
          "id": 13,
          "x": 9,
          "y": 81,
          "tw_start": 242,
          "tw_end": 475
        },
        {
          "id": 14,
          "x": 89,
          "y": 68,
          "tw_start": 214,
          "tw_end": 450
        },
        {
          "id": 15,
          "x": 0,
          "y": 100,
          "tw_start": 114,
          "tw_end": 400
        }
      ],
      "depot": 1,
      "objective": 607.7154773387698
    },
    "solution_variant": [
      1,
      11,
      7,
      6,
      15,
      13,
      2,
      8,
      5,
      14,
      3,
      9,
      12,
      4,
      10,
      1
    ],
    "context_index": 33,
    "input_format": "json",
    "input_index_base": 1
  },
  {
    "task_name": "TSPTW",
    "problem_type": "TSPTW",
    "instruction": "Out in the field, planning a tech’s day looks like this: pick a route that leaves the depot, hits every customer one time during the slot they were promised, and heads back to the depot at the end. What counts as a good route is simple — the one with the smallest sum of miles driven — and that sum comes from adding the distances between each pair of consecutive stops in the route plus the trip out and the trip back. Arriving before a window opens and waiting is allowed, but no customer can be missed or visited twice. The concrete route details and appointment times are shown below.\n\nBelow are the 14 locations (depot 1 included):\nStop 1 at coordinates (25, 0) — arrive between 0 and 1067.\nStop 2 at coordinates (0, 33) — arrive between 296 and 503.\nStop 3 at coordinates (86, 27) — arrive between 336 and 578.\nStop 4 at coordinates (15, 43) — arrive between 347 and 618.\nStop 5 at coordinates (42, 47) — arrive between 164 and 361.\nStop 6 at coordinates (100, 49) — arrive between 104 and 350.\nStop 7 at coordinates (3, 61) — arrive between 245 and 464.\nStop 8 at coordinates (99, 58) — arrive between 54 and 329.\nStop 9 at coordinates (58, 71) — arrive between 381 and 626.\nStop 10 at coordinates (70, 69) — arrive between 66 and 287.\nStop 11 at coordinates (53, 77) — arrive between 7 and 289.\nStop 12 at coordinates (44, 95) — arrive between 45 and 295.\nStop 13 at coordinates (59, 100) — arrive between 106 and 354.\nStop 14 at coordinates (70, 97) — arrive between 252 and 527.\nVisit every one of the 14 stops exactly once, starting and ending at 1.\n\nAnd hey — when you send the route back, please use a tiny JSON shape so it's easy to read and plug in. Something like this:\n\n{\n  \"solution\": [depot_id, location_id, ..., depot_id]\n}\n\nThis little block just means: put the stops in order inside \"solution\", starting at the depot and finishing at the depot, with every customer listed exactly once. It's just a quick sketch of the shape I need, not the real answer itself.\n\nPlease don’t rename any of the identifiers from the instance input — use them exactly as given, no made-up labels. \n- for example: Valid identifiers look like plain numbers such as “1” or “23”, single capital letters like “A” or “B”, or a capital letter followed by digits like “A1” or “X7”.",
    "instance": {
      "coordinates": [
        [
          25,
          0
        ],
        [
          0,
          33
        ],
        [
          86,
          27
        ],
        [
          15,
          43
        ],
        [
          42,
          47
        ],
        [
          100,
          49
        ],
        [
          3,
          61
        ],
        [
          99,
          58
        ],
        [
          58,
          71
        ],
        [
          70,
          69
        ],
        [
          53,
          77
        ],
        [
          44,
          95
        ],
        [
          59,
          100
        ],
        [
          70,
          97
        ]
      ],
      "depot": 0,
      "num_nodes": 14,
      "time_windows": [
        [
          0,
          1067
        ],
        [
          296,
          503
        ],
        [
          336,
          578
        ],
        [
          347,
          618
        ],
        [
          164,
          361
        ],
        [
          104,
          350
        ],
        [
          245,
          464
        ],
        [
          54,
          329
        ],
        [
          381,
          626
        ],
        [
          66,
          287
        ],
        [
          7,
          289
        ],
        [
          45,
          295
        ],
        [
          106,
          354
        ],
        [
          252,
          527
        ]
      ],
      "tour_length": 412.5360263607499,
      "objective": 412.5360263607499
    },
    "solution": [
      0,
      4,
      10,
      11,
      12,
      13,
      9,
      7,
      5,
      2,
      8,
      6,
      3,
      1,
      0
    ],
    "obj": 412.5360263607499,
    "instance_variant": {
      "problem_type": "TSPTW",
      "num_nodes": 14,
      "nodes": [
        {
          "id": 1,
          "x": 25,
          "y": 0,
          "tw_start": 0,
          "tw_end": 1067
        },
        {
          "id": 2,
          "x": 0,
          "y": 33,
          "tw_start": 296,
          "tw_end": 503
        },
        {
          "id": 3,
          "x": 86,
          "y": 27,
          "tw_start": 336,
          "tw_end": 578
        },
        {
          "id": 4,
          "x": 15,
          "y": 43,
          "tw_start": 347,
          "tw_end": 618
        },
        {
          "id": 5,
          "x": 42,
          "y": 47,
          "tw_start": 164,
          "tw_end": 361
        },
        {
          "id": 6,
          "x": 100,
          "y": 49,
          "tw_start": 104,
          "tw_end": 350
        },
        {
          "id": 7,
          "x": 3,
          "y": 61,
          "tw_start": 245,
          "tw_end": 464
        },
        {
          "id": 8,
          "x": 99,
          "y": 58,
          "tw_start": 54,
          "tw_end": 329
        },
        {
          "id": 9,
          "x": 58,
          "y": 71,
          "tw_start": 381,
          "tw_end": 626
        },
        {
          "id": 10,
          "x": 70,
          "y": 69,
          "tw_start": 66,
          "tw_end": 287
        },
        {
          "id": 11,
          "x": 53,
          "y": 77,
          "tw_start": 7,
          "tw_end": 289
        },
        {
          "id": 12,
          "x": 44,
          "y": 95,
          "tw_start": 45,
          "tw_end": 295
        },
        {
          "id": 13,
          "x": 59,
          "y": 100,
          "tw_start": 106,
          "tw_end": 354
        },
        {
          "id": 14,
          "x": 70,
          "y": 97,
          "tw_start": 252,
          "tw_end": 527
        }
      ],
      "depot": 1,
      "objective": 412.5360263607499
    },
    "solution_variant": [
      1,
      5,
      11,
      12,
      13,
      14,
      10,
      8,
      6,
      3,
      9,
      7,
      4,
      2,
      1
    ],
    "context_index": 34,
    "input_format": "nl",
    "input_index_base": 1
  },
  {
    "task_name": "TSPTW",
    "problem_type": "TSPTW",
    "instruction": "We’ve got a vintage-car rally that starts at the clubhouse, must call at each museum and landmark exactly one time, and then finishes back at the clubhouse. The crew has to decide the visiting order, making sure each stop is reached during its hours (waiting is allowed if they get there early). What makes one visiting order better than another is simply how many miles the cars end up doing — total miles are found by adding every segment between consecutive stops, including the return — and the goal is the route with the smallest total. The concrete stops, hours and distances appear below.\n\nThere are 14 locations in total, with the clubhouse at A.\n\n| stop_id | map_x_coordinate | map_y_coordinate | opening_time | closing_time |\n|---|---|---|---|---|\n| A | 29 | 38 | 0 | 1067 |\n| B | 54 | 100 | 80 | 275 |\n| C | 40 | 48 | 53 | 334 |\n| D | 73 | 76 | 339 | 591 |\n| E | 34 | 97 | 233 | 491 |\n| F | 67 | 23 | 68 | 350 |\n| G | 40 | 41 | 162 | 393 |\n| H | 14 | 1 | 201 | 399 |\n| I | 55 | 47 | 64 | 330 |\n| J | 83 | 70 | 32 | 284 |\n| K | 71 | 97 | 95 | 326 |\n| L | 100 | 76 | 112 | 340 |\n| M | 14 | 72 | 278 | 501 |\n| N | 0 | 0 | 219 | 459 |\n\nWe’ll use these entries to plan the shortest route that starts and ends at A while visiting all 14 stops within their hours.\n\nAlso, when you send back the chosen route, please use this simple JSON layout so it's easy to read and feed into whatever's checking the rally results:\n\n{\n  \"solution\": [\"clubhouse_id\", \"museum_id\", ..., \"clubhouse_id\"]\n}\n\nThis just says: \"solution\" is the tour as an ordered list — start at the clubhouse, list each stop in visiting order, and finish back at the clubhouse. The quoted names in the array are placeholders: swap them for the exact identifiers from the instance when you give the real route. It's just a sketch of the shape I need, not the final answer itself.\n\nPlease use the identifiers exactly as they appear in the instance input — no renaming and no invented labels. \nFor example: \"Valid identifiers look like plain numbers such as “1” or “23”, single capital letters like “A” or “B”, or a capital letter followed by digits like “A1” or “X7”.\"",
    "instance": {
      "coordinates": [
        [
          29,
          38
        ],
        [
          54,
          100
        ],
        [
          40,
          48
        ],
        [
          73,
          76
        ],
        [
          34,
          97
        ],
        [
          67,
          23
        ],
        [
          40,
          41
        ],
        [
          14,
          1
        ],
        [
          55,
          47
        ],
        [
          83,
          70
        ],
        [
          71,
          97
        ],
        [
          100,
          76
        ],
        [
          14,
          72
        ],
        [
          0,
          0
        ]
      ],
      "depot": 0,
      "num_nodes": 14,
      "time_windows": [
        [
          0,
          1067
        ],
        [
          80,
          275
        ],
        [
          53,
          334
        ],
        [
          339,
          591
        ],
        [
          233,
          491
        ],
        [
          68,
          350
        ],
        [
          162,
          393
        ],
        [
          201,
          399
        ],
        [
          64,
          330
        ],
        [
          32,
          284
        ],
        [
          95,
          326
        ],
        [
          112,
          340
        ],
        [
          278,
          501
        ],
        [
          219,
          459
        ]
      ],
      "tour_length": 491.7254682427593,
      "objective": 491.7254682427593
    },
    "solution": [
      0,
      1,
      10,
      11,
      9,
      8,
      2,
      6,
      13,
      7,
      5,
      3,
      4,
      12,
      0
    ],
    "obj": 491.7254682427593,
    "instance_variant": {
      "problem_type": "TSPTW",
      "num_nodes": 14,
      "nodes": [
        {
          "id": "A",
          "x": 29,
          "y": 38,
          "tw_start": 0,
          "tw_end": 1067
        },
        {
          "id": "B",
          "x": 54,
          "y": 100,
          "tw_start": 80,
          "tw_end": 275
        },
        {
          "id": "C",
          "x": 40,
          "y": 48,
          "tw_start": 53,
          "tw_end": 334
        },
        {
          "id": "D",
          "x": 73,
          "y": 76,
          "tw_start": 339,
          "tw_end": 591
        },
        {
          "id": "E",
          "x": 34,
          "y": 97,
          "tw_start": 233,
          "tw_end": 491
        },
        {
          "id": "F",
          "x": 67,
          "y": 23,
          "tw_start": 68,
          "tw_end": 350
        },
        {
          "id": "G",
          "x": 40,
          "y": 41,
          "tw_start": 162,
          "tw_end": 393
        },
        {
          "id": "H",
          "x": 14,
          "y": 1,
          "tw_start": 201,
          "tw_end": 399
        },
        {
          "id": "I",
          "x": 55,
          "y": 47,
          "tw_start": 64,
          "tw_end": 330
        },
        {
          "id": "J",
          "x": 83,
          "y": 70,
          "tw_start": 32,
          "tw_end": 284
        },
        {
          "id": "K",
          "x": 71,
          "y": 97,
          "tw_start": 95,
          "tw_end": 326
        },
        {
          "id": "L",
          "x": 100,
          "y": 76,
          "tw_start": 112,
          "tw_end": 340
        },
        {
          "id": "M",
          "x": 14,
          "y": 72,
          "tw_start": 278,
          "tw_end": 501
        },
        {
          "id": "N",
          "x": 0,
          "y": 0,
          "tw_start": 219,
          "tw_end": 459
        }
      ],
      "depot": "A",
      "objective": 491.7254682427593
    },
    "solution_variant": [
      "A",
      "B",
      "K",
      "L",
      "J",
      "I",
      "C",
      "G",
      "N",
      "H",
      "F",
      "D",
      "E",
      "M",
      "A"
    ],
    "context_index": 35,
    "input_format": "markdown_table",
    "input_index_base": "names"
  },
  {
    "task_name": "TSPTW",
    "problem_type": "TSPTW",
    "instruction": "On a typical service day, the technician must leave the garage, go out to a collection of sites (each expecting service only during a given time window), and return home, making sure each site is visited exactly once and waiting if arriving early. The goal is to arrange the order and timing so the round trip uses as few miles as possible — the total distance being the sum of all legs between stops. The precise locations and their time slots are shown below.\n\nThe technician will consider 11 locations in total, with the garage identified as node A.\n\n| location_id | map_x_coordinate | map_y_coordinate | service_time_window_start | service_time_window_end |\n|---|---|---|---|---|\n| A | 35 | 0 | 0 | 1067 |\n| B | 31 | 8 | 257 | 542 |\n| C | 100 | 11 | 284 | 499 |\n| D | 9 | 21 | 12 | 231 |\n| E | 49 | 21 | 230 | 429 |\n| F | 23 | 23 | 192 | 444 |\n| G | 12 | 31 | 129 | 398 |\n| H | 65 | 38 | 41 | 242 |\n| I | 0 | 45 | 282 | 524 |\n| J | 94 | 99 | 267 | 503 |\n| K | 66 | 100 | 95 | 369 |\n\nThe technician must schedule visits for these 11 locations (garage A) so the round trip covers as few miles as possible.\n\nAlso, when you send back the final route, just use a small JSON snippet like this so it's easy to parse:\n\n{\n  \"solution\": [garage_id, site_id, ..., garage_id]\n}\n\nThink of this as a little form: \"solution\" is the ordered list of stops — start at the garage, go visit each site once in the order shown, and then come back to the garage. The garage_id and site_id bits are just placeholders showing where the actual stop identifiers go. This block is only a sketch of the shape I want, not the actual route.\n\nPlease make sure to use the exact identifiers from the instance input — don't rename them or invent new labels.  \n- for example: \"Valid identifiers look like plain numbers such as “1” or “23”, single capital letters like “A” or “B”, or a capital letter followed by digits like “A1” or “X7”.\"",
    "instance": {
      "coordinates": [
        [
          35,
          0
        ],
        [
          31,
          8
        ],
        [
          100,
          11
        ],
        [
          9,
          21
        ],
        [
          49,
          21
        ],
        [
          23,
          23
        ],
        [
          12,
          31
        ],
        [
          65,
          38
        ],
        [
          0,
          45
        ],
        [
          94,
          99
        ],
        [
          66,
          100
        ]
      ],
      "depot": 0,
      "num_nodes": 11,
      "time_windows": [
        [
          0,
          1067
        ],
        [
          257,
          542
        ],
        [
          284,
          499
        ],
        [
          12,
          231
        ],
        [
          230,
          429
        ],
        [
          192,
          444
        ],
        [
          129,
          398
        ],
        [
          41,
          242
        ],
        [
          282,
          524
        ],
        [
          267,
          503
        ],
        [
          95,
          369
        ]
      ],
      "tour_length": 442.64230763211816,
      "objective": 442.64230763211816
    },
    "solution": [
      0,
      3,
      6,
      7,
      10,
      9,
      2,
      4,
      5,
      8,
      1,
      0
    ],
    "obj": 442.64230763211816,
    "instance_variant": {
      "problem_type": "TSPTW",
      "num_nodes": 11,
      "nodes": [
        {
          "id": "A",
          "x": 35,
          "y": 0,
          "tw_start": 0,
          "tw_end": 1067
        },
        {
          "id": "B",
          "x": 31,
          "y": 8,
          "tw_start": 257,
          "tw_end": 542
        },
        {
          "id": "C",
          "x": 100,
          "y": 11,
          "tw_start": 284,
          "tw_end": 499
        },
        {
          "id": "D",
          "x": 9,
          "y": 21,
          "tw_start": 12,
          "tw_end": 231
        },
        {
          "id": "E",
          "x": 49,
          "y": 21,
          "tw_start": 230,
          "tw_end": 429
        },
        {
          "id": "F",
          "x": 23,
          "y": 23,
          "tw_start": 192,
          "tw_end": 444
        },
        {
          "id": "G",
          "x": 12,
          "y": 31,
          "tw_start": 129,
          "tw_end": 398
        },
        {
          "id": "H",
          "x": 65,
          "y": 38,
          "tw_start": 41,
          "tw_end": 242
        },
        {
          "id": "I",
          "x": 0,
          "y": 45,
          "tw_start": 282,
          "tw_end": 524
        },
        {
          "id": "J",
          "x": 94,
          "y": 99,
          "tw_start": 267,
          "tw_end": 503
        },
        {
          "id": "K",
          "x": 66,
          "y": 100,
          "tw_start": 95,
          "tw_end": 369
        }
      ],
      "depot": "A",
      "objective": 442.64230763211816
    },
    "solution_variant": [
      "A",
      "D",
      "G",
      "H",
      "K",
      "J",
      "C",
      "E",
      "F",
      "I",
      "B",
      "A"
    ],
    "context_index": 36,
    "input_format": "markdown_table",
    "input_index_base": "names"
  },
  {
    "task_name": "TSPTW",
    "problem_type": "TSPTW",
    "instruction": "There’s a morning puzzle at the community shuttle: the van needs to head out from the depot, stop at each registered rider’s place exactly once during that rider’s pickup window (it can wait if it gets there too soon), and then return to base. The goal is straightforward in plain terms — keep the total driving distance down by summing all the segments of the route and picking the shortest possible loop that still meets everyone’s time window. No stop can be skipped or visited twice. Concrete details about riders, locations, and windows appear below.\n\nBelow are the 11 locations (including depot A) to visit in that loop.\n\n| stop_id | x_coord | y_coord | pickup_window_start | pickup_window_end |\n|---|---|---|---|---|\n| A | 51 | 67 | 0 | 1067 |\n| B | 45 | 77 | 310 | 571 |\n| C | 56 | 71 | 105 | 356 |\n| D | 27 | 15 | 140 | 342 |\n| E | 19 | 88 | 355 | 563 |\n| F | 80 | 33 | 368 | 605 |\n| G | 58 | 0 | 71 | 318 |\n| H | 100 | 17 | 338 | 603 |\n| I | 56 | 100 | 312 | 570 |\n| J | 23 | 21 | 268 | 544 |\n| K | 0 | 37 | 96 | 338 |\n\nThe route must start and end at depot A, visiting each of the 11 locations exactly once within their windows.\n\nAlso, when you send the route back, just use this simple JSON layout so it's clear and easy to read:\n\n{\n  \"solution\": [depot_id, location_id, ..., depot_id]\n}\n\n\"solution\" should be the ordered list of stops: start at the depot, visit each rider once in the order shown, and finish back at the depot. The names in the array above are placeholders to show the shape of the answer — this is just a sketch, not the actual route.\n\nPlease use the exact identifiers from the instance input — don’t rename or invent labels. \n- for example: \"Valid identifiers look like plain numbers such as “1” or “23”, single capital letters like “A” or “B”, or a capital letter followed by digits like “A1” or “X7”.\"",
    "instance": {
      "coordinates": [
        [
          51,
          67
        ],
        [
          45,
          77
        ],
        [
          56,
          71
        ],
        [
          27,
          15
        ],
        [
          19,
          88
        ],
        [
          80,
          33
        ],
        [
          58,
          0
        ],
        [
          100,
          17
        ],
        [
          56,
          100
        ],
        [
          23,
          21
        ],
        [
          0,
          37
        ]
      ],
      "depot": 0,
      "num_nodes": 11,
      "time_windows": [
        [
          0,
          1067
        ],
        [
          310,
          571
        ],
        [
          105,
          356
        ],
        [
          140,
          342
        ],
        [
          355,
          563
        ],
        [
          368,
          605
        ],
        [
          71,
          318
        ],
        [
          338,
          603
        ],
        [
          312,
          570
        ],
        [
          268,
          544
        ],
        [
          96,
          338
        ]
      ],
      "tour_length": 362.4655326481173,
      "objective": 362.4655326481173
    },
    "solution": [
      0,
      2,
      10,
      9,
      3,
      6,
      7,
      5,
      8,
      4,
      1,
      0
    ],
    "obj": 362.4655326481173,
    "instance_variant": {
      "problem_type": "TSPTW",
      "num_nodes": 11,
      "nodes": [
        {
          "id": "A",
          "x": 51,
          "y": 67,
          "tw_start": 0,
          "tw_end": 1067
        },
        {
          "id": "B",
          "x": 45,
          "y": 77,
          "tw_start": 310,
          "tw_end": 571
        },
        {
          "id": "C",
          "x": 56,
          "y": 71,
          "tw_start": 105,
          "tw_end": 356
        },
        {
          "id": "D",
          "x": 27,
          "y": 15,
          "tw_start": 140,
          "tw_end": 342
        },
        {
          "id": "E",
          "x": 19,
          "y": 88,
          "tw_start": 355,
          "tw_end": 563
        },
        {
          "id": "F",
          "x": 80,
          "y": 33,
          "tw_start": 368,
          "tw_end": 605
        },
        {
          "id": "G",
          "x": 58,
          "y": 0,
          "tw_start": 71,
          "tw_end": 318
        },
        {
          "id": "H",
          "x": 100,
          "y": 17,
          "tw_start": 338,
          "tw_end": 603
        },
        {
          "id": "I",
          "x": 56,
          "y": 100,
          "tw_start": 312,
          "tw_end": 570
        },
        {
          "id": "J",
          "x": 23,
          "y": 21,
          "tw_start": 268,
          "tw_end": 544
        },
        {
          "id": "K",
          "x": 0,
          "y": 37,
          "tw_start": 96,
          "tw_end": 338
        }
      ],
      "depot": "A",
      "objective": 362.4655326481173
    },
    "solution_variant": [
      "A",
      "C",
      "K",
      "J",
      "D",
      "G",
      "H",
      "F",
      "I",
      "E",
      "B",
      "A"
    ],
    "context_index": 37,
    "input_format": "markdown_table",
    "input_index_base": "names"
  },
  {
    "task_name": "TSPTW",
    "problem_type": "TSPTW",
    "instruction": "There’s a repair crew that needs a daily run: one technician leaves the shop, visits each customer one time during their appointment window (they can hang out if they get there early), and then returns to the shop. The goal is to choose the sequence of stops so the total miles driven — the sum of distances from the shop through every house and back — is as small as possible. It’s important that every household gets exactly one visit and nobody is visited twice or left out. The concrete details follow below.\n\n# total_locations_count=11\n# shop_node=1\n# time windows are listed per node in the table\nlocation_id,coord_x,coord_y,appointment_window_start,appointment_window_end\n1,70,68,0,1067\n2,61,21,85,375\n3,23,0,366,564\n4,35,80,273,557\n5,100,43,70,319\n6,83,49,355,552\n7,67,90,270,493\n8,0,36,358,646\n9,41,100,366,606\n10,55,98,334,610\n11,22,82,123,398\n\nAlso, when you send back the route, please put it in a little JSON sketch so it's easy to read and check. Something like this:\n\n{\n  \"solution\": [shop_id, customer_id, ..., shop_id]\n}\n\nHere \"solution\" is just the ordered list of stops for the day: start at the shop, go to each customer once, and come back to the shop. The placeholders shop_id and customer_id are just examples showing the kind of labels that go in the list — think of them like blanks you fill in with the actual IDs from the instance. This JSON is just the shape I want you to follow, not the real answer itself.\n\nPlease make sure you use the exact identifiers from the instance input — don't rename them or invent new labels. Valid identifiers look like plain numbers such as \"1\" or \"23\", single capital letters like \"A\" or \"B\", or a capital letter followed by digits like \"A1\" or \"X7\".",
    "instance": {
      "coordinates": [
        [
          70,
          68
        ],
        [
          61,
          21
        ],
        [
          23,
          0
        ],
        [
          35,
          80
        ],
        [
          100,
          43
        ],
        [
          83,
          49
        ],
        [
          67,
          90
        ],
        [
          0,
          36
        ],
        [
          41,
          100
        ],
        [
          55,
          98
        ],
        [
          22,
          82
        ]
      ],
      "depot": 0,
      "num_nodes": 11,
      "time_windows": [
        [
          0,
          1067
        ],
        [
          85,
          375
        ],
        [
          366,
          564
        ],
        [
          273,
          557
        ],
        [
          70,
          319
        ],
        [
          355,
          552
        ],
        [
          270,
          493
        ],
        [
          358,
          646
        ],
        [
          366,
          606
        ],
        [
          334,
          610
        ],
        [
          123,
          398
        ]
      ],
      "tour_length": 457.35809597637774,
      "objective": 457.35809597637774
    },
    "solution": [
      0,
      4,
      1,
      3,
      10,
      8,
      9,
      6,
      5,
      2,
      7,
      0
    ],
    "obj": 457.35809597637774,
    "instance_variant": {
      "problem_type": "TSPTW",
      "num_nodes": 11,
      "nodes": [
        {
          "id": 1,
          "x": 70,
          "y": 68,
          "tw_start": 0,
          "tw_end": 1067
        },
        {
          "id": 2,
          "x": 61,
          "y": 21,
          "tw_start": 85,
          "tw_end": 375
        },
        {
          "id": 3,
          "x": 23,
          "y": 0,
          "tw_start": 366,
          "tw_end": 564
        },
        {
          "id": 4,
          "x": 35,
          "y": 80,
          "tw_start": 273,
          "tw_end": 557
        },
        {
          "id": 5,
          "x": 100,
          "y": 43,
          "tw_start": 70,
          "tw_end": 319
        },
        {
          "id": 6,
          "x": 83,
          "y": 49,
          "tw_start": 355,
          "tw_end": 552
        },
        {
          "id": 7,
          "x": 67,
          "y": 90,
          "tw_start": 270,
          "tw_end": 493
        },
        {
          "id": 8,
          "x": 0,
          "y": 36,
          "tw_start": 358,
          "tw_end": 646
        },
        {
          "id": 9,
          "x": 41,
          "y": 100,
          "tw_start": 366,
          "tw_end": 606
        },
        {
          "id": 10,
          "x": 55,
          "y": 98,
          "tw_start": 334,
          "tw_end": 610
        },
        {
          "id": 11,
          "x": 22,
          "y": 82,
          "tw_start": 123,
          "tw_end": 398
        }
      ],
      "depot": 1,
      "objective": 457.35809597637774
    },
    "solution_variant": [
      1,
      5,
      2,
      4,
      11,
      9,
      10,
      7,
      6,
      3,
      8,
      1
    ],
    "context_index": 38,
    "input_format": "csv",
    "input_index_base": 1
  },
  {
    "task_name": "TSPTW",
    "problem_type": "TSPTW",
    "instruction": "Someone has to map out the phlebotomist’s day so they can start at the lab, hit each appointment once within its window (it’s fine to wait if an appointment’s not open yet), and finish back at the lab. The clear goal is to pick the order of visits that yields the least total travel distance — simply add up the distances between stops and back to the lab to get that number. The full list of locations and their time slots appears below.\n\nThere are 13 locations including the lab 1 that must be visited in the route.\n\n| stop_id | coord_x | coord_y | earliest_arrival_time | latest_arrival_time |\n|---|---|---|---|---|\n| 1 | 30 | 14 | 0 | 1067 |\n| 2 | 38 | 88 | 14 | 266 |\n| 3 | 50 | 30 | 89 | 294 |\n| 4 | 4 | 82 | 29 | 291 |\n| 5 | 21 | 45 | 131 | 396 |\n| 6 | 100 | 21 | 25 | 249 |\n| 7 | 75 | 76 | 209 | 480 |\n| 8 | 81 | 100 | 123 | 378 |\n| 9 | 48 | 88 | 343 | 597 |\n| 10 | 0 | 50 | 90 | 286 |\n| 11 | 0 | 26 | 337 | 533 |\n| 12 | 39 | 60 | 339 | 584 |\n| 13 | 1 | 0 | 364 | 635 |\n\nSomeone should choose the visit order that starts and ends at 1 and visits every appointment once, minimizing total travel distance.\n\nYou can just send back the visit order in a little JSON snippet like this so it's easy to read and use.\n\n{\n  \"solution\": [lab_id, appointment_id, ..., lab_id]\n}\n\nThink of that array as the day’s itinerary: start at the lab (the first lab_id), list each appointment once in the order you plan to visit them, and finish back at the lab (the final lab_id). It’s just a simple checklist-style list, nothing fancy.\n\nPlease use the exact identifiers that appear in the instance input — don’t rename them or invent new labels. \n- for example: \"Valid identifiers look like plain numbers such as “1” or “23”, single capital letters like “A” or “B”, or a capital letter followed by digits like “A1” or “X7”.",
    "instance": {
      "coordinates": [
        [
          30,
          14
        ],
        [
          38,
          88
        ],
        [
          50,
          30
        ],
        [
          4,
          82
        ],
        [
          21,
          45
        ],
        [
          100,
          21
        ],
        [
          75,
          76
        ],
        [
          81,
          100
        ],
        [
          48,
          88
        ],
        [
          0,
          50
        ],
        [
          0,
          26
        ],
        [
          39,
          60
        ],
        [
          1,
          0
        ]
      ],
      "depot": 0,
      "num_nodes": 13,
      "time_windows": [
        [
          0,
          1067
        ],
        [
          14,
          266
        ],
        [
          89,
          294
        ],
        [
          29,
          291
        ],
        [
          131,
          396
        ],
        [
          25,
          249
        ],
        [
          209,
          480
        ],
        [
          123,
          378
        ],
        [
          343,
          597
        ],
        [
          90,
          286
        ],
        [
          337,
          533
        ],
        [
          339,
          584
        ],
        [
          364,
          635
        ]
      ],
      "tour_length": 479.91168268575274,
      "objective": 479.91168268575274
    },
    "solution": [
      0,
      5,
      2,
      9,
      3,
      1,
      6,
      7,
      8,
      11,
      4,
      10,
      12,
      0
    ],
    "obj": 479.91168268575274,
    "instance_variant": {
      "problem_type": "TSPTW",
      "num_nodes": 13,
      "nodes": [
        {
          "id": 1,
          "x": 30,
          "y": 14,
          "tw_start": 0,
          "tw_end": 1067
        },
        {
          "id": 2,
          "x": 38,
          "y": 88,
          "tw_start": 14,
          "tw_end": 266
        },
        {
          "id": 3,
          "x": 50,
          "y": 30,
          "tw_start": 89,
          "tw_end": 294
        },
        {
          "id": 4,
          "x": 4,
          "y": 82,
          "tw_start": 29,
          "tw_end": 291
        },
        {
          "id": 5,
          "x": 21,
          "y": 45,
          "tw_start": 131,
          "tw_end": 396
        },
        {
          "id": 6,
          "x": 100,
          "y": 21,
          "tw_start": 25,
          "tw_end": 249
        },
        {
          "id": 7,
          "x": 75,
          "y": 76,
          "tw_start": 209,
          "tw_end": 480
        },
        {
          "id": 8,
          "x": 81,
          "y": 100,
          "tw_start": 123,
          "tw_end": 378
        },
        {
          "id": 9,
          "x": 48,
          "y": 88,
          "tw_start": 343,
          "tw_end": 597
        },
        {
          "id": 10,
          "x": 0,
          "y": 50,
          "tw_start": 90,
          "tw_end": 286
        },
        {
          "id": 11,
          "x": 0,
          "y": 26,
          "tw_start": 337,
          "tw_end": 533
        },
        {
          "id": 12,
          "x": 39,
          "y": 60,
          "tw_start": 339,
          "tw_end": 584
        },
        {
          "id": 13,
          "x": 1,
          "y": 0,
          "tw_start": 364,
          "tw_end": 635
        }
      ],
      "depot": 1,
      "objective": 479.91168268575274
    },
    "solution_variant": [
      1,
      6,
      3,
      10,
      4,
      2,
      7,
      8,
      9,
      12,
      5,
      11,
      13,
      1
    ],
    "context_index": 39,
    "input_format": "markdown_table",
    "input_index_base": 1
  },
  {
    "task_name": "TSPTW",
    "problem_type": "TSPTW",
    "instruction": "Back at the warehouse the team is figuring out today’s loop: leave the yard, top up each stand one time only during that stand’s allowed restocking window (pauses are fine if the crew is early), and come home when done. The winning route is simply the one that minimizes total driving distance — add the distance from warehouse to the first stand, each stretch between successive stands, and the leg back to the warehouse to get the total. No stand can be skipped or repeated, and the concrete instance details follow below.\n\n# total_locations_including_warehouse=14\n# warehouse_id=1\n# time windows are listed per node in the table\nlocation_id,map_x_coordinate,map_y_coordinate,restock_window_start,restock_window_end\n1,13,100,0,1067\n2,6,91,387,615\n3,26,28,297,530\n4,0,7,186,441\n5,96,93,338,628\n6,55,98,298,532\n7,48,100,163,429\n8,46,31,92,297\n9,48,7,137,359\n10,50,4,114,331\n11,53,1,16,212\n12,99,0,383,618\n13,100,20,149,409\n14,96,27,84,370\n\nAlso, when you send the route back, just use this little JSON shape so it's easy to parse:\n\n{\n  \"solution\": [warehouse_id, stand_id, ..., warehouse_id]\n}\n\nThink of that as a simple form: \"solution\" holds the ordered list of stops — start at the warehouse, visit each stand exactly once (waiting is fine if you arrive early), and finish back at the warehouse. The names in the array are just placeholders showing the expected layout, not the real IDs.\n\nPlease make sure you use the exact identifiers from the instance input — don’t rename them or invent new labels. \n\n- for example: \"Valid identifiers look like plain numbers such as “1” or “23”, single capital letters like “A” or “B”, or a capital letter followed by digits like “A1” or “X7”.\"",
    "instance": {
      "coordinates": [
        [
          13,
          100
        ],
        [
          6,
          91
        ],
        [
          26,
          28
        ],
        [
          0,
          7
        ],
        [
          96,
          93
        ],
        [
          55,
          98
        ],
        [
          48,
          100
        ],
        [
          46,
          31
        ],
        [
          48,
          7
        ],
        [
          50,
          4
        ],
        [
          53,
          1
        ],
        [
          99,
          0
        ],
        [
          100,
          20
        ],
        [
          96,
          27
        ]
      ],
      "depot": 0,
      "num_nodes": 14,
      "time_windows": [
        [
          0,
          1067
        ],
        [
          387,
          615
        ],
        [
          297,
          530
        ],
        [
          186,
          441
        ],
        [
          338,
          628
        ],
        [
          298,
          532
        ],
        [
          163,
          429
        ],
        [
          92,
          297
        ],
        [
          137,
          359
        ],
        [
          114,
          331
        ],
        [
          16,
          212
        ],
        [
          383,
          618
        ],
        [
          149,
          409
        ],
        [
          84,
          370
        ]
      ],
      "tour_length": 704.7391044144571,
      "objective": 704.7391044144571
    },
    "solution": [
      0,
      7,
      9,
      10,
      3,
      8,
      12,
      13,
      4,
      5,
      6,
      1,
      2,
      11,
      0
    ],
    "obj": 704.7391044144571,
    "instance_variant": {
      "problem_type": "TSPTW",
      "num_nodes": 14,
      "nodes": [
        {
          "id": 1,
          "x": 13,
          "y": 100,
          "tw_start": 0,
          "tw_end": 1067
        },
        {
          "id": 2,
          "x": 6,
          "y": 91,
          "tw_start": 387,
          "tw_end": 615
        },
        {
          "id": 3,
          "x": 26,
          "y": 28,
          "tw_start": 297,
          "tw_end": 530
        },
        {
          "id": 4,
          "x": 0,
          "y": 7,
          "tw_start": 186,
          "tw_end": 441
        },
        {
          "id": 5,
          "x": 96,
          "y": 93,
          "tw_start": 338,
          "tw_end": 628
        },
        {
          "id": 6,
          "x": 55,
          "y": 98,
          "tw_start": 298,
          "tw_end": 532
        },
        {
          "id": 7,
          "x": 48,
          "y": 100,
          "tw_start": 163,
          "tw_end": 429
        },
        {
          "id": 8,
          "x": 46,
          "y": 31,
          "tw_start": 92,
          "tw_end": 297
        },
        {
          "id": 9,
          "x": 48,
          "y": 7,
          "tw_start": 137,
          "tw_end": 359
        },
        {
          "id": 10,
          "x": 50,
          "y": 4,
          "tw_start": 114,
          "tw_end": 331
        },
        {
          "id": 11,
          "x": 53,
          "y": 1,
          "tw_start": 16,
          "tw_end": 212
        },
        {
          "id": 12,
          "x": 99,
          "y": 0,
          "tw_start": 383,
          "tw_end": 618
        },
        {
          "id": 13,
          "x": 100,
          "y": 20,
          "tw_start": 149,
          "tw_end": 409
        },
        {
          "id": 14,
          "x": 96,
          "y": 27,
          "tw_start": 84,
          "tw_end": 370
        }
      ],
      "depot": 1,
      "objective": 704.7391044144571
    },
    "solution_variant": [
      1,
      8,
      10,
      11,
      4,
      9,
      13,
      14,
      5,
      6,
      7,
      2,
      3,
      12,
      1
    ],
    "context_index": 40,
    "input_format": "csv",
    "input_index_base": 1
  },
  {
    "task_name": "TSPTW",
    "problem_type": "TSPTW",
    "instruction": "Someone who runs the medical-waste rounds needs a route that departs the facility, hits every clinic one time during its designated pickup period (waiting allowed if arriving early), and returns to the facility afterward. The key decision is the order of visits: different orders change the total driving needed, and the aim is to pick the order that leads to the least total driving distance — computed by summing each leg from the depot to the first stop, from each stop to the next, and finally back to the depot. Nothing can be skipped or doubled up, and each clinic’s pickup window must be obeyed. The detailed list of clinics, time windows, and distances is shown below.\n\nThere are 11 locations including the facility, and the facility node id is 0.\nLocation 0 is at (0, 17) and must be visited between 0 and 1067.\nLocation 1 is at (18, 30) and must be visited between 305 and 507.\nLocation 2 is at (25, 13) and must be visited between 162 and 441.\nLocation 3 is at (67, 54) and must be visited between 366 and 605.\nLocation 4 is at (70, 100) and must be visited between 238 and 448.\nLocation 5 is at (72, 0) and must be visited between 384 and 601.\nLocation 6 is at (81, 47) and must be visited between 365 and 622.\nLocation 7 is at (83, 69) and must be visited between 235 and 479.\nLocation 8 is at (84, 15) and must be visited between 89 and 300.\nLocation 9 is at (96, 23) and must be visited between 85 and 297.\nLocation 10 is at (100, 12) and must be visited between 302 and 530.\nThese entries should be used to select the visit order that minimizes total driving distance while obeying every pickup window and returning to the facility.\n\nWhen you send the final route back, just drop it in this simple JSON shape so it's easy to pick up:\n\n{\n  \"solution\": [\"depot_id\", \"location_id\", \"...\", \"depot_id\"]\n}\n\nPretty straightforward — \"solution\" is the ordered list of stops (start at the depot, visit each clinic once, and end at the depot). Think of the items in the array as the exact IDs you see in the instance (this JSON is only a sketch of the shape I expect, not the actual route).\n\nPlease use the identifiers exactly as they appear in the problem input — do not rename them or invent new labels.\n- for example: Valid identifiers look like plain numbers such as \"1\" or \"23\", single capital letters like \"A\" or \"B\", or a capital letter followed by digits like \"A1\" or \"X7\".",
    "instance": {
      "coordinates": [
        [
          0,
          17
        ],
        [
          18,
          30
        ],
        [
          25,
          13
        ],
        [
          67,
          54
        ],
        [
          70,
          100
        ],
        [
          72,
          0
        ],
        [
          81,
          47
        ],
        [
          83,
          69
        ],
        [
          84,
          15
        ],
        [
          96,
          23
        ],
        [
          100,
          12
        ]
      ],
      "depot": 0,
      "num_nodes": 11,
      "time_windows": [
        [
          0,
          1067
        ],
        [
          305,
          507
        ],
        [
          162,
          441
        ],
        [
          366,
          605
        ],
        [
          238,
          448
        ],
        [
          384,
          601
        ],
        [
          365,
          622
        ],
        [
          235,
          479
        ],
        [
          89,
          300
        ],
        [
          85,
          297
        ],
        [
          302,
          530
        ]
      ],
      "tour_length": 477.72078742760357,
      "objective": 477.72078742760357
    },
    "solution": [
      0,
      2,
      8,
      9,
      1,
      3,
      4,
      7,
      6,
      10,
      5,
      0
    ],
    "obj": 477.72078742760357,
    "instance_variant": {
      "problem_type": "TSPTW",
      "num_nodes": 11,
      "nodes": [
        {
          "id": 0,
          "x": 0,
          "y": 17,
          "tw_start": 0,
          "tw_end": 1067
        },
        {
          "id": 1,
          "x": 18,
          "y": 30,
          "tw_start": 305,
          "tw_end": 507
        },
        {
          "id": 2,
          "x": 25,
          "y": 13,
          "tw_start": 162,
          "tw_end": 441
        },
        {
          "id": 3,
          "x": 67,
          "y": 54,
          "tw_start": 366,
          "tw_end": 605
        },
        {
          "id": 4,
          "x": 70,
          "y": 100,
          "tw_start": 238,
          "tw_end": 448
        },
        {
          "id": 5,
          "x": 72,
          "y": 0,
          "tw_start": 384,
          "tw_end": 601
        },
        {
          "id": 6,
          "x": 81,
          "y": 47,
          "tw_start": 365,
          "tw_end": 622
        },
        {
          "id": 7,
          "x": 83,
          "y": 69,
          "tw_start": 235,
          "tw_end": 479
        },
        {
          "id": 8,
          "x": 84,
          "y": 15,
          "tw_start": 89,
          "tw_end": 300
        },
        {
          "id": 9,
          "x": 96,
          "y": 23,
          "tw_start": 85,
          "tw_end": 297
        },
        {
          "id": 10,
          "x": 100,
          "y": 12,
          "tw_start": 302,
          "tw_end": 530
        }
      ],
      "depot": 0,
      "objective": 477.72078742760357
    },
    "solution_variant": [
      0,
      2,
      8,
      9,
      1,
      3,
      4,
      7,
      6,
      10,
      5,
      0
    ],
    "context_index": 41,
    "input_format": "nl",
    "input_index_base": 0
  },
  {
    "task_name": "TSPTW",
    "problem_type": "TSPTW",
    "instruction": "Recently a detailer had to plan a day of driveway cleanings: start at the garage, hit every driveway one time during the customer’s requested window (it’s okay to wait if the window isn’t open yet), and then come back to base. The only thing that separates a decent day from a great one is how little driving is done overall — just add up the distances of each leg (garage to first stop, between stops, and back) and choose the route with the smallest sum. No driveways can be skipped or repeated, and every job must fall inside its time slot. The concrete route data is shown below.\n\n# total_locations_including_garage=14\n# garage_node_id=A\n# time windows are listed per node in the table\nlocation_id,x_coordinate,y_coordinate,earliest_service_time,latest_service_time\nA,14,83,0,1067\nB,43,79,22,310\nC,100,46,342,626\nD,100,79,386,596\nE,100,96,153,421\nF,5,25,270,478\nG,0,50,316,532\nH,24,0,86,332\nI,29,25,230,480\nJ,24,75,35,314\nK,57,50,103,309\nL,62,100,344,631\nM,81,25,334,607\nN,81,50,254,501\n\nAlso, when you give the final route, please stick to this simple JSON shape so it's easy to parse:\n\n{\n  \"solution\": [garage_id, driveway_id, ..., garage_id]\n}\n\nHere \"solution\" is just the ordered list of stops: start at the garage, list each driveway once in the order they’re visited (you can wait if a time slot isn’t open yet), and end back at the garage. Think of the placeholders as the labels you’ll fill in from the instance — just a form to show the visited sequence. This JSON is only a sketch of the expected shape, not the actual answer.\n\nPlease make sure to use the exact identifiers from the instance input — don’t rename them or invent new ones. \nfor example: \"Valid identifiers look like plain numbers such as “1” or “23”, single capital letters like “A” or “B”, or a capital letter followed by digits like “A1” or “X7”.\"",
    "instance": {
      "coordinates": [
        [
          14,
          83
        ],
        [
          43,
          79
        ],
        [
          100,
          46
        ],
        [
          100,
          79
        ],
        [
          100,
          96
        ],
        [
          5,
          25
        ],
        [
          0,
          50
        ],
        [
          24,
          0
        ],
        [
          29,
          25
        ],
        [
          24,
          75
        ],
        [
          57,
          50
        ],
        [
          62,
          100
        ],
        [
          81,
          25
        ],
        [
          81,
          50
        ]
      ],
      "depot": 0,
      "num_nodes": 14,
      "time_windows": [
        [
          0,
          1067
        ],
        [
          22,
          310
        ],
        [
          342,
          626
        ],
        [
          386,
          596
        ],
        [
          153,
          421
        ],
        [
          270,
          478
        ],
        [
          316,
          532
        ],
        [
          86,
          332
        ],
        [
          230,
          480
        ],
        [
          35,
          314
        ],
        [
          103,
          309
        ],
        [
          344,
          631
        ],
        [
          334,
          607
        ],
        [
          254,
          501
        ]
      ],
      "tour_length": 531.1244131088996,
      "objective": 531.1244131088996
    },
    "solution": [
      0,
      9,
      1,
      4,
      10,
      8,
      7,
      5,
      6,
      12,
      13,
      2,
      3,
      11,
      0
    ],
    "obj": 531.1244131088996,
    "instance_variant": {
      "problem_type": "TSPTW",
      "num_nodes": 14,
      "nodes": [
        {
          "id": "A",
          "x": 14,
          "y": 83,
          "tw_start": 0,
          "tw_end": 1067
        },
        {
          "id": "B",
          "x": 43,
          "y": 79,
          "tw_start": 22,
          "tw_end": 310
        },
        {
          "id": "C",
          "x": 100,
          "y": 46,
          "tw_start": 342,
          "tw_end": 626
        },
        {
          "id": "D",
          "x": 100,
          "y": 79,
          "tw_start": 386,
          "tw_end": 596
        },
        {
          "id": "E",
          "x": 100,
          "y": 96,
          "tw_start": 153,
          "tw_end": 421
        },
        {
          "id": "F",
          "x": 5,
          "y": 25,
          "tw_start": 270,
          "tw_end": 478
        },
        {
          "id": "G",
          "x": 0,
          "y": 50,
          "tw_start": 316,
          "tw_end": 532
        },
        {
          "id": "H",
          "x": 24,
          "y": 0,
          "tw_start": 86,
          "tw_end": 332
        },
        {
          "id": "I",
          "x": 29,
          "y": 25,
          "tw_start": 230,
          "tw_end": 480
        },
        {
          "id": "J",
          "x": 24,
          "y": 75,
          "tw_start": 35,
          "tw_end": 314
        },
        {
          "id": "K",
          "x": 57,
          "y": 50,
          "tw_start": 103,
          "tw_end": 309
        },
        {
          "id": "L",
          "x": 62,
          "y": 100,
          "tw_start": 344,
          "tw_end": 631
        },
        {
          "id": "M",
          "x": 81,
          "y": 25,
          "tw_start": 334,
          "tw_end": 607
        },
        {
          "id": "N",
          "x": 81,
          "y": 50,
          "tw_start": 254,
          "tw_end": 501
        }
      ],
      "depot": "A",
      "objective": 531.1244131088996
    },
    "solution_variant": [
      "A",
      "J",
      "B",
      "E",
      "K",
      "I",
      "H",
      "F",
      "G",
      "M",
      "N",
      "C",
      "D",
      "L",
      "A"
    ],
    "context_index": 42,
    "input_format": "csv",
    "input_index_base": "names"
  },
  {
    "task_name": "TSPTW",
    "problem_type": "TSPTW",
    "instruction": "Back at the store the dispatcher sketches a run: the truck must leave the store, visit every customer exactly once to deliver during the customer’s specified time window (waiting is allowed), and return to the starting point. The planner’s job is to pick the order of customers, since that order sets the total miles traveled. The “better” plan is simply the one that results in fewer total miles — figured by summing the distance between each consecutive stop plus the return leg. The concrete details are listed below.\n\n# total_locations_including_store=13\n# store_node_id=0\n# time windows are listed per node in the table\nlocation_id,x_coordinate,y_coordinate,earliest_delivery_time,latest_delivery_time\n0,0,45,0,1067\n1,4,36,33,267\n2,22,100,144,363\n3,30,64,280,522\n4,41,9,31,246\n5,44,76,265,466\n6,59,45,330,572\n7,67,0,186,437\n8,89,42,319,547\n9,93,27,263,511\n10,100,33,103,382\n11,20,68,309,567\n12,83,12,330,608\n\nJust so we're on the same page, send the route back in this simple JSON shape — an ordered list of stop IDs starting and ending at the store.\n\n{\n  \"solution\": [\"store_id\", \"customer_id\", \"...\", \"store_id\"]\n}\n\nThink of this like a little form: the array is the run in order, the first entry is where the truck leaves from, the last entry is where it comes back to, and everything in between is each customer visited exactly once. This JSON is just a sketch of the shape I expect, not the actual route.\n\nPlease use the exact identifiers from the instance input — don’t rename them or invent new labels.  \nValid identifiers look like plain numbers such as “1” or “23”, single capital letters like “A” or “B”, or a capital letter followed by digits like “A1” or “X7”.",
    "instance": {
      "coordinates": [
        [
          0,
          45
        ],
        [
          4,
          36
        ],
        [
          22,
          100
        ],
        [
          30,
          64
        ],
        [
          41,
          9
        ],
        [
          44,
          76
        ],
        [
          59,
          45
        ],
        [
          67,
          0
        ],
        [
          89,
          42
        ],
        [
          93,
          27
        ],
        [
          100,
          33
        ],
        [
          20,
          68
        ],
        [
          83,
          12
        ]
      ],
      "depot": 0,
      "num_nodes": 13,
      "time_windows": [
        [
          0,
          1067
        ],
        [
          33,
          267
        ],
        [
          144,
          363
        ],
        [
          280,
          522
        ],
        [
          31,
          246
        ],
        [
          265,
          466
        ],
        [
          330,
          572
        ],
        [
          186,
          437
        ],
        [
          319,
          547
        ],
        [
          263,
          511
        ],
        [
          103,
          382
        ],
        [
          309,
          567
        ],
        [
          330,
          608
        ]
      ],
      "tour_length": 382.54479796819044,
      "objective": 382.54479796819044
    },
    "solution": [
      0,
      1,
      2,
      4,
      7,
      12,
      9,
      10,
      8,
      6,
      5,
      3,
      11,
      0
    ],
    "obj": 382.54479796819044,
    "instance_variant": {
      "problem_type": "TSPTW",
      "num_nodes": 13,
      "nodes": [
        {
          "id": 0,
          "x": 0,
          "y": 45,
          "tw_start": 0,
          "tw_end": 1067
        },
        {
          "id": 1,
          "x": 4,
          "y": 36,
          "tw_start": 33,
          "tw_end": 267
        },
        {
          "id": 2,
          "x": 22,
          "y": 100,
          "tw_start": 144,
          "tw_end": 363
        },
        {
          "id": 3,
          "x": 30,
          "y": 64,
          "tw_start": 280,
          "tw_end": 522
        },
        {
          "id": 4,
          "x": 41,
          "y": 9,
          "tw_start": 31,
          "tw_end": 246
        },
        {
          "id": 5,
          "x": 44,
          "y": 76,
          "tw_start": 265,
          "tw_end": 466
        },
        {
          "id": 6,
          "x": 59,
          "y": 45,
          "tw_start": 330,
          "tw_end": 572
        },
        {
          "id": 7,
          "x": 67,
          "y": 0,
          "tw_start": 186,
          "tw_end": 437
        },
        {
          "id": 8,
          "x": 89,
          "y": 42,
          "tw_start": 319,
          "tw_end": 547
        },
        {
          "id": 9,
          "x": 93,
          "y": 27,
          "tw_start": 263,
          "tw_end": 511
        },
        {
          "id": 10,
          "x": 100,
          "y": 33,
          "tw_start": 103,
          "tw_end": 382
        },
        {
          "id": 11,
          "x": 20,
          "y": 68,
          "tw_start": 309,
          "tw_end": 567
        },
        {
          "id": 12,
          "x": 83,
          "y": 12,
          "tw_start": 330,
          "tw_end": 608
        }
      ],
      "depot": 0,
      "objective": 382.54479796819044
    },
    "solution_variant": [
      0,
      1,
      2,
      4,
      7,
      12,
      9,
      10,
      8,
      6,
      5,
      3,
      11,
      0
    ],
    "context_index": 43,
    "input_format": "csv",
    "input_index_base": 0
  },
  {
    "task_name": "TSPTW",
    "problem_type": "TSPTW",
    "instruction": "Back at the office the scheduler lays out a run: start and end at the office, visit every meter site once and only once, and make sure each visit falls inside that site's permitted time slot (waiting ahead of the slot is allowed). The decision is how to arrange the stops so the whole loop uses the least driving — figured by adding up the distances between consecutive stops and the return trip. Every meter must be visited exactly one time, and the precise locations and their access windows are provided below.\n\n{\n  \"total_locations_including_office\": 14,\n  \"nodes\": [\n    {\n      \"site_id\": \"A\",\n      \"x_coordinate\": 90,\n      \"y_coordinate\": 91,\n      \"access_window_start\": 0,\n      \"access_window_end\": 1067\n    },\n    {\n      \"site_id\": \"B\",\n      \"x_coordinate\": 0,\n      \"y_coordinate\": 40,\n      \"access_window_start\": 274,\n      \"access_window_end\": 550\n    },\n    {\n      \"site_id\": \"C\",\n      \"x_coordinate\": 23,\n      \"y_coordinate\": 46,\n      \"access_window_start\": 270,\n      \"access_window_end\": 530\n    },\n    {\n      \"site_id\": \"D\",\n      \"x_coordinate\": 75,\n      \"y_coordinate\": 88,\n      \"access_window_start\": 240,\n      \"access_window_end\": 507\n    },\n    {\n      \"site_id\": \"E\",\n      \"x_coordinate\": 58,\n      \"y_coordinate\": 100,\n      \"access_window_start\": 61,\n      \"access_window_end\": 340\n    },\n    {\n      \"site_id\": \"F\",\n      \"x_coordinate\": 48,\n      \"y_coordinate\": 29,\n      \"access_window_start\": 338,\n      \"access_window_end\": 535\n    },\n    {\n      \"site_id\": \"G\",\n      \"x_coordinate\": 100,\n      \"y_coordinate\": 91,\n      \"access_window_start\": 320,\n      \"access_window_end\": 526\n    },\n    {\n      \"site_id\": \"H\",\n      \"x_coordinate\": 21,\n      \"y_coordinate\": 84,\n      \"access_window_start\": 130,\n      \"access_window_end\": 396\n    },\n    {\n      \"site_id\": \"I\",\n      \"x_coordinate\": 3,\n      \"y_coordinate\": 43,\n      \"access_window_start\": 62,\n      \"access_window_end\": 335\n    },\n    {\n      \"site_id\": \"J\",\n      \"x_coordinate\": 41,\n      \"y_coordinate\": 90,\n      \"access_window_start\": 322,\n      \"access_window_end\": 566\n    },\n    {\n      \"site_id\": \"K\",\n      \"x_coordinate\": 45,\n      \"y_coordinate\": 32,\n      \"access_window_start\": 2,\n      \"access_window_end\": 224\n    },\n    {\n      \"site_id\": \"L\",\n      \"x_coordinate\": 64,\n      \"y_coordinate\": 60,\n      \"access_window_start\": 239,\n      \"access_window_end\": 528\n    },\n    {\n      \"site_id\": \"M\",\n      \"x_coordinate\": 41,\n      \"y_coordinate\": 2,\n      \"access_window_start\": 245,\n      \"access_window_end\": 464\n    },\n    {\n      \"site_id\": \"N\",\n      \"x_coordinate\": 21,\n      \"y_coordinate\": 0,\n      \"access_window_start\": 245,\n      \"access_window_end\": 492\n    }\n  ],\n  \"office_node_id\": \"A\"\n}\n\nAlso, when you send the route back, just use this simple JSON shape so I can read it easily:\n\n{\n  \"solution\": [office_id, site_id, ..., office_id]\n}\n\nThink of that as a little form: \"solution\" holds the stop-by-stop order of the loop (starting and ending at the office). office_id and site_id are just placeholders for the actual site identifiers in your instance, and the ... stands in for the other stops in between. This is just the shape I want — not the real answer filled in.\n\nPlease make sure you use the exact identifiers from the instance input — no renaming and no new labels. Valid identifiers look like plain numbers such as \"1\" or \"23\", single capital letters like \"A\" or \"B\", or a capital letter followed by digits like \"A1\" or \"X7\".",
    "instance": {
      "coordinates": [
        [
          90,
          91
        ],
        [
          0,
          40
        ],
        [
          23,
          46
        ],
        [
          75,
          88
        ],
        [
          58,
          100
        ],
        [
          48,
          29
        ],
        [
          100,
          91
        ],
        [
          21,
          84
        ],
        [
          3,
          43
        ],
        [
          41,
          90
        ],
        [
          45,
          32
        ],
        [
          64,
          60
        ],
        [
          41,
          2
        ],
        [
          21,
          0
        ]
      ],
      "depot": 0,
      "num_nodes": 14,
      "time_windows": [
        [
          0,
          1067
        ],
        [
          274,
          550
        ],
        [
          270,
          530
        ],
        [
          240,
          507
        ],
        [
          61,
          340
        ],
        [
          338,
          535
        ],
        [
          320,
          526
        ],
        [
          130,
          396
        ],
        [
          62,
          335
        ],
        [
          322,
          566
        ],
        [
          2,
          224
        ],
        [
          239,
          528
        ],
        [
          245,
          464
        ],
        [
          245,
          492
        ]
      ],
      "tour_length": 416.4629153761622,
      "objective": 416.4629153761622
    },
    "solution": [
      0,
      4,
      7,
      10,
      2,
      8,
      1,
      13,
      12,
      5,
      11,
      9,
      3,
      6,
      0
    ],
    "obj": 416.4629153761622,
    "instance_variant": {
      "problem_type": "TSPTW",
      "num_nodes": 14,
      "nodes": [
        {
          "id": "A",
          "x": 90,
          "y": 91,
          "tw_start": 0,
          "tw_end": 1067
        },
        {
          "id": "B",
          "x": 0,
          "y": 40,
          "tw_start": 274,
          "tw_end": 550
        },
        {
          "id": "C",
          "x": 23,
          "y": 46,
          "tw_start": 270,
          "tw_end": 530
        },
        {
          "id": "D",
          "x": 75,
          "y": 88,
          "tw_start": 240,
          "tw_end": 507
        },
        {
          "id": "E",
          "x": 58,
          "y": 100,
          "tw_start": 61,
          "tw_end": 340
        },
        {
          "id": "F",
          "x": 48,
          "y": 29,
          "tw_start": 338,
          "tw_end": 535
        },
        {
          "id": "G",
          "x": 100,
          "y": 91,
          "tw_start": 320,
          "tw_end": 526
        },
        {
          "id": "H",
          "x": 21,
          "y": 84,
          "tw_start": 130,
          "tw_end": 396
        },
        {
          "id": "I",
          "x": 3,
          "y": 43,
          "tw_start": 62,
          "tw_end": 335
        },
        {
          "id": "J",
          "x": 41,
          "y": 90,
          "tw_start": 322,
          "tw_end": 566
        },
        {
          "id": "K",
          "x": 45,
          "y": 32,
          "tw_start": 2,
          "tw_end": 224
        },
        {
          "id": "L",
          "x": 64,
          "y": 60,
          "tw_start": 239,
          "tw_end": 528
        },
        {
          "id": "M",
          "x": 41,
          "y": 2,
          "tw_start": 245,
          "tw_end": 464
        },
        {
          "id": "N",
          "x": 21,
          "y": 0,
          "tw_start": 245,
          "tw_end": 492
        }
      ],
      "depot": "A",
      "objective": 416.4629153761622
    },
    "solution_variant": [
      "A",
      "E",
      "H",
      "K",
      "C",
      "I",
      "B",
      "N",
      "M",
      "F",
      "L",
      "J",
      "D",
      "G",
      "A"
    ],
    "context_index": 44,
    "input_format": "json",
    "input_index_base": "names"
  },
  {
    "task_name": "TSPTW",
    "problem_type": "TSPTW",
    "instruction": "Many households booked cleanings for the same day, and the team must be routed from the office through every address one time and back to the office, all while respecting each household’s allowed arrival period (a bit of waiting is fine). The question is which order to visit the homes so the crew can hit all the time slots without going back over the same address. A better schedule is simply the one that results in fewer kilometers driven overall — compute that by adding the distances for every consecutive hop in the route, including leaving and returning to the office. The detailed bookings and windows are listed below.\n\nThere are 14 locations including the office; the office is node A.\n\n| location_id | location_x_coordinate | location_y_coordinate | earliest_allowed_arrival | latest_allowed_arrival |\n|---|---|---|---|---|\n| A | 3 | 49 | 0 | 1067 |\n| B | 41 | 1 | 302 | 506 |\n| C | 89 | 39 | 295 | 541 |\n| D | 69 | 66 | 373 | 600 |\n| E | 86 | 17 | 245 | 529 |\n| F | 92 | 0 | 39 | 324 |\n| G | 100 | 16 | 266 | 467 |\n| H | 100 | 32 | 116 | 379 |\n| I | 82 | 96 | 26 | 276 |\n| J | 35 | 76 | 134 | 388 |\n| K | 25 | 21 | 17 | 296 |\n| L | 30 | 43 | 377 | 665 |\n| M | 16 | 99 | 290 | 497 |\n| N | 0 | 100 | 294 | 490 |\n\nPlan a tour that visits each location once and returns to the office at node A while respecting all arrival windows and minimizing kilometers driven.\n\nAlso, when you give the final route, please use a tiny JSON layout like this so it's easy to parse:\n\n{\n  \"solution\": [office_id, address_id, ..., office_id]\n}\n\nThis just shows the shape I want — \"solution\" is the ordered list of stops, starting at the office, visiting every home once, and coming back to the office. Think of it like filling in the visit order on a simple form; replace each placeholder with the matching identifier from the instance. The JSON above is only a sketch of the expected shape, not the actual answer.\n\nAll identifiers must be used exactly as they appear in the instance input — no renaming and no new labels.  \nValid identifiers look like plain numbers such as “1” or “23”, single capital letters like “A” or “B”, or a capital letter followed by digits like “A1” or “X7”.",
    "instance": {
      "coordinates": [
        [
          3,
          49
        ],
        [
          41,
          1
        ],
        [
          89,
          39
        ],
        [
          69,
          66
        ],
        [
          86,
          17
        ],
        [
          92,
          0
        ],
        [
          100,
          16
        ],
        [
          100,
          32
        ],
        [
          82,
          96
        ],
        [
          35,
          76
        ],
        [
          25,
          21
        ],
        [
          30,
          43
        ],
        [
          16,
          99
        ],
        [
          0,
          100
        ]
      ],
      "depot": 0,
      "num_nodes": 14,
      "time_windows": [
        [
          0,
          1067
        ],
        [
          302,
          506
        ],
        [
          295,
          541
        ],
        [
          373,
          600
        ],
        [
          245,
          529
        ],
        [
          39,
          324
        ],
        [
          266,
          467
        ],
        [
          116,
          379
        ],
        [
          26,
          276
        ],
        [
          134,
          388
        ],
        [
          17,
          296
        ],
        [
          377,
          665
        ],
        [
          290,
          497
        ],
        [
          294,
          490
        ]
      ],
      "tour_length": 557.2349161922258,
      "objective": 557.2349161922258
    },
    "solution": [
      0,
      10,
      5,
      7,
      8,
      12,
      13,
      9,
      3,
      2,
      6,
      4,
      1,
      11,
      0
    ],
    "obj": 557.2349161922258,
    "instance_variant": {
      "problem_type": "TSPTW",
      "num_nodes": 14,
      "nodes": [
        {
          "id": "A",
          "x": 3,
          "y": 49,
          "tw_start": 0,
          "tw_end": 1067
        },
        {
          "id": "B",
          "x": 41,
          "y": 1,
          "tw_start": 302,
          "tw_end": 506
        },
        {
          "id": "C",
          "x": 89,
          "y": 39,
          "tw_start": 295,
          "tw_end": 541
        },
        {
          "id": "D",
          "x": 69,
          "y": 66,
          "tw_start": 373,
          "tw_end": 600
        },
        {
          "id": "E",
          "x": 86,
          "y": 17,
          "tw_start": 245,
          "tw_end": 529
        },
        {
          "id": "F",
          "x": 92,
          "y": 0,
          "tw_start": 39,
          "tw_end": 324
        },
        {
          "id": "G",
          "x": 100,
          "y": 16,
          "tw_start": 266,
          "tw_end": 467
        },
        {
          "id": "H",
          "x": 100,
          "y": 32,
          "tw_start": 116,
          "tw_end": 379
        },
        {
          "id": "I",
          "x": 82,
          "y": 96,
          "tw_start": 26,
          "tw_end": 276
        },
        {
          "id": "J",
          "x": 35,
          "y": 76,
          "tw_start": 134,
          "tw_end": 388
        },
        {
          "id": "K",
          "x": 25,
          "y": 21,
          "tw_start": 17,
          "tw_end": 296
        },
        {
          "id": "L",
          "x": 30,
          "y": 43,
          "tw_start": 377,
          "tw_end": 665
        },
        {
          "id": "M",
          "x": 16,
          "y": 99,
          "tw_start": 290,
          "tw_end": 497
        },
        {
          "id": "N",
          "x": 0,
          "y": 100,
          "tw_start": 294,
          "tw_end": 490
        }
      ],
      "depot": "A",
      "objective": 557.2349161922258
    },
    "solution_variant": [
      "A",
      "K",
      "F",
      "H",
      "I",
      "M",
      "N",
      "J",
      "D",
      "C",
      "G",
      "E",
      "B",
      "L",
      "A"
    ],
    "context_index": 45,
    "input_format": "markdown_table",
    "input_index_base": "names"
  },
  {
    "task_name": "TSPTW",
    "problem_type": "TSPTW",
    "instruction": "I pictured a sales rep leaving the branch in the morning, swinging by a handful of prospects, and then heading back to the office at the end of the day. The trick is picking the order to visit so every prospective client is seen exactly once, each meeting happens inside the slot they gave, and the rep doesn’t rack up more driving than necessary — total distance is just the sum of the miles between stops (including the trip home), so the plan with the smallest sum is the nicer one. If the rep gets to a place early, waiting until the meeting window opens is fine, but nobody can be skipped or visited twice. The exact locations, times, and distances are listed below.\n\nThere are 13 locations including the branch office (depot node 0).\n\n| location_id | location_x | location_y | earliest_meeting_time | latest_meeting_time |\n|---|---|---|---|---|\n| 0 | 0 | 23 | 0 | 1067 |\n| 1 | 5 | 41 | 8 | 233 |\n| 2 | 2 | 55 | 189 | 458 |\n| 3 | 0 | 59 | 265 | 502 |\n| 4 | 5 | 59 | 106 | 396 |\n| 5 | 2 | 80 | 165 | 403 |\n| 6 | 0 | 100 | 63 | 334 |\n| 7 | 7 | 100 | 269 | 484 |\n| 8 | 100 | 0 | 31 | 291 |\n| 9 | 95 | 75 | 253 | 474 |\n| 10 | 100 | 80 | 368 | 577 |\n| 11 | 95 | 100 | 167 | 453 |\n| 12 | 100 | 100 | 162 | 418 |\n\nI'll pick the shortest valid tour among the 13 locations that starts and ends at depot 0.\n\nIf you want the route in a neat, machine-friendly form, just drop it into a tiny JSON object like this:\n\n{\n  \"solution\": [branch_id, location_id, ..., branch_id]\n}\n\nThink of that as: \"solution\" is the list that gives the visit order — start at the branch (first placeholder), go visit each prospect once (the middle placeholders), and come back to the branch (last placeholder). This is just a sketch of the shape I expect, not the actual route.\n\nPlease use the exact identifiers from the instance input — no renaming and no invented labels. \n- for example: \"Valid identifiers look like plain numbers such as “1” or “23”, single capital letters like “A” or “B”, or a capital letter followed by digits like “A1” or “X7”.\"",
    "instance": {
      "coordinates": [
        [
          0,
          23
        ],
        [
          5,
          41
        ],
        [
          2,
          55
        ],
        [
          0,
          59
        ],
        [
          5,
          59
        ],
        [
          2,
          80
        ],
        [
          0,
          100
        ],
        [
          7,
          100
        ],
        [
          100,
          0
        ],
        [
          95,
          75
        ],
        [
          100,
          80
        ],
        [
          95,
          100
        ],
        [
          100,
          100
        ]
      ],
      "depot": 0,
      "num_nodes": 13,
      "time_windows": [
        [
          0,
          1067
        ],
        [
          8,
          233
        ],
        [
          189,
          458
        ],
        [
          265,
          502
        ],
        [
          106,
          396
        ],
        [
          165,
          403
        ],
        [
          63,
          334
        ],
        [
          269,
          484
        ],
        [
          31,
          291
        ],
        [
          253,
          474
        ],
        [
          368,
          577
        ],
        [
          167,
          453
        ],
        [
          162,
          418
        ]
      ],
      "tour_length": 506.55520531202313,
      "objective": 506.55520531202313
    },
    "solution": [
      0,
      8,
      1,
      2,
      3,
      4,
      5,
      6,
      7,
      11,
      12,
      10,
      9,
      0
    ],
    "obj": 506.55520531202313,
    "instance_variant": {
      "problem_type": "TSPTW",
      "num_nodes": 13,
      "nodes": [
        {
          "id": 0,
          "x": 0,
          "y": 23,
          "tw_start": 0,
          "tw_end": 1067
        },
        {
          "id": 1,
          "x": 5,
          "y": 41,
          "tw_start": 8,
          "tw_end": 233
        },
        {
          "id": 2,
          "x": 2,
          "y": 55,
          "tw_start": 189,
          "tw_end": 458
        },
        {
          "id": 3,
          "x": 0,
          "y": 59,
          "tw_start": 265,
          "tw_end": 502
        },
        {
          "id": 4,
          "x": 5,
          "y": 59,
          "tw_start": 106,
          "tw_end": 396
        },
        {
          "id": 5,
          "x": 2,
          "y": 80,
          "tw_start": 165,
          "tw_end": 403
        },
        {
          "id": 6,
          "x": 0,
          "y": 100,
          "tw_start": 63,
          "tw_end": 334
        },
        {
          "id": 7,
          "x": 7,
          "y": 100,
          "tw_start": 269,
          "tw_end": 484
        },
        {
          "id": 8,
          "x": 100,
          "y": 0,
          "tw_start": 31,
          "tw_end": 291
        },
        {
          "id": 9,
          "x": 95,
          "y": 75,
          "tw_start": 253,
          "tw_end": 474
        },
        {
          "id": 10,
          "x": 100,
          "y": 80,
          "tw_start": 368,
          "tw_end": 577
        },
        {
          "id": 11,
          "x": 95,
          "y": 100,
          "tw_start": 167,
          "tw_end": 453
        },
        {
          "id": 12,
          "x": 100,
          "y": 100,
          "tw_start": 162,
          "tw_end": 418
        }
      ],
      "depot": 0,
      "objective": 506.55520531202313
    },
    "solution_variant": [
      0,
      8,
      1,
      2,
      3,
      4,
      5,
      6,
      7,
      11,
      12,
      10,
      9,
      0
    ],
    "context_index": 46,
    "input_format": "markdown_table",
    "input_index_base": 0
  },
  {
    "task_name": "TSPTW",
    "problem_type": "TSPTW",
    "instruction": "Recently the logistics team had to map out a route where a researcher leaves the basecamp, stops at every survey point exactly once to collect data, and ends the day back at basecamp. Each stop has its own allowed sampling hours, so arrivals must be within those windows (it’s acceptable to hang around a bit if the window hasn’t started), and no detours that repeat sites or skip them are permitted. The goal is to minimize how much they have to drive — check that by totaling the distances of all legs of the trip — and the concrete site/timing info appears below.\n\n# total_sites_including_basecamp=14\n# basecamp_node_id=0\n# time windows are listed per node in the table\nsite_id,coord_x,coord_y,earliest_sampling_time,latest_sampling_time\n0,50,33,0,1067\n1,93,70,154,374\n2,61,67,381,615\n3,54,57,346,563\n4,86,56,82,279\n5,0,53,252,482\n6,52,31,335,575\n7,52,21,375,587\n8,85,23,337,606\n9,19,72,299,575\n10,73,52,295,550\n11,86,23,50,248\n12,18,100,357,611\n13,100,0,309,549\n\nOh, and when you send the final route back, please use a tiny JSON snippet like this so it's easy to parse:\n\n{\n  \"solution\": [basecamp_id, survey_point_id, ..., basecamp_id]\n}\n\nThis just means: \"solution\" is the ordered list of stops for the day, starting and ending at the basecamp, with every survey point shown in the order they'll be visited. The tokens in the list (like basecamp_id and survey_point_id) are placeholders for the actual site identifiers from the instance — this block is just a sketch of the shape I expect, not the real answer.\n\nPlease use the exact identifiers from the instance input with no renaming and don’t introduce new labels. Valid identifiers look like plain numbers such as “1” or “23”, single capital letters like “A” or “B”, or a capital letter followed by digits like “A1” or “X7”.",
    "instance": {
      "coordinates": [
        [
          50,
          33
        ],
        [
          93,
          70
        ],
        [
          61,
          67
        ],
        [
          54,
          57
        ],
        [
          86,
          56
        ],
        [
          0,
          53
        ],
        [
          52,
          31
        ],
        [
          52,
          21
        ],
        [
          85,
          23
        ],
        [
          19,
          72
        ],
        [
          73,
          52
        ],
        [
          86,
          23
        ],
        [
          18,
          100
        ],
        [
          100,
          0
        ]
      ],
      "depot": 0,
      "num_nodes": 14,
      "time_windows": [
        [
          0,
          1067
        ],
        [
          154,
          374
        ],
        [
          381,
          615
        ],
        [
          346,
          563
        ],
        [
          82,
          279
        ],
        [
          252,
          482
        ],
        [
          335,
          575
        ],
        [
          375,
          587
        ],
        [
          337,
          606
        ],
        [
          299,
          575
        ],
        [
          295,
          550
        ],
        [
          50,
          248
        ],
        [
          357,
          611
        ],
        [
          309,
          549
        ]
      ],
      "tour_length": 445.56616881725824,
      "objective": 445.56616881725824
    },
    "solution": [
      0,
      11,
      4,
      1,
      5,
      9,
      12,
      2,
      3,
      10,
      8,
      13,
      7,
      6,
      0
    ],
    "obj": 445.56616881725824,
    "instance_variant": {
      "problem_type": "TSPTW",
      "num_nodes": 14,
      "nodes": [
        {
          "id": 0,
          "x": 50,
          "y": 33,
          "tw_start": 0,
          "tw_end": 1067
        },
        {
          "id": 1,
          "x": 93,
          "y": 70,
          "tw_start": 154,
          "tw_end": 374
        },
        {
          "id": 2,
          "x": 61,
          "y": 67,
          "tw_start": 381,
          "tw_end": 615
        },
        {
          "id": 3,
          "x": 54,
          "y": 57,
          "tw_start": 346,
          "tw_end": 563
        },
        {
          "id": 4,
          "x": 86,
          "y": 56,
          "tw_start": 82,
          "tw_end": 279
        },
        {
          "id": 5,
          "x": 0,
          "y": 53,
          "tw_start": 252,
          "tw_end": 482
        },
        {
          "id": 6,
          "x": 52,
          "y": 31,
          "tw_start": 335,
          "tw_end": 575
        },
        {
          "id": 7,
          "x": 52,
          "y": 21,
          "tw_start": 375,
          "tw_end": 587
        },
        {
          "id": 8,
          "x": 85,
          "y": 23,
          "tw_start": 337,
          "tw_end": 606
        },
        {
          "id": 9,
          "x": 19,
          "y": 72,
          "tw_start": 299,
          "tw_end": 575
        },
        {
          "id": 10,
          "x": 73,
          "y": 52,
          "tw_start": 295,
          "tw_end": 550
        },
        {
          "id": 11,
          "x": 86,
          "y": 23,
          "tw_start": 50,
          "tw_end": 248
        },
        {
          "id": 12,
          "x": 18,
          "y": 100,
          "tw_start": 357,
          "tw_end": 611
        },
        {
          "id": 13,
          "x": 100,
          "y": 0,
          "tw_start": 309,
          "tw_end": 549
        }
      ],
      "depot": 0,
      "objective": 445.56616881725824
    },
    "solution_variant": [
      0,
      11,
      4,
      1,
      5,
      9,
      12,
      2,
      3,
      10,
      8,
      13,
      7,
      6,
      0
    ],
    "context_index": 47,
    "input_format": "csv",
    "input_index_base": 0
  },
  {
    "task_name": "TSPTW",
    "problem_type": "TSPTW",
    "instruction": "Someone at the shop is mapping out the day’s bouquet drops: the route must start and finish at the store, visit every delivery address exactly once, and hit each recipient within their promised delivery window. Hanging around until a window opens is allowed, but any route that racks up more driving distance is worse — total distance is just the sum of the driving between each pair of stops, including coming back to the shop. The specific locations and their time slots are shown below.\n\nThere are 13 locations in total and the shop is node 1.\n\n| stop_id | location_x | location_y | earliest_delivery_time | latest_delivery_time |\n|---|---|---|---|---|\n| 1 | 0 | 84 | 0 | 1067 |\n| 2 | 27 | 100 | 45 | 251 |\n| 3 | 40 | 98 | 265 | 501 |\n| 4 | 70 | 94 | 77 | 319 |\n| 5 | 89 | 42 | 24 | 275 |\n| 6 | 86 | 34 | 104 | 375 |\n| 7 | 85 | 32 | 120 | 358 |\n| 8 | 80 | 26 | 4 | 205 |\n| 9 | 74 | 20 | 152 | 392 |\n| 10 | 81 | 15 | 232 | 455 |\n| 11 | 79 | 3 | 269 | 547 |\n| 12 | 81 | 3 | 302 | 500 |\n| 13 | 100 | 0 | 186 | 390 |\n\nPlan a route that visits all 13 locations and returns to 1, meeting each delivery window while keeping total driving distance as low as possible.\n\nAlso, when you send the route back, just stick to a tiny JSON shape like this — nothing fancy:\n\n{\n  \"solution\": [\"shop_id\", \"address_id\", \"...\", \"shop_id\"]\n}\n\nThis just means: \"solution\" holds the tour as an ordered list of stops — start at the shop, list each delivery address once in the order you'll visit them, and finish back at the shop. Think of the placeholders ( shop_id, address_id ) as blanks you'll fill with the actual IDs from the instance.\n\nThis JSON is only a sketch of the expected shape, not the real answer.\n\nPlease use the identifiers exactly as they appear in the instance input — no renaming and no new labels.\n- for example: \"Valid identifiers look like plain numbers such as “1” or “23”, single capital letters like “A” or “B”, or a capital letter followed by digits like “A1” or “X7”.\"",
    "instance": {
      "coordinates": [
        [
          0,
          84
        ],
        [
          27,
          100
        ],
        [
          40,
          98
        ],
        [
          70,
          94
        ],
        [
          89,
          42
        ],
        [
          86,
          34
        ],
        [
          85,
          32
        ],
        [
          80,
          26
        ],
        [
          74,
          20
        ],
        [
          81,
          15
        ],
        [
          79,
          3
        ],
        [
          81,
          3
        ],
        [
          100,
          0
        ]
      ],
      "depot": 0,
      "num_nodes": 13,
      "time_windows": [
        [
          0,
          1067
        ],
        [
          45,
          251
        ],
        [
          265,
          501
        ],
        [
          77,
          319
        ],
        [
          24,
          275
        ],
        [
          104,
          375
        ],
        [
          120,
          358
        ],
        [
          4,
          205
        ],
        [
          152,
          392
        ],
        [
          232,
          455
        ],
        [
          269,
          547
        ],
        [
          302,
          500
        ],
        [
          186,
          390
        ]
      ],
      "tour_length": 350.429716731438,
      "objective": 350.429716731438
    },
    "solution": [
      0,
      1,
      3,
      4,
      5,
      6,
      7,
      9,
      12,
      11,
      10,
      8,
      2,
      0
    ],
    "obj": 350.429716731438,
    "instance_variant": {
      "problem_type": "TSPTW",
      "num_nodes": 13,
      "nodes": [
        {
          "id": 1,
          "x": 0,
          "y": 84,
          "tw_start": 0,
          "tw_end": 1067
        },
        {
          "id": 2,
          "x": 27,
          "y": 100,
          "tw_start": 45,
          "tw_end": 251
        },
        {
          "id": 3,
          "x": 40,
          "y": 98,
          "tw_start": 265,
          "tw_end": 501
        },
        {
          "id": 4,
          "x": 70,
          "y": 94,
          "tw_start": 77,
          "tw_end": 319
        },
        {
          "id": 5,
          "x": 89,
          "y": 42,
          "tw_start": 24,
          "tw_end": 275
        },
        {
          "id": 6,
          "x": 86,
          "y": 34,
          "tw_start": 104,
          "tw_end": 375
        },
        {
          "id": 7,
          "x": 85,
          "y": 32,
          "tw_start": 120,
          "tw_end": 358
        },
        {
          "id": 8,
          "x": 80,
          "y": 26,
          "tw_start": 4,
          "tw_end": 205
        },
        {
          "id": 9,
          "x": 74,
          "y": 20,
          "tw_start": 152,
          "tw_end": 392
        },
        {
          "id": 10,
          "x": 81,
          "y": 15,
          "tw_start": 232,
          "tw_end": 455
        },
        {
          "id": 11,
          "x": 79,
          "y": 3,
          "tw_start": 269,
          "tw_end": 547
        },
        {
          "id": 12,
          "x": 81,
          "y": 3,
          "tw_start": 302,
          "tw_end": 500
        },
        {
          "id": 13,
          "x": 100,
          "y": 0,
          "tw_start": 186,
          "tw_end": 390
        }
      ],
      "depot": 1,
      "objective": 350.429716731438
    },
    "solution_variant": [
      1,
      2,
      4,
      5,
      6,
      7,
      8,
      10,
      13,
      12,
      11,
      9,
      3,
      1
    ],
    "context_index": 48,
    "input_format": "markdown_table",
    "input_index_base": 1
  },
  {
    "task_name": "TSPTW",
    "problem_type": "TSPTW",
    "instruction": "We have an outreach plan to make: a counselor leaves the service center, drops by every household on a roster exactly once, and comes back to base. The aim is to arrange the order of visits so every household is met within its available meeting window and the total distance driven is as small as possible — tally the distance between each consecutive stop and the final leg home, and that total should be minimized. Waiting at a house if the counselor gets there before the window starts is allowed, but no household can be skipped or visited twice. The concrete list of homes and their time windows is provided below.\n\n# total_locations_including_service_center=11\n# service_center_id=1\n# time windows are listed per node in the table\nlocation_id,x_coordinate,y_coordinate,earliest_meeting_time,latest_meeting_time\n1,98,73,0,1067\n2,10,31,12,297\n3,81,100,20,266\n4,97,0,275,553\n5,41,23,277,548\n6,55,17,131,404\n7,100,44,31,311\n8,14,15,212,485\n9,0,26,175,431\n10,68,11,204,469\n11,77,85,31,231\n\nAlso, when you send the actual plan back, please use this simple JSON shape so it's easy to read and check:\n\n{\n  \"solution\": [center_id, house_id, ..., center_id]\n}\n\nThis just means: \"solution\" is a list showing the visit order — start at the service center, list each household exactly once in the order they'll be visited, and finish back at the center. The names in the example above are just placeholders to show the shape, not the real labels you'll use.\n\nPlease make sure to use the exact identifiers from the instance input — do not rename them or invent new ones. Valid identifiers look like plain numbers such as “1” or “23”, single capital letters like “A” or “B”, or a capital letter followed by digits like “A1” or “X7”.",
    "instance": {
      "coordinates": [
        [
          98,
          73
        ],
        [
          10,
          31
        ],
        [
          81,
          100
        ],
        [
          97,
          0
        ],
        [
          41,
          23
        ],
        [
          55,
          17
        ],
        [
          100,
          44
        ],
        [
          14,
          15
        ],
        [
          0,
          26
        ],
        [
          68,
          11
        ],
        [
          77,
          85
        ]
      ],
      "depot": 0,
      "num_nodes": 11,
      "time_windows": [
        [
          0,
          1067
        ],
        [
          12,
          297
        ],
        [
          20,
          266
        ],
        [
          275,
          553
        ],
        [
          277,
          548
        ],
        [
          131,
          404
        ],
        [
          31,
          311
        ],
        [
          212,
          485
        ],
        [
          175,
          431
        ],
        [
          204,
          469
        ],
        [
          31,
          231
        ]
      ],
      "tour_length": 376.09239657823724,
      "objective": 376.09239657823724
    },
    "solution": [
      0,
      2,
      10,
      6,
      1,
      8,
      7,
      4,
      5,
      9,
      3,
      0
    ],
    "obj": 376.09239657823724,
    "instance_variant": {
      "problem_type": "TSPTW",
      "num_nodes": 11,
      "nodes": [
        {
          "id": 1,
          "x": 98,
          "y": 73,
          "tw_start": 0,
          "tw_end": 1067
        },
        {
          "id": 2,
          "x": 10,
          "y": 31,
          "tw_start": 12,
          "tw_end": 297
        },
        {
          "id": 3,
          "x": 81,
          "y": 100,
          "tw_start": 20,
          "tw_end": 266
        },
        {
          "id": 4,
          "x": 97,
          "y": 0,
          "tw_start": 275,
          "tw_end": 553
        },
        {
          "id": 5,
          "x": 41,
          "y": 23,
          "tw_start": 277,
          "tw_end": 548
        },
        {
          "id": 6,
          "x": 55,
          "y": 17,
          "tw_start": 131,
          "tw_end": 404
        },
        {
          "id": 7,
          "x": 100,
          "y": 44,
          "tw_start": 31,
          "tw_end": 311
        },
        {
          "id": 8,
          "x": 14,
          "y": 15,
          "tw_start": 212,
          "tw_end": 485
        },
        {
          "id": 9,
          "x": 0,
          "y": 26,
          "tw_start": 175,
          "tw_end": 431
        },
        {
          "id": 10,
          "x": 68,
          "y": 11,
          "tw_start": 204,
          "tw_end": 469
        },
        {
          "id": 11,
          "x": 77,
          "y": 85,
          "tw_start": 31,
          "tw_end": 231
        }
      ],
      "depot": 1,
      "objective": 376.09239657823724
    },
    "solution_variant": [
      1,
      3,
      11,
      7,
      2,
      9,
      8,
      5,
      6,
      10,
      4,
      1
    ],
    "context_index": 49,
    "input_format": "csv",
    "input_index_base": 1
  },
  {
    "task_name": "TSPTW",
    "problem_type": "TSPTW",
    "instruction": "Across town there’s a charity van that needs a single, tidy loop: start at the depot, visit each distribution site one time only, and come back to the depot, all while making sure each visit falls inside that site’s receiving hours (waiting is okay if the van shows up early). The deciding factor is total miles driven — add together the distances of each leg in the journey to get the total, and aim for the route with the smallest number. The concrete route data and time windows are shown below.\n\n{\n  \"total_locations_including_depot\": 12,\n  \"nodes\": [\n    {\n      \"location_id\": \"A\",\n      \"x_coordinate\": 0,\n      \"y_coordinate\": 62,\n      \"earliest_receiving_time\": 0,\n      \"latest_receiving_time\": 1067\n    },\n    {\n      \"location_id\": \"B\",\n      \"x_coordinate\": 0,\n      \"y_coordinate\": 100,\n      \"earliest_receiving_time\": 95,\n      \"latest_receiving_time\": 305\n    },\n    {\n      \"location_id\": \"C\",\n      \"x_coordinate\": 87,\n      \"y_coordinate\": 81,\n      \"earliest_receiving_time\": 338,\n      \"latest_receiving_time\": 553\n    },\n    {\n      \"location_id\": \"D\",\n      \"x_coordinate\": 77,\n      \"y_coordinate\": 93,\n      \"earliest_receiving_time\": 378,\n      \"latest_receiving_time\": 605\n    },\n    {\n      \"location_id\": \"E\",\n      \"x_coordinate\": 92,\n      \"y_coordinate\": 40,\n      \"earliest_receiving_time\": 70,\n      \"latest_receiving_time\": 341\n    },\n    {\n      \"location_id\": \"F\",\n      \"x_coordinate\": 100,\n      \"y_coordinate\": 43,\n      \"earliest_receiving_time\": 255,\n      \"latest_receiving_time\": 497\n    },\n    {\n      \"location_id\": \"G\",\n      \"x_coordinate\": 62,\n      \"y_coordinate\": 0,\n      \"earliest_receiving_time\": 215,\n      \"latest_receiving_time\": 479\n    },\n    {\n      \"location_id\": \"H\",\n      \"x_coordinate\": 50,\n      \"y_coordinate\": 14,\n      \"earliest_receiving_time\": 88,\n      \"latest_receiving_time\": 379\n    },\n    {\n      \"location_id\": \"I\",\n      \"x_coordinate\": 8,\n      \"y_coordinate\": 43,\n      \"earliest_receiving_time\": 378,\n      \"latest_receiving_time\": 635\n    },\n    {\n      \"location_id\": \"J\",\n      \"x_coordinate\": 8,\n      \"y_coordinate\": 33,\n      \"earliest_receiving_time\": 77,\n      \"latest_receiving_time\": 337\n    },\n    {\n      \"location_id\": \"K\",\n      \"x_coordinate\": 10,\n      \"y_coordinate\": 21,\n      \"earliest_receiving_time\": 28,\n      \"latest_receiving_time\": 224\n    },\n    {\n      \"location_id\": \"L\",\n      \"x_coordinate\": 4,\n      \"y_coordinate\": 2,\n      \"earliest_receiving_time\": 99,\n      \"latest_receiving_time\": 338\n    }\n  ],\n  \"depot_node_id\": \"A\"\n}\n\nIf you'd like the answer in a tidy, machine-friendly form, just use this simple layout:\n\n{\n  \"solution\": [depot_id, location_id, ..., depot_id]\n}\n\nHere \"solution\" is an ordered list showing the van's loop — start at the depot, visit each site once (in the order shown), and come back to the depot. Think of it like filling in a short itinerary: each entry is the identifier for the spot visited, in travel order. This JSON is just a sketch of the shape I expect the real answer to take, not the actual route.\n\nPlease make sure to use the identifiers exactly as they appear in the instance input — no renaming and no new labels.\n- for example: \"Valid identifiers look like plain numbers such as “1” or “23”, single capital letters like “A” or “B”, or a capital letter followed by digits like “A1” or “X7”.\"",
    "instance": {
      "coordinates": [
        [
          0,
          62
        ],
        [
          0,
          100
        ],
        [
          87,
          81
        ],
        [
          77,
          93
        ],
        [
          92,
          40
        ],
        [
          100,
          43
        ],
        [
          62,
          0
        ],
        [
          50,
          14
        ],
        [
          8,
          43
        ],
        [
          8,
          33
        ],
        [
          10,
          21
        ],
        [
          4,
          2
        ]
      ],
      "depot": 0,
      "num_nodes": 12,
      "time_windows": [
        [
          0,
          1067
        ],
        [
          95,
          305
        ],
        [
          338,
          553
        ],
        [
          378,
          605
        ],
        [
          70,
          341
        ],
        [
          255,
          497
        ],
        [
          215,
          479
        ],
        [
          88,
          379
        ],
        [
          378,
          635
        ],
        [
          77,
          337
        ],
        [
          28,
          224
        ],
        [
          99,
          338
        ]
      ],
      "tour_length": 423.69855580007805,
      "objective": 423.69855580007805
    },
    "solution": [
      0,
      1,
      9,
      10,
      11,
      7,
      6,
      4,
      5,
      2,
      3,
      8,
      0
    ],
    "obj": 423.69855580007805,
    "instance_variant": {
      "problem_type": "TSPTW",
      "num_nodes": 12,
      "nodes": [
        {
          "id": "A",
          "x": 0,
          "y": 62,
          "tw_start": 0,
          "tw_end": 1067
        },
        {
          "id": "B",
          "x": 0,
          "y": 100,
          "tw_start": 95,
          "tw_end": 305
        },
        {
          "id": "C",
          "x": 87,
          "y": 81,
          "tw_start": 338,
          "tw_end": 553
        },
        {
          "id": "D",
          "x": 77,
          "y": 93,
          "tw_start": 378,
          "tw_end": 605
        },
        {
          "id": "E",
          "x": 92,
          "y": 40,
          "tw_start": 70,
          "tw_end": 341
        },
        {
          "id": "F",
          "x": 100,
          "y": 43,
          "tw_start": 255,
          "tw_end": 497
        },
        {
          "id": "G",
          "x": 62,
          "y": 0,
          "tw_start": 215,
          "tw_end": 479
        },
        {
          "id": "H",
          "x": 50,
          "y": 14,
          "tw_start": 88,
          "tw_end": 379
        },
        {
          "id": "I",
          "x": 8,
          "y": 43,
          "tw_start": 378,
          "tw_end": 635
        },
        {
          "id": "J",
          "x": 8,
          "y": 33,
          "tw_start": 77,
          "tw_end": 337
        },
        {
          "id": "K",
          "x": 10,
          "y": 21,
          "tw_start": 28,
          "tw_end": 224
        },
        {
          "id": "L",
          "x": 4,
          "y": 2,
          "tw_start": 99,
          "tw_end": 338
        }
      ],
      "depot": "A",
      "objective": 423.69855580007805
    },
    "solution_variant": [
      "A",
      "B",
      "J",
      "K",
      "L",
      "H",
      "G",
      "E",
      "F",
      "C",
      "D",
      "I",
      "A"
    ],
    "context_index": 50,
    "input_format": "json",
    "input_index_base": "names"
  }
]