TSP/TSP_S_context.json

[
  {
    "task_name": "TSP",
    "problem_type": "TSP",
    "instruction": "We have a bakery to run and a tray of deliveries to make, so the task is to choose the delivery sequence that starts at the shop, visits every customer location one time, and finishes back at the shop. What makes one sequence better than another is simple: the one that results in the least driving, measured by summing the miles between consecutive stops for the whole loop. Every stop has to be included exactly once — no skipping a house and no visiting the same house twice. The concrete addresses and coordinates are shown below.\n\n# total_stops_including_shop=10\n# shop_node_id=0\nstop_id,x_coord_miles,y_coord_miles\n0,64,1\n1,20,77\n2,97,56\n3,0,70\n4,69,100\n5,14,30\n6,100,31\n7,49,0\n8,61,30\n9,20,41\n\nAlso, when you send back the route, please follow this simple JSON layout so it's easy to read and check:\n\n{\n  \"solution\": [\"shop_id\", \"customer_id\", ..., \"shop_id\"]\n}\n\nThis just means \"solution\" should be a list showing the stops in order — start at the shop, visit each customer once, and finish back at the shop. The strings in the list are the location identifiers taken straight from the instance.\n\nThis JSON is only a sketch of the shape I expect, not the actual route — I'll fill in the real identifiers when I give the final answer. Please use the identifiers exactly as they appear in 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": [
      [
        64,
        1
      ],
      [
        20,
        77
      ],
      [
        97,
        56
      ],
      [
        0,
        70
      ],
      [
        69,
        100
      ],
      [
        14,
        30
      ],
      [
        100,
        31
      ],
      [
        49,
        0
      ],
      [
        61,
        30
      ],
      [
        20,
        41
      ]
    ],
    "solution": [
      0,
      7,
      5,
      9,
      3,
      1,
      4,
      2,
      6,
      8,
      0
    ],
    "obj": 329.708459854126,
    "instance_variant": {
      "problem_type": "TSP",
      "num_nodes": 10,
      "nodes": [
        {
          "id": 0,
          "x": 64,
          "y": 1
        },
        {
          "id": 1,
          "x": 20,
          "y": 77
        },
        {
          "id": 2,
          "x": 97,
          "y": 56
        },
        {
          "id": 3,
          "x": 0,
          "y": 70
        },
        {
          "id": 4,
          "x": 69,
          "y": 100
        },
        {
          "id": 5,
          "x": 14,
          "y": 30
        },
        {
          "id": 6,
          "x": 100,
          "y": 31
        },
        {
          "id": 7,
          "x": 49,
          "y": 0
        },
        {
          "id": 8,
          "x": 61,
          "y": 30
        },
        {
          "id": 9,
          "x": 20,
          "y": 41
        }
      ],
      "depot": 0
    },
    "solution_variant": [
      0,
      7,
      5,
      9,
      3,
      1,
      4,
      2,
      6,
      8,
      0
    ],
    "context_index": 1,
    "input_format": "csv",
    "input_index_base": 0
  },
  {
    "task_name": "TSP",
    "problem_type": "TSP",
    "instruction": "Recently the team needs a planned route that begins at the garage, visits all service addresses one time only, and returns to the garage at day’s end. The task is to decide the visiting order — the smarter the order, the smaller the day’s mileage. To figure that out, just add up the miles between every pair of consecutive stops in the order you pick (counting the trip out and the trip home) and prefer the order with the smallest overall total. No stops can be skipped or repeated. Exact instance details are provided below.\n\nThere are 10 locations to cover, and the garage is 0.\nStop 0 is located at coordinates (38, 90).\nStop 1 is located at coordinates (18, 80).\nStop 2 is located at coordinates (73, 30).\nStop 3 is located at coordinates (0, 22).\nStop 4 is located at coordinates (44, 44).\nStop 5 is located at coordinates (100, 56).\nStop 6 is located at coordinates (3, 0).\nStop 7 is located at coordinates (65, 80).\nStop 8 is located at coordinates (91, 100).\nStop 9 is located at coordinates (24, 92).\nBegin the tour at 0 and return there after visiting all 10 locations once.\n\nJust drop the final route into a little JSON snippet like this so it's easy to parse and check:\n\n{\n  \"solution\": [depot_id, location_id, ..., depot_id]\n}\n\nThink of \"solution\" as the ordered list of stops — start at the garage (the depot), list each service address exactly once in the order you'll visit them, and finish back at the garage. This JSON is only a sketch of the shape I need, not the actual answer itself.\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": [
      [
        38,
        90
      ],
      [
        18,
        80
      ],
      [
        73,
        30
      ],
      [
        0,
        22
      ],
      [
        44,
        44
      ],
      [
        100,
        56
      ],
      [
        3,
        0
      ],
      [
        65,
        80
      ],
      [
        91,
        100
      ],
      [
        24,
        92
      ]
    ],
    "solution": [
      0,
      7,
      8,
      5,
      2,
      4,
      6,
      3,
      1,
      9,
      0
    ],
    "obj": 346.82418727874756,
    "instance_variant": {
      "problem_type": "TSP",
      "num_nodes": 10,
      "nodes": [
        {
          "id": 0,
          "x": 38,
          "y": 90
        },
        {
          "id": 1,
          "x": 18,
          "y": 80
        },
        {
          "id": 2,
          "x": 73,
          "y": 30
        },
        {
          "id": 3,
          "x": 0,
          "y": 22
        },
        {
          "id": 4,
          "x": 44,
          "y": 44
        },
        {
          "id": 5,
          "x": 100,
          "y": 56
        },
        {
          "id": 6,
          "x": 3,
          "y": 0
        },
        {
          "id": 7,
          "x": 65,
          "y": 80
        },
        {
          "id": 8,
          "x": 91,
          "y": 100
        },
        {
          "id": 9,
          "x": 24,
          "y": 92
        }
      ],
      "depot": 0
    },
    "solution_variant": [
      0,
      7,
      8,
      5,
      2,
      4,
      6,
      3,
      1,
      9,
      0
    ],
    "context_index": 2,
    "input_format": "nl",
    "input_index_base": 0
  },
  {
    "task_name": "TSP",
    "problem_type": "TSP",
    "instruction": "On a typical morning the studio van will head out, visit a handful of shoot locations one after another, and then roll back into the studio at the end of the day. The decision is which order to pick so the van covers the least ground overall — calculate that by summing each segment between stops plus the last leg back to base. No shoot can be skipped or visited twice. The exact list of stops and their coordinates is shown below.\n\n# total_locations=9\n# studio_node_id=0\nlocation_id,x_coord,y_coord\n0,29,9\n1,97,63\n2,0,1\n3,45,40\n4,100,84\n5,56,100\n6,98,0\n7,37,53\n8,61,12\n\nAlso, when you send the route back, please follow this little JSON layout so it's easy to read and process:\n\n{\n  \"solution\": [studio_id, location_id, ..., studio_id]\n}\n\nThink of \"solution\" as the ordered list the van will drive: start at the studio (studio_id), visit each shoot spot in turn (each location_id), and finally come back to the studio (the same studio_id again). It's just a template showing the shape I need — not the final tour.\n\nPlease 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": [
      [
        29,
        9
      ],
      [
        97,
        63
      ],
      [
        0,
        1
      ],
      [
        45,
        40
      ],
      [
        100,
        84
      ],
      [
        56,
        100
      ],
      [
        98,
        0
      ],
      [
        37,
        53
      ],
      [
        61,
        12
      ]
    ],
    "solution": [
      0,
      2,
      3,
      7,
      5,
      4,
      1,
      6,
      8,
      0
    ],
    "obj": 357.6685733795166,
    "instance_variant": {
      "problem_type": "TSP",
      "num_nodes": 9,
      "nodes": [
        {
          "id": 0,
          "x": 29,
          "y": 9
        },
        {
          "id": 1,
          "x": 97,
          "y": 63
        },
        {
          "id": 2,
          "x": 0,
          "y": 1
        },
        {
          "id": 3,
          "x": 45,
          "y": 40
        },
        {
          "id": 4,
          "x": 100,
          "y": 84
        },
        {
          "id": 5,
          "x": 56,
          "y": 100
        },
        {
          "id": 6,
          "x": 98,
          "y": 0
        },
        {
          "id": 7,
          "x": 37,
          "y": 53
        },
        {
          "id": 8,
          "x": 61,
          "y": 12
        }
      ],
      "depot": 0
    },
    "solution_variant": [
      0,
      2,
      3,
      7,
      5,
      4,
      1,
      6,
      8,
      0
    ],
    "context_index": 3,
    "input_format": "csv",
    "input_index_base": 0
  },
  {
    "task_name": "TSP",
    "problem_type": "TSP",
    "instruction": "Many of the regular patrons count on a neat bookmobile loop that starts and ends at the main branch and touches every stop only once, so the librarian wants the route that uses the least driving. The way to judge one route versus another is to add up the distance between each stop in the route, including the last stretch back to the branch — the smaller that sum, the better the route. Every stop must appear exactly once, no repeats. The exact stops and their coordinates follow below.\n\nThere are 9 stops in total, and the route must start and finish at A.\n\n| stop_id | x_coordinate | y_coordinate |\n|---|---|---|\n| A | 88 | 0 |\n| B | 50 | 28 |\n| C | 8 | 67 |\n| D | 25 | 67 |\n| E | 83 | 100 |\n| F | 21 | 0 |\n| G | 92 | 33 |\n| H | 0 | 78 |\n| I | 100 | 100 |\n\nList each stop once so the librarian can sum the segment distances and choose the shortest loop.\n\nIf you want to hand me a candidate route, just pop it into a tiny JSON snippet like this so I can read it cleanly:\n\n{\n  \"solution\": [branch_id, stop_id, ..., branch_id]\n}\n\nThink of \"solution\" as the tour: start at the main branch (branch_id), then list each stop in the order the bookmobile should visit them (stop_id placeholders), and finish back at the branch. This is just a sketch of the shape I expect, not the actual route — I'll need the real identifiers from the instance to give a concrete answer.\n\nPlease 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": [
      [
        88,
        0
      ],
      [
        50,
        28
      ],
      [
        8,
        67
      ],
      [
        25,
        67
      ],
      [
        83,
        100
      ],
      [
        21,
        0
      ],
      [
        92,
        33
      ],
      [
        0,
        78
      ],
      [
        100,
        100
      ]
    ],
    "solution": [
      0,
      1,
      5,
      2,
      7,
      3,
      4,
      8,
      6,
      0
    ],
    "obj": 381.12525939941406,
    "instance_variant": {
      "problem_type": "TSP",
      "num_nodes": 9,
      "nodes": [
        {
          "id": "A",
          "x": 88,
          "y": 0
        },
        {
          "id": "B",
          "x": 50,
          "y": 28
        },
        {
          "id": "C",
          "x": 8,
          "y": 67
        },
        {
          "id": "D",
          "x": 25,
          "y": 67
        },
        {
          "id": "E",
          "x": 83,
          "y": 100
        },
        {
          "id": "F",
          "x": 21,
          "y": 0
        },
        {
          "id": "G",
          "x": 92,
          "y": 33
        },
        {
          "id": "H",
          "x": 0,
          "y": 78
        },
        {
          "id": "I",
          "x": 100,
          "y": 100
        }
      ],
      "depot": "A"
    },
    "solution_variant": [
      "A",
      "B",
      "F",
      "C",
      "H",
      "D",
      "E",
      "I",
      "G",
      "A"
    ],
    "context_index": 4,
    "input_format": "markdown_table",
    "input_index_base": "names"
  },
  {
    "task_name": "TSP",
    "problem_type": "TSP",
    "instruction": "There’s a farmer who does porch-to-porch dropoffs around the neighborhood and wants a sensible route that starts and ends at the farm and doesn’t hit any stop more than once. A smarter route is simply the one that adds up to the fewest miles overall — add up every leg between stops to get the total — so the plan with the smallest sum of those legs wins. The full list of stops and their specifics appears below.\n\nBelow are the 10 stops (including the farm depot 1), listed one per line:\n\n| dropoff_id | x_coord | y_coord |\n|---|---|---|\n| 1 | 22 | 100 |\n| 2 | 59 | 47 |\n| 3 | 20 | 92 |\n| 4 | 39 | 81 |\n| 5 | 0 | 46 |\n| 6 | 44 | 62 |\n| 7 | 100 | 94 |\n| 8 | 81 | 30 |\n| 9 | 9 | 73 |\n| 10 | 47 | 0 |\n\nThe farmer must visit each of the 10 stops once, begin and end at 1, and choose the route with the fewest total miles.\n\nWhen you send the route back, just use this simple JSON layout so it's easy to read and parse:\n\n{\n  \"solution\": [farm_id, stop_id, ..., farm_id]\n}\n\nHere \"solution\" holds the ordered list of stops the farmer will make — the first entry is the farm where we start, then every porch in the order they’re visited, and the last entry is the farm again to end the loop. Think of it like filling out a short form: list the farm, then the porches, then the farm.\n\nThis JSON is only a sketch of the shape I expect, not the actual route answer.\n\nPlease use the exact identifiers given 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": [
      [
        22,
        100
      ],
      [
        59,
        47
      ],
      [
        20,
        92
      ],
      [
        39,
        81
      ],
      [
        0,
        46
      ],
      [
        44,
        62
      ],
      [
        100,
        94
      ],
      [
        81,
        30
      ],
      [
        9,
        73
      ],
      [
        47,
        0
      ]
    ],
    "solution": [
      0,
      2,
      8,
      4,
      9,
      7,
      6,
      1,
      5,
      3,
      0
    ],
    "obj": 365.25489139556885,
    "instance_variant": {
      "problem_type": "TSP",
      "num_nodes": 10,
      "nodes": [
        {
          "id": 1,
          "x": 22,
          "y": 100
        },
        {
          "id": 2,
          "x": 59,
          "y": 47
        },
        {
          "id": 3,
          "x": 20,
          "y": 92
        },
        {
          "id": 4,
          "x": 39,
          "y": 81
        },
        {
          "id": 5,
          "x": 0,
          "y": 46
        },
        {
          "id": 6,
          "x": 44,
          "y": 62
        },
        {
          "id": 7,
          "x": 100,
          "y": 94
        },
        {
          "id": 8,
          "x": 81,
          "y": 30
        },
        {
          "id": 9,
          "x": 9,
          "y": 73
        },
        {
          "id": 10,
          "x": 47,
          "y": 0
        }
      ],
      "depot": 1
    },
    "solution_variant": [
      1,
      3,
      9,
      5,
      10,
      8,
      7,
      2,
      6,
      4,
      1
    ],
    "context_index": 5,
    "input_format": "markdown_table",
    "input_index_base": 1
  },
  {
    "task_name": "TSP",
    "problem_type": "TSP",
    "instruction": "I’m picturing a caterer who needs to plan a single outing that leaves the kitchen, drops off food at every booked venue, and comes back to the kitchen at the end of the day. The job is to pick the order of stops so the whole trip uses the fewest miles possible — that total is just the sum of the distances between each stop in the route, including the leg back to the kitchen — and nothing can be skipped or visited more than once. The exact list of venues and their locations is shown below.\n\n{\n  \"total_locations_in_route\": 5,\n  \"nodes\": [\n    {\n      \"venue_id\": 1,\n      \"x_coordinate\": 93,\n      \"y_coordinate\": 21\n    },\n    {\n      \"venue_id\": 2,\n      \"x_coordinate\": 100,\n      \"y_coordinate\": 0\n    },\n    {\n      \"venue_id\": 3,\n      \"x_coordinate\": 0,\n      \"y_coordinate\": 100\n    },\n    {\n      \"venue_id\": 4,\n      \"x_coordinate\": 32,\n      \"y_coordinate\": 43\n    },\n    {\n      \"venue_id\": 5,\n      \"x_coordinate\": 3,\n      \"y_coordinate\": 45\n    }\n  ],\n  \"kitchen_node_id\": 1\n}\n\nOh, and when you give the planned route back, a tiny JSON sketch like this is perfect — just a simple list that starts and ends at the kitchen:\n\n{\n  \"solution\": [kitchen_id, venue_id, ..., kitchen_id]\n}\n\nThink of \"solution\" as the ordered checklist: the first item is where the truck leaves (the kitchen), the middle items are the stops in the order you’ll visit them, and the last item is the kitchen again when you're done. This is just the shape I need, not the actual route.\n\nPlease use the exact identifiers from the instance input — no renaming, 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": [
      [
        93,
        21
      ],
      [
        100,
        0
      ],
      [
        0,
        100
      ],
      [
        32,
        43
      ],
      [
        3,
        45
      ]
    ],
    "solution": [
      0,
      1,
      3,
      4,
      2,
      0
    ],
    "obj": 308.7661304473877,
    "instance_variant": {
      "problem_type": "TSP",
      "num_nodes": 5,
      "nodes": [
        {
          "id": 1,
          "x": 93,
          "y": 21
        },
        {
          "id": 2,
          "x": 100,
          "y": 0
        },
        {
          "id": 3,
          "x": 0,
          "y": 100
        },
        {
          "id": 4,
          "x": 32,
          "y": 43
        },
        {
          "id": 5,
          "x": 3,
          "y": 45
        }
      ],
      "depot": 1
    },
    "solution_variant": [
      1,
      2,
      4,
      5,
      3,
      1
    ],
    "context_index": 6,
    "input_format": "json",
    "input_index_base": 1
  },
  {
    "task_name": "TSP",
    "problem_type": "TSP",
    "instruction": "We’ve got a maintenance planner trying to put together a route so a tech can leave HQ, stop at each equipment location once, and come home without backtracking. The decision is which stop to go to next at each turn, and a good decision is one that keeps the overall driving to a minimum. You measure how good a route is by totaling the miles between consecutive stops, including the leg that returns to headquarters. It’s important that every site gets exactly one visit and that none are missed or repeated. The detailed list and numbers are shown below.\n\nBelow are the 10 sites, with headquarters A.\n\n| site_id | x_coord | y_coord |\n|---|---|---|\n| A | 68 | 14 |\n| B | 16 | 61 |\n| C | 19 | 60 |\n| D | 100 | 78 |\n| E | 35 | 58 |\n| F | 0 | 17 |\n| G | 53 | 0 |\n| H | 94 | 21 |\n| I | 34 | 76 |\n| J | 19 | 100 |\n\nMake sure each site is visited exactly once and the tour returns to A.\n\nWhen you send back the route, just use this tiny JSON layout so it's easy to plug into the planner:\n\n{\n  \"solution\": [hq_id, site_id, ..., hq_id]\n}\n\nThink of \"solution\" as the simple list of stops in order: start at HQ (the first hq_id), visit each site once (the site_id entries), and come back to HQ (the final hq_id). It's just a sketch of the shape I want, not the actual route.\n\nPlease make sure you 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”.\"\n\nThat's it — drop the actual sequence of IDs into that array and we're good.",
    "instance": [
      [
        68,
        14
      ],
      [
        16,
        61
      ],
      [
        19,
        60
      ],
      [
        100,
        78
      ],
      [
        35,
        58
      ],
      [
        0,
        17
      ],
      [
        53,
        0
      ],
      [
        94,
        21
      ],
      [
        34,
        76
      ],
      [
        19,
        100
      ]
    ],
    "solution": [
      0,
      6,
      5,
      1,
      2,
      4,
      8,
      9,
      3,
      7,
      0
    ],
    "obj": 356.7884964942932,
    "instance_variant": {
      "problem_type": "TSP",
      "num_nodes": 10,
      "nodes": [
        {
          "id": "A",
          "x": 68,
          "y": 14
        },
        {
          "id": "B",
          "x": 16,
          "y": 61
        },
        {
          "id": "C",
          "x": 19,
          "y": 60
        },
        {
          "id": "D",
          "x": 100,
          "y": 78
        },
        {
          "id": "E",
          "x": 35,
          "y": 58
        },
        {
          "id": "F",
          "x": 0,
          "y": 17
        },
        {
          "id": "G",
          "x": 53,
          "y": 0
        },
        {
          "id": "H",
          "x": 94,
          "y": 21
        },
        {
          "id": "I",
          "x": 34,
          "y": 76
        },
        {
          "id": "J",
          "x": 19,
          "y": 100
        }
      ],
      "depot": "A"
    },
    "solution_variant": [
      "A",
      "G",
      "F",
      "B",
      "C",
      "E",
      "I",
      "J",
      "D",
      "H",
      "A"
    ],
    "context_index": 7,
    "input_format": "markdown_table",
    "input_index_base": "names"
  },
  {
    "task_name": "TSP",
    "problem_type": "TSP",
    "instruction": "On a busy morning the flower shop needs a single delivery loop: out from the storefront, one drop at every recipient, and back to the shop without visiting any address more than once. Picking the right order of stops is the task — the best order is the one that keeps the overall driving distance lowest, calculated by summing each leg of the trip including the return. Every address on the list must be visited exactly once. The specific locations are listed below.\n\n# total_locations=9\n# storefront_id=1\nlocation_id,x_coord,y_coord\n1,0,79\n2,99,2\n3,21,100\n4,19,28\n5,18,75\n6,100,56\n7,63,51\n8,99,0\n9,61,40\n\nAlso, when you send back the delivery order, please keep it in a tiny JSON shape like this:\n\n{\n  \"solution\": [shop_id, recipient_id, ..., shop_id]\n}\n\nThis just shows the shape I’m expecting: the solution array lists the stops in order — starting at the shop, hitting every recipient once, and coming back to the shop. It’s only a sketch of the expected format, 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": [
      [
        0,
        79
      ],
      [
        99,
        2
      ],
      [
        21,
        100
      ],
      [
        19,
        28
      ],
      [
        18,
        75
      ],
      [
        100,
        56
      ],
      [
        63,
        51
      ],
      [
        99,
        0
      ],
      [
        61,
        40
      ]
    ],
    "solution": [
      0,
      2,
      4,
      6,
      5,
      1,
      7,
      8,
      3,
      0
    ],
    "obj": 352.5007858276367,
    "instance_variant": {
      "problem_type": "TSP",
      "num_nodes": 9,
      "nodes": [
        {
          "id": 1,
          "x": 0,
          "y": 79
        },
        {
          "id": 2,
          "x": 99,
          "y": 2
        },
        {
          "id": 3,
          "x": 21,
          "y": 100
        },
        {
          "id": 4,
          "x": 19,
          "y": 28
        },
        {
          "id": 5,
          "x": 18,
          "y": 75
        },
        {
          "id": 6,
          "x": 100,
          "y": 56
        },
        {
          "id": 7,
          "x": 63,
          "y": 51
        },
        {
          "id": 8,
          "x": 99,
          "y": 0
        },
        {
          "id": 9,
          "x": 61,
          "y": 40
        }
      ],
      "depot": 1
    },
    "solution_variant": [
      1,
      3,
      5,
      7,
      6,
      2,
      8,
      9,
      4,
      1
    ],
    "context_index": 8,
    "input_format": "csv",
    "input_index_base": 1
  },
  {
    "task_name": "TSP",
    "problem_type": "TSP",
    "instruction": "Recently the courier asked for a plan that begins at the dispatch office, visits every client one time, and returns to the office in a single loop. The choice to make is the sequence of stops; the best sequence is the one with the smallest total travel distance, computed by adding up all the distances between each stop and the next, including the return trip. Every customer must be visited exactly once. The detailed list of stops appears below.\n\n{\n  \"total_stops_in_route\": 6,\n  \"nodes\": [\n    {\n      \"location_id\": 0,\n      \"x_coordinate\": 100,\n      \"y_coordinate\": 0\n    },\n    {\n      \"location_id\": 1,\n      \"x_coordinate\": 84,\n      \"y_coordinate\": 15\n    },\n    {\n      \"location_id\": 2,\n      \"x_coordinate\": 81,\n      \"y_coordinate\": 34\n    },\n    {\n      \"location_id\": 3,\n      \"x_coordinate\": 0,\n      \"y_coordinate\": 100\n    },\n    {\n      \"location_id\": 4,\n      \"x_coordinate\": 14,\n      \"y_coordinate\": 20\n    },\n    {\n      \"location_id\": 5,\n      \"x_coordinate\": 67,\n      \"y_coordinate\": 44\n    }\n  ],\n  \"dispatch_office_id\": 0\n}\n\nAlso, when you send back the route, please use this simple JSON layout so it's easy to parse and check.\n\n{\n  \"solution\": [\"dispatch_office_id\", \"client_id\", \"...\", \"dispatch_office_id\"]\n}\n\nHere \"solution\" is just the tour: a list of stop identifiers in the order they should be visited, starting and ending at the dispatch office. The words in the example are placeholders showing the shape I expect — replace them with the real IDs from the instance when you give the actual route.\n\nAll identifiers must be used exactly as they appear in the instance input — no renaming and no 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": [
      [
        100,
        0
      ],
      [
        84,
        15
      ],
      [
        81,
        34
      ],
      [
        0,
        100
      ],
      [
        14,
        20
      ],
      [
        67,
        44
      ]
    ],
    "solution": [
      0,
      1,
      2,
      5,
      3,
      4,
      0
    ],
    "obj": 315.2037105560303,
    "instance_variant": {
      "problem_type": "TSP",
      "num_nodes": 6,
      "nodes": [
        {
          "id": 0,
          "x": 100,
          "y": 0
        },
        {
          "id": 1,
          "x": 84,
          "y": 15
        },
        {
          "id": 2,
          "x": 81,
          "y": 34
        },
        {
          "id": 3,
          "x": 0,
          "y": 100
        },
        {
          "id": 4,
          "x": 14,
          "y": 20
        },
        {
          "id": 5,
          "x": 67,
          "y": 44
        }
      ],
      "depot": 0
    },
    "solution_variant": [
      0,
      1,
      2,
      5,
      3,
      4,
      0
    ],
    "context_index": 9,
    "input_format": "json",
    "input_index_base": 0
  },
  {
    "task_name": "TSP",
    "problem_type": "TSP",
    "instruction": "Recently the clinic scheduled house calls across town, and the driver has to turn that schedule into a single loop: leave the clinic, visit every address exactly once, and return to the clinic at the end. The question is which route order will make the least driving — the better route is the one with the lowest sum of all the successive distances between stops, plus the trip back to base. The detailed addresses and coordinates are shown below.\n\n# total_locations_including_clinic=10\n# clinic_node_id=0\nlocation_id,x_coordinate_east_west,y_coordinate_north_south\n0,34,79\n1,46,13\n2,0,95\n3,78,82\n4,76,0\n5,58,78\n6,100,69\n7,81,51\n8,15,14\n9,61,100\n\nIf you want to hand me the route in a compact form, just pop it into a little JSON array like this:\n\n{\n  \"solution\": [clinic_id, house_id, ..., clinic_id]\n}\n\nThis shows the tour order: the array under \"solution\" is the sequence of place identifiers to visit, starting at the clinic, then each house once, and ending back at the clinic. It's just a sketch of the shape I expect — not your actual route yet.\n\nPlease make sure to use the exact identifiers from the instance input, with no renaming or made-up labels. Valid identifiers look like:\n- plain numbers such as “1” or “23”\n- single capital letters like “A” or “B”\n- a capital letter followed by digits like “A1” or “X7”\n\nThose are the kinds of IDs I need — use them exactly as given.",
    "instance": [
      [
        34,
        79
      ],
      [
        46,
        13
      ],
      [
        0,
        95
      ],
      [
        78,
        82
      ],
      [
        76,
        0
      ],
      [
        58,
        78
      ],
      [
        100,
        69
      ],
      [
        81,
        51
      ],
      [
        15,
        14
      ],
      [
        61,
        100
      ]
    ],
    "solution": [
      0,
      2,
      8,
      1,
      4,
      7,
      6,
      3,
      9,
      5,
      0
    ],
    "obj": 357.6196041107178,
    "instance_variant": {
      "problem_type": "TSP",
      "num_nodes": 10,
      "nodes": [
        {
          "id": 0,
          "x": 34,
          "y": 79
        },
        {
          "id": 1,
          "x": 46,
          "y": 13
        },
        {
          "id": 2,
          "x": 0,
          "y": 95
        },
        {
          "id": 3,
          "x": 78,
          "y": 82
        },
        {
          "id": 4,
          "x": 76,
          "y": 0
        },
        {
          "id": 5,
          "x": 58,
          "y": 78
        },
        {
          "id": 6,
          "x": 100,
          "y": 69
        },
        {
          "id": 7,
          "x": 81,
          "y": 51
        },
        {
          "id": 8,
          "x": 15,
          "y": 14
        },
        {
          "id": 9,
          "x": 61,
          "y": 100
        }
      ],
      "depot": 0
    },
    "solution_variant": [
      0,
      2,
      8,
      1,
      4,
      7,
      6,
      3,
      9,
      5,
      0
    ],
    "context_index": 10,
    "input_format": "csv",
    "input_index_base": 0
  },
  {
    "task_name": "TSP",
    "problem_type": "TSP",
    "instruction": "Many people on the art team joke about the “pick-up puzzle”: the van needs to leave the gallery, swing by each lender exactly once to grab artwork, then return to base. Deciding which stop comes when is the whole point — the better the sequence, the less driving. You evaluate a sequence by adding together the lengths of each leg of the trip (including the last leg back to the gallery); the smallest total distance is what we want, with every lending venue visited once and only once. The exact stop list and coordinates are shown below.\n\n# total_locations=7\n# gallery_depot=1\nvenue_node_id,x_coord,y_coord\n1,38,74\n2,64,28\n3,0,24\n4,71,74\n5,89,100\n6,53,0\n7,100,16\n\nIf you want to hand me the final route, the easiest is to drop it in a tiny JSON snippet like this so everything's clear and machine-friendly:\n\n{\n  \"solution\": [depot_id, location_id, ..., depot_id]\n}\n\nThink of that \"solution\" list as the trip sheet: start at the depot/gallery id, then list each lender once in the order the van will visit them, and finish back at the same depot id. The placeholders above are just a sketch of the shape I expect — you'll replace them with the actual IDs from the instance.\n\nPlease be sure to use the identifiers exactly as they appear in the instance input — no renaming and no 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": [
      [
        38,
        74
      ],
      [
        64,
        28
      ],
      [
        0,
        24
      ],
      [
        71,
        74
      ],
      [
        89,
        100
      ],
      [
        53,
        0
      ],
      [
        100,
        16
      ]
    ],
    "solution": [
      0,
      2,
      5,
      1,
      6,
      4,
      3,
      0
    ],
    "obj": 338.3525276184082,
    "instance_variant": {
      "problem_type": "TSP",
      "num_nodes": 7,
      "nodes": [
        {
          "id": 1,
          "x": 38,
          "y": 74
        },
        {
          "id": 2,
          "x": 64,
          "y": 28
        },
        {
          "id": 3,
          "x": 0,
          "y": 24
        },
        {
          "id": 4,
          "x": 71,
          "y": 74
        },
        {
          "id": 5,
          "x": 89,
          "y": 100
        },
        {
          "id": 6,
          "x": 53,
          "y": 0
        },
        {
          "id": 7,
          "x": 100,
          "y": 16
        }
      ],
      "depot": 1
    },
    "solution_variant": [
      1,
      3,
      6,
      2,
      7,
      5,
      4,
      1
    ],
    "context_index": 11,
    "input_format": "csv",
    "input_index_base": 1
  },
  {
    "task_name": "TSP",
    "problem_type": "TSP",
    "instruction": "I run a little vintage furniture workshop and need to plan a buying trip that leaves from the shop, visits every seller on the list exactly once, and then brings me straight back to the workshop. The choice to make is the order to visit those sellers; a better plan is the one that keeps the whole drive as short as possible — add up the miles between each stop in the order chosen, including the final leg home, and that total should be as small as it can be. Nothing on the seller list can be skipped or visited twice. The exact addresses and distances are shown below.\n\nMy list contains 6 locations in total, with the workshop listed as 1.\n\n| location_id | map_x_coordinate | map_y_coordinate |\n|---|---|---|\n| 1 | 64 | 77 |\n| 2 | 100 | 61 |\n| 3 | 0 | 0 |\n| 4 | 26 | 60 |\n| 5 | 15 | 100 |\n| 6 | 79 | 9 |\n\nI'll plan a route that starts and ends at 1 and visits every stop once to keep the total drive as short as possible.\n\nAlso, when you send the route back, a little JSON sketch like this is perfect for me — keeps things tidy and easy to read.\n\n{\n  \"solution\": [shop_id, seller_id, ..., shop_id]\n}\n\nThink of \"solution\" as the ordered list of stops: start at the shop (the depot), visit each seller once in the middle, and finish back at the shop. The placeholders there just show the shape I need — the actual reply should replace them with the real identifiers from the instance.\n\nThis JSON is only a template of the expected shape, not the actual answer. All 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": [
      [
        64,
        77
      ],
      [
        100,
        61
      ],
      [
        0,
        0
      ],
      [
        26,
        60
      ],
      [
        15,
        100
      ],
      [
        79,
        9
      ]
    ],
    "solution": [
      0,
      1,
      5,
      2,
      3,
      4,
      0
    ],
    "obj": 335.9922790527344,
    "instance_variant": {
      "problem_type": "TSP",
      "num_nodes": 6,
      "nodes": [
        {
          "id": 1,
          "x": 64,
          "y": 77
        },
        {
          "id": 2,
          "x": 100,
          "y": 61
        },
        {
          "id": 3,
          "x": 0,
          "y": 0
        },
        {
          "id": 4,
          "x": 26,
          "y": 60
        },
        {
          "id": 5,
          "x": 15,
          "y": 100
        },
        {
          "id": 6,
          "x": 79,
          "y": 9
        }
      ],
      "depot": 1
    },
    "solution_variant": [
      1,
      2,
      6,
      3,
      4,
      5,
      1
    ],
    "context_index": 12,
    "input_format": "markdown_table",
    "input_index_base": 1
  },
  {
    "task_name": "TSP",
    "problem_type": "TSP",
    "instruction": "There's a simple task for the community health planner: schedule a circuit that starts at the health center, goes to every neighborhood stop exactly once, and finishes back at the health center. What matters most when comparing different circuits is how far the van has to drive in total — add up the distance between each pair of consecutive stops along the loop (including the return leg) and the route with the smallest total is the one to use. No stops can be left out or driven twice. The concrete stop locations and distances are shown below.\n\nThe list below gives 8 locations, with the health center identified as 1.\nStop 1 is located at coordinates (8, 100).\nStop 2 is located at coordinates (94, 14).\nStop 3 is located at coordinates (84, 14).\nStop 4 is located at coordinates (4, 31).\nStop 5 is located at coordinates (0, 66).\nStop 6 is located at coordinates (100, 28).\nStop 7 is located at coordinates (76, 0).\nStop 8 is located at coordinates (8, 34).\nChoose the circuit with the smallest total driving distance (sum distances between consecutive stops, including the return to the health center).\n\nWhen you send the route back, just drop it into this simple JSON shape so it's easy to read and check:\n\n{\n  \"solution\": [health_center_id, neighborhood_id, ..., health_center_id]\n}\n\nThis is just a short sketch of the form I need: \"solution\" holds the ordered list of stops starting and ending at the health center (so the first and last placeholder are the same). Think of it like filling in a little form: put the health center identifier first, list each neighborhood once in the order the van will visit them, and finish with the health center again.\n\nPlease make sure to use the exact identifiers from the instance input — don't rename them or invent new ones. \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”.\n\nRemember, the JSON above is just the expected shape (not the route itself).",
    "instance": [
      [
        8,
        100
      ],
      [
        94,
        14
      ],
      [
        84,
        14
      ],
      [
        4,
        31
      ],
      [
        0,
        66
      ],
      [
        100,
        28
      ],
      [
        76,
        0
      ],
      [
        8,
        34
      ]
    ],
    "solution": [
      0,
      4,
      3,
      7,
      6,
      2,
      1,
      5,
      0
    ],
    "obj": 309.3633556365967,
    "instance_variant": {
      "problem_type": "TSP",
      "num_nodes": 8,
      "nodes": [
        {
          "id": 1,
          "x": 8,
          "y": 100
        },
        {
          "id": 2,
          "x": 94,
          "y": 14
        },
        {
          "id": 3,
          "x": 84,
          "y": 14
        },
        {
          "id": 4,
          "x": 4,
          "y": 31
        },
        {
          "id": 5,
          "x": 0,
          "y": 66
        },
        {
          "id": 6,
          "x": 100,
          "y": 28
        },
        {
          "id": 7,
          "x": 76,
          "y": 0
        },
        {
          "id": 8,
          "x": 8,
          "y": 34
        }
      ],
      "depot": 1
    },
    "solution_variant": [
      1,
      5,
      4,
      8,
      7,
      3,
      2,
      6,
      1
    ],
    "context_index": 13,
    "input_format": "nl",
    "input_index_base": 1
  },
  {
    "task_name": "TSP",
    "problem_type": "TSP",
    "instruction": "Someone in the neighborhood organizes a vending tour: they need to leave their garage, hit every market location one time only, and return home at the end. The choice is how to order those stops; the better ordering is the one that results in the smallest total distance traveled — calculate the trip length by summing the distance between each consecutive stop, plus the legs from garage to first and last back to garage, and pick the route with the smallest sum. No market can be omitted or repeated. The full list of markets and coordinates appears below.\n\n# total_locations_count=9\n# garage_node_id=A\nlocation_id,x_coord,y_coord\nA,100,73\nB,73,23\nC,56,0\nD,0,59\nE,49,68\nF,69,100\nG,57,46\nH,97,46\nI,43,15\n\nOh, and when you give the final route, please put it in a tiny JSON snippet like this so it's straightforward to read:\n\n{\n  \"solution\": [\"garage_id\", \"market_id\", ..., \"garage_id\"]\n}\n\nThis is just a simple sketch: \"solution\" should be the ordered list of stops (start at the garage, visit every market once, and come back to the garage). Think of the placeholders as blanks you fill in with the exact IDs from the instance — don't invent new names or change the IDs. The JSON above is only the shape I expect, not the actual tour.\n\nAlso, make sure to use the identifiers exactly as they appear in the input — no renaming and no extra 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": [
      [
        100,
        73
      ],
      [
        73,
        23
      ],
      [
        56,
        0
      ],
      [
        0,
        59
      ],
      [
        49,
        68
      ],
      [
        69,
        100
      ],
      [
        57,
        46
      ],
      [
        97,
        46
      ],
      [
        43,
        15
      ]
    ],
    "solution": [
      0,
      5,
      4,
      3,
      6,
      8,
      2,
      1,
      7,
      0
    ],
    "obj": 330.0013999938965,
    "instance_variant": {
      "problem_type": "TSP",
      "num_nodes": 9,
      "nodes": [
        {
          "id": "A",
          "x": 100,
          "y": 73
        },
        {
          "id": "B",
          "x": 73,
          "y": 23
        },
        {
          "id": "C",
          "x": 56,
          "y": 0
        },
        {
          "id": "D",
          "x": 0,
          "y": 59
        },
        {
          "id": "E",
          "x": 49,
          "y": 68
        },
        {
          "id": "F",
          "x": 69,
          "y": 100
        },
        {
          "id": "G",
          "x": 57,
          "y": 46
        },
        {
          "id": "H",
          "x": 97,
          "y": 46
        },
        {
          "id": "I",
          "x": 43,
          "y": 15
        }
      ],
      "depot": "A"
    },
    "solution_variant": [
      "A",
      "F",
      "E",
      "D",
      "G",
      "I",
      "C",
      "B",
      "H",
      "A"
    ],
    "context_index": 14,
    "input_format": "csv",
    "input_index_base": "names"
  },
  {
    "task_name": "TSP",
    "problem_type": "TSP",
    "instruction": "My friend is organizing a small tour: kick off at home, play each venue once (no repeats), and finish back at home. The choice comes down to the order of shows — the best route is the one that keeps overall travel to a minimum, which you can calculate by adding the distance between every consecutive stop in the itinerary, plus the trips from home to the first stop and from the last stop back home. The concrete details for the venues are included below.\n\n# total_locations=6\n# home_base_id=1\nlocation_id,x_coord,y_coord\n1,26,100\n2,100,58\n3,78,56\n4,37,36\n5,30,0\n6,0,17\n\nOh — and when you reply, please use this simple JSON layout for the route:\n\n{\n  \"solution\": [depot_id, location_id, ..., depot_id]\n}\n\nThink of it like a little form: \"solution\" is the ordered list of stops starting and ending at your home base. The placeholder depot_id marks the home/depot, each location_id stands for a venue on the tour, and the \"...\" just means the rest of the stops in order. This 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.\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": [
      [
        26,
        100
      ],
      [
        100,
        58
      ],
      [
        78,
        56
      ],
      [
        37,
        36
      ],
      [
        30,
        0
      ],
      [
        0,
        17
      ]
    ],
    "solution": [
      0,
      1,
      2,
      3,
      4,
      5,
      0
    ],
    "obj": 310.9300117492676,
    "instance_variant": {
      "problem_type": "TSP",
      "num_nodes": 6,
      "nodes": [
        {
          "id": 1,
          "x": 26,
          "y": 100
        },
        {
          "id": 2,
          "x": 100,
          "y": 58
        },
        {
          "id": 3,
          "x": 78,
          "y": 56
        },
        {
          "id": 4,
          "x": 37,
          "y": 36
        },
        {
          "id": 5,
          "x": 30,
          "y": 0
        },
        {
          "id": 6,
          "x": 0,
          "y": 17
        }
      ],
      "depot": 1
    },
    "solution_variant": [
      1,
      2,
      3,
      4,
      5,
      6,
      1
    ],
    "context_index": 15,
    "input_format": "csv",
    "input_index_base": 1
  },
  {
    "task_name": "TSP",
    "problem_type": "TSP",
    "instruction": "Recently the inspector’s rounds were being reorganized: the plan is to leave the municipal office, visit each property exactly once for inspection, and end the day back at the office. The trick is picking the order so the total distance traveled is as small as possible — total distance equals the sum of distances between each stop in the chosen order. No revisits and no omissions are allowed. The concrete site details and coordinates are listed below.\n\nThere are 5 locations in total, with the municipal office identified as 1.\n\n| location_id | coord_x | coord_y |\n|---|---|---|\n| 1 | 49 | 100 |\n| 2 | 0 | 100 |\n| 3 | 33 | 100 |\n| 4 | 100 | 0 |\n| 5 | 0 | 6 |\n\nEnsure the tour starts and ends at 1 and covers all 5 locations.\n\nI'll return the planned route in a small JSON sketch so it's easy to parse — something like this is the shape I expect you to use when giving me the route:\n\n{\n  \"solution\": [\"office_id\", \"property_id\", \"...\", \"office_id\"]\n}\n\nIn that little example, \"solution\" is the ordered list of stops: start with the office (the depot), list each property once in the inspection order, and finish back at the office. It's just a sketch of the shape I want, not the actual route.\n\nPlease be 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": [
      [
        49,
        100
      ],
      [
        0,
        100
      ],
      [
        33,
        100
      ],
      [
        100,
        0
      ],
      [
        0,
        6
      ]
    ],
    "solution": [
      0,
      2,
      1,
      4,
      3,
      0
    ],
    "obj": 355.4340133666992,
    "instance_variant": {
      "problem_type": "TSP",
      "num_nodes": 5,
      "nodes": [
        {
          "id": 1,
          "x": 49,
          "y": 100
        },
        {
          "id": 2,
          "x": 0,
          "y": 100
        },
        {
          "id": 3,
          "x": 33,
          "y": 100
        },
        {
          "id": 4,
          "x": 100,
          "y": 0
        },
        {
          "id": 5,
          "x": 0,
          "y": 6
        }
      ],
      "depot": 1
    },
    "solution_variant": [
      1,
      3,
      2,
      5,
      4,
      1
    ],
    "context_index": 16,
    "input_format": "markdown_table",
    "input_index_base": 1
  },
  {
    "task_name": "TSP",
    "problem_type": "TSP",
    "instruction": "There’s a charity van that needs to go out, call on every donor once, and come back to the warehouse at the end of the day. The decision is about the order of visits: the aim is to make the route as short as possible — simply add up the length of each leg between stops, including the final trip home — and it’s important that no donor is left out or visited more than once. The concrete pickup details and location info are shown below.\n\n{\n  \"total_stops\": 5,\n  \"nodes\": [\n    {\n      \"stop_id\": \"A\",\n      \"x_coord\": 65,\n      \"y_coord\": 50\n    },\n    {\n      \"stop_id\": \"B\",\n      \"x_coord\": 100,\n      \"y_coord\": 100\n    },\n    {\n      \"stop_id\": \"C\",\n      \"x_coord\": 0,\n      \"y_coord\": 0\n    },\n    {\n      \"stop_id\": \"D\",\n      \"x_coord\": 41,\n      \"y_coord\": 0\n    },\n    {\n      \"stop_id\": \"E\",\n      \"x_coord\": 16,\n      \"y_coord\": 4\n    }\n  ],\n  \"warehouse_stop_id\": \"A\"\n}\n\nOh — one more thing: when you send the tour back, it helps to put it in a tiny JSON snippet like this so it's clear and easy to read.\n\n{\n  \"solution\": [\"warehouse_id\", \"donor_id\", \"...\", \"warehouse_id\"]\n}\n\nJust so it's clear: \"solution\" should be a list that starts at the warehouse, shows each donor in the order the van will visit them, and ends back at the warehouse. The strings above are placeholders — replace them with the actual IDs from the instance; this is just a sketch of the shape I expect, not the real answer.\n\nPlease use the identifiers exactly as they appear in the 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": [
      [
        65,
        50
      ],
      [
        100,
        100
      ],
      [
        0,
        0
      ],
      [
        41,
        0
      ],
      [
        16,
        4
      ]
    ],
    "solution": [
      0,
      1,
      2,
      4,
      3,
      0
    ],
    "obj": 299.7262325286865,
    "instance_variant": {
      "problem_type": "TSP",
      "num_nodes": 5,
      "nodes": [
        {
          "id": "A",
          "x": 65,
          "y": 50
        },
        {
          "id": "B",
          "x": 100,
          "y": 100
        },
        {
          "id": "C",
          "x": 0,
          "y": 0
        },
        {
          "id": "D",
          "x": 41,
          "y": 0
        },
        {
          "id": "E",
          "x": 16,
          "y": 4
        }
      ],
      "depot": "A"
    },
    "solution_variant": [
      "A",
      "B",
      "C",
      "E",
      "D",
      "A"
    ],
    "context_index": 17,
    "input_format": "json",
    "input_index_base": "names"
  },
  {
    "task_name": "TSP",
    "problem_type": "TSP",
    "instruction": "On a typical scouting morning the antique buyer wants a tidy route: depart the showroom, hit all the listed prospects one after another without repeating any, then return to the showroom. The choice is the order of the visits, and the measure of success is how small the total miles driven turns out to be — calculated by adding up the miles between every pair of consecutive stops along the loop (final leg back included). Every location must be checked once and only once. The exact stops and distances appear below.\n\nBelow are 6 locations, with the showroom labeled A.\nLocation A: coordinates (100, 88) in miles.\nLocation B: coordinates (97, 49) in miles.\nLocation C: coordinates (4, 0) in miles.\nLocation D: coordinates (68, 36) in miles.\nLocation E: coordinates (0, 100) in miles.\nLocation F: coordinates (100, 16) in miles.\nThe antique buyer needs a loop visiting each of the 6 locations once and returning to showroom A.\n\nWhen you send the route back, just use a little JSON object so it's easy to parse. Something like this:\n\n{\n  \"solution\": [showroom_id, prospect_id, ..., showroom_id]\n}\n\nThe \"solution\" array is simply the visit order: start at the showroom (showroom_id), list each prospect in the order you plan to visit them (each prospect_id), and finish back at the showroom. This is only 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. \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": [
      [
        100,
        88
      ],
      [
        97,
        49
      ],
      [
        4,
        0
      ],
      [
        68,
        36
      ],
      [
        0,
        100
      ],
      [
        100,
        16
      ]
    ],
    "solution": [
      0,
      1,
      5,
      3,
      2,
      4,
      0
    ],
    "obj": 384.21485900878906,
    "instance_variant": {
      "problem_type": "TSP",
      "num_nodes": 6,
      "nodes": [
        {
          "id": "A",
          "x": 100,
          "y": 88
        },
        {
          "id": "B",
          "x": 97,
          "y": 49
        },
        {
          "id": "C",
          "x": 4,
          "y": 0
        },
        {
          "id": "D",
          "x": 68,
          "y": 36
        },
        {
          "id": "E",
          "x": 0,
          "y": 100
        },
        {
          "id": "F",
          "x": 100,
          "y": 16
        }
      ],
      "depot": "A"
    },
    "solution_variant": [
      "A",
      "B",
      "F",
      "D",
      "C",
      "E",
      "A"
    ],
    "context_index": 18,
    "input_format": "nl",
    "input_index_base": "names"
  },
  {
    "task_name": "TSP",
    "problem_type": "TSP",
    "instruction": "Someone managing the milk subscriptions needs a driving plan that starts at the depot, hits every household once, and then returns to where it started. The decision is really about ordering the stops so the total distance driven — obtained by adding up the lengths of all the legs between stops including the last one home — is as low as possible, while never skipping or repeating a delivery. The full set of location details appears below.\n\n# total_locations_count=9\n# depot_node_id=0\nlocation_id,coord_x,coord_y\n0,19,100\n1,55,68\n2,0,72\n3,89,0\n4,28,99\n5,89,0\n6,100,70\n7,14,0\n8,46,21\n\nWhen you send the route back, just use this relaxed JSON shape so it's easy to parse:\n\n{\n  \"solution\": [milk_depot_id, household_id, ..., milk_depot_id]\n}\n\nThink of \"solution\" as the ordered list of stops: it should start at the depot, list every household once in the order you'll drive to them, and finish back at the depot. The names like milk_depot_id and household_id are placeholders showing where to drop in the actual identifiers from the instance; the \"...\" just means \"and so on\" for the rest of the stops. This is only a sketch of the expected shape, not the actual answer.\n\nPlease 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": [
      [
        19,
        100
      ],
      [
        55,
        68
      ],
      [
        0,
        72
      ],
      [
        89,
        0
      ],
      [
        28,
        99
      ],
      [
        89,
        0
      ],
      [
        100,
        70
      ],
      [
        14,
        0
      ],
      [
        46,
        21
      ]
    ],
    "solution": [
      0,
      2,
      7,
      8,
      5,
      3,
      6,
      1,
      4,
      0
    ],
    "obj": 359.3840217590332,
    "instance_variant": {
      "problem_type": "TSP",
      "num_nodes": 9,
      "nodes": [
        {
          "id": 0,
          "x": 19,
          "y": 100
        },
        {
          "id": 1,
          "x": 55,
          "y": 68
        },
        {
          "id": 2,
          "x": 0,
          "y": 72
        },
        {
          "id": 3,
          "x": 89,
          "y": 0
        },
        {
          "id": 4,
          "x": 28,
          "y": 99
        },
        {
          "id": 5,
          "x": 89,
          "y": 0
        },
        {
          "id": 6,
          "x": 100,
          "y": 70
        },
        {
          "id": 7,
          "x": 14,
          "y": 0
        },
        {
          "id": 8,
          "x": 46,
          "y": 21
        }
      ],
      "depot": 0
    },
    "solution_variant": [
      0,
      2,
      7,
      8,
      5,
      3,
      6,
      1,
      4,
      0
    ],
    "context_index": 19,
    "input_format": "csv",
    "input_index_base": 0
  },
  {
    "task_name": "TSP",
    "problem_type": "TSP",
    "instruction": "On a busy day the van should leave the shop, swing through every scheduled driveway once, and finish back where it started. The decision is simply which sequence to follow; the best sequence is the one that leads to the lowest overall driving distance, calculated by summing each segment between stops and the return trip. Each address must be visited one time only. The specific addresses and coordinates appear below.\n\nThere are 6 locations to include in the closed route, with the shop depot identified as 0.\nStop 0 is located at coordinates (89, 0).\nStop 1 is located at coordinates (74, 88).\nStop 2 is located at coordinates (89, 37).\nStop 3 is located at coordinates (100, 24).\nStop 4 is located at coordinates (14, 37).\nStop 5 is located at coordinates (0, 100).\nUse these 6 locations, starting and ending at 0, to determine the sequence that minimizes the total driving distance.\n\nWhen you send back the chosen sequence, just pop it into this little JSON sketch so it's easy to read and use:\n\n{\n  \"solution\": [depot_id, location_id, ..., depot_id]\n}\n\n\"solution\" is just the ordered list of stop IDs: start at the depot, visit each driveway once, and finish back at the depot. Think of it like filling in a simple checklist of IDs in the order the van will drive them. This JSON block is only the shape I want — it's a template, not the actual route.\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": [
      [
        89,
        0
      ],
      [
        74,
        88
      ],
      [
        89,
        37
      ],
      [
        100,
        24
      ],
      [
        14,
        37
      ],
      [
        0,
        100
      ]
    ],
    "solution": [
      0,
      3,
      2,
      1,
      5,
      4,
      0
    ],
    "obj": 319.72388648986816,
    "instance_variant": {
      "problem_type": "TSP",
      "num_nodes": 6,
      "nodes": [
        {
          "id": 0,
          "x": 89,
          "y": 0
        },
        {
          "id": 1,
          "x": 74,
          "y": 88
        },
        {
          "id": 2,
          "x": 89,
          "y": 37
        },
        {
          "id": 3,
          "x": 100,
          "y": 24
        },
        {
          "id": 4,
          "x": 14,
          "y": 37
        },
        {
          "id": 5,
          "x": 0,
          "y": 100
        }
      ],
      "depot": 0
    },
    "solution_variant": [
      0,
      3,
      2,
      1,
      5,
      4,
      0
    ],
    "context_index": 20,
    "input_format": "nl",
    "input_index_base": 0
  },
  {
    "task_name": "TSP",
    "problem_type": "TSP",
    "instruction": "We’ve got a weekday routine where pickups start at my house, go to each activity drop-off one time only, and then come back home, and I need to choose the order of visits. A good plan is simply the one that makes the total miles driven for the full loop as small as possible — that total is just the sum of each leg of the trip — and no location can be left out or visited twice. I’ll show the exact places and numbers down below.\n\n{\n  \"total_locations\": 7,\n  \"nodes\": [\n    {\n      \"location_id\": 0,\n      \"x_coordinate\": 22,\n      \"y_coordinate\": 18\n    },\n    {\n      \"location_id\": 1,\n      \"x_coordinate\": 100,\n      \"y_coordinate\": 22\n    },\n    {\n      \"location_id\": 2,\n      \"x_coordinate\": 0,\n      \"y_coordinate\": 0\n    },\n    {\n      \"location_id\": 3,\n      \"x_coordinate\": 64,\n      \"y_coordinate\": 33\n    },\n    {\n      \"location_id\": 4,\n      \"x_coordinate\": 61,\n      \"y_coordinate\": 18\n    },\n    {\n      \"location_id\": 5,\n      \"x_coordinate\": 16,\n      \"y_coordinate\": 28\n    },\n    {\n      \"location_id\": 6,\n      \"x_coordinate\": 71,\n      \"y_coordinate\": 100\n    }\n  ],\n  \"home_node_id\": 0\n}\n\nAlso, when you give me the route, please use this simple JSON layout so it's easy to read and reuse:\n\n{\n  \"solution\": [\"home_id\", \"stop_id\", ..., \"home_id\"]\n}\n\nThis just means \"solution\" is a list showing the order of visits: start at your house (home_id), go to each stop once (stop_id entries), and come back home. The \"...\" is just standing in for the rest of the stops in order. 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. \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": [
      [
        22,
        18
      ],
      [
        100,
        22
      ],
      [
        0,
        0
      ],
      [
        64,
        33
      ],
      [
        61,
        18
      ],
      [
        16,
        28
      ],
      [
        71,
        100
      ]
    ],
    "solution": [
      0,
      2,
      5,
      6,
      1,
      3,
      4,
      0
    ],
    "obj": 326.43460273742676,
    "instance_variant": {
      "problem_type": "TSP",
      "num_nodes": 7,
      "nodes": [
        {
          "id": 0,
          "x": 22,
          "y": 18
        },
        {
          "id": 1,
          "x": 100,
          "y": 22
        },
        {
          "id": 2,
          "x": 0,
          "y": 0
        },
        {
          "id": 3,
          "x": 64,
          "y": 33
        },
        {
          "id": 4,
          "x": 61,
          "y": 18
        },
        {
          "id": 5,
          "x": 16,
          "y": 28
        },
        {
          "id": 6,
          "x": 71,
          "y": 100
        }
      ],
      "depot": 0
    },
    "solution_variant": [
      0,
      2,
      5,
      6,
      1,
      3,
      4,
      0
    ],
    "context_index": 21,
    "input_format": "json",
    "input_index_base": 0
  },
  {
    "task_name": "TSP",
    "problem_type": "TSP",
    "instruction": "There’s a warehouse that needs one smooth loop — the driver departs, hits every delivery point once, then returns to where they started — and the aim is to make that loop as short as possible. Concretely, that’s done by summing the distances between each pair of successive stops in the chosen route, including the final leg home, and choosing the route with the least total miles. Every address must be called exactly once. The concrete stops and distances appear below.\n\nThere are 7 stops listed below, with the warehouse identified as 1.\n\n| stop_id | x_coord | y_coord |\n|---|---|---|\n| 1 | 2 | 14 |\n| 2 | 60 | 100 |\n| 3 | 58 | 80 |\n| 4 | 0 | 0 |\n| 5 | 100 | 39 |\n| 6 | 44 | 92 |\n| 7 | 96 | 72 |\n\nThe tour must visit every stop exactly once and return to 1.\n\nAlso, when you send the route back, please use this little JSON sketch so it's easy to read and check:\n\n{\n  \"solution\": [warehouse_id, stop_id, ..., warehouse_id]\n}\n\nHere \"solution\" is just the ordered list of stops: start at the warehouse (warehouse_id), visit each delivery stop once (each stop_id), and come back to the warehouse at the end. Think of it like filling out a short form: put the starting place first, then the stops in the order the driver will visit them, and finish with the starting place again.\n\nThis JSON is only a sketch of the expected shape — not the actual route answer.\n\nPlease use the exact identifiers given in the instance input — do not 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": [
      [
        2,
        14
      ],
      [
        60,
        100
      ],
      [
        58,
        80
      ],
      [
        0,
        0
      ],
      [
        100,
        39
      ],
      [
        44,
        92
      ],
      [
        96,
        72
      ]
    ],
    "solution": [
      0,
      3,
      4,
      6,
      2,
      1,
      5,
      0
    ],
    "obj": 320.12980461120605,
    "instance_variant": {
      "problem_type": "TSP",
      "num_nodes": 7,
      "nodes": [
        {
          "id": 1,
          "x": 2,
          "y": 14
        },
        {
          "id": 2,
          "x": 60,
          "y": 100
        },
        {
          "id": 3,
          "x": 58,
          "y": 80
        },
        {
          "id": 4,
          "x": 0,
          "y": 0
        },
        {
          "id": 5,
          "x": 100,
          "y": 39
        },
        {
          "id": 6,
          "x": 44,
          "y": 92
        },
        {
          "id": 7,
          "x": 96,
          "y": 72
        }
      ],
      "depot": 1
    },
    "solution_variant": [
      1,
      4,
      5,
      7,
      3,
      2,
      6,
      1
    ],
    "context_index": 22,
    "input_format": "markdown_table",
    "input_index_base": 1
  },
  {
    "task_name": "TSP",
    "problem_type": "TSP",
    "instruction": "Every week the salon schedules home appointments, and the task is to plan a trip that starts at the salon, stops at every client’s home one time only, and ends at the salon. The ordering matters because a better order means fewer miles on the road — total driving distance is found by adding together the lengths of all the legs of the trip, including the last leg back to the salon. The concrete client details and coordinates are listed below.\n\n{\n  \"total_locations_count\": 7,\n  \"nodes\": [\n    {\n      \"stop_id\": 0,\n      \"location_longitude_like\": 40,\n      \"location_latitude_like\": 100\n    },\n    {\n      \"stop_id\": 1,\n      \"location_longitude_like\": 99,\n      \"location_latitude_like\": 1\n    },\n    {\n      \"stop_id\": 2,\n      \"location_longitude_like\": 50,\n      \"location_latitude_like\": 91\n    },\n    {\n      \"stop_id\": 3,\n      \"location_longitude_like\": 0,\n      \"location_latitude_like\": 0\n    },\n    {\n      \"stop_id\": 4,\n      \"location_longitude_like\": 45,\n      \"location_latitude_like\": 54\n    },\n    {\n      \"stop_id\": 5,\n      \"location_longitude_like\": 70,\n      \"location_latitude_like\": 88\n    },\n    {\n      \"stop_id\": 6,\n      \"location_longitude_like\": 100,\n      \"location_latitude_like\": 99\n    }\n  ],\n  \"salon_node_id\": 0\n}\n\nAlso, when you send the route back, please stick to a simple JSON layout so it’s easy to read and plug in. Something like this:\n\n{\n  \"solution\": [salon_id, client_id, ..., salon_id]\n}\n\nThis just means the \"solution\" is the trip as an ordered list: start at the salon, list each client’s location once in the order you want to visit them, and finish back at the salon. Think of the placeholders (salon_id, client_id, ...) as showing the shape of the reply — they’re not the real IDs.\n\nThe JSON above is only a sketch of the expected shape, 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": [
      [
        40,
        100
      ],
      [
        99,
        1
      ],
      [
        50,
        91
      ],
      [
        0,
        0
      ],
      [
        45,
        54
      ],
      [
        70,
        88
      ],
      [
        100,
        99
      ]
    ],
    "solution": [
      0,
      2,
      5,
      6,
      1,
      3,
      4,
      0
    ],
    "obj": 379.2038049697876,
    "instance_variant": {
      "problem_type": "TSP",
      "num_nodes": 7,
      "nodes": [
        {
          "id": 0,
          "x": 40,
          "y": 100
        },
        {
          "id": 1,
          "x": 99,
          "y": 1
        },
        {
          "id": 2,
          "x": 50,
          "y": 91
        },
        {
          "id": 3,
          "x": 0,
          "y": 0
        },
        {
          "id": 4,
          "x": 45,
          "y": 54
        },
        {
          "id": 5,
          "x": 70,
          "y": 88
        },
        {
          "id": 6,
          "x": 100,
          "y": 99
        }
      ],
      "depot": 0
    },
    "solution_variant": [
      0,
      2,
      5,
      6,
      1,
      3,
      4,
      0
    ],
    "context_index": 23,
    "input_format": "json",
    "input_index_base": 0
  },
  {
    "task_name": "TSP",
    "problem_type": "TSP",
    "instruction": "A rep needs a plan that begins at the office, touches every clinic on the list exactly once, and returns to the office at the end. The decision is the order to visit the clinics so the day isn’t wasted on extra driving. The way to compare plans is straightforward: add up the distance of every leg in the proposed route, including the trip back to the office, and prefer the route with the smallest total. Nothing can be skipped or repeated, and the exact clinic locations and distances are shown below.\n\n# total_locations=10\n# office_id=0\nlocation_id,x_coordinate,y_coordinate\n0,54,100\n1,14,83\n2,71,100\n3,22,26\n4,23,54\n5,11,83\n6,100,0\n7,72,23\n8,75,76\n9,0,79\n\nOh, and when you send the route back, you can just follow this simple JSON shape so it's easy to read and check:\n\n{\n  \"solution\": [office_id, clinic_id, ..., office_id]\n}\n\nThink of it like a little form: \"solution\" is the ordered list of stops. The first and last entry are the office, and everything between is the clinics in the order you plan to visit them. This is just the expected shape — not the actual route itself.\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": [
      [
        54,
        100
      ],
      [
        14,
        83
      ],
      [
        71,
        100
      ],
      [
        22,
        26
      ],
      [
        23,
        54
      ],
      [
        11,
        83
      ],
      [
        100,
        0
      ],
      [
        72,
        23
      ],
      [
        75,
        76
      ],
      [
        0,
        79
      ]
    ],
    "solution": [
      0,
      1,
      5,
      9,
      4,
      3,
      7,
      6,
      8,
      2,
      0
    ],
    "obj": 327.81831455230713,
    "instance_variant": {
      "problem_type": "TSP",
      "num_nodes": 10,
      "nodes": [
        {
          "id": 0,
          "x": 54,
          "y": 100
        },
        {
          "id": 1,
          "x": 14,
          "y": 83
        },
        {
          "id": 2,
          "x": 71,
          "y": 100
        },
        {
          "id": 3,
          "x": 22,
          "y": 26
        },
        {
          "id": 4,
          "x": 23,
          "y": 54
        },
        {
          "id": 5,
          "x": 11,
          "y": 83
        },
        {
          "id": 6,
          "x": 100,
          "y": 0
        },
        {
          "id": 7,
          "x": 72,
          "y": 23
        },
        {
          "id": 8,
          "x": 75,
          "y": 76
        },
        {
          "id": 9,
          "x": 0,
          "y": 79
        }
      ],
      "depot": 0
    },
    "solution_variant": [
      0,
      1,
      5,
      9,
      4,
      3,
      7,
      6,
      8,
      2,
      0
    ],
    "context_index": 24,
    "input_format": "csv",
    "input_index_base": 0
  },
  {
    "task_name": "TSP",
    "problem_type": "TSP",
    "instruction": "I’m planning a run to pick up a pile of antiques: start at the storage unit, swing by every seller’s address one time only, and come back to the storage unit at the end. The decision is the order to visit those seller addresses; a better order means less driving overall, which is measured by adding up the miles (or minutes) between each stop on the loop. Nothing can be skipped or visited twice, and the exact addresses and map points are shown below.\n\n{\n  \"total_locations\": 7,\n  \"nodes\": [\n    {\n      \"stop_node_id\": 1,\n      \"longitude_like_coordinate\": 0,\n      \"latitude_like_coordinate\": 61\n    },\n    {\n      \"stop_node_id\": 2,\n      \"longitude_like_coordinate\": 78,\n      \"latitude_like_coordinate\": 100\n    },\n    {\n      \"stop_node_id\": 3,\n      \"longitude_like_coordinate\": 7,\n      \"latitude_like_coordinate\": 12\n    },\n    {\n      \"stop_node_id\": 4,\n      \"longitude_like_coordinate\": 47,\n      \"latitude_like_coordinate\": 0\n    },\n    {\n      \"stop_node_id\": 5,\n      \"longitude_like_coordinate\": 100,\n      \"latitude_like_coordinate\": 54\n    },\n    {\n      \"stop_node_id\": 6,\n      \"longitude_like_coordinate\": 23,\n      \"latitude_like_coordinate\": 92\n    },\n    {\n      \"stop_node_id\": 7,\n      \"longitude_like_coordinate\": 43,\n      \"latitude_like_coordinate\": 73\n    }\n  ],\n  \"storage_unit_node_id\": 1\n}\n\nOh, and when you send the answer back, just stick to this simple JSON layout so it's easy to read and check:\n\n{\n  \"solution\": [storage_unit_id, seller_id, ..., storage_unit_id]\n}\n\nHere \"solution\" is the loop: start at the storage unit placeholder, list each seller placeholder in the order you visit them, and end back at the storage unit placeholder. Think of it like filling in the blanks on a route card — just the sequence of stop IDs, nothing else.\n\nQuick reminder: 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": [
      [
        0,
        61
      ],
      [
        78,
        100
      ],
      [
        7,
        12
      ],
      [
        47,
        0
      ],
      [
        100,
        54
      ],
      [
        23,
        92
      ],
      [
        43,
        73
      ]
    ],
    "solution": [
      0,
      2,
      3,
      4,
      1,
      6,
      5,
      0
    ],
    "obj": 328.3034420013428,
    "instance_variant": {
      "problem_type": "TSP",
      "num_nodes": 7,
      "nodes": [
        {
          "id": 1,
          "x": 0,
          "y": 61
        },
        {
          "id": 2,
          "x": 78,
          "y": 100
        },
        {
          "id": 3,
          "x": 7,
          "y": 12
        },
        {
          "id": 4,
          "x": 47,
          "y": 0
        },
        {
          "id": 5,
          "x": 100,
          "y": 54
        },
        {
          "id": 6,
          "x": 23,
          "y": 92
        },
        {
          "id": 7,
          "x": 43,
          "y": 73
        }
      ],
      "depot": 1
    },
    "solution_variant": [
      1,
      3,
      4,
      5,
      2,
      7,
      6,
      1
    ],
    "context_index": 25,
    "input_format": "json",
    "input_index_base": 1
  },
  {
    "task_name": "TSP",
    "problem_type": "TSP",
    "instruction": "I’m picturing the community kitchen loading up meals and sending a driver out to hit every recipient’s house once before coming back to the kitchen — the question is what order to visit the stops so the whole trip covers as few miles as possible. In practice that means choosing a route that starts at the kitchen, goes to every address exactly one time (no skipping, no doubling back), then returns to the kitchen, and the “score” of a route is just the total distance you get by adding up each stretch between consecutive stops (including the final leg home). The specific addresses and distances are shown below.\n\n{\n  \"total_stops\": 5,\n  \"nodes\": [\n    {\n      \"stop_id\": 0,\n      \"stop_x\": 93,\n      \"stop_y\": 0\n    },\n    {\n      \"stop_id\": 1,\n      \"stop_x\": 0,\n      \"stop_y\": 82\n    },\n    {\n      \"stop_id\": 2,\n      \"stop_x\": 100,\n      \"stop_y\": 63\n    },\n    {\n      \"stop_id\": 3,\n      \"stop_x\": 41,\n      \"stop_y\": 75\n    },\n    {\n      \"stop_id\": 4,\n      \"stop_x\": 78,\n      \"stop_y\": 100\n    }\n  ],\n  \"kitchen_node\": 0\n}\n\nOh, and when you reply, just toss the route into a tiny JSON snippet like this — it's just the shape I expect:\n\n{\n  \"solution\": [kitchen_id, recipient_id, ..., kitchen_id]\n}\n\nThis \"solution\" array is the order the driver will visit stops: start at the kitchen, go through each recipient once, and come back to the kitchen. The first and last entries are the kitchen, and the ... just means the other stops go in between. It's just a sketch of the format — not your final answer.\n\nImportant: when you fill in that JSON, use the identifiers exactly as they appear in the instance input — don't rename them or make up 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": [
      [
        93,
        0
      ],
      [
        0,
        82
      ],
      [
        100,
        63
      ],
      [
        41,
        75
      ],
      [
        78,
        100
      ]
    ],
    "solution": [
      0,
      1,
      3,
      4,
      2,
      0
    ],
    "obj": 316.6695785522461,
    "instance_variant": {
      "problem_type": "TSP",
      "num_nodes": 5,
      "nodes": [
        {
          "id": 0,
          "x": 93,
          "y": 0
        },
        {
          "id": 1,
          "x": 0,
          "y": 82
        },
        {
          "id": 2,
          "x": 100,
          "y": 63
        },
        {
          "id": 3,
          "x": 41,
          "y": 75
        },
        {
          "id": 4,
          "x": 78,
          "y": 100
        }
      ],
      "depot": 0
    },
    "solution_variant": [
      0,
      1,
      3,
      4,
      2,
      0
    ],
    "context_index": 26,
    "input_format": "json",
    "input_index_base": 0
  },
  {
    "task_name": "TSP",
    "problem_type": "TSP",
    "instruction": "Someone from the moving crew put together a list of pickups and the truck has to handle them all in a single tour: depart the depot, visit each pickup location one time, and return to the depot. The task is picking the visiting order. A preferred order is the one that keeps the total driving to a minimum — total distance equals the sum of distances between each successive stop plus the final leg home. No duplicates, no skips. The exact points and coordinates are given below.\n\nThere are 6 distinct stops; begin and end the tour at depot 1.\n\n| location_node_id | x_coordinate | y_coordinate |\n|---|---|---|\n| 1 | 0 | 30 |\n| 2 | 100 | 49 |\n| 3 | 91 | 100 |\n| 4 | 91 | 6 |\n| 5 | 91 | 62 |\n| 6 | 96 | 0 |\n\nConfirm the tour visits all 6 stops and returns to 1.\n\nAlso, when you give the answer, please stick to this simple JSON layout:\n\n{\n  \"solution\": [depot_id, location_id, ..., depot_id]\n}\n\nThink of \"solution\" as just the list of stops in order: start at the depot, go to each pickup once, and come back to the depot. The words depot_id and location_id above are placeholders — you'll replace them with the actual IDs from the instance when you provide the real route. This JSON is just a sketch of the shape I need, not the final tour.\n\nPlease make sure to use the exact identifiers from the 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": [
      [
        0,
        30
      ],
      [
        100,
        49
      ],
      [
        91,
        100
      ],
      [
        91,
        6
      ],
      [
        91,
        62
      ],
      [
        96,
        0
      ]
    ],
    "solution": [
      0,
      2,
      4,
      1,
      5,
      3,
      0
    ],
    "obj": 319.70479822158813,
    "instance_variant": {
      "problem_type": "TSP",
      "num_nodes": 6,
      "nodes": [
        {
          "id": 1,
          "x": 0,
          "y": 30
        },
        {
          "id": 2,
          "x": 100,
          "y": 49
        },
        {
          "id": 3,
          "x": 91,
          "y": 100
        },
        {
          "id": 4,
          "x": 91,
          "y": 6
        },
        {
          "id": 5,
          "x": 91,
          "y": 62
        },
        {
          "id": 6,
          "x": 96,
          "y": 0
        }
      ],
      "depot": 1
    },
    "solution_variant": [
      1,
      3,
      5,
      2,
      6,
      4,
      1
    ],
    "context_index": 27,
    "input_format": "markdown_table",
    "input_index_base": 1
  },
  {
    "task_name": "TSP",
    "problem_type": "TSP",
    "instruction": "In our town the distributor needs a simple route plan: the driver leaves the regional warehouse, goes to each shop one time only, and comes back to the warehouse when finished. What separates a good plan from a bad one is how much driving it forces — compare plans by adding together the distances from stop to stop (and the final leg home); the lower that sum, the better the route — and it’s mandatory that every retail outlet is served once and only once. The exact stops and coordinates are shown below.\n\nThe tour includes 5 stops and begins and ends at warehouse 1.\nStop 1: longitude 72, latitude 45.\nStop 2: longitude 71, latitude 100.\nStop 3: longitude 100, latitude 91.\nStop 4: longitude 95, latitude 27.\nStop 5: longitude 0, latitude 0.\nEach retail outlet must be visited once and only once, and the driver returns to 1.\n\nIf you want to send the route back to me, just use this little JSON sketch for the shape of the answer:\n\n{\n  \"solution\": [warehouse_id, shop_id, ..., warehouse_id]\n}\n\nThink of \"solution\" as the ordered list of stops — you start at the warehouse (the first placeholder), go to each shop once (the middle placeholders), and then come back to the warehouse (the last placeholder). This is just the expected shape of the reply, not the actual route — you'll replace those placeholders with the real IDs from the instance.\n\nPlease be 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": [
      [
        72,
        45
      ],
      [
        71,
        100
      ],
      [
        100,
        91
      ],
      [
        95,
        27
      ],
      [
        0,
        0
      ]
    ],
    "solution": [
      0,
      3,
      2,
      1,
      4,
      0
    ],
    "obj": 331.3132152557373,
    "instance_variant": {
      "problem_type": "TSP",
      "num_nodes": 5,
      "nodes": [
        {
          "id": 1,
          "x": 72,
          "y": 45
        },
        {
          "id": 2,
          "x": 71,
          "y": 100
        },
        {
          "id": 3,
          "x": 100,
          "y": 91
        },
        {
          "id": 4,
          "x": 95,
          "y": 27
        },
        {
          "id": 5,
          "x": 0,
          "y": 0
        }
      ],
      "depot": 1
    },
    "solution_variant": [
      1,
      4,
      3,
      2,
      5,
      1
    ],
    "context_index": 28,
    "input_format": "nl",
    "input_index_base": 1
  },
  {
    "task_name": "TSP",
    "problem_type": "TSP",
    "instruction": "There’s a daily juggling act at the pest control office: a technician has a stack of client addresses and needs to visit each home exactly once, starting from the office and finishing back there. The trick is picking the order of visits so the van covers the least distance overall — calculate that by adding the length of each leg of the journey in the chosen order, including the return leg. No house can be left out or checked twice. The concrete details will be shown below.\n\n# total_stops=9\n# office_node_id=A\nlocation_id,x_coordinate,y_coordinate\nA,82,51\nB,84,10\nC,90,44\nD,17,21\nE,95,20\nF,60,81\nG,95,79\nH,100,100\nI,0,0\n\nAlso — when you send the route back, please follow this little JSON shape so it's easy to read and check:\n\n{\n  \"solution\": [office_id, house_id, ..., office_id]\n}\n\nThis just means \"solution\" holds the ordered list of stops: start at the office, visit each house once in the chosen order, and return to the office at the end. Think of it like filling in a simple itinerary form — the array is the visit sequence. It's just a sketch of the shape I need, not the actual route.\n\nPlease make sure you use the exact identifiers from the instance input — don't rename them or invent new ones.\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": [
      [
        82,
        51
      ],
      [
        84,
        10
      ],
      [
        90,
        44
      ],
      [
        17,
        21
      ],
      [
        95,
        20
      ],
      [
        60,
        81
      ],
      [
        95,
        79
      ],
      [
        100,
        100
      ],
      [
        0,
        0
      ]
    ],
    "solution": [
      0,
      2,
      4,
      1,
      8,
      3,
      5,
      7,
      6,
      0
    ],
    "obj": 332.1814317703247,
    "instance_variant": {
      "problem_type": "TSP",
      "num_nodes": 9,
      "nodes": [
        {
          "id": "A",
          "x": 82,
          "y": 51
        },
        {
          "id": "B",
          "x": 84,
          "y": 10
        },
        {
          "id": "C",
          "x": 90,
          "y": 44
        },
        {
          "id": "D",
          "x": 17,
          "y": 21
        },
        {
          "id": "E",
          "x": 95,
          "y": 20
        },
        {
          "id": "F",
          "x": 60,
          "y": 81
        },
        {
          "id": "G",
          "x": 95,
          "y": 79
        },
        {
          "id": "H",
          "x": 100,
          "y": 100
        },
        {
          "id": "I",
          "x": 0,
          "y": 0
        }
      ],
      "depot": "A"
    },
    "solution_variant": [
      "A",
      "C",
      "E",
      "B",
      "I",
      "D",
      "F",
      "H",
      "G",
      "A"
    ],
    "context_index": 29,
    "input_format": "csv",
    "input_index_base": "names"
  },
  {
    "task_name": "TSP",
    "problem_type": "TSP",
    "instruction": "Many people think of delivery as just driving until the job’s done, but this press wants the truck to visit every newsstand exactly once and return, using the least total miles. The decision is the visiting order, and the performance is judged by adding up the distances along that loop (stop-to-stop and back to the press); smaller totals are better, and no stand may be skipped or doubled. The specific instance information follows below.\n\nThere are 6 locations, with the press at 1.\nLocation 1 is at (0, 0).\nLocation 2 is at (38, 42).\nLocation 3 is at (41, 56).\nLocation 4 is at (66, 20).\nLocation 5 is at (100, 100).\nLocation 6 is at (3, 19).\nList each of the 6 locations once so the route starts and ends at 1 and the total loop miles can be computed.\n\nAlso, when you send the visiting order back, just use a tiny JSON snippet like this so it's easy to parse:\n\n{\n  \"solution\": [depot_id, location_id, ..., depot_id]\n}\n\nThis simply shows the sequence of stops in order — the array is the order the truck visits each newsstand, starting and ending at the depot. Think of it as filling in the blanks with the labels you were given for the depot and each stand. This JSON is just a sketch of the shape I need, not your actual answer.\n\nPlease be sure to use the exact identifiers from the instance input — don’t rename them or invent 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": [
      [
        0,
        0
      ],
      [
        38,
        42
      ],
      [
        41,
        56
      ],
      [
        66,
        20
      ],
      [
        100,
        100
      ],
      [
        3,
        19
      ]
    ],
    "solution": [
      0,
      3,
      4,
      2,
      1,
      5,
      0
    ],
    "obj": 304.9232769012451,
    "instance_variant": {
      "problem_type": "TSP",
      "num_nodes": 6,
      "nodes": [
        {
          "id": 1,
          "x": 0,
          "y": 0
        },
        {
          "id": 2,
          "x": 38,
          "y": 42
        },
        {
          "id": 3,
          "x": 41,
          "y": 56
        },
        {
          "id": 4,
          "x": 66,
          "y": 20
        },
        {
          "id": 5,
          "x": 100,
          "y": 100
        },
        {
          "id": 6,
          "x": 3,
          "y": 19
        }
      ],
      "depot": 1
    },
    "solution_variant": [
      1,
      4,
      5,
      3,
      2,
      6,
      1
    ],
    "context_index": 30,
    "input_format": "nl",
    "input_index_base": 1
  },
  {
    "task_name": "TSP",
    "problem_type": "TSP",
    "instruction": "There's an ice cream truck driver staring at a map deciding the best sequence to visit a bunch of parks: the truck must pull out of the garage, stop at every park one time only, and end the day back at the garage. What counts as “best” is the route that uses the least amount of driving — calculated by adding the distances between each stop along the whole loop. The specific parks and distances are shown below.\n\n# total_locations_including_garage=10\n# garage_location_id=1\nlocation_id,map_x_coordinate,map_y_coordinate\n1,21,41\n2,66,30\n3,64,51\n4,7,23\n5,0,100\n6,45,52\n7,93,68\n8,71,9\n9,74,14\n10,100,0\n\nOh, and if you want to hand me the route (or if I return one), please follow this little JSON layout so everything stays neat and machine-friendly:\n\n{\n  \"solution\": [depot_id, location_id, ..., depot_id]\n}\n\nThink of \"solution\" as a simple list that shows the loop: the first item is the depot (the garage), then every park you visit in order, and the last item is the depot again to show the truck came home. This is just the shape I expect — a sketch, not the actual answer.\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": [
      [
        21,
        41
      ],
      [
        66,
        30
      ],
      [
        64,
        51
      ],
      [
        7,
        23
      ],
      [
        0,
        100
      ],
      [
        45,
        52
      ],
      [
        93,
        68
      ],
      [
        71,
        9
      ],
      [
        74,
        14
      ],
      [
        100,
        0
      ]
    ],
    "solution": [
      0,
      3,
      4,
      6,
      9,
      7,
      8,
      1,
      2,
      5,
      0
    ],
    "obj": 387.43781661987305,
    "instance_variant": {
      "problem_type": "TSP",
      "num_nodes": 10,
      "nodes": [
        {
          "id": 1,
          "x": 21,
          "y": 41
        },
        {
          "id": 2,
          "x": 66,
          "y": 30
        },
        {
          "id": 3,
          "x": 64,
          "y": 51
        },
        {
          "id": 4,
          "x": 7,
          "y": 23
        },
        {
          "id": 5,
          "x": 0,
          "y": 100
        },
        {
          "id": 6,
          "x": 45,
          "y": 52
        },
        {
          "id": 7,
          "x": 93,
          "y": 68
        },
        {
          "id": 8,
          "x": 71,
          "y": 9
        },
        {
          "id": 9,
          "x": 74,
          "y": 14
        },
        {
          "id": 10,
          "x": 100,
          "y": 0
        }
      ],
      "depot": 1
    },
    "solution_variant": [
      1,
      4,
      5,
      7,
      10,
      8,
      9,
      2,
      3,
      6,
      1
    ],
    "context_index": 31,
    "input_format": "csv",
    "input_index_base": 1
  },
  {
    "task_name": "TSP",
    "problem_type": "TSP",
    "instruction": "I’ve been helping the city figure out the inspector’s day: start at city hall, swing by every construction site once (no skipping, no double-checking), and come back to city hall at the end. The choice to make is the order of the stops so the inspector doesn’t drive more than necessary — the plan that’s better is the one with the smallest total driving distance, which is just the sum of each drive between consecutive stops on the route. The exact sites and map are shown below.\n\nThere are 7 locations in total, and the depot (city hall) is node A.\n\n| location_id | map_x_coordinate | map_y_coordinate |\n|---|---|---|\n| A | 22 | 6 |\n| B | 16 | 93 |\n| C | 100 | 15 |\n| D | 16 | 0 |\n| E | 28 | 61 |\n| F | 100 | 0 |\n| G | 0 | 100 |\n\nI'll use these to compute the route that minimizes the total driving distance and returns to city hall.\n\nOh, and when you send the planned route back, a tiny JSON snippet like this works nicely:\n\n{\n  \"solution\": [city_hall_id, site_id, ..., city_hall_id]\n}\n\n\"solution\" is just the ordered list of stops: start at city hall, visit each construction site once, and come back to city hall. The placeholders (city_hall_id, site_id, ...) are just showing the shape — you'll replace them with the actual IDs from the instance when you give the real route. This is only a sketch of the format, not the actual answer.\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": [
      [
        22,
        6
      ],
      [
        16,
        93
      ],
      [
        100,
        15
      ],
      [
        16,
        0
      ],
      [
        28,
        61
      ],
      [
        100,
        0
      ],
      [
        0,
        100
      ]
    ],
    "solution": [
      0,
      3,
      6,
      1,
      4,
      2,
      5,
      0
    ],
    "obj": 340.06792640686035,
    "instance_variant": {
      "problem_type": "TSP",
      "num_nodes": 7,
      "nodes": [
        {
          "id": "A",
          "x": 22,
          "y": 6
        },
        {
          "id": "B",
          "x": 16,
          "y": 93
        },
        {
          "id": "C",
          "x": 100,
          "y": 15
        },
        {
          "id": "D",
          "x": 16,
          "y": 0
        },
        {
          "id": "E",
          "x": 28,
          "y": 61
        },
        {
          "id": "F",
          "x": 100,
          "y": 0
        },
        {
          "id": "G",
          "x": 0,
          "y": 100
        }
      ],
      "depot": "A"
    },
    "solution_variant": [
      "A",
      "D",
      "G",
      "B",
      "E",
      "C",
      "F",
      "A"
    ],
    "context_index": 32,
    "input_format": "markdown_table",
    "input_index_base": "names"
  },
  {
    "task_name": "TSP",
    "problem_type": "TSP",
    "instruction": "On a typical morning the plan is to drive out from the farmhouse, check every plot one by one without doubling back, and finish at the farmhouse. Choosing the order of checks is the only decision; a smarter order trims the total driving distance, which is found by summing all the segments between stops and the final drive home. Every plot has to be included exactly once — no skipping, no repeats. The detailed plot info is provided below.\n\nThere are 7 locations in total, and the farmhouse is node 0.\n\n| plot_node_id | plot_x_coordinate | plot_y_coordinate |\n|---|---|---|\n| 0 | 0 | 100 |\n| 1 | 56 | 59 |\n| 2 | 38 | 94 |\n| 3 | 51 | 60 |\n| 4 | 8 | 91 |\n| 5 | 62 | 84 |\n| 6 | 100 | 0 |\n\nMake a closed loop visiting each plot once so all 7 locations are checked and the tour finishes back at node 0.\n\nYou can just hand me the tour in a tiny JSON blob like this — nothing fancy, just the order of stops.\n\n{\n  \"solution\": [\"farmhouse_id\", \"plot_id\", ..., \"farmhouse_id\"]\n}\n\nThink of that array as the driving order: start at the farmhouse_id, go to each plot_id once in the listed order, and finish back at the farmhouse_id. It’s just a sketch of the shape I expect — don’t treat this as the real answer, just the format to follow when you give the route.\n\nPlease make sure to use the exact identifiers from the instance input — don’t rename them or invent new ones. \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": [
      [
        0,
        100
      ],
      [
        56,
        59
      ],
      [
        38,
        94
      ],
      [
        51,
        60
      ],
      [
        8,
        91
      ],
      [
        62,
        84
      ],
      [
        100,
        0
      ]
    ],
    "solution": [
      0,
      2,
      5,
      6,
      1,
      3,
      4,
      0
    ],
    "obj": 300.416531085968,
    "instance_variant": {
      "problem_type": "TSP",
      "num_nodes": 7,
      "nodes": [
        {
          "id": 0,
          "x": 0,
          "y": 100
        },
        {
          "id": 1,
          "x": 56,
          "y": 59
        },
        {
          "id": 2,
          "x": 38,
          "y": 94
        },
        {
          "id": 3,
          "x": 51,
          "y": 60
        },
        {
          "id": 4,
          "x": 8,
          "y": 91
        },
        {
          "id": 5,
          "x": 62,
          "y": 84
        },
        {
          "id": 6,
          "x": 100,
          "y": 0
        }
      ],
      "depot": 0
    },
    "solution_variant": [
      0,
      2,
      5,
      6,
      1,
      3,
      4,
      0
    ],
    "context_index": 33,
    "input_format": "markdown_table",
    "input_index_base": 0
  },
  {
    "task_name": "TSP",
    "problem_type": "TSP",
    "instruction": "There’s a practical puzzle in the dog-walking rounds: start at the central park, stop by every client’s house once without doubling back, and finish back at the park. What makes one plan better than another is how many miles you’ll end up walking — count up the distances between the consecutive stops (and don’t forget the walk out from the park and the walk back) to get that total. The specific locations and details are shown below.\n\n{\n  \"total_locations_count\": 9,\n  \"nodes\": [\n    {\n      \"location_id\": 0,\n      \"x_coordinate\": 21,\n      \"y_coordinate\": 40\n    },\n    {\n      \"location_id\": 1,\n      \"x_coordinate\": 0,\n      \"y_coordinate\": 100\n    },\n    {\n      \"location_id\": 2,\n      \"x_coordinate\": 61,\n      \"y_coordinate\": 0\n    },\n    {\n      \"location_id\": 3,\n      \"x_coordinate\": 100,\n      \"y_coordinate\": 73\n    },\n    {\n      \"location_id\": 4,\n      \"x_coordinate\": 67,\n      \"y_coordinate\": 98\n    },\n    {\n      \"location_id\": 5,\n      \"x_coordinate\": 45,\n      \"y_coordinate\": 8\n    },\n    {\n      \"location_id\": 6,\n      \"x_coordinate\": 99,\n      \"y_coordinate\": 71\n    },\n    {\n      \"location_id\": 7,\n      \"x_coordinate\": 91,\n      \"y_coordinate\": 6\n    },\n    {\n      \"location_id\": 8,\n      \"x_coordinate\": 16,\n      \"y_coordinate\": 100\n    }\n  ],\n  \"central_park_id\": 0\n}\n\nWhen you send the route back, just stick to this simple JSON layout so it's easy to read and check.\n\n{\n  \"solution\": [park_id, client_id, ..., park_id]\n}\n\n\"solution\" is the list of stops in the order you'll walk them: start at the park, visit each client once, and come back to the park at the end. Think of the array as the itinerary — each entry is the identifier for that spot in the sequence. This block is just a sketch of the shape I need, not the final tour 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": [
      [
        21,
        40
      ],
      [
        0,
        100
      ],
      [
        61,
        0
      ],
      [
        100,
        73
      ],
      [
        67,
        98
      ],
      [
        45,
        8
      ],
      [
        99,
        71
      ],
      [
        91,
        6
      ],
      [
        16,
        100
      ]
    ],
    "solution": [
      0,
      1,
      8,
      4,
      3,
      6,
      7,
      2,
      5,
      0
    ],
    "obj": 328.21772503852844,
    "instance_variant": {
      "problem_type": "TSP",
      "num_nodes": 9,
      "nodes": [
        {
          "id": 0,
          "x": 21,
          "y": 40
        },
        {
          "id": 1,
          "x": 0,
          "y": 100
        },
        {
          "id": 2,
          "x": 61,
          "y": 0
        },
        {
          "id": 3,
          "x": 100,
          "y": 73
        },
        {
          "id": 4,
          "x": 67,
          "y": 98
        },
        {
          "id": 5,
          "x": 45,
          "y": 8
        },
        {
          "id": 6,
          "x": 99,
          "y": 71
        },
        {
          "id": 7,
          "x": 91,
          "y": 6
        },
        {
          "id": 8,
          "x": 16,
          "y": 100
        }
      ],
      "depot": 0
    },
    "solution_variant": [
      0,
      1,
      8,
      4,
      3,
      6,
      7,
      2,
      5,
      0
    ],
    "context_index": 34,
    "input_format": "json",
    "input_index_base": 0
  },
  {
    "task_name": "TSP",
    "problem_type": "TSP",
    "instruction": "At the office there’s a map with pins for each client and the task is to draw a single loop that starts and ends at the office and visits every pin exactly once. The route that’s preferred is the one with the smallest sum of driving distances along the loop — just add the distance between each consecutive stop in that order and include the drive back to the office. Every pin must be included and none can be repeated; the full coordinates and site list are below.\n\n{\n  \"total_locations\": 10,\n  \"nodes\": [\n    {\n      \"location_id\": 0,\n      \"x_coordinate\": 0,\n      \"y_coordinate\": 49\n    },\n    {\n      \"location_id\": 1,\n      \"x_coordinate\": 98,\n      \"y_coordinate\": 42\n    },\n    {\n      \"location_id\": 2,\n      \"x_coordinate\": 72,\n      \"y_coordinate\": 46\n    },\n    {\n      \"location_id\": 3,\n      \"x_coordinate\": 25,\n      \"y_coordinate\": 38\n    },\n    {\n      \"location_id\": 4,\n      \"x_coordinate\": 39,\n      \"y_coordinate\": 0\n    },\n    {\n      \"location_id\": 5,\n      \"x_coordinate\": 80,\n      \"y_coordinate\": 64\n    },\n    {\n      \"location_id\": 6,\n      \"x_coordinate\": 100,\n      \"y_coordinate\": 76\n    },\n    {\n      \"location_id\": 7,\n      \"x_coordinate\": 64,\n      \"y_coordinate\": 57\n    },\n    {\n      \"location_id\": 8,\n      \"x_coordinate\": 7,\n      \"y_coordinate\": 100\n    },\n    {\n      \"location_id\": 9,\n      \"x_coordinate\": 57,\n      \"y_coordinate\": 69\n    }\n  ],\n  \"office_node_id\": 0\n}\n\nAlso, when you send the final loop back, just drop it into this little JSON shape so it’s easy to parse:\n\n{\n  \"solution\": [office_id, client_id, ..., office_id]\n}\n\n\"solution\" is the ordered list of stops: start with the office identifier, list each client once in the order you’ll visit them, and end back at the office. Think of it like filling out a simple form — the JSON above is just a sketch of the shape I expect, not the actual answer.\n\nPlease use the identifiers 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": [
      [
        0,
        49
      ],
      [
        98,
        42
      ],
      [
        72,
        46
      ],
      [
        25,
        38
      ],
      [
        39,
        0
      ],
      [
        80,
        64
      ],
      [
        100,
        76
      ],
      [
        64,
        57
      ],
      [
        7,
        100
      ],
      [
        57,
        69
      ]
    ],
    "solution": [
      0,
      3,
      4,
      2,
      1,
      6,
      5,
      7,
      9,
      8,
      0
    ],
    "obj": 349.77621364593506,
    "instance_variant": {
      "problem_type": "TSP",
      "num_nodes": 10,
      "nodes": [
        {
          "id": 0,
          "x": 0,
          "y": 49
        },
        {
          "id": 1,
          "x": 98,
          "y": 42
        },
        {
          "id": 2,
          "x": 72,
          "y": 46
        },
        {
          "id": 3,
          "x": 25,
          "y": 38
        },
        {
          "id": 4,
          "x": 39,
          "y": 0
        },
        {
          "id": 5,
          "x": 80,
          "y": 64
        },
        {
          "id": 6,
          "x": 100,
          "y": 76
        },
        {
          "id": 7,
          "x": 64,
          "y": 57
        },
        {
          "id": 8,
          "x": 7,
          "y": 100
        },
        {
          "id": 9,
          "x": 57,
          "y": 69
        }
      ],
      "depot": 0
    },
    "solution_variant": [
      0,
      3,
      4,
      2,
      1,
      6,
      5,
      7,
      9,
      8,
      0
    ],
    "context_index": 35,
    "input_format": "json",
    "input_index_base": 0
  },
  {
    "task_name": "TSP",
    "problem_type": "TSP",
    "instruction": "On route-planning day the librarian sketches a loop that leaves the branch, stops at each book drop exactly once, and comes back to the branch — no repeats, no missed drops. The puzzle is ordering the stops so the van travels as little as possible; for any chosen order, the total distance is just the sum of the distances between each stop in the loop (include the first leg out of the branch and the final leg returning). The detailed list of drop locations and distances is given below.\n\nThere are 9 total locations in this run, and the van begins and ends its loop at A.\n\n| location_id | x_coordinate | y_coordinate |\n|---|---|---|\n| A | 77 | 13 |\n| B | 90 | 27 |\n| C | 25 | 70 |\n| D | 23 | 100 |\n| E | 56 | 33 |\n| F | 87 | 85 |\n| G | 0 | 96 |\n| H | 44 | 55 |\n| I | 100 | 0 |\n\nEnsure the list covers every location so the van visits all 9 points and returns to A.\n\nWhen you return the chosen loop, tuck it into this little JSON shape so it's easy to read and process:\n\n{\n  \"solution\": [branch_id, drop_id, ..., branch_id]\n}\n\nThink of that as a simple form: \"solution\" is the ordered list of stops starting from the branch, going to each book drop once, and coming back to the branch at the end. It’s just a sketch of the shape we want — replace those placeholders with the actual stop identifiers from the instance when you submit the answer.\n\nPlease be sure to use the identifiers exactly as they appear in the instance input — don’t 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": [
      [
        77,
        13
      ],
      [
        90,
        27
      ],
      [
        25,
        70
      ],
      [
        23,
        100
      ],
      [
        56,
        33
      ],
      [
        87,
        85
      ],
      [
        0,
        96
      ],
      [
        44,
        55
      ],
      [
        100,
        0
      ]
    ],
    "solution": [
      0,
      4,
      7,
      2,
      6,
      3,
      5,
      1,
      8,
      0
    ],
    "obj": 316.70587730407715,
    "instance_variant": {
      "problem_type": "TSP",
      "num_nodes": 9,
      "nodes": [
        {
          "id": "A",
          "x": 77,
          "y": 13
        },
        {
          "id": "B",
          "x": 90,
          "y": 27
        },
        {
          "id": "C",
          "x": 25,
          "y": 70
        },
        {
          "id": "D",
          "x": 23,
          "y": 100
        },
        {
          "id": "E",
          "x": 56,
          "y": 33
        },
        {
          "id": "F",
          "x": 87,
          "y": 85
        },
        {
          "id": "G",
          "x": 0,
          "y": 96
        },
        {
          "id": "H",
          "x": 44,
          "y": 55
        },
        {
          "id": "I",
          "x": 100,
          "y": 0
        }
      ],
      "depot": "A"
    },
    "solution_variant": [
      "A",
      "E",
      "H",
      "C",
      "G",
      "D",
      "F",
      "B",
      "I",
      "A"
    ],
    "context_index": 36,
    "input_format": "markdown_table",
    "input_index_base": "names"
  },
  {
    "task_name": "TSP",
    "problem_type": "TSP",
    "instruction": "Recently a musician decided to do a looped busking circuit: start at home, visit a set list of plazas one by one, and then return home at the end of the day. The planning task is to pick the sequence of plazas so the total amount of walking is minimized — less total walking means more time playing and less tired feet. To see which sequence is best, go through the route and add up each stretch of walking (home to first stop, then between each stop, and finally back home); the route with the lowest total walking distance is the goal. All listed plazas must be visited exactly once before finishing the loop. The concrete route details are shown below.\n\n# total_locations_count=9\n# home_location_id=1\nlocation_id,x_coordinate,y_coordinate\n1,0,51\n2,96,100\n3,0,42\n4,100,51\n5,55,3\n6,59,94\n7,9,0\n8,36,94\n9,50,44\n\nOh, and when you send the answer back, please use a little JSON outline so it's easy to check automatically. Something casual like this works fine:\n\n{\n  \"solution\": [home_id, plaza_id, ..., home_id]\n}\n\nThink of \"solution\" as the ordered list of stops for the day: start with your home id, then each plaza id in the order you plan to visit them, and finish by listing your home id again. It's just a sketch of the shape I need, not the actual route.\n\nPlease make sure to use the exact identifiers given 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": [
      [
        0,
        51
      ],
      [
        96,
        100
      ],
      [
        0,
        42
      ],
      [
        100,
        51
      ],
      [
        55,
        3
      ],
      [
        59,
        94
      ],
      [
        9,
        0
      ],
      [
        36,
        94
      ],
      [
        50,
        44
      ]
    ],
    "solution": [
      0,
      2,
      6,
      4,
      8,
      3,
      1,
      5,
      7,
      0
    ],
    "obj": 355.5691833496094,
    "instance_variant": {
      "problem_type": "TSP",
      "num_nodes": 9,
      "nodes": [
        {
          "id": 1,
          "x": 0,
          "y": 51
        },
        {
          "id": 2,
          "x": 96,
          "y": 100
        },
        {
          "id": 3,
          "x": 0,
          "y": 42
        },
        {
          "id": 4,
          "x": 100,
          "y": 51
        },
        {
          "id": 5,
          "x": 55,
          "y": 3
        },
        {
          "id": 6,
          "x": 59,
          "y": 94
        },
        {
          "id": 7,
          "x": 9,
          "y": 0
        },
        {
          "id": 8,
          "x": 36,
          "y": 94
        },
        {
          "id": 9,
          "x": 50,
          "y": 44
        }
      ],
      "depot": 1
    },
    "solution_variant": [
      1,
      3,
      7,
      5,
      9,
      4,
      2,
      6,
      8,
      1
    ],
    "context_index": 37,
    "input_format": "csv",
    "input_index_base": 1
  },
  {
    "task_name": "TSP",
    "problem_type": "TSP",
    "instruction": "We’ve got an open-house circuit to arrange: start at the brokerage, swing by every property on the list exactly once, and finish back at the brokerage at the end of the day. The decision is the sequence of stops — the one that wins is the route with the least total miles or total drive time. Figure that out by summing the distances (or times) between each consecutive stop all the way around the loop. Each listing must be visited once, with no repeats and no omissions. The concrete stop details are listed below.\n\n# total_stops=10\n# brokerage_id=0\nstop_id,coord_x,coord_y\n0,100,12\n1,93,31\n2,5,31\n3,95,45\n4,95,27\n5,93,0\n6,7,100\n7,0,0\n8,95,63\n9,7,27\n\nWhen you send back the route, just follow this simple JSON layout so it's easy to read and check.\n\n{\n  \"solution\": [brokerage_id, property_id, ..., brokerage_id]\n}\n\nThis just shows an ordered list under \"solution\": start at the brokerage, list each property once in the order you plan to visit them, and finish back at the brokerage. Think of each placeholder as the exact stop ID from the instance — it’s just a little form to fill in with the route.\n\nThe JSON above is only a sketch of the shape I expect, not the actual route.\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": [
      [
        100,
        12
      ],
      [
        93,
        31
      ],
      [
        5,
        31
      ],
      [
        95,
        45
      ],
      [
        95,
        27
      ],
      [
        93,
        0
      ],
      [
        7,
        100
      ],
      [
        0,
        0
      ],
      [
        95,
        63
      ],
      [
        7,
        27
      ]
    ],
    "solution": [
      0,
      4,
      1,
      3,
      8,
      6,
      2,
      9,
      7,
      5,
      0
    ],
    "obj": 356.1739025115967,
    "instance_variant": {
      "problem_type": "TSP",
      "num_nodes": 10,
      "nodes": [
        {
          "id": 0,
          "x": 100,
          "y": 12
        },
        {
          "id": 1,
          "x": 93,
          "y": 31
        },
        {
          "id": 2,
          "x": 5,
          "y": 31
        },
        {
          "id": 3,
          "x": 95,
          "y": 45
        },
        {
          "id": 4,
          "x": 95,
          "y": 27
        },
        {
          "id": 5,
          "x": 93,
          "y": 0
        },
        {
          "id": 6,
          "x": 7,
          "y": 100
        },
        {
          "id": 7,
          "x": 0,
          "y": 0
        },
        {
          "id": 8,
          "x": 95,
          "y": 63
        },
        {
          "id": 9,
          "x": 7,
          "y": 27
        }
      ],
      "depot": 0
    },
    "solution_variant": [
      0,
      4,
      1,
      3,
      8,
      6,
      2,
      9,
      7,
      5,
      0
    ],
    "context_index": 38,
    "input_format": "csv",
    "input_index_base": 0
  },
  {
    "task_name": "TSP",
    "problem_type": "TSP",
    "instruction": "I’ve got to sketch out the lab van’s day: it leaves the hospital, swings by every clinic to pick up samples, and comes back to the lab at the end. The choice to make is the order the van visits those clinics — one order might be a short, efficient loop, another might double back and add lots of miles. The better plan is simply the one that results in the fewest total miles driven; that total is found by adding up the distances for each leg of the trip (from the lab to the first clinic, between each pair of clinics in sequence, and from the last clinic back to the lab). It’s also important that no clinic is skipped or visited more than once. The exact list of clinic locations and distances are shown below.\n\nSo here are the stops I need to work with — 7 total stops, with the hospital lab depot identified as 1.\n\n| stop_id | longitude | latitude |\n|---|---|---|\n| 1 | 31 | 27 |\n| 2 | 2 | 25 |\n| 3 | 100 | 9 |\n| 4 | 51 | 0 |\n| 5 | 15 | 25 |\n| 6 | 76 | 54 |\n| 7 | 0 | 100 |\n\nI'll use these stop entries to sum the leg distances and pick the shortest loop for the van.\n\nAlso, when you send back the chosen route, just use this little JSON layout so it's clear and tidy:\n\n{\n  \"solution\": [lab_id, clinic_id, ..., lab_id]\n}\n\nHere, \"solution\" is the ordered list the van will drive: start at the lab (the first lab_id), go to each clinic once (each clinic_id in order), and return to the lab at the end (the last lab_id). This block is just a sketch of the shape I’m expecting, not the actual route.\n\nPlease make sure you use the exact identifiers from the instance input — don’t rename them and don’t invent 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": [
      [
        31,
        27
      ],
      [
        2,
        25
      ],
      [
        100,
        9
      ],
      [
        51,
        0
      ],
      [
        15,
        25
      ],
      [
        76,
        54
      ],
      [
        0,
        100
      ]
    ],
    "solution": [
      0,
      3,
      2,
      5,
      6,
      1,
      4,
      0
    ],
    "obj": 327.4083786010742,
    "instance_variant": {
      "problem_type": "TSP",
      "num_nodes": 7,
      "nodes": [
        {
          "id": 1,
          "x": 31,
          "y": 27
        },
        {
          "id": 2,
          "x": 2,
          "y": 25
        },
        {
          "id": 3,
          "x": 100,
          "y": 9
        },
        {
          "id": 4,
          "x": 51,
          "y": 0
        },
        {
          "id": 5,
          "x": 15,
          "y": 25
        },
        {
          "id": 6,
          "x": 76,
          "y": 54
        },
        {
          "id": 7,
          "x": 0,
          "y": 100
        }
      ],
      "depot": 1
    },
    "solution_variant": [
      1,
      4,
      3,
      6,
      7,
      2,
      5,
      1
    ],
    "context_index": 39,
    "input_format": "markdown_table",
    "input_index_base": 1
  },
  {
    "task_name": "TSP",
    "problem_type": "TSP",
    "instruction": "There’s a neighborhood audit coming up where an inspector will start at the town depot, walk or drive past every mailbox to inspect them, and finally head back to where they began. The choice to make is the sequence of mailboxes to visit — it needs to include every mailbox without revisiting any. A route is better if the inspector ends up covering fewer miles overall; that’s measured by adding up the lengths of each step from one stop to the next, plus the return trip to the depot. Details of the specific stops follow below.\n\nThere are 5 stops in total, and the inspector will start and finish at depot A.\n\n| location_id | x_coord | y_coord |\n|---|---|---|\n| A | 86 | 100 |\n| B | 100 | 91 |\n| C | 27 | 20 |\n| D | 30 | 74 |\n| E | 0 | 0 |\n\nThe inspector must visit all 5 stops exactly once and return to depot A.\n\nOh, and when you send the route back, please follow this simple JSON shape so it's easy to check:\n\n{\n  \"solution\": [depot_id, location_id, ..., depot_id]\n}\n\nThis just means the answer should be a list: start at the depot, list each mailbox in the order you want them visited, and finish at the depot again. Think of each placeholder as the label you'll see in the instance input — it's just a little form showing the order, not the actual numbers or coordinates.\n\nThe JSON above is only a sketch of the expected shape, not the real route — replace the placeholders with the exact identifiers from the instance input.\n\nPlease use the identifiers exactly as they appear in the instance input — no renaming and no 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": [
      [
        86,
        100
      ],
      [
        100,
        91
      ],
      [
        27,
        20
      ],
      [
        30,
        74
      ],
      [
        0,
        0
      ]
    ],
    "solution": [
      0,
      1,
      2,
      4,
      3,
      0
    ],
    "obj": 293.66836738586426,
    "instance_variant": {
      "problem_type": "TSP",
      "num_nodes": 5,
      "nodes": [
        {
          "id": "A",
          "x": 86,
          "y": 100
        },
        {
          "id": "B",
          "x": 100,
          "y": 91
        },
        {
          "id": "C",
          "x": 27,
          "y": 20
        },
        {
          "id": "D",
          "x": 30,
          "y": 74
        },
        {
          "id": "E",
          "x": 0,
          "y": 0
        }
      ],
      "depot": "A"
    },
    "solution_variant": [
      "A",
      "B",
      "C",
      "E",
      "D",
      "A"
    ],
    "context_index": 40,
    "input_format": "markdown_table",
    "input_index_base": "names"
  },
  {
    "task_name": "TSP",
    "problem_type": "TSP",
    "instruction": "Someone on the team is figuring out which lawns the gardeners should hit first, second, third, etc., knowing the route must start at the equipment shed and finish there after visiting every customer’s garden once. The core choice is the visit order for the day. A cleaner plan is the one that results in the fewest miles on the van, measured by summing the distance between every pair of consecutive stops in the loop, including the return leg. Every customer must be included exactly once — no omissions, no double-dips. The concrete details are shown below.\n\n{\n  \"total_stops\": 5,\n  \"nodes\": [\n    {\n      \"location_id\": 0,\n      \"x_coord\": 97,\n      \"y_coord\": 100\n    },\n    {\n      \"location_id\": 1,\n      \"x_coord\": 5,\n      \"y_coord\": 0\n    },\n    {\n      \"location_id\": 2,\n      \"x_coord\": 0,\n      \"y_coord\": 34\n    },\n    {\n      \"location_id\": 3,\n      \"x_coord\": 97,\n      \"y_coord\": 0\n    },\n    {\n      \"location_id\": 4,\n      \"x_coord\": 100,\n      \"y_coord\": 40\n    }\n  ],\n  \"equipment_shed\": 0\n}\n\nWhen you reply with the planned route, please use this simple JSON shape so it's easy to parse:\n\n{\n  \"solution\": [depot_id, location_id, ..., depot_id]\n}\n\n\"solution\" is just the ordered list of stops for the day — start at the equipment shed (the depot), visit every garden once, and finish back at the shed. The placeholders (depot_id, location_id, etc.) stand in for the actual location identifiers from the instance. This is only a sketch of the expected shape, not the real answer.\n\nPlease make sure to use the identifiers exactly as they appear in the instance input — do not 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": [
      [
        97,
        100
      ],
      [
        5,
        0
      ],
      [
        0,
        34
      ],
      [
        97,
        0
      ],
      [
        100,
        40
      ]
    ],
    "solution": [
      0,
      2,
      1,
      3,
      4,
      0
    ],
    "obj": 343.87731170654297,
    "instance_variant": {
      "problem_type": "TSP",
      "num_nodes": 5,
      "nodes": [
        {
          "id": 0,
          "x": 97,
          "y": 100
        },
        {
          "id": 1,
          "x": 5,
          "y": 0
        },
        {
          "id": 2,
          "x": 0,
          "y": 34
        },
        {
          "id": 3,
          "x": 97,
          "y": 0
        },
        {
          "id": 4,
          "x": 100,
          "y": 40
        }
      ],
      "depot": 0
    },
    "solution_variant": [
      0,
      2,
      1,
      3,
      4,
      0
    ],
    "context_index": 41,
    "input_format": "json",
    "input_index_base": 0
  },
  {
    "task_name": "TSP",
    "problem_type": "TSP",
    "instruction": "Picture this: the municipal garage is the launch point for a sign inspection run that has to touch every sign exactly once and then come home, with no returning to any already-visited location. What’s being chosen is the visiting order, and the calm, sensible choice is the order that leads to the least total driving — the amount you’d get by adding up the distance between every consecutive stop on the tour. The detailed sign list and route data are shown below.\n\n{\n  \"total_locations\": 5,\n  \"nodes\": [\n    {\n      \"location_id\": \"A\",\n      \"x_coordinate\": 35,\n      \"y_coordinate\": 0\n    },\n    {\n      \"location_id\": \"B\",\n      \"x_coordinate\": 10,\n      \"y_coordinate\": 100\n    },\n    {\n      \"location_id\": \"C\",\n      \"x_coordinate\": 100,\n      \"y_coordinate\": 0\n    },\n    {\n      \"location_id\": \"D\",\n      \"x_coordinate\": 37,\n      \"y_coordinate\": 0\n    },\n    {\n      \"location_id\": \"E\",\n      \"x_coordinate\": 0,\n      \"y_coordinate\": 100\n    }\n  ],\n  \"garage_node_id\": \"A\"\n}\n\nAlso, when you hand the route back, just put it in this little JSON shape so it's easy to parse:\n\n{\n  \"solution\": [garage_id, sign_id, ..., garage_id]\n}\n\nThink of it like a simple form: \"solution\" is the ordered list of stops — start at the garage (garage_id), then each sign in the order you visit them (sign_id), and finally back to the garage. This is only a sketch of the expected shape, not the actual route.\n\nPlease use the exact identifiers from the instance input — 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": [
      [
        35,
        0
      ],
      [
        10,
        100
      ],
      [
        100,
        0
      ],
      [
        37,
        0
      ],
      [
        0,
        100
      ]
    ],
    "solution": [
      0,
      3,
      2,
      1,
      4,
      0
    ],
    "obj": 315.48433685302734,
    "instance_variant": {
      "problem_type": "TSP",
      "num_nodes": 5,
      "nodes": [
        {
          "id": "A",
          "x": 35,
          "y": 0
        },
        {
          "id": "B",
          "x": 10,
          "y": 100
        },
        {
          "id": "C",
          "x": 100,
          "y": 0
        },
        {
          "id": "D",
          "x": 37,
          "y": 0
        },
        {
          "id": "E",
          "x": 0,
          "y": 100
        }
      ],
      "depot": "A"
    },
    "solution_variant": [
      "A",
      "D",
      "C",
      "B",
      "E",
      "A"
    ],
    "context_index": 42,
    "input_format": "json",
    "input_index_base": "names"
  },
  {
    "task_name": "TSP",
    "problem_type": "TSP",
    "instruction": "Recently the festival team had to sort out how to restock all the stalls from one storage tent: the supplier must go out, visit each booth once to top up stock, and come straight back at the end. What counts as a smarter choice here is simply keeping the overall travel distance minimal — just add up the distances for each segment of the trip to see which route is shortest. The detailed booth coordinates and distances are provided below.\n\n{\n  \"total_locations\": 9,\n  \"nodes\": [\n    {\n      \"location_id\": 0,\n      \"x_coord\": 100,\n      \"y_coord\": 100\n    },\n    {\n      \"location_id\": 1,\n      \"x_coord\": 68,\n      \"y_coord\": 14\n    },\n    {\n      \"location_id\": 2,\n      \"x_coord\": 16,\n      \"y_coord\": 0\n    },\n    {\n      \"location_id\": 3,\n      \"x_coord\": 4,\n      \"y_coord\": 26\n    },\n    {\n      \"location_id\": 4,\n      \"x_coord\": 0,\n      \"y_coord\": 27\n    },\n    {\n      \"location_id\": 5,\n      \"x_coord\": 70,\n      \"y_coord\": 20\n    },\n    {\n      \"location_id\": 6,\n      \"x_coord\": 59,\n      \"y_coord\": 43\n    },\n    {\n      \"location_id\": 7,\n      \"x_coord\": 41,\n      \"y_coord\": 46\n    },\n    {\n      \"location_id\": 8,\n      \"x_coord\": 37,\n      \"y_coord\": 17\n    }\n  ],\n  \"storage_tent_id\": 0\n}\n\nAlso, when you send the route back, just stick to this simple JSON layout so it's easy to parse:\n\n{\n  \"solution\": [storage_tent_id, booth_id, ..., storage_tent_id]\n}\n\n\"solution\" is just the ordered list of stops: start at the storage tent, list each booth once in the order you’ll visit them, and finish back at the storage tent. Think of it like filling in a little form that says \"start here, then these booths, then back here.\"\n\nThis is only a sketch of the shape I expect, not the actual route — please fill it in with the exact identifiers from the instance input. All identifiers must be used exactly as they appear in the input — no renaming and 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": [
      [
        100,
        100
      ],
      [
        68,
        14
      ],
      [
        16,
        0
      ],
      [
        4,
        26
      ],
      [
        0,
        27
      ],
      [
        70,
        20
      ],
      [
        59,
        43
      ],
      [
        41,
        46
      ],
      [
        37,
        17
      ]
    ],
    "solution": [
      0,
      5,
      1,
      8,
      2,
      4,
      3,
      7,
      6,
      0
    ],
    "obj": 315.9574761390686,
    "instance_variant": {
      "problem_type": "TSP",
      "num_nodes": 9,
      "nodes": [
        {
          "id": 0,
          "x": 100,
          "y": 100
        },
        {
          "id": 1,
          "x": 68,
          "y": 14
        },
        {
          "id": 2,
          "x": 16,
          "y": 0
        },
        {
          "id": 3,
          "x": 4,
          "y": 26
        },
        {
          "id": 4,
          "x": 0,
          "y": 27
        },
        {
          "id": 5,
          "x": 70,
          "y": 20
        },
        {
          "id": 6,
          "x": 59,
          "y": 43
        },
        {
          "id": 7,
          "x": 41,
          "y": 46
        },
        {
          "id": 8,
          "x": 37,
          "y": 17
        }
      ],
      "depot": 0
    },
    "solution_variant": [
      0,
      5,
      1,
      8,
      2,
      4,
      3,
      7,
      6,
      0
    ],
    "context_index": 43,
    "input_format": "json",
    "input_index_base": 0
  },
  {
    "task_name": "TSP",
    "problem_type": "TSP",
    "instruction": "I’m picturing a bike courier leaving dispatch with a stack of pickup slips and a list of offices to visit. The job is to pick up from every office exactly once and come back to dispatch at the end, so the question is which order to ride in. A better plan is simply the one that makes the total ride shorter — add up the distances between each consecutive stop, including the ride back to dispatch, and that total should be as small as possible. Nothing can be skipped or visited twice. The concrete details will be shown below.\n\n{\n  \"total_stops_count\": 7,\n  \"nodes\": [\n    {\n      \"stop_id\": 0,\n      \"x_coord\": 100,\n      \"y_coord\": 35\n    },\n    {\n      \"stop_id\": 1,\n      \"x_coord\": 67,\n      \"y_coord\": 68\n    },\n    {\n      \"stop_id\": 2,\n      \"x_coord\": 2,\n      \"y_coord\": 81\n    },\n    {\n      \"stop_id\": 3,\n      \"x_coord\": 33,\n      \"y_coord\": 100\n    },\n    {\n      \"stop_id\": 4,\n      \"x_coord\": 48,\n      \"y_coord\": 59\n    },\n    {\n      \"stop_id\": 5,\n      \"x_coord\": 100,\n      \"y_coord\": 8\n    },\n    {\n      \"stop_id\": 6,\n      \"x_coord\": 0,\n      \"y_coord\": 0\n    }\n  ],\n  \"dispatch_id\": 0\n}\n\nWhile we're on the same page about what to return, it helps to have a tiny example of the shape I expect — just a simple JSON sketch that lists the stops in order. Something like this:\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, go visit each place once in the order shown, and finish back at the depot. This little block is just the form I want — it's a sketch of the shape, not the actual route.\n\nPlease make sure to use the exact identifiers from the problem 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": [
      [
        100,
        35
      ],
      [
        67,
        68
      ],
      [
        2,
        81
      ],
      [
        33,
        100
      ],
      [
        48,
        59
      ],
      [
        100,
        8
      ],
      [
        0,
        0
      ]
    ],
    "solution": [
      0,
      1,
      4,
      3,
      2,
      6,
      5,
      0
    ],
    "obj": 356.0541000366211,
    "instance_variant": {
      "problem_type": "TSP",
      "num_nodes": 7,
      "nodes": [
        {
          "id": 0,
          "x": 100,
          "y": 35
        },
        {
          "id": 1,
          "x": 67,
          "y": 68
        },
        {
          "id": 2,
          "x": 2,
          "y": 81
        },
        {
          "id": 3,
          "x": 33,
          "y": 100
        },
        {
          "id": 4,
          "x": 48,
          "y": 59
        },
        {
          "id": 5,
          "x": 100,
          "y": 8
        },
        {
          "id": 6,
          "x": 0,
          "y": 0
        }
      ],
      "depot": 0
    },
    "solution_variant": [
      0,
      1,
      4,
      3,
      2,
      6,
      5,
      0
    ],
    "context_index": 44,
    "input_format": "json",
    "input_index_base": 0
  },
  {
    "task_name": "TSP",
    "problem_type": "TSP",
    "instruction": "There’s a service van parked up that needs to go out, visit every client building one time, and then roll back to the lot — the trick is deciding in which order to visit them. The measure of success is straightforward: add up the distance traveled from stop to stop throughout the whole loop (including the return leg) and keep that total as low as you can. No building gets left out or visited twice. The concrete route details appear below.\n\n{\n  \"total_locations\": 9,\n  \"nodes\": [\n    {\n      \"location_id\": 1,\n      \"x_coord\": 8,\n      \"y_coord\": 42\n    },\n    {\n      \"location_id\": 2,\n      \"x_coord\": 8,\n      \"y_coord\": 32\n    },\n    {\n      \"location_id\": 3,\n      \"x_coord\": 4,\n      \"y_coord\": 58\n    },\n    {\n      \"location_id\": 4,\n      \"x_coord\": 86,\n      \"y_coord\": 58\n    },\n    {\n      \"location_id\": 5,\n      \"x_coord\": 9,\n      \"y_coord\": 42\n    },\n    {\n      \"location_id\": 6,\n      \"x_coord\": 0,\n      \"y_coord\": 0\n    },\n    {\n      \"location_id\": 7,\n      \"x_coord\": 100,\n      \"y_coord\": 57\n    },\n    {\n      \"location_id\": 8,\n      \"x_coord\": 82,\n      \"y_coord\": 64\n    },\n    {\n      \"location_id\": 9,\n      \"x_coord\": 83,\n      \"y_coord\": 100\n    }\n  ],\n  \"depot_id\": 1\n}\n\nAlso, when you send the final route back, just use a tiny JSON snippet like this so it’s easy to check:\n\n{\n  \"solution\": [depot_id, location_id, ..., depot_id]\n}\n\nThink of \"solution\" as the ordered list of stops the van will make — start at the depot, visit each client once, and come back to the depot. The JSON above is just a sketch of the shape I expect, not the actual route.\n\nPlease make sure all identifiers in that list match the instance input exactly — 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": [
      [
        8,
        42
      ],
      [
        8,
        32
      ],
      [
        4,
        58
      ],
      [
        86,
        58
      ],
      [
        9,
        42
      ],
      [
        0,
        0
      ],
      [
        100,
        57
      ],
      [
        82,
        64
      ],
      [
        83,
        100
      ]
    ],
    "solution": [
      0,
      2,
      8,
      6,
      3,
      7,
      5,
      1,
      4,
      0
    ],
    "obj": 321.50231742858887,
    "instance_variant": {
      "problem_type": "TSP",
      "num_nodes": 9,
      "nodes": [
        {
          "id": 1,
          "x": 8,
          "y": 42
        },
        {
          "id": 2,
          "x": 8,
          "y": 32
        },
        {
          "id": 3,
          "x": 4,
          "y": 58
        },
        {
          "id": 4,
          "x": 86,
          "y": 58
        },
        {
          "id": 5,
          "x": 9,
          "y": 42
        },
        {
          "id": 6,
          "x": 0,
          "y": 0
        },
        {
          "id": 7,
          "x": 100,
          "y": 57
        },
        {
          "id": 8,
          "x": 82,
          "y": 64
        },
        {
          "id": 9,
          "x": 83,
          "y": 100
        }
      ],
      "depot": 1
    },
    "solution_variant": [
      1,
      3,
      9,
      7,
      4,
      8,
      6,
      2,
      5,
      1
    ],
    "context_index": 45,
    "input_format": "json",
    "input_index_base": 1
  },
  {
    "task_name": "TSP",
    "problem_type": "TSP",
    "instruction": "Recently there’s been a request to craft a drive that starts and ends at the office, visiting each house on the showing list only once. The goal is simple in plain terms: pick the route with the smallest total miles, which you get by adding up the distances for each hop from one stop to the next and finally back to the office. Leave no house out and don’t circle back to any place. The detailed info is provided below.\n\n{\n  \"total_locations\": 8,\n  \"nodes\": [\n    {\n      \"stop_id\": 1,\n      \"x_coord\": 2,\n      \"y_coord\": 60\n    },\n    {\n      \"stop_id\": 2,\n      \"x_coord\": 78,\n      \"y_coord\": 100\n    },\n    {\n      \"stop_id\": 3,\n      \"x_coord\": 83,\n      \"y_coord\": 41\n    },\n    {\n      \"stop_id\": 4,\n      \"x_coord\": 28,\n      \"y_coord\": 0\n    },\n    {\n      \"stop_id\": 5,\n      \"x_coord\": 0,\n      \"y_coord\": 18\n    },\n    {\n      \"stop_id\": 6,\n      \"x_coord\": 100,\n      \"y_coord\": 66\n    },\n    {\n      \"stop_id\": 7,\n      \"x_coord\": 93,\n      \"y_coord\": 48\n    },\n    {\n      \"stop_id\": 8,\n      \"x_coord\": 30,\n      \"y_coord\": 80\n    }\n  ],\n  \"office_id\": 1\n}\n\nAlso, when you hand the route back, please use this simple JSON layout so it's easy to parse:\n\n{\n  \"solution\": [office_id, house_id, ..., office_id]\n}\n\nThink of this like a short form: \"solution\" holds the ordered list of stops for the drive — start at the office, go to each house on the list exactly once, and return to the office at the end. The names in the array are just placeholders showing the shape I expect; replace them with the actual stop identifiers from the instance when you give the real route.\n\nThis JSON is only a sketch of the expected shape, not the actual answer. Please make sure to use the exact identifiers from the instance input — do not 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": [
      [
        2,
        60
      ],
      [
        78,
        100
      ],
      [
        83,
        41
      ],
      [
        28,
        0
      ],
      [
        0,
        18
      ],
      [
        100,
        66
      ],
      [
        93,
        48
      ],
      [
        30,
        80
      ]
    ],
    "solution": [
      0,
      4,
      3,
      2,
      6,
      5,
      1,
      7,
      0
    ],
    "obj": 302.3604917526245,
    "instance_variant": {
      "problem_type": "TSP",
      "num_nodes": 8,
      "nodes": [
        {
          "id": 1,
          "x": 2,
          "y": 60
        },
        {
          "id": 2,
          "x": 78,
          "y": 100
        },
        {
          "id": 3,
          "x": 83,
          "y": 41
        },
        {
          "id": 4,
          "x": 28,
          "y": 0
        },
        {
          "id": 5,
          "x": 0,
          "y": 18
        },
        {
          "id": 6,
          "x": 100,
          "y": 66
        },
        {
          "id": 7,
          "x": 93,
          "y": 48
        },
        {
          "id": 8,
          "x": 30,
          "y": 80
        }
      ],
      "depot": 1
    },
    "solution_variant": [
      1,
      5,
      4,
      3,
      7,
      6,
      2,
      8,
      1
    ],
    "context_index": 46,
    "input_format": "json",
    "input_index_base": 1
  },
  {
    "task_name": "TSP",
    "problem_type": "TSP",
    "instruction": "On a busy morning the shop wants a single circular run: the rider leaves the shop, stops at every delivery address one time only, and then rides back to the shop. Choosing the route means picking the sequence of stops; every address must be covered exactly once and cannot be revisited. The simplest way to tell which sequence is best is to add together the distances of all the legs between stops (don’t forget the return leg) and go with the sequence that gives the smallest total distance. The concrete stop list and coordinates follow below.\n\nThe list contains 7 locations, with the shop as node 1.\n\n| stop_id | x_coord | y_coord |\n|---|---|---|\n| 1 | 54 | 0 |\n| 2 | 12 | 83 |\n| 3 | 100 | 0 |\n| 4 | 44 | 23 |\n| 5 | 76 | 29 |\n| 6 | 19 | 52 |\n| 7 | 0 | 100 |\n\nCompute straight-line distances between these 7 stops (starting and ending at node 1) to determine the shortest circular route.\n\nIf you'd like the route in a simple, machine-friendly form, you can return it in this little JSON sketch:\n\n{\n  \"solution\": [shop_id, stop_id, ..., shop_id]\n}\n\nThink of \"solution\" as just the list of stops in order: start at the shop, visit every delivery once, and come back to the shop at the end. The placeholders above just show the shape — you'll replace them with the actual stop identifiers from the instance.\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": [
      [
        54,
        0
      ],
      [
        12,
        83
      ],
      [
        100,
        0
      ],
      [
        44,
        23
      ],
      [
        76,
        29
      ],
      [
        19,
        52
      ],
      [
        0,
        100
      ]
    ],
    "solution": [
      0,
      2,
      4,
      6,
      1,
      5,
      3,
      0
    ],
    "obj": 303.6052665710449,
    "instance_variant": {
      "problem_type": "TSP",
      "num_nodes": 7,
      "nodes": [
        {
          "id": 1,
          "x": 54,
          "y": 0
        },
        {
          "id": 2,
          "x": 12,
          "y": 83
        },
        {
          "id": 3,
          "x": 100,
          "y": 0
        },
        {
          "id": 4,
          "x": 44,
          "y": 23
        },
        {
          "id": 5,
          "x": 76,
          "y": 29
        },
        {
          "id": 6,
          "x": 19,
          "y": 52
        },
        {
          "id": 7,
          "x": 0,
          "y": 100
        }
      ],
      "depot": 1
    },
    "solution_variant": [
      1,
      3,
      5,
      7,
      2,
      6,
      4,
      1
    ],
    "context_index": 47,
    "input_format": "markdown_table",
    "input_index_base": 1
  },
  {
    "task_name": "TSP",
    "problem_type": "TSP",
    "instruction": "Back when the shoot schedule was being mapped out, the brief said to start at the studio, visit each selected landmark a single time for photos, and come back to base. What makes one itinerary better than another is how little you end up driving; tally the distances between consecutive stops and the route with the smallest total is the one to pick. No repeats or omissions are allowed. The full set of landmark details is provided below.\n\n{\n  \"total_stops\": 8,\n  \"nodes\": [\n    {\n      \"stop_id\": 1,\n      \"x_coordinate\": 0,\n      \"y_coordinate\": 26\n    },\n    {\n      \"stop_id\": 2,\n      \"x_coordinate\": 22,\n      \"y_coordinate\": 100\n    },\n    {\n      \"stop_id\": 3,\n      \"x_coordinate\": 43,\n      \"y_coordinate\": 52\n    },\n    {\n      \"stop_id\": 4,\n      \"x_coordinate\": 48,\n      \"y_coordinate\": 43\n    },\n    {\n      \"stop_id\": 5,\n      \"x_coordinate\": 39,\n      \"y_coordinate\": 78\n    },\n    {\n      \"stop_id\": 6,\n      \"x_coordinate\": 74,\n      \"y_coordinate\": 91\n    },\n    {\n      \"stop_id\": 7,\n      \"x_coordinate\": 48,\n      \"y_coordinate\": 70\n    },\n    {\n      \"stop_id\": 8,\n      \"x_coordinate\": 100,\n      \"y_coordinate\": 0\n    }\n  ],\n  \"studio_node_id\": 1\n}\n\nWhen you send back the planned route, just use this little JSON layout so it's easy to read and parse:\n\n{\n  \"solution\": [studio_id, landmark_id, ..., studio_id]\n}\n\nThis just shows the order of stops: start at the studio_id, visit each landmark_id once in the listed sequence, and return to the studio_id at the end. It's a sketch of the shape I want — not the actual route yet.\n\nPlease make sure to use the exact identifiers from the instance input — don't rename them or make up 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": [
      [
        0,
        26
      ],
      [
        22,
        100
      ],
      [
        43,
        52
      ],
      [
        48,
        43
      ],
      [
        39,
        78
      ],
      [
        74,
        91
      ],
      [
        48,
        70
      ],
      [
        100,
        0
      ]
    ],
    "solution": [
      0,
      3,
      2,
      6,
      4,
      1,
      5,
      7,
      0
    ],
    "obj": 370.48240661621094,
    "instance_variant": {
      "problem_type": "TSP",
      "num_nodes": 8,
      "nodes": [
        {
          "id": 1,
          "x": 0,
          "y": 26
        },
        {
          "id": 2,
          "x": 22,
          "y": 100
        },
        {
          "id": 3,
          "x": 43,
          "y": 52
        },
        {
          "id": 4,
          "x": 48,
          "y": 43
        },
        {
          "id": 5,
          "x": 39,
          "y": 78
        },
        {
          "id": 6,
          "x": 74,
          "y": 91
        },
        {
          "id": 7,
          "x": 48,
          "y": 70
        },
        {
          "id": 8,
          "x": 100,
          "y": 0
        }
      ],
      "depot": 1
    },
    "solution_variant": [
      1,
      4,
      3,
      7,
      5,
      2,
      6,
      8,
      1
    ],
    "context_index": 48,
    "input_format": "json",
    "input_index_base": 1
  },
  {
    "task_name": "TSP",
    "problem_type": "TSP",
    "instruction": "Recently the service team needed a single-route plan: the truck should roll out from the depot, go to each customer once, and finish back at the depot. The choice to make is the sequence of customers; the most efficient sequence is the one that keeps the total driving distance as low as possible — that total is the sum of all the individual legs between stops, counting the trip home — and no address can be skipped or visited more than once. The concrete numbers and locations appear below.\n\n{\n  \"total_stops\": 5,\n  \"nodes\": [\n    {\n      \"stop_id\": 0,\n      \"x_coord\": 62,\n      \"y_coord\": 84\n    },\n    {\n      \"stop_id\": 1,\n      \"x_coord\": 77,\n      \"y_coord\": 51\n    },\n    {\n      \"stop_id\": 2,\n      \"x_coord\": 0,\n      \"y_coord\": 62\n    },\n    {\n      \"stop_id\": 3,\n      \"x_coord\": 5,\n      \"y_coord\": 100\n    },\n    {\n      \"stop_id\": 4,\n      \"x_coord\": 100,\n      \"y_coord\": 0\n    }\n  ],\n  \"depot_node\": 0\n}\n\nOh, and when you send the final route back, please use this simple JSON layout so it's easy to parse:\n\n{\n  \"solution\": [depot_id, location_id, ..., depot_id]\n}\n\nThis just sketches the shape I need: \"solution\" is the ordered list of stops — start at the depot, list each customer in the order they should be visited, and finish at the depot again. The placeholders in the array are just that, placeholders showing the type of identifier I expect; this block is an example of the format, not the actual route.\n\nPlease be sure to use the identifiers exactly as they appear in 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": [
      [
        62,
        84
      ],
      [
        77,
        51
      ],
      [
        0,
        62
      ],
      [
        5,
        100
      ],
      [
        100,
        0
      ]
    ],
    "solution": [
      0,
      1,
      4,
      2,
      3,
      0
    ],
    "obj": 307.3866500854492,
    "instance_variant": {
      "problem_type": "TSP",
      "num_nodes": 5,
      "nodes": [
        {
          "id": 0,
          "x": 62,
          "y": 84
        },
        {
          "id": 1,
          "x": 77,
          "y": 51
        },
        {
          "id": 2,
          "x": 0,
          "y": 62
        },
        {
          "id": 3,
          "x": 5,
          "y": 100
        },
        {
          "id": 4,
          "x": 100,
          "y": 0
        }
      ],
      "depot": 0
    },
    "solution_variant": [
      0,
      1,
      4,
      2,
      3,
      0
    ],
    "context_index": 49,
    "input_format": "json",
    "input_index_base": 0
  },
  {
    "task_name": "TSP",
    "problem_type": "TSP",
    "instruction": "There’s a little plan to stroll from the flat, swing by several public squares, and return home without doubling back on any square. The choice to make is which square to go to next each time. What makes one plan better than another is simply the total distance walked — add up each segment of the walk (home to first square, each square-to-square walk, and last square back to home) and pick the plan with the smallest sum. Every listed square needs to be visited once and only once, and the walk must start and finish at the apartment. The concrete details are shown below.\n\n{\n  \"total_locations_count\": 6,\n  \"nodes\": [\n    {\n      \"location_id\": \"A\",\n      \"x_coordinate\": 91,\n      \"y_coordinate\": 6\n    },\n    {\n      \"location_id\": \"B\",\n      \"x_coordinate\": 12,\n      \"y_coordinate\": 59\n    },\n    {\n      \"location_id\": \"C\",\n      \"x_coordinate\": 80,\n      \"y_coordinate\": 68\n    },\n    {\n      \"location_id\": \"D\",\n      \"x_coordinate\": 12,\n      \"y_coordinate\": 0\n    },\n    {\n      \"location_id\": \"E\",\n      \"x_coordinate\": 0,\n      \"y_coordinate\": 100\n    },\n    {\n      \"location_id\": \"F\",\n      \"x_coordinate\": 100,\n      \"y_coordinate\": 12\n    }\n  ],\n  \"apartment_id\": \"A\"\n}\n\nOh, and when you send the route back, just use this simple JSON layout so it's easy to read and use:\n\n{\n  \"solution\": [home_id, square_id, ..., home_id]\n}\n\nHere \"solution\" is just the ordered list of places in the walk: start at the apartment (home_id), hit each public square (square_id) once in the order shown, and finish back at the apartment (home_id). It's just a sketch of the shape I expect — not the actual route.\n\nPlease use the identifiers 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": [
      [
        91,
        6
      ],
      [
        12,
        59
      ],
      [
        80,
        68
      ],
      [
        12,
        0
      ],
      [
        0,
        100
      ],
      [
        100,
        12
      ]
    ],
    "solution": [
      0,
      3,
      1,
      4,
      2,
      5,
      0
    ],
    "obj": 337.39110946655273,
    "instance_variant": {
      "problem_type": "TSP",
      "num_nodes": 6,
      "nodes": [
        {
          "id": "A",
          "x": 91,
          "y": 6
        },
        {
          "id": "B",
          "x": 12,
          "y": 59
        },
        {
          "id": "C",
          "x": 80,
          "y": 68
        },
        {
          "id": "D",
          "x": 12,
          "y": 0
        },
        {
          "id": "E",
          "x": 0,
          "y": 100
        },
        {
          "id": "F",
          "x": 100,
          "y": 12
        }
      ],
      "depot": "A"
    },
    "solution_variant": [
      "A",
      "D",
      "B",
      "E",
      "C",
      "F",
      "A"
    ],
    "context_index": 50,
    "input_format": "json",
    "input_index_base": "names"
  }
]