task_name,problem_type,instruction,instance,solution,obj,instance_variant,solution_variant,context_index,input_format,input_index_base
PMED,PMED,"Recently the city discussed which handful of public restrooms to put into service from several candidate points. The task is to pick that exact number of sites and assign each neighborhood to one, and only one, of them so that when all the walking distances are added up the total is as low as possible. The detailed list of neighborhoods, candidate sites, and distances is provided below.

# total_candidate_locations=5
# num_restrooms_to_activate=1
# location_ids=1, 2, 3, 4, 5
origin_location_id,destination_location_id,walking_distance
1,2,153
1,3,199
1,4,108
1,5,116
2,1,153
2,3,46
2,4,165
2,5,37
3,1,199
3,2,46
3,4,211
3,5,83
4,1,108
4,2,165
4,3,211
4,5,128
5,1,116
5,2,37
5,3,83
5,4,128

When you send the final plan, please use this simple JSON layout so it's easy to check and compare:

{
  ""solution"": {
    ""selected"": [<site_to_open>, <site_to_open>, ...],
    ""assignments"": [<chosen_open_site>, <chosen_open_site>, ...]
  }
}

This little sketch means: ""selected"" is the list of the sites we decide to open, and ""assignments"" lists, for each neighborhood in the same order as the input, which opened site that neighborhood will use. It's just the shape I need — a friendly form, not the actual answer yet.

Please make sure every identifier you put in there exactly matches the ones in the instance input — do not rename them or invent new labels.
- for example: ""Valid identifiers look like plain numbers such as “1” or “23”, single capital letters like “A” or “B”, or a capital letter followed by digits like “A1” or “X7”.""","{'distance_matrix': [[0, 153, 199, 108, 116], [153, 0, 46, 165, 37], [199, 46, 0, 211, 83], [108, 165, 211, 0, 128], [116, 37, 83, 128, 0]], 'p': 1, 'objective': 364.0}","{'facilities': [4], 'assignments': [4, 4, 4, 4, 4]}",364.0,"{'problem_type': 'PMED', 'num_nodes': 5, 'num_open': 1, 'sites': [{'id': 1, 'distances': {1: 0, 2: 153, 3: 199, 4: 108, 5: 116}}, {'id': 2, 'distances': {1: 153, 2: 0, 3: 46, 4: 165, 5: 37}}, {'id': 3, 'distances': {1: 199, 2: 46, 3: 0, 4: 211, 5: 83}}, {'id': 4, 'distances': {1: 108, 2: 165, 3: 211, 4: 0, 5: 128}}, {'id': 5, 'distances': {1: 116, 2: 37, 3: 83, 4: 128, 5: 0}}], 'objective': 364.0}","{'selected': [5], 'assignments': [5, 5, 5, 5, 5]}",1,csv,1
PMED,PMED,"There’s a scheduling headache at the coffee chain: pick a certain number of sites to operate as cafés from a list of candidates, make sure every customer area is assigned to exactly one of those open spots, and prefer the arrangement that keeps the total travel for everyone smallest — that total is simply the sum of each area’s distance to whatever café serves it. The specific locations, pairwise distances, and how many cafés to open are given below.

Here are the details for 5 candidate sites — open exactly 1 cafés, with site identifiers A, B, C, D, E.
From customer area A to candidate café B: travel distance 17.
From customer area A to candidate café C: travel distance 33.
From customer area A to candidate café D: travel distance 23.
From customer area A to candidate café E: travel distance 31.
From customer area B to candidate café A: travel distance 17.
From customer area B to candidate café C: travel distance 25.
From customer area B to candidate café D: travel distance 10.
From customer area B to candidate café E: travel distance 29.
From customer area C to candidate café A: travel distance 33.
From customer area C to candidate café B: travel distance 25.
From customer area C to candidate café D: travel distance 27.
From customer area C to candidate café E: travel distance 34.
From customer area D to candidate café A: travel distance 23.
From customer area D to candidate café B: travel distance 10.
From customer area D to candidate café C: travel distance 27.
From customer area D to candidate café E: travel distance 25.
From customer area E to candidate café A: travel distance 31.
From customer area E to candidate café B: travel distance 29.
From customer area E to candidate café C: travel distance 34.
From customer area E to candidate café D: travel distance 25.
Use these pairwise distances to choose which 1 cafés to open among the 5 sites and assign every area to one open café to minimize total travel.

Oh, and when you send the final answer, please stick to this simple JSON layout so I can read it automatically:

{
  ""solution"": {
    ""selected"": [<site_to_open>, <site_to_open>, ...],
    ""assignments"": [<assigned_open_site>, <assigned_open_site>, ...]
  }
}

This just sketches the shape I need: ""selected"" is the list of sites you decide to open, and ""assignments"" says, for each location in the original order, which open site serves it. It's just a template — not the final plan.

Also, please 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”.","{'distance_matrix': [[0, 17, 33, 23, 31], [17, 0, 25, 10, 29], [33, 25, 0, 27, 34], [23, 10, 27, 0, 25], [31, 29, 34, 25, 0]], 'p': 1, 'objective': 81.0}","{'facilities': [1], 'assignments': [1, 1, 1, 1, 1]}",81.0,"{'problem_type': 'PMED', 'num_nodes': 5, 'num_open': 1, 'sites': [{'id': 'A', 'distances': {'A': 0, 'B': 17, 'C': 33, 'D': 23, 'E': 31}}, {'id': 'B', 'distances': {'A': 17, 'B': 0, 'C': 25, 'D': 10, 'E': 29}}, {'id': 'C', 'distances': {'A': 33, 'B': 25, 'C': 0, 'D': 27, 'E': 34}}, {'id': 'D', 'distances': {'A': 23, 'B': 10, 'C': 27, 'D': 0, 'E': 25}}, {'id': 'E', 'distances': {'A': 31, 'B': 29, 'C': 34, 'D': 25, 'E': 0}}], 'objective': 81.0}","{'selected': ['B'], 'assignments': ['B', 'B', 'B', 'B', 'B']}",2,markdown_table,names
PMED,PMED,"Recently the housing office talked about installing a set number of quiet pods and assigning every dorm block to one of them so students walk as little as possible. A plan is judged by the total distance students would travel — you get that by adding the distance from each dorm block to its assigned pod — and the aim is to make that sum as small as possible. No dorm block can be left out or split across multiple pods. The full data and distances are shown below.

Below are 5 candidate locations A, B, C, D, E and the pairwise walking distances, so you can select exactly 2 pod sites.
From A to B, the walking distance is 12.
From A to C, the walking distance is 57.
From A to D, the walking distance is 57.
From A to E, the walking distance is 38.
From B to A, the walking distance is 12.
From B to C, the walking distance is 45.
From B to D, the walking distance is 57.
From B to E, the walking distance is 26.
From C to A, the walking distance is 57.
From C to B, the walking distance is 45.
From C to D, the walking distance is 66.
From C to E, the walking distance is 51.
From D to A, the walking distance is 57.
From D to B, the walking distance is 57.
From D to C, the walking distance is 66.
From D to E, the walking distance is 63.
From E to A, the walking distance is 38.
From E to B, the walking distance is 26.
From E to C, the walking distance is 51.
From E to D, the walking distance is 63.
Use these distances to compute the total walking distance and pick the 2 pod locations that minimize it.

If you want to hand me a plan, just stick to this simple JSON shape — nothing fancy, just a tidy way to show which pods are opened and which pod each dorm is assigned to.

{
  ""solution"": {
    ""selected"": [<pod_to_open>, <pod_to_open>, ...],
    ""assignments"": [<assigned_pod>, <assigned_pod>, ...]
  }
}

Pretty straightforward: ""selected"" lists the pod locations you choose to open, and ""assignments"" lists, for each dorm block (in the same order as the input), which opened pod that dorm would use. Think of it like filling out a short form—this block is just a sketch of the expected shape, not the actual final plan.

Please remember: use the exact identifiers from the instance input — do not rename or invent 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”.""","{'distance_matrix': [[0, 12, 57, 57, 38], [12, 0, 45, 57, 26], [57, 45, 0, 66, 51], [57, 57, 66, 0, 63], [38, 26, 51, 63, 0]], 'p': 2, 'objective': 83.0}","{'facilities': [1, 3], 'assignments': [1, 1, 1, 3, 1]}",83.0,"{'problem_type': 'PMED', 'num_nodes': 5, 'num_open': 2, 'sites': [{'id': 'A', 'distances': {'A': 0, 'B': 12, 'C': 57, 'D': 57, 'E': 38}}, {'id': 'B', 'distances': {'A': 12, 'B': 0, 'C': 45, 'D': 57, 'E': 26}}, {'id': 'C', 'distances': {'A': 57, 'B': 45, 'C': 0, 'D': 66, 'E': 51}}, {'id': 'D', 'distances': {'A': 57, 'B': 57, 'C': 66, 'D': 0, 'E': 63}}, {'id': 'E', 'distances': {'A': 38, 'B': 26, 'C': 51, 'D': 63, 'E': 0}}], 'objective': 83.0}","{'selected': ['B', 'D'], 'assignments': ['B', 'B', 'B', 'D', 'B']}",3,nl,names
PMED,PMED,"There's a logistics puzzle at work: from a bunch of possible locker locations pick a fixed number to actually open, and then attach every delivery address to one of those open lockers. One solution beats another if, when you sum up how far all couriers must travel from addresses to their assigned lockers, that grand total is lower. Every address must be assigned to exactly one open locker — no address left out and no address sent to two lockers. The specific candidate sites and distances are shown below.

The instance lists 8 locations; you must open 1 lockers, and the location identifiers are A, B, C, D, E, F, G, H.
Travel distance from A to B is 37.
Travel distance from A to C is 52.
Travel distance from A to D is 56.
Travel distance from A to E is 40.
Travel distance from A to F is 57.
Travel distance from A to G is 57.
Travel distance from A to H is 37.
Travel distance from B to A is 37.
Travel distance from B to C is 40.
Travel distance from B to D is 38.
Travel distance from B to E is 24.
Travel distance from B to F is 40.
Travel distance from B to G is 49.
Travel distance from B to H is 34.
Travel distance from C to A is 52.
Travel distance from C to B is 40.
Travel distance from C to D is 45.
Travel distance from C to E is 31.
Travel distance from C to F is 45.
Travel distance from C to G is 61.
Travel distance from C to H is 20.
Travel distance from D to A is 56.
Travel distance from D to B is 38.
Travel distance from D to C is 45.
Travel distance from D to E is 26.
Travel distance from D to F is 28.
Travel distance from D to G is 59.
Travel distance from D to H is 36.
Travel distance from E to A is 40.
Travel distance from E to B is 24.
Travel distance from E to C is 31.
Travel distance from E to D is 26.
Travel distance from E to F is 28.
Travel distance from E to G is 40.
Travel distance from E to H is 22.
Travel distance from F to A is 57.
Travel distance from F to B is 40.
Travel distance from F to C is 45.
Travel distance from F to D is 28.
Travel distance from F to E is 28.
Travel distance from F to G is 61.
Travel distance from F to H is 38.
Travel distance from G to A is 57.
Travel distance from G to B is 49.
Travel distance from G to C is 61.
Travel distance from G to D is 59.
Travel distance from G to E is 40.
Travel distance from G to F is 61.
Travel distance from G to H is 48.
Travel distance from H to A is 37.
Travel distance from H to B is 34.
Travel distance from H to C is 20.
Travel distance from H to D is 36.
Travel distance from H to E is 22.
Travel distance from H to F is 38.
Travel distance from H to G is 48.
Use these pairwise distances to compute the total courier travel for any choice of 1 lockers.

Just so we're on the same page, please reply using a little JSON sketch that shows which sites you open and, for every address, which open site it gets attached to. Something like this:

{
  ""solution"": {
    ""selected"": [<site_to_open>, <site_to_open>, ...],
    ""assignments"": [<chosen_open_site>, <chosen_open_site>, ...]
  }
}

""selected"" is the list of sites you decide to open (use the same identifiers from the instance). ""assignments"" is parallel to the address list in the instance: for each address, put the identifier of the open site it's assigned to. This is just the shape I want — not the real answer yet.

Also please remember: use the exact identifiers as they appear in the input — do not rename them or invent new labels. Valid identifiers look like plain numbers such as “1” or “23”, single capital letters like “A” or “B”, or a capital letter followed by digits like “A1” or “X7”.","{'distance_matrix': [[0, 37, 52, 56, 40, 57, 57, 37], [37, 0, 40, 38, 24, 40, 49, 34], [52, 40, 0, 45, 31, 45, 61, 20], [56, 38, 45, 0, 26, 28, 59, 36], [40, 24, 31, 26, 0, 28, 40, 22], [57, 40, 45, 28, 28, 0, 61, 38], [57, 49, 61, 59, 40, 61, 0, 48], [37, 34, 20, 36, 22, 38, 48, 0]], 'p': 1, 'objective': 211.0}","{'facilities': [4], 'assignments': [4, 4, 4, 4, 4, 4, 4, 4]}",211.0,"{'problem_type': 'PMED', 'num_nodes': 8, 'num_open': 1, 'sites': [{'id': 'A', 'distances': {'A': 0, 'B': 37, 'C': 52, 'D': 56, 'E': 40, 'F': 57, 'G': 57, 'H': 37}}, {'id': 'B', 'distances': {'A': 37, 'B': 0, 'C': 40, 'D': 38, 'E': 24, 'F': 40, 'G': 49, 'H': 34}}, {'id': 'C', 'distances': {'A': 52, 'B': 40, 'C': 0, 'D': 45, 'E': 31, 'F': 45, 'G': 61, 'H': 20}}, {'id': 'D', 'distances': {'A': 56, 'B': 38, 'C': 45, 'D': 0, 'E': 26, 'F': 28, 'G': 59, 'H': 36}}, {'id': 'E', 'distances': {'A': 40, 'B': 24, 'C': 31, 'D': 26, 'E': 0, 'F': 28, 'G': 40, 'H': 22}}, {'id': 'F', 'distances': {'A': 57, 'B': 40, 'C': 45, 'D': 28, 'E': 28, 'F': 0, 'G': 61, 'H': 38}}, {'id': 'G', 'distances': {'A': 57, 'B': 49, 'C': 61, 'D': 59, 'E': 40, 'F': 61, 'G': 0, 'H': 48}}, {'id': 'H', 'distances': {'A': 37, 'B': 34, 'C': 20, 'D': 36, 'E': 22, 'F': 38, 'G': 48, 'H': 0}}], 'objective': 211.0}","{'selected': ['E'], 'assignments': ['E', 'E', 'E', 'E', 'E', 'E', 'E', 'E']}",4,nl,names
PMED,PMED,"Around here the food bank coordinator must decide which fixed number of proposed sites will become distribution hubs. Every client area gets assigned to exactly one of the opened hubs — nothing can be split or skipped — and choices are judged by total travel distance: sum the distances from each area to its assigned hub, and the smaller that total, the better the setup. The concrete list of potential sites and their distances appears below.

{
  ""total_proposed_sites"": 7,
  ""num_hubs_to_open"": 1,
  ""site_identifiers"": [
    ""A"",
    ""B"",
    ""C"",
    ""D"",
    ""E"",
    ""F"",
    ""G""
  ],
  ""data"": [
    {
      ""origin_site_id"": ""A"",
      ""destination_site_id"": ""B"",
      ""travel_distance"": 43
    },
    {
      ""origin_site_id"": ""A"",
      ""destination_site_id"": ""C"",
      ""travel_distance"": 57
    },
    {
      ""origin_site_id"": ""A"",
      ""destination_site_id"": ""D"",
      ""travel_distance"": 57
    },
    {
      ""origin_site_id"": ""A"",
      ""destination_site_id"": ""E"",
      ""travel_distance"": 30
    },
    {
      ""origin_site_id"": ""A"",
      ""destination_site_id"": ""F"",
      ""travel_distance"": 40
    },
    {
      ""origin_site_id"": ""A"",
      ""destination_site_id"": ""G"",
      ""travel_distance"": 37
    },
    {
      ""origin_site_id"": ""B"",
      ""destination_site_id"": ""A"",
      ""travel_distance"": 43
    },
    {
      ""origin_site_id"": ""B"",
      ""destination_site_id"": ""C"",
      ""travel_distance"": 44
    },
    {
      ""origin_site_id"": ""B"",
      ""destination_site_id"": ""D"",
      ""travel_distance"": 46
    },
    {
      ""origin_site_id"": ""B"",
      ""destination_site_id"": ""E"",
      ""travel_distance"": 28
    },
    {
      ""origin_site_id"": ""B"",
      ""destination_site_id"": ""F"",
      ""travel_distance"": 22
    },
    {
      ""origin_site_id"": ""B"",
      ""destination_site_id"": ""G"",
      ""travel_distance"": 52
    },
    {
      ""origin_site_id"": ""C"",
      ""destination_site_id"": ""A"",
      ""travel_distance"": 57
    },
    {
      ""origin_site_id"": ""C"",
      ""destination_site_id"": ""B"",
      ""travel_distance"": 44
    },
    {
      ""origin_site_id"": ""C"",
      ""destination_site_id"": ""D"",
      ""travel_distance"": 53
    },
    {
      ""origin_site_id"": ""C"",
      ""destination_site_id"": ""E"",
      ""travel_distance"": 50
    },
    {
      ""origin_site_id"": ""C"",
      ""destination_site_id"": ""F"",
      ""travel_distance"": 28
    },
    {
      ""origin_site_id"": ""C"",
      ""destination_site_id"": ""G"",
      ""travel_distance"": 60
    },
    {
      ""origin_site_id"": ""D"",
      ""destination_site_id"": ""A"",
      ""travel_distance"": 57
    },
    {
      ""origin_site_id"": ""D"",
      ""destination_site_id"": ""B"",
      ""travel_distance"": 46
    },
    {
      ""origin_site_id"": ""D"",
      ""destination_site_id"": ""C"",
      ""travel_distance"": 53
    },
    {
      ""origin_site_id"": ""D"",
      ""destination_site_id"": ""E"",
      ""travel_distance"": 35
    },
    {
      ""origin_site_id"": ""D"",
      ""destination_site_id"": ""F"",
      ""travel_distance"": 33
    },
    {
      ""origin_site_id"": ""D"",
      ""destination_site_id"": ""G"",
      ""travel_distance"": 59
    },
    {
      ""origin_site_id"": ""E"",
      ""destination_site_id"": ""A"",
      ""travel_distance"": 30
    },
    {
      ""origin_site_id"": ""E"",
      ""destination_site_id"": ""B"",
      ""travel_distance"": 28
    },
    {
      ""origin_site_id"": ""E"",
      ""destination_site_id"": ""C"",
      ""travel_distance"": 50
    },
    {
      ""origin_site_id"": ""E"",
      ""destination_site_id"": ""D"",
      ""travel_distance"": 35
    },
    {
      ""origin_site_id"": ""E"",
      ""destination_site_id"": ""F"",
      ""travel_distance"": 27
    },
    {
      ""origin_site_id"": ""E"",
      ""destination_site_id"": ""G"",
      ""travel_distance"": 41
    },
    {
      ""origin_site_id"": ""F"",
      ""destination_site_id"": ""A"",
      ""travel_distance"": 40
    },
    {
      ""origin_site_id"": ""F"",
      ""destination_site_id"": ""B"",
      ""travel_distance"": 22
    },
    {
      ""origin_site_id"": ""F"",
      ""destination_site_id"": ""C"",
      ""travel_distance"": 28
    },
    {
      ""origin_site_id"": ""F"",
      ""destination_site_id"": ""D"",
      ""travel_distance"": 33
    },
    {
      ""origin_site_id"": ""F"",
      ""destination_site_id"": ""E"",
      ""travel_distance"": 27
    },
    {
      ""origin_site_id"": ""F"",
      ""destination_site_id"": ""G"",
      ""travel_distance"": 32
    },
    {
      ""origin_site_id"": ""G"",
      ""destination_site_id"": ""A"",
      ""travel_distance"": 37
    },
    {
      ""origin_site_id"": ""G"",
      ""destination_site_id"": ""B"",
      ""travel_distance"": 52
    },
    {
      ""origin_site_id"": ""G"",
      ""destination_site_id"": ""C"",
      ""travel_distance"": 60
    },
    {
      ""origin_site_id"": ""G"",
      ""destination_site_id"": ""D"",
      ""travel_distance"": 59
    },
    {
      ""origin_site_id"": ""G"",
      ""destination_site_id"": ""E"",
      ""travel_distance"": 41
    },
    {
      ""origin_site_id"": ""G"",
      ""destination_site_id"": ""F"",
      ""travel_distance"": 32
    }
  ]
}

I'll just mention casually how I’d like the final reply packaged — a small JSON outline to make things easy to read and parse:

{
  ""solution"": {
    ""selected"": [<site_to_open>, <site_to_open>, ...],
    ""assignments"": [<assigned_site>, <assigned_site>, ...]
  }
}

""selected"" is where you list the proposed sites you decide to open (those are the hub locations). ""assignments"" is a list that picks, for each client area in the same order they appear in the instance, which opened site it gets assigned to. Think of it like filling out a simple form: pick the open hubs, then say which hub each area goes to.

This JSON is just a sketch of the shape I expect, not the actual solution values.

Please be careful to use the exact identifiers given in the instance input — do not rename them or invent new labels. 
- for example: ""Valid identifiers look like plain numbers such as “1” or “23”, single capital letters like “A” or “B”, or a capital letter followed by digits like “A1” or “X7”.""","{'distance_matrix': [[0, 43, 57, 57, 30, 40, 37], [43, 0, 44, 46, 28, 22, 52], [57, 44, 0, 53, 50, 28, 60], [57, 46, 53, 0, 35, 33, 59], [30, 28, 50, 35, 0, 27, 41], [40, 22, 28, 33, 27, 0, 32], [37, 52, 60, 59, 41, 32, 0]], 'p': 1, 'objective': 182.0}","{'facilities': [5], 'assignments': [5, 5, 5, 5, 5, 5, 5]}",182.0,"{'problem_type': 'PMED', 'num_nodes': 7, 'num_open': 1, 'sites': [{'id': 'A', 'distances': {'A': 0, 'B': 43, 'C': 57, 'D': 57, 'E': 30, 'F': 40, 'G': 37}}, {'id': 'B', 'distances': {'A': 43, 'B': 0, 'C': 44, 'D': 46, 'E': 28, 'F': 22, 'G': 52}}, {'id': 'C', 'distances': {'A': 57, 'B': 44, 'C': 0, 'D': 53, 'E': 50, 'F': 28, 'G': 60}}, {'id': 'D', 'distances': {'A': 57, 'B': 46, 'C': 53, 'D': 0, 'E': 35, 'F': 33, 'G': 59}}, {'id': 'E', 'distances': {'A': 30, 'B': 28, 'C': 50, 'D': 35, 'E': 0, 'F': 27, 'G': 41}}, {'id': 'F', 'distances': {'A': 40, 'B': 22, 'C': 28, 'D': 33, 'E': 27, 'F': 0, 'G': 32}}, {'id': 'G', 'distances': {'A': 37, 'B': 52, 'C': 60, 'D': 59, 'E': 41, 'F': 32, 'G': 0}}], 'objective': 182.0}","{'selected': ['F'], 'assignments': ['F', 'F', 'F', 'F', 'F', 'F', 'F']}",5,json,names
PMED,PMED,"Someone in the planning office is trying to map out where to activate a fixed number of free Wi‑Fi hotspots from among possible sites. Once the chosen hotspots are up, each block has to be connected to exactly one of them — no block is left unassigned or tied to more than one hotspot. The better the plan, the less total distance users have to travel, which is measured by adding up each block’s distance to its assigned hotspot; the plan with the smallest sum is preferred. The concrete candidate locations, the distances between them, and the number of hotspots to turn on are shown below.

# total_candidate_locations=5
# hotspots_to_activate=1
# location_ids=0, 1, 2, 3, 4
origin_location_id,destination_location_id,pairwise_travel_distance
0,1,209
0,2,112
0,3,168
0,4,98
1,0,209
1,2,195
1,3,245
1,4,161
2,0,112
2,1,195
2,3,56
2,4,136
3,0,168
3,1,245
3,2,56
3,4,192
4,0,98
4,1,161
4,2,136
4,3,192

If you like, you can just send back the plan in a tiny JSON snippet so it's easy to read and parse. Here's the shape I'd expect — nothing complicated, just which sites you turn on and which site each block connects to:

{
  ""solution"": {
    ""selected"": [<site_to_open>, <site_to_open>, ...],
    ""assignments"": [<assigned_site>, <assigned_site>, ...]
  }
}

Think of ""selected"" as the list of hotspot sites you're switching on, and ""assignments"" as, for each block (in the same order the instance lists them), the selected site that block will use. Super informal: first array = which spots open, second array = where each block connects.

This JSON is only a sketch of the expected shape — not the actual answer.

Please use the exact identifiers from the instance input — no renaming and no new labels.
For example: ""Valid identifiers look like plain numbers such as “1” or “23”, single capital letters like “A” or “B”, or a capital letter followed by digits like “A1” or “X7”.""","{'distance_matrix': [[0, 209, 112, 168, 98], [209, 0, 195, 245, 161], [112, 195, 0, 56, 136], [168, 245, 56, 0, 192], [98, 161, 136, 192, 0]], 'p': 1, 'objective': 499.0}","{'facilities': [2], 'assignments': [2, 2, 2, 2, 2]}",499.0,"{'problem_type': 'PMED', 'num_nodes': 5, 'num_open': 1, 'sites': [{'id': 0, 'distances': {0: 0, 1: 209, 2: 112, 3: 168, 4: 98}}, {'id': 1, 'distances': {0: 209, 1: 0, 2: 195, 3: 245, 4: 161}}, {'id': 2, 'distances': {0: 112, 1: 195, 2: 0, 3: 56, 4: 136}}, {'id': 3, 'distances': {0: 168, 1: 245, 2: 56, 3: 0, 4: 192}}, {'id': 4, 'distances': {0: 98, 1: 161, 2: 136, 3: 192, 4: 0}}], 'objective': 499.0}","{'selected': [2], 'assignments': [2, 2, 2, 2, 2]}",6,csv,0
PMED,PMED,"Many people on the team know we need to open only a handful of garages as charging sites and then assign each vehicle base to one of those sites. That means choosing a fixed number of depots, making sure every base goes to exactly one open depot (nothing left out, nothing doubled up), and measuring a plan by summing the drives from each base to its depot — the lower that sum, the better. The full set of garages, bases, and distance values is shown below.

Below are the 8 candidate garages and bases; we will open exactly 3 depots and the locations (in order) are A, B, C, D, E, F, G, H.
Drive distance from A to B is 35.
Drive distance from A to C is 22.
Drive distance from A to D is 31.
Drive distance from A to E is 30.
Drive distance from A to F is 45.
Drive distance from A to G is 38.
Drive distance from A to H is 28.
Drive distance from B to A is 35.
Drive distance from B to C is 29.
Drive distance from B to D is 34.
Drive distance from B to E is 31.
Drive distance from B to F is 43.
Drive distance from B to G is 36.
Drive distance from B to H is 31.
Drive distance from C to A is 22.
Drive distance from C to B is 29.
Drive distance from C to D is 24.
Drive distance from C to E is 25.
Drive distance from C to F is 33.
Drive distance from C to G is 29.
Drive distance from C to H is 15.
Drive distance from D to A is 31.
Drive distance from D to B is 34.
Drive distance from D to C is 24.
Drive distance from D to E is 9.
Drive distance from D to F is 47.
Drive distance from D to G is 29.
Drive distance from D to H is 25.
Drive distance from E to A is 30.
Drive distance from E to B is 31.
Drive distance from E to C is 25.
Drive distance from E to D is 9.
Drive distance from E to F is 46.
Drive distance from E to G is 28.
Drive distance from E to H is 24.
Drive distance from F to A is 45.
Drive distance from F to B is 43.
Drive distance from F to C is 33.
Drive distance from F to D is 47.
Drive distance from F to E is 46.
Drive distance from F to G is 35.
Drive distance from F to H is 46.
Drive distance from G to A is 38.
Drive distance from G to B is 36.
Drive distance from G to C is 29.
Drive distance from G to D is 29.
Drive distance from G to E is 28.
Drive distance from G to F is 35.
Drive distance from G to H is 28.
Drive distance from H to A is 28.
Drive distance from H to B is 31.
Drive distance from H to C is 15.
Drive distance from H to D is 25.
Drive distance from H to E is 24.
Drive distance from H to F is 46.
Drive distance from H to G is 28.
Use these 8 locations and distances to evaluate plans that open 3 depots.

Also, when you reply with a candidate plan, please use this simple JSON shape so it's straightforward to parse:

{
  ""solution"": {
    ""selected"": [<site_to_open>, <site_to_open>, ...],
    ""assignments"": [<site_assigned>, <site_assigned>, ...]
  }
}

Quick note on what that means in plain terms: ""selected"" is the list of garages (sites) you choose to open. ""assignments"" lists, in the same order as the vehicle bases are given in the instance, which opened site each base is assigned to. Think of it like a short form: pick the open sites, then say for each base which open site it uses.

This JSON is just the shape I need — not the filled-in answer. When you fill it in, be sure to use the exact identifiers from the instance input with no renaming or made-up 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”.","{'distance_matrix': [[0, 35, 22, 31, 30, 45, 38, 28], [35, 0, 29, 34, 31, 43, 36, 31], [22, 29, 0, 24, 25, 33, 29, 15], [31, 34, 24, 0, 9, 47, 29, 25], [30, 31, 25, 9, 0, 46, 28, 24], [45, 43, 33, 47, 46, 0, 35, 46], [38, 36, 29, 29, 28, 35, 0, 28], [28, 31, 15, 25, 24, 46, 28, 0]], 'p': 3, 'objective': 103.0}","{'facilities': [2, 4, 5], 'assignments': [2, 2, 2, 4, 4, 5, 4, 2]}",103.0,"{'problem_type': 'PMED', 'num_nodes': 8, 'num_open': 3, 'sites': [{'id': 'A', 'distances': {'A': 0, 'B': 35, 'C': 22, 'D': 31, 'E': 30, 'F': 45, 'G': 38, 'H': 28}}, {'id': 'B', 'distances': {'A': 35, 'B': 0, 'C': 29, 'D': 34, 'E': 31, 'F': 43, 'G': 36, 'H': 31}}, {'id': 'C', 'distances': {'A': 22, 'B': 29, 'C': 0, 'D': 24, 'E': 25, 'F': 33, 'G': 29, 'H': 15}}, {'id': 'D', 'distances': {'A': 31, 'B': 34, 'C': 24, 'D': 0, 'E': 9, 'F': 47, 'G': 29, 'H': 25}}, {'id': 'E', 'distances': {'A': 30, 'B': 31, 'C': 25, 'D': 9, 'E': 0, 'F': 46, 'G': 28, 'H': 24}}, {'id': 'F', 'distances': {'A': 45, 'B': 43, 'C': 33, 'D': 47, 'E': 46, 'F': 0, 'G': 35, 'H': 46}}, {'id': 'G', 'distances': {'A': 38, 'B': 36, 'C': 29, 'D': 29, 'E': 28, 'F': 35, 'G': 0, 'H': 28}}, {'id': 'H', 'distances': {'A': 28, 'B': 31, 'C': 15, 'D': 25, 'E': 24, 'F': 46, 'G': 28, 'H': 0}}], 'objective': 103.0}","{'selected': ['C', 'E', 'F'], 'assignments': ['C', 'C', 'C', 'E', 'E', 'F', 'E', 'C']}",7,markdown_table,names
PMED,PMED,"Many people will be coming and the team must choose exactly a certain number of staffed info points from the proposed spots, then assign each campsite to one of those points. The better the choice, the less everyone walks — you figure that by summing each campsite’s distance to its assigned booth and preferring the layout with the smallest sum. No campsite can be skipped or linked to more than one booth. Concrete details are listed below.

There are 7 proposed spots; you must staff exactly 1 booths chosen from 1, 2, 3, 4, 5, 6, 7.
From site 1 to site 2: walking distance 53.
From site 1 to site 3: walking distance 37.
From site 1 to site 4: walking distance 46.
From site 1 to site 5: walking distance 48.
From site 1 to site 6: walking distance 41.
From site 1 to site 7: walking distance 35.
From site 2 to site 1: walking distance 53.
From site 2 to site 3: walking distance 40.
From site 2 to site 4: walking distance 47.
From site 2 to site 5: walking distance 38.
From site 2 to site 6: walking distance 41.
From site 2 to site 7: walking distance 32.
From site 3 to site 1: walking distance 37.
From site 3 to site 2: walking distance 40.
From site 3 to site 4: walking distance 41.
From site 3 to site 5: walking distance 34.
From site 3 to site 6: walking distance 39.
From site 3 to site 7: walking distance 24.
From site 4 to site 1: walking distance 46.
From site 4 to site 2: walking distance 47.
From site 4 to site 3: walking distance 41.
From site 4 to site 5: walking distance 30.
From site 4 to site 6: walking distance 26.
From site 4 to site 7: walking distance 33.
From site 5 to site 1: walking distance 48.
From site 5 to site 2: walking distance 38.
From site 5 to site 3: walking distance 34.
From site 5 to site 4: walking distance 30.
From site 5 to site 6: walking distance 32.
From site 5 to site 7: walking distance 26.
From site 6 to site 1: walking distance 41.
From site 6 to site 2: walking distance 41.
From site 6 to site 3: walking distance 39.
From site 6 to site 4: walking distance 26.
From site 6 to site 5: walking distance 32.
From site 6 to site 7: walking distance 29.
From site 7 to site 1: walking distance 35.
From site 7 to site 2: walking distance 32.
From site 7 to site 3: walking distance 24.
From site 7 to site 4: walking distance 33.
From site 7 to site 5: walking distance 26.
From site 7 to site 6: walking distance 29.
Use these distances to assign every campsite to one staffed booth so your chosen 1 booths minimize total walking.

Just so we're on the same page, please return your answer in this little JSON shape — it's just a compact way to say which spots we open and where each campsite should go.

{
  ""solution"": {
    ""selected"": [<site_to_open>, <site_to_open>, ...],
    ""assignments"": [<chosen_open_site>, <chosen_open_site>, ...]
  }
}

Think of ""selected"" as the list of staffed info points you decide to open, and ""assignments"" as, for each campsite in the original list (in that same order), the open site it gets sent to. This is only a sketch of the expected shape — not the real solution itself.

One important note: every identifier you put in here must exactly match the identifiers used in the instance input — do not rename them or invent new labels. Valid identifiers look like plain numbers such as “1” or “23”, single capital letters like “A” or “B”, or a capital letter followed by digits like “A1” or “X7”.","{'distance_matrix': [[0, 53, 37, 46, 48, 41, 35], [53, 0, 40, 47, 38, 41, 32], [37, 40, 0, 41, 34, 39, 24], [46, 47, 41, 0, 30, 26, 33], [48, 38, 34, 30, 0, 32, 26], [41, 41, 39, 26, 32, 0, 29], [35, 32, 24, 33, 26, 29, 0]], 'p': 1, 'objective': 179.0}","{'facilities': [6], 'assignments': [6, 6, 6, 6, 6, 6, 6]}",179.0,"{'problem_type': 'PMED', 'num_nodes': 7, 'num_open': 1, 'sites': [{'id': 1, 'distances': {1: 0, 2: 53, 3: 37, 4: 46, 5: 48, 6: 41, 7: 35}}, {'id': 2, 'distances': {1: 53, 2: 0, 3: 40, 4: 47, 5: 38, 6: 41, 7: 32}}, {'id': 3, 'distances': {1: 37, 2: 40, 3: 0, 4: 41, 5: 34, 6: 39, 7: 24}}, {'id': 4, 'distances': {1: 46, 2: 47, 3: 41, 4: 0, 5: 30, 6: 26, 7: 33}}, {'id': 5, 'distances': {1: 48, 2: 38, 3: 34, 4: 30, 5: 0, 6: 32, 7: 26}}, {'id': 6, 'distances': {1: 41, 2: 41, 3: 39, 4: 26, 5: 32, 6: 0, 7: 29}}, {'id': 7, 'distances': {1: 35, 2: 32, 3: 24, 4: 33, 5: 26, 6: 29, 7: 0}}], 'objective': 179.0}","{'selected': [7], 'assignments': [7, 7, 7, 7, 7, 7, 7]}",8,nl,1
PMED,PMED,"Back when the planners drew the master plan they left a shortlist of possible dock sites and now must pick a limited number to actually build. Each residential cluster must be connected to one of the selected docks — one connection per cluster, no extras — and the goal is to keep residents’ trips short. Practically that means for any proposed set of docks you measure each cluster’s distance to its chosen dock, add up those distances, and prefer the arrangement with the smallest total. The detailed list of candidate sites, clusters, and distances is given below.

It contains 5 mapped locations, of which 2 docks must be opened; the location identifiers are A, B, C, D, E.
Distance between A and B: 52.
Distance between A and C: 41.
Distance between A and D: 34.
Distance between A and E: 36.
Distance between B and A: 52.
Distance between B and C: 42.
Distance between B and D: 49.
Distance between B and E: 50.
Distance between C and A: 41.
Distance between C and B: 42.
Distance between C and D: 32.
Distance between C and E: 33.
Distance between D and A: 34.
Distance between D and B: 49.
Distance between D and C: 32.
Distance between D and E: 23.
Distance between E and A: 36.
Distance between E and B: 50.
Distance between E and C: 33.
Distance between E and D: 23.
Use these records to assign each residential cluster to one open dock so the total travel distance is minimized.

Oh, and when you send the final answer, please follow this simple JSON layout so it's easy to check automatically:

{
  ""solution"": {
    ""selected"": [<site_to_open>, <site_to_open>, ...],
    ""assignments"": [<chosen_open_site>, <chosen_open_site>, ...]
  }
}

Think of it like a little form: ""selected"" is the shortlist of docks you actually build, and ""assignments"" lists, for each residential cluster (in the same order as the instance input), which of those built docks it connects to. The placeholders are just showing the shape I expect — they aren't the real choices.

Please make sure to use the exact identifiers from the instance input (do not rename them or invent new ones).
- 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”.""","{'distance_matrix': [[0, 52, 41, 34, 36], [52, 0, 42, 49, 50], [41, 42, 0, 32, 33], [34, 49, 32, 0, 23], [36, 50, 33, 23, 0]], 'p': 2, 'objective': 89.0}","{'facilities': [1, 3], 'assignments': [3, 1, 3, 3, 3]}",89.0,"{'problem_type': 'PMED', 'num_nodes': 5, 'num_open': 2, 'sites': [{'id': 'A', 'distances': {'A': 0, 'B': 52, 'C': 41, 'D': 34, 'E': 36}}, {'id': 'B', 'distances': {'A': 52, 'B': 0, 'C': 42, 'D': 49, 'E': 50}}, {'id': 'C', 'distances': {'A': 41, 'B': 42, 'C': 0, 'D': 32, 'E': 33}}, {'id': 'D', 'distances': {'A': 34, 'B': 49, 'C': 32, 'D': 0, 'E': 23}}, {'id': 'E', 'distances': {'A': 36, 'B': 50, 'C': 33, 'D': 23, 'E': 0}}], 'objective': 89.0}","{'selected': ['B', 'D'], 'assignments': ['D', 'B', 'D', 'D', 'D']}",9,markdown_table,names
PMED,PMED,"We’re sorting out which mailboxes to keep on our routes, but there’s a limit on how many can stay open. From the candidate locations, a fixed number will be kept, and every delivery neighborhood must be linked to one of those kept boxes — one link per neighborhood, exactly. The goal is simple in everyday terms: make the total walking distance for everyone as low as possible by summing each neighborhood’s distance to its chosen mailbox and choosing the arrangement with the lowest sum. The specific mailbox options and distance details are listed below.

There are 7 candidate mailbox posts; we must keep 1 open, chosen from 1, 2, 3, 4, 5, 6, 7.
For delivery neighborhood 1, we measure a walking distance of 187 to mailbox 2.
For delivery neighborhood 1, we measure a walking distance of 202 to mailbox 3.
For delivery neighborhood 1, we measure a walking distance of 154 to mailbox 4.
For delivery neighborhood 1, we measure a walking distance of 143 to mailbox 5.
For delivery neighborhood 1, we measure a walking distance of 212 to mailbox 6.
For delivery neighborhood 1, we measure a walking distance of 202 to mailbox 7.
For delivery neighborhood 2, we measure a walking distance of 187 to mailbox 1.
For delivery neighborhood 2, we measure a walking distance of 157 to mailbox 3.
For delivery neighborhood 2, we measure a walking distance of 101 to mailbox 4.
For delivery neighborhood 2, we measure a walking distance of 127 to mailbox 5.
For delivery neighborhood 2, we measure a walking distance of 164 to mailbox 6.
For delivery neighborhood 2, we measure a walking distance of 149 to mailbox 7.
For delivery neighborhood 3, we measure a walking distance of 202 to mailbox 1.
For delivery neighborhood 3, we measure a walking distance of 157 to mailbox 2.
For delivery neighborhood 3, we measure a walking distance of 60 to mailbox 4.
For delivery neighborhood 3, we measure a walking distance of 129 to mailbox 5.
For delivery neighborhood 3, we measure a walking distance of 52 to mailbox 6.
For delivery neighborhood 3, we measure a walking distance of 92 to mailbox 7.
For delivery neighborhood 4, we measure a walking distance of 154 to mailbox 1.
For delivery neighborhood 4, we measure a walking distance of 101 to mailbox 2.
For delivery neighborhood 4, we measure a walking distance of 60 to mailbox 3.
For delivery neighborhood 4, we measure a walking distance of 158 to mailbox 5.
For delivery neighborhood 4, we measure a walking distance of 90 to mailbox 6.
For delivery neighborhood 4, we measure a walking distance of 66 to mailbox 7.
For delivery neighborhood 5, we measure a walking distance of 143 to mailbox 1.
For delivery neighborhood 5, we measure a walking distance of 127 to mailbox 2.
For delivery neighborhood 5, we measure a walking distance of 129 to mailbox 3.
For delivery neighborhood 5, we measure a walking distance of 158 to mailbox 4.
For delivery neighborhood 5, we measure a walking distance of 89 to mailbox 6.
For delivery neighborhood 5, we measure a walking distance of 129 to mailbox 7.
For delivery neighborhood 6, we measure a walking distance of 212 to mailbox 1.
For delivery neighborhood 6, we measure a walking distance of 164 to mailbox 2.
For delivery neighborhood 6, we measure a walking distance of 52 to mailbox 3.
For delivery neighborhood 6, we measure a walking distance of 90 to mailbox 4.
For delivery neighborhood 6, we measure a walking distance of 89 to mailbox 5.
For delivery neighborhood 6, we measure a walking distance of 40 to mailbox 7.
For delivery neighborhood 7, we measure a walking distance of 202 to mailbox 1.
For delivery neighborhood 7, we measure a walking distance of 149 to mailbox 2.
For delivery neighborhood 7, we measure a walking distance of 92 to mailbox 3.
For delivery neighborhood 7, we measure a walking distance of 66 to mailbox 4.
For delivery neighborhood 7, we measure a walking distance of 129 to mailbox 5.
For delivery neighborhood 7, we measure a walking distance of 40 to mailbox 6.
We’ll use these distances to choose which 1 of the 7 candidate posts to keep.

Also, when you send the result back, just use this simple JSON layout so it's easy to parse:

{
  ""solution"": {
    ""selected"": [<mailbox_to_keep>, <mailbox_to_keep>, ...],
    ""assignments"": [<assigned_mailbox>, <assigned_mailbox>, ...]
  }
}

""selected"" is the list of the mailboxes we decide to keep open. ""assignments"" is a list (in the same order as the input locations) that says which kept mailbox each neighborhood is linked to. It's just a sketch of the shape I expect — you'll fill in the actual identifiers from the instance.

Please use the exact identifiers from the input (do not rename them or invent new labels). 
- for example: ""Valid identifiers look like plain numbers such as “1” or “23”, single capital letters like “A” or “B”, or a capital letter followed by digits like “A1” or “X7”.""","{'distance_matrix': [[0, 187, 202, 154, 143, 212, 202], [187, 0, 157, 101, 127, 164, 149], [202, 157, 0, 60, 129, 52, 92], [154, 101, 60, 0, 158, 90, 66], [143, 127, 129, 158, 0, 89, 129], [212, 164, 52, 90, 89, 0, 40], [202, 149, 92, 66, 129, 40, 0]], 'p': 1, 'objective': 629.0}","{'facilities': [3], 'assignments': [3, 3, 3, 3, 3, 3, 3]}",629.0,"{'problem_type': 'PMED', 'num_nodes': 7, 'num_open': 1, 'sites': [{'id': 1, 'distances': {1: 0, 2: 187, 3: 202, 4: 154, 5: 143, 6: 212, 7: 202}}, {'id': 2, 'distances': {1: 187, 2: 0, 3: 157, 4: 101, 5: 127, 6: 164, 7: 149}}, {'id': 3, 'distances': {1: 202, 2: 157, 3: 0, 4: 60, 5: 129, 6: 52, 7: 92}}, {'id': 4, 'distances': {1: 154, 2: 101, 3: 60, 4: 0, 5: 158, 6: 90, 7: 66}}, {'id': 5, 'distances': {1: 143, 2: 127, 3: 129, 4: 158, 5: 0, 6: 89, 7: 129}}, {'id': 6, 'distances': {1: 212, 2: 164, 3: 52, 4: 90, 5: 89, 6: 0, 7: 40}}, {'id': 7, 'distances': {1: 202, 2: 149, 3: 92, 4: 66, 5: 129, 6: 40, 7: 0}}], 'objective': 629.0}","{'selected': [4], 'assignments': [4, 4, 4, 4, 4, 4, 4]}",10,markdown_table,1
PMED,PMED,"Many people depend on the cooperative to pick a handful of collection yards from a list of candidates and then route each farm to one of those yards. The rule is strict: there’s a fixed number of yards to run, and each farm must be assigned to exactly one open yard — no splitting or omissions. A better routing is the one that makes the sum of all farm-to-yard trips as small as possible; just add up each farm’s distance to its assigned yard to see how good it is. The concrete data about farms and distances appears below.

Below are the 6 candidate yards (IDs: 1, 2, 3, 4, 5, 6); the cooperative must open exactly 2 of them and assign every farm to one opened yard.
Distance from 1 to 2: 28.
Distance from 1 to 3: 42.
Distance from 1 to 4: 38.
Distance from 1 to 5: 45.
Distance from 1 to 6: 43.
Distance from 2 to 1: 28.
Distance from 2 to 3: 47.
Distance from 2 to 4: 36.
Distance from 2 to 5: 35.
Distance from 2 to 6: 33.
Distance from 3 to 1: 42.
Distance from 3 to 2: 47.
Distance from 3 to 4: 35.
Distance from 3 to 5: 35.
Distance from 3 to 6: 39.
Distance from 4 to 1: 38.
Distance from 4 to 2: 36.
Distance from 4 to 3: 35.
Distance from 4 to 5: 53.
Distance from 4 to 6: 51.
Distance from 5 to 1: 45.
Distance from 5 to 2: 35.
Distance from 5 to 3: 35.
Distance from 5 to 4: 53.
Distance from 5 to 6: 42.
Distance from 6 to 1: 43.
Distance from 6 to 2: 33.
Distance from 6 to 3: 39.
Distance from 6 to 4: 51.
Distance from 6 to 5: 42.
These distances will be used to assign farms to the chosen yards so the cooperative can minimize the total travel distance.

Oh, and when you reply, please use this simple JSON layout so I can read the shortlist and the farm-to-yard assignments easily:

{
  ""solution"": {
    ""selected"": [<yard_to_open>, <yard_to_open>, ...],
    ""assignments"": [<chosen_open_yard>, <chosen_open_yard>, ...]
  }
}

This is just a sketch of the shape I need:
- ""selected"" is the list of yards you decide to open (those are the yard identifiers).
- ""assignments"" lists, for each farm in the same order as the instance, which open yard it goes to (use the yard identifier you picked).

Please use the identifiers exactly as they appear in the instance input — no renaming and no new labels. For example:
- plain numbers such as “1” or “23”
- single capital letters like “A” or “B”
- a capital letter followed by digits like “A1” or “X7”","{'distance_matrix': [[0, 28, 42, 38, 45, 43], [28, 0, 47, 36, 35, 33], [42, 47, 0, 35, 35, 39], [38, 36, 35, 0, 53, 51], [45, 35, 35, 53, 0, 42], [43, 33, 39, 51, 42, 0]], 'p': 2, 'objective': 131.0}","{'facilities': [1, 3], 'assignments': [1, 1, 3, 3, 1, 1]}",131.0,"{'problem_type': 'PMED', 'num_nodes': 6, 'num_open': 2, 'sites': [{'id': 1, 'distances': {1: 0, 2: 28, 3: 42, 4: 38, 5: 45, 6: 43}}, {'id': 2, 'distances': {1: 28, 2: 0, 3: 47, 4: 36, 5: 35, 6: 33}}, {'id': 3, 'distances': {1: 42, 2: 47, 3: 0, 4: 35, 5: 35, 6: 39}}, {'id': 4, 'distances': {1: 38, 2: 36, 3: 35, 4: 0, 5: 53, 6: 51}}, {'id': 5, 'distances': {1: 45, 2: 35, 3: 35, 4: 53, 5: 0, 6: 42}}, {'id': 6, 'distances': {1: 43, 2: 33, 3: 39, 4: 51, 5: 42, 6: 0}}], 'objective': 131.0}","{'selected': [2, 4], 'assignments': [2, 2, 4, 4, 2, 2]}",11,markdown_table,1
PMED,PMED,"Someone in the ranger office needs to decide which clearings get staffed first-aid teams and then connect every trailhead to one staffed clearing so hikers aren’t wandering around. The rule of thumb is: compute how far people from each trailhead would have to go to reach their assigned station, sum those distances across all trailheads, and prefer the setup with the smallest total distance. Each trailhead gets one—and only one—assigned station; none can be left out or routed to multiple stations. The exact list of clearings, trailheads, and their pairwise distances appears below.

{
  ""total_locations_count"": 6,
  ""num_first_aid_to_staff"": 1,
  ""location_ids"": [
    0,
    1,
    2,
    3,
    4,
    5
  ],
  ""data"": [
    {
      ""from_location_id"": 0,
      ""to_location_id"": 1,
      ""travel_distance"": 28
    },
    {
      ""from_location_id"": 0,
      ""to_location_id"": 2,
      ""travel_distance"": 14
    },
    {
      ""from_location_id"": 0,
      ""to_location_id"": 3,
      ""travel_distance"": 31
    },
    {
      ""from_location_id"": 0,
      ""to_location_id"": 4,
      ""travel_distance"": 17
    },
    {
      ""from_location_id"": 0,
      ""to_location_id"": 5,
      ""travel_distance"": 33
    },
    {
      ""from_location_id"": 1,
      ""to_location_id"": 0,
      ""travel_distance"": 28
    },
    {
      ""from_location_id"": 1,
      ""to_location_id"": 2,
      ""travel_distance"": 29
    },
    {
      ""from_location_id"": 1,
      ""to_location_id"": 3,
      ""travel_distance"": 34
    },
    {
      ""from_location_id"": 1,
      ""to_location_id"": 4,
      ""travel_distance"": 25
    },
    {
      ""from_location_id"": 1,
      ""to_location_id"": 5,
      ""travel_distance"": 31
    },
    {
      ""from_location_id"": 2,
      ""to_location_id"": 0,
      ""travel_distance"": 14
    },
    {
      ""from_location_id"": 2,
      ""to_location_id"": 1,
      ""travel_distance"": 29
    },
    {
      ""from_location_id"": 2,
      ""to_location_id"": 3,
      ""travel_distance"": 35
    },
    {
      ""from_location_id"": 2,
      ""to_location_id"": 4,
      ""travel_distance"": 27
    },
    {
      ""from_location_id"": 2,
      ""to_location_id"": 5,
      ""travel_distance"": 41
    },
    {
      ""from_location_id"": 3,
      ""to_location_id"": 0,
      ""travel_distance"": 31
    },
    {
      ""from_location_id"": 3,
      ""to_location_id"": 1,
      ""travel_distance"": 34
    },
    {
      ""from_location_id"": 3,
      ""to_location_id"": 2,
      ""travel_distance"": 35
    },
    {
      ""from_location_id"": 3,
      ""to_location_id"": 4,
      ""travel_distance"": 29
    },
    {
      ""from_location_id"": 3,
      ""to_location_id"": 5,
      ""travel_distance"": 37
    },
    {
      ""from_location_id"": 4,
      ""to_location_id"": 0,
      ""travel_distance"": 17
    },
    {
      ""from_location_id"": 4,
      ""to_location_id"": 1,
      ""travel_distance"": 25
    },
    {
      ""from_location_id"": 4,
      ""to_location_id"": 2,
      ""travel_distance"": 27
    },
    {
      ""from_location_id"": 4,
      ""to_location_id"": 3,
      ""travel_distance"": 29
    },
    {
      ""from_location_id"": 4,
      ""to_location_id"": 5,
      ""travel_distance"": 41
    },
    {
      ""from_location_id"": 5,
      ""to_location_id"": 0,
      ""travel_distance"": 33
    },
    {
      ""from_location_id"": 5,
      ""to_location_id"": 1,
      ""travel_distance"": 31
    },
    {
      ""from_location_id"": 5,
      ""to_location_id"": 2,
      ""travel_distance"": 41
    },
    {
      ""from_location_id"": 5,
      ""to_location_id"": 3,
      ""travel_distance"": 37
    },
    {
      ""from_location_id"": 5,
      ""to_location_id"": 4,
      ""travel_distance"": 41
    }
  ]
}

Oh, and when you send back the plan, just use this little JSON layout so it's easy to plug into the other tools:

{
  ""solution"": {
    ""selected"": [<clearing_to_open>, <clearing_to_open>, ...],
    ""assignments"": [<assigned_clearing>, <assigned_clearing>, ...]
  }
}

Think of it like a simple form: ""selected"" is the list of clearings we decide to staff, and ""assignments"" is which staffed clearing each trailhead gets routed to (one entry per trailhead, in the same order as the trailheads are listed in the instance). This JSON is just a sketch of the shape I need — not your final answer — so fill in the actual identifiers from the instance when you reply.

Please be careful to use the exact identifiers given in the instance input — no renaming, no made-up 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”.""","{'distance_matrix': [[0, 28, 14, 31, 17, 33], [28, 0, 29, 34, 25, 31], [14, 29, 0, 35, 27, 41], [31, 34, 35, 0, 29, 37], [17, 25, 27, 29, 0, 41], [33, 31, 41, 37, 41, 0]], 'p': 1, 'objective': 123.0}","{'facilities': [0], 'assignments': [0, 0, 0, 0, 0, 0]}",123.0,"{'problem_type': 'PMED', 'num_nodes': 6, 'num_open': 1, 'sites': [{'id': 0, 'distances': {0: 0, 1: 28, 2: 14, 3: 31, 4: 17, 5: 33}}, {'id': 1, 'distances': {0: 28, 1: 0, 2: 29, 3: 34, 4: 25, 5: 31}}, {'id': 2, 'distances': {0: 14, 1: 29, 2: 0, 3: 35, 4: 27, 5: 41}}, {'id': 3, 'distances': {0: 31, 1: 34, 2: 35, 3: 0, 4: 29, 5: 37}}, {'id': 4, 'distances': {0: 17, 1: 25, 2: 27, 3: 29, 4: 0, 5: 41}}, {'id': 5, 'distances': {0: 33, 1: 31, 2: 41, 3: 37, 4: 41, 5: 0}}], 'objective': 123.0}","{'selected': [0], 'assignments': [0, 0, 0, 0, 0, 0]}",12,json,0
PMED,PMED,"I’m running the ride‑hail ops side and need to pick which driver rest stops to keep open from a list of possible spots. The plan is to choose a fixed number of those stops and then link every service zone to one of the open stops — one and only one, no zone left out or split between stops. The better choice is the one that makes the drivers travel the least overall, measured by adding up the distance from each zone to its assigned rest stop. Concrete details are shown below.

{
  ""total_candidate_locations"": 7,
  ""stops_to_keep_open"": 1,
  ""location_ids"": [
    0,
    1,
    2,
    3,
    4,
    5,
    6
  ],
  ""data"": [
    {
      ""source_location_id"": 0,
      ""target_location_id"": 1,
      ""travel_distance"": 43
    },
    {
      ""source_location_id"": 0,
      ""target_location_id"": 2,
      ""travel_distance"": 50
    },
    {
      ""source_location_id"": 0,
      ""target_location_id"": 3,
      ""travel_distance"": 44
    },
    {
      ""source_location_id"": 0,
      ""target_location_id"": 4,
      ""travel_distance"": 27
    },
    {
      ""source_location_id"": 0,
      ""target_location_id"": 5,
      ""travel_distance"": 49
    },
    {
      ""source_location_id"": 0,
      ""target_location_id"": 6,
      ""travel_distance"": 43
    },
    {
      ""source_location_id"": 1,
      ""target_location_id"": 0,
      ""travel_distance"": 43
    },
    {
      ""source_location_id"": 1,
      ""target_location_id"": 2,
      ""travel_distance"": 51
    },
    {
      ""source_location_id"": 1,
      ""target_location_id"": 3,
      ""travel_distance"": 32
    },
    {
      ""source_location_id"": 1,
      ""target_location_id"": 4,
      ""travel_distance"": 46
    },
    {
      ""source_location_id"": 1,
      ""target_location_id"": 5,
      ""travel_distance"": 47
    },
    {
      ""source_location_id"": 1,
      ""target_location_id"": 6,
      ""travel_distance"": 55
    },
    {
      ""source_location_id"": 2,
      ""target_location_id"": 0,
      ""travel_distance"": 50
    },
    {
      ""source_location_id"": 2,
      ""target_location_id"": 1,
      ""travel_distance"": 51
    },
    {
      ""source_location_id"": 2,
      ""target_location_id"": 3,
      ""travel_distance"": 50
    },
    {
      ""source_location_id"": 2,
      ""target_location_id"": 4,
      ""travel_distance"": 45
    },
    {
      ""source_location_id"": 2,
      ""target_location_id"": 5,
      ""travel_distance"": 42
    },
    {
      ""source_location_id"": 2,
      ""target_location_id"": 6,
      ""travel_distance"": 42
    },
    {
      ""source_location_id"": 3,
      ""target_location_id"": 0,
      ""travel_distance"": 44
    },
    {
      ""source_location_id"": 3,
      ""target_location_id"": 1,
      ""travel_distance"": 32
    },
    {
      ""source_location_id"": 3,
      ""target_location_id"": 2,
      ""travel_distance"": 50
    },
    {
      ""source_location_id"": 3,
      ""target_location_id"": 4,
      ""travel_distance"": 36
    },
    {
      ""source_location_id"": 3,
      ""target_location_id"": 5,
      ""travel_distance"": 57
    },
    {
      ""source_location_id"": 3,
      ""target_location_id"": 6,
      ""travel_distance"": 44
    },
    {
      ""source_location_id"": 4,
      ""target_location_id"": 0,
      ""travel_distance"": 27
    },
    {
      ""source_location_id"": 4,
      ""target_location_id"": 1,
      ""travel_distance"": 46
    },
    {
      ""source_location_id"": 4,
      ""target_location_id"": 2,
      ""travel_distance"": 45
    },
    {
      ""source_location_id"": 4,
      ""target_location_id"": 3,
      ""travel_distance"": 36
    },
    {
      ""source_location_id"": 4,
      ""target_location_id"": 5,
      ""travel_distance"": 42
    },
    {
      ""source_location_id"": 4,
      ""target_location_id"": 6,
      ""travel_distance"": 54
    },
    {
      ""source_location_id"": 5,
      ""target_location_id"": 0,
      ""travel_distance"": 49
    },
    {
      ""source_location_id"": 5,
      ""target_location_id"": 1,
      ""travel_distance"": 47
    },
    {
      ""source_location_id"": 5,
      ""target_location_id"": 2,
      ""travel_distance"": 42
    },
    {
      ""source_location_id"": 5,
      ""target_location_id"": 3,
      ""travel_distance"": 57
    },
    {
      ""source_location_id"": 5,
      ""target_location_id"": 4,
      ""travel_distance"": 42
    },
    {
      ""source_location_id"": 5,
      ""target_location_id"": 6,
      ""travel_distance"": 62
    },
    {
      ""source_location_id"": 6,
      ""target_location_id"": 0,
      ""travel_distance"": 43
    },
    {
      ""source_location_id"": 6,
      ""target_location_id"": 1,
      ""travel_distance"": 55
    },
    {
      ""source_location_id"": 6,
      ""target_location_id"": 2,
      ""travel_distance"": 42
    },
    {
      ""source_location_id"": 6,
      ""target_location_id"": 3,
      ""travel_distance"": 44
    },
    {
      ""source_location_id"": 6,
      ""target_location_id"": 4,
      ""travel_distance"": 54
    },
    {
      ""source_location_id"": 6,
      ""target_location_id"": 5,
      ""travel_distance"": 62
    }
  ]
}

I'll keep the answer in a tiny, predictable JSON shape so it's easy to plug into whatever you're using. Something like this:

{
  ""solution"": {
    ""selected"": [<site_to_open>, <site_to_open>, ...],
    ""assignments"": [<assigned_open_site>, <assigned_open_site>, ...]
  }
}

""selected"" is where you list the rest stops we choose to keep open. ""assignments"" is a list, in the same order as the input zones, saying which open stop each zone gets linked to. Super casual — think of it as filling out a form, not a report.

This JSON is just a sketch of the shape I need you to return, not the actual choices. And please use the exact identifiers from 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”.""","{'distance_matrix': [[0, 43, 50, 44, 27, 49, 43], [43, 0, 51, 32, 46, 47, 55], [50, 51, 0, 50, 45, 42, 42], [44, 32, 50, 0, 36, 57, 44], [27, 46, 45, 36, 0, 42, 54], [49, 47, 42, 57, 42, 0, 62], [43, 55, 42, 44, 54, 62, 0]], 'p': 1, 'objective': 250.0}","{'facilities': [4], 'assignments': [4, 4, 4, 4, 4, 4, 4]}",250.0,"{'problem_type': 'PMED', 'num_nodes': 7, 'num_open': 1, 'sites': [{'id': 0, 'distances': {0: 0, 1: 43, 2: 50, 3: 44, 4: 27, 5: 49, 6: 43}}, {'id': 1, 'distances': {0: 43, 1: 0, 2: 51, 3: 32, 4: 46, 5: 47, 6: 55}}, {'id': 2, 'distances': {0: 50, 1: 51, 2: 0, 3: 50, 4: 45, 5: 42, 6: 42}}, {'id': 3, 'distances': {0: 44, 1: 32, 2: 50, 3: 0, 4: 36, 5: 57, 6: 44}}, {'id': 4, 'distances': {0: 27, 1: 46, 2: 45, 3: 36, 4: 0, 5: 42, 6: 54}}, {'id': 5, 'distances': {0: 49, 1: 47, 2: 42, 3: 57, 4: 42, 5: 0, 6: 62}}, {'id': 6, 'distances': {0: 43, 1: 55, 2: 42, 3: 44, 4: 54, 5: 62, 6: 0}}], 'objective': 250.0}","{'selected': [4], 'assignments': [4, 4, 4, 4, 4, 4, 4]}",13,json,0
PMED,PMED,"I run the hospital’s community outreach, and now I have to pick a fixed number of pop‑up vaccination clinics to open in town at some of the community centers. Every neighborhood needs to be signed up with exactly one of those clinics — nobody gets left out or sent to two places — and the whole point is to make the total travel everyone has to do as small as possible. That means adding up the distance from each neighborhood to the clinic it’s assigned to, and choosing clinic sites so that that sum is as low as it can be. The specific list of candidate centers and the distances between neighborhoods and centers are shown below.

There are 7 locations in total; I must open 1 clinics and the listed location IDs are: 0, 1, 2, 3, 4, 5, 6.
I note the travel distance from 0 to 1 is 38.
I note the travel distance from 0 to 2 is 47.
I note the travel distance from 0 to 3 is 24.
I note the travel distance from 0 to 4 is 56.
I note the travel distance from 0 to 5 is 29.
I note the travel distance from 0 to 6 is 42.
I note the travel distance from 1 to 0 is 38.
I note the travel distance from 1 to 2 is 45.
I note the travel distance from 1 to 3 is 33.
I note the travel distance from 1 to 4 is 59.
I note the travel distance from 1 to 5 is 57.
I note the travel distance from 1 to 6 is 70.
I note the travel distance from 2 to 0 is 47.
I note the travel distance from 2 to 1 is 45.
I note the travel distance from 2 to 3 is 50.
I note the travel distance from 2 to 4 is 62.
I note the travel distance from 2 to 5 is 45.
I note the travel distance from 2 to 6 is 58.
I note the travel distance from 3 to 0 is 24.
I note the travel distance from 3 to 1 is 33.
I note the travel distance from 3 to 2 is 50.
I note the travel distance from 3 to 4 is 32.
I note the travel distance from 3 to 5 is 53.
I note the travel distance from 3 to 6 is 66.
I note the travel distance from 4 to 0 is 56.
I note the travel distance from 4 to 1 is 59.
I note the travel distance from 4 to 2 is 62.
I note the travel distance from 4 to 3 is 32.
I note the travel distance from 4 to 5 is 66.
I note the travel distance from 4 to 6 is 79.
I note the travel distance from 5 to 0 is 29.
I note the travel distance from 5 to 1 is 57.
I note the travel distance from 5 to 2 is 45.
I note the travel distance from 5 to 3 is 53.
I note the travel distance from 5 to 4 is 66.
I note the travel distance from 5 to 6 is 13.
I note the travel distance from 6 to 0 is 42.
I note the travel distance from 6 to 1 is 70.
I note the travel distance from 6 to 2 is 58.
I note the travel distance from 6 to 3 is 66.
I note the travel distance from 6 to 4 is 79.
I note the travel distance from 6 to 5 is 13.
With these distances, I'll choose 1 clinic sites from the 7 locations to minimize total travel.

I'll put the actual choices and assignments into a simple JSON snippet so it's easy to read and reuse. It'll follow this shape:

{
  ""solution"": {
    ""selected"": [<site_to_open>, <site_to_open>, ...],
    ""assignments"": [<chosen_open_site>, <chosen_open_site>, ...]
  }
}

""selected"" is where I'll list which community centers we decide to open as pop‑up clinics, and ""assignments"" is a matching list showing, for each neighborhood in the order they were given, which opened site it gets signed up with. This is just a sketch of the shape I will use — not the final answer.

Please make sure to use the exact identifiers from the instance input (don't rename them and don't invent new ones):
- 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”.""","{'distance_matrix': [[0, 38, 47, 24, 56, 29, 42], [38, 0, 45, 33, 59, 57, 70], [47, 45, 0, 50, 62, 45, 58], [24, 33, 50, 0, 32, 53, 66], [56, 59, 62, 32, 0, 66, 79], [29, 57, 45, 53, 66, 0, 13], [42, 70, 58, 66, 79, 13, 0]], 'p': 1, 'objective': 236.0}","{'facilities': [0], 'assignments': [0, 0, 0, 0, 0, 0, 0]}",236.0,"{'problem_type': 'PMED', 'num_nodes': 7, 'num_open': 1, 'sites': [{'id': 0, 'distances': {0: 0, 1: 38, 2: 47, 3: 24, 4: 56, 5: 29, 6: 42}}, {'id': 1, 'distances': {0: 38, 1: 0, 2: 45, 3: 33, 4: 59, 5: 57, 6: 70}}, {'id': 2, 'distances': {0: 47, 1: 45, 2: 0, 3: 50, 4: 62, 5: 45, 6: 58}}, {'id': 3, 'distances': {0: 24, 1: 33, 2: 50, 3: 0, 4: 32, 5: 53, 6: 66}}, {'id': 4, 'distances': {0: 56, 1: 59, 2: 62, 3: 32, 4: 0, 5: 66, 6: 79}}, {'id': 5, 'distances': {0: 29, 1: 57, 2: 45, 3: 53, 4: 66, 5: 0, 6: 13}}, {'id': 6, 'distances': {0: 42, 1: 70, 2: 58, 3: 66, 4: 79, 5: 13, 6: 0}}], 'objective': 236.0}","{'selected': [0], 'assignments': [0, 0, 0, 0, 0, 0, 0]}",14,nl,0
PMED,PMED,"We’ve been handed a list of candidate spots for temporary library pop‑ups and have to choose only a set number to actually open. Then each residential block gets attached to one of the opened spots — only one — and the success of the plan is judged by the combined walking distance of everyone: sum up the distance from each block to its assigned pop‑up, and the lower that combined distance, the better. The concrete locations and distances follow below.

{
  ""total_locations_count"": 8,
  ""popups_to_open"": 1,
  ""location_ids"": [
    1,
    2,
    3,
    4,
    5,
    6,
    7,
    8
  ],
  ""data"": [
    {
      ""origin_location_id"": 1,
      ""destination_location_id"": 2,
      ""walking_distance"": 189
    },
    {
      ""origin_location_id"": 1,
      ""destination_location_id"": 3,
      ""walking_distance"": 220
    },
    {
      ""origin_location_id"": 1,
      ""destination_location_id"": 4,
      ""walking_distance"": 121
    },
    {
      ""origin_location_id"": 1,
      ""destination_location_id"": 5,
      ""walking_distance"": 176
    },
    {
      ""origin_location_id"": 1,
      ""destination_location_id"": 6,
      ""walking_distance"": 134
    },
    {
      ""origin_location_id"": 1,
      ""destination_location_id"": 7,
      ""walking_distance"": 204
    },
    {
      ""origin_location_id"": 1,
      ""destination_location_id"": 8,
      ""walking_distance"": 89
    },
    {
      ""origin_location_id"": 2,
      ""destination_location_id"": 1,
      ""walking_distance"": 189
    },
    {
      ""origin_location_id"": 2,
      ""destination_location_id"": 3,
      ""walking_distance"": 181
    },
    {
      ""origin_location_id"": 2,
      ""destination_location_id"": 4,
      ""walking_distance"": 139
    },
    {
      ""origin_location_id"": 2,
      ""destination_location_id"": 5,
      ""walking_distance"": 210
    },
    {
      ""origin_location_id"": 2,
      ""destination_location_id"": 6,
      ""walking_distance"": 81
    },
    {
      ""origin_location_id"": 2,
      ""destination_location_id"": 7,
      ""walking_distance"": 147
    },
    {
      ""origin_location_id"": 2,
      ""destination_location_id"": 8,
      ""walking_distance"": 123
    },
    {
      ""origin_location_id"": 3,
      ""destination_location_id"": 1,
      ""walking_distance"": 220
    },
    {
      ""origin_location_id"": 3,
      ""destination_location_id"": 2,
      ""walking_distance"": 181
    },
    {
      ""origin_location_id"": 3,
      ""destination_location_id"": 4,
      ""walking_distance"": 144
    },
    {
      ""origin_location_id"": 3,
      ""destination_location_id"": 5,
      ""walking_distance"": 280
    },
    {
      ""origin_location_id"": 3,
      ""destination_location_id"": 6,
      ""walking_distance"": 134
    },
    {
      ""origin_location_id"": 3,
      ""destination_location_id"": 7,
      ""walking_distance"": 200
    },
    {
      ""origin_location_id"": 3,
      ""destination_location_id"": 8,
      ""walking_distance"": 201
    },
    {
      ""origin_location_id"": 4,
      ""destination_location_id"": 1,
      ""walking_distance"": 121
    },
    {
      ""origin_location_id"": 4,
      ""destination_location_id"": 2,
      ""walking_distance"": 139
    },
    {
      ""origin_location_id"": 4,
      ""destination_location_id"": 3,
      ""walking_distance"": 144
    },
    {
      ""origin_location_id"": 4,
      ""destination_location_id"": 5,
      ""walking_distance"": 208
    },
    {
      ""origin_location_id"": 4,
      ""destination_location_id"": 6,
      ""walking_distance"": 58
    },
    {
      ""origin_location_id"": 4,
      ""destination_location_id"": 7,
      ""walking_distance"": 128
    },
    {
      ""origin_location_id"": 4,
      ""destination_location_id"": 8,
      ""walking_distance"": 127
    },
    {
      ""origin_location_id"": 5,
      ""destination_location_id"": 1,
      ""walking_distance"": 176
    },
    {
      ""origin_location_id"": 5,
      ""destination_location_id"": 2,
      ""walking_distance"": 210
    },
    {
      ""origin_location_id"": 5,
      ""destination_location_id"": 3,
      ""walking_distance"": 280
    },
    {
      ""origin_location_id"": 5,
      ""destination_location_id"": 4,
      ""walking_distance"": 208
    },
    {
      ""origin_location_id"": 5,
      ""destination_location_id"": 6,
      ""walking_distance"": 160
    },
    {
      ""origin_location_id"": 5,
      ""destination_location_id"": 7,
      ""walking_distance"": 90
    },
    {
      ""origin_location_id"": 5,
      ""destination_location_id"": 8,
      ""walking_distance"": 87
    },
    {
      ""origin_location_id"": 6,
      ""destination_location_id"": 1,
      ""walking_distance"": 134
    },
    {
      ""origin_location_id"": 6,
      ""destination_location_id"": 2,
      ""walking_distance"": 81
    },
    {
      ""origin_location_id"": 6,
      ""destination_location_id"": 3,
      ""walking_distance"": 134
    },
    {
      ""origin_location_id"": 6,
      ""destination_location_id"": 4,
      ""walking_distance"": 58
    },
    {
      ""origin_location_id"": 6,
      ""destination_location_id"": 5,
      ""walking_distance"": 160
    },
    {
      ""origin_location_id"": 6,
      ""destination_location_id"": 7,
      ""walking_distance"": 96
    },
    {
      ""origin_location_id"": 6,
      ""destination_location_id"": 8,
      ""walking_distance"": 114
    },
    {
      ""origin_location_id"": 7,
      ""destination_location_id"": 1,
      ""walking_distance"": 204
    },
    {
      ""origin_location_id"": 7,
      ""destination_location_id"": 2,
      ""walking_distance"": 147
    },
    {
      ""origin_location_id"": 7,
      ""destination_location_id"": 3,
      ""walking_distance"": 200
    },
    {
      ""origin_location_id"": 7,
      ""destination_location_id"": 4,
      ""walking_distance"": 128
    },
    {
      ""origin_location_id"": 7,
      ""destination_location_id"": 5,
      ""walking_distance"": 90
    },
    {
      ""origin_location_id"": 7,
      ""destination_location_id"": 6,
      ""walking_distance"": 96
    },
    {
      ""origin_location_id"": 7,
      ""destination_location_id"": 8,
      ""walking_distance"": 130
    },
    {
      ""origin_location_id"": 8,
      ""destination_location_id"": 1,
      ""walking_distance"": 89
    },
    {
      ""origin_location_id"": 8,
      ""destination_location_id"": 2,
      ""walking_distance"": 123
    },
    {
      ""origin_location_id"": 8,
      ""destination_location_id"": 3,
      ""walking_distance"": 201
    },
    {
      ""origin_location_id"": 8,
      ""destination_location_id"": 4,
      ""walking_distance"": 127
    },
    {
      ""origin_location_id"": 8,
      ""destination_location_id"": 5,
      ""walking_distance"": 87
    },
    {
      ""origin_location_id"": 8,
      ""destination_location_id"": 6,
      ""walking_distance"": 114
    },
    {
      ""origin_location_id"": 8,
      ""destination_location_id"": 7,
      ""walking_distance"": 130
    }
  ]
}

Also, when you send the actual selection back, please use this JSON layout so it's easy for me to read and parse:

{
  ""solution"": {
    ""selected"": [<site_to_open>, <site_to_open>, ...],
    ""assignments"": [<assigned_pop_up>, <assigned_pop_up>, ...]
  }
}

'selected' is where you list the pop‑up locations you choose to open, and 'assignments' lists, for each residential block in the same order as the input, which opened pop‑up it gets attached to. Think of it like a simple form: which sites are open, and which open site each block is assigned to.

This is just the sketch of the shape I expect — not the final answer.

All identifiers must be used exactly as they appear in the instance input — no renaming and no new labels.
- for example: ""Valid identifiers look like plain numbers such as “1” or “23”, single capital letters like “A” or “B”, or a capital letter followed by digits like “A1” or “X7”.""","{'distance_matrix': [[0, 189, 220, 121, 176, 134, 204, 89], [189, 0, 181, 139, 210, 81, 147, 123], [220, 181, 0, 144, 280, 134, 200, 201], [121, 139, 144, 0, 208, 58, 128, 127], [176, 210, 280, 208, 0, 160, 90, 87], [134, 81, 134, 58, 160, 0, 96, 114], [204, 147, 200, 128, 90, 96, 0, 130], [89, 123, 201, 127, 87, 114, 130, 0]], 'p': 1, 'objective': 777.0}","{'facilities': [5], 'assignments': [5, 5, 5, 5, 5, 5, 5, 5]}",777.0,"{'problem_type': 'PMED', 'num_nodes': 8, 'num_open': 1, 'sites': [{'id': 1, 'distances': {1: 0, 2: 189, 3: 220, 4: 121, 5: 176, 6: 134, 7: 204, 8: 89}}, {'id': 2, 'distances': {1: 189, 2: 0, 3: 181, 4: 139, 5: 210, 6: 81, 7: 147, 8: 123}}, {'id': 3, 'distances': {1: 220, 2: 181, 3: 0, 4: 144, 5: 280, 6: 134, 7: 200, 8: 201}}, {'id': 4, 'distances': {1: 121, 2: 139, 3: 144, 4: 0, 5: 208, 6: 58, 7: 128, 8: 127}}, {'id': 5, 'distances': {1: 176, 2: 210, 3: 280, 4: 208, 5: 0, 6: 160, 7: 90, 8: 87}}, {'id': 6, 'distances': {1: 134, 2: 81, 3: 134, 4: 58, 5: 160, 6: 0, 7: 96, 8: 114}}, {'id': 7, 'distances': {1: 204, 2: 147, 3: 200, 4: 128, 5: 90, 6: 96, 7: 0, 8: 130}}, {'id': 8, 'distances': {1: 89, 2: 123, 3: 201, 4: 127, 5: 87, 6: 114, 7: 130, 8: 0}}], 'objective': 777.0}","{'selected': [6], 'assignments': [6, 6, 6, 6, 6, 6, 6, 6]}",15,json,1
PMED,PMED,"Someone at the waste reduction office has to decide which curbside candidates will get the new glass bins — but only a set number can be installed. Each neighborhood must go to one, and only one, installed bin; then the quality of any selection is judged by adding together all the distances people would travel from their area to their assigned bin — the lower that combined distance, the more efficient the placement. The exact spots and distance details appear below.

{
  ""total_locations"": 6,
  ""bins_to_install"": 1,
  ""location_ids"": [
    0,
    1,
    2,
    3,
    4,
    5
  ],
  ""data"": [
    {
      ""origin_location_id"": 0,
      ""destination_location_id"": 1,
      ""travel_distance"": 36
    },
    {
      ""origin_location_id"": 0,
      ""destination_location_id"": 2,
      ""travel_distance"": 37
    },
    {
      ""origin_location_id"": 0,
      ""destination_location_id"": 3,
      ""travel_distance"": 38
    },
    {
      ""origin_location_id"": 0,
      ""destination_location_id"": 4,
      ""travel_distance"": 42
    },
    {
      ""origin_location_id"": 0,
      ""destination_location_id"": 5,
      ""travel_distance"": 33
    },
    {
      ""origin_location_id"": 1,
      ""destination_location_id"": 0,
      ""travel_distance"": 36
    },
    {
      ""origin_location_id"": 1,
      ""destination_location_id"": 2,
      ""travel_distance"": 35
    },
    {
      ""origin_location_id"": 1,
      ""destination_location_id"": 3,
      ""travel_distance"": 22
    },
    {
      ""origin_location_id"": 1,
      ""destination_location_id"": 4,
      ""travel_distance"": 40
    },
    {
      ""origin_location_id"": 1,
      ""destination_location_id"": 5,
      ""travel_distance"": 31
    },
    {
      ""origin_location_id"": 2,
      ""destination_location_id"": 0,
      ""travel_distance"": 37
    },
    {
      ""origin_location_id"": 2,
      ""destination_location_id"": 1,
      ""travel_distance"": 35
    },
    {
      ""origin_location_id"": 2,
      ""destination_location_id"": 3,
      ""travel_distance"": 33
    },
    {
      ""origin_location_id"": 2,
      ""destination_location_id"": 4,
      ""travel_distance"": 40
    },
    {
      ""origin_location_id"": 2,
      ""destination_location_id"": 5,
      ""travel_distance"": 39
    },
    {
      ""origin_location_id"": 3,
      ""destination_location_id"": 0,
      ""travel_distance"": 38
    },
    {
      ""origin_location_id"": 3,
      ""destination_location_id"": 1,
      ""travel_distance"": 22
    },
    {
      ""origin_location_id"": 3,
      ""destination_location_id"": 2,
      ""travel_distance"": 33
    },
    {
      ""origin_location_id"": 3,
      ""destination_location_id"": 4,
      ""travel_distance"": 28
    },
    {
      ""origin_location_id"": 3,
      ""destination_location_id"": 5,
      ""travel_distance"": 24
    },
    {
      ""origin_location_id"": 4,
      ""destination_location_id"": 0,
      ""travel_distance"": 42
    },
    {
      ""origin_location_id"": 4,
      ""destination_location_id"": 1,
      ""travel_distance"": 40
    },
    {
      ""origin_location_id"": 4,
      ""destination_location_id"": 2,
      ""travel_distance"": 40
    },
    {
      ""origin_location_id"": 4,
      ""destination_location_id"": 3,
      ""travel_distance"": 28
    },
    {
      ""origin_location_id"": 4,
      ""destination_location_id"": 5,
      ""travel_distance"": 35
    },
    {
      ""origin_location_id"": 5,
      ""destination_location_id"": 0,
      ""travel_distance"": 33
    },
    {
      ""origin_location_id"": 5,
      ""destination_location_id"": 1,
      ""travel_distance"": 31
    },
    {
      ""origin_location_id"": 5,
      ""destination_location_id"": 2,
      ""travel_distance"": 39
    },
    {
      ""origin_location_id"": 5,
      ""destination_location_id"": 3,
      ""travel_distance"": 24
    },
    {
      ""origin_location_id"": 5,
      ""destination_location_id"": 4,
      ""travel_distance"": 35
    }
  ]
}

You can put the answer in a small JSON snippet like this so it's easy to parse and check — something casual and form-like:

{
  ""solution"": {
    ""selected"": [<site_to_open>, <site_to_open>, ...],
    ""assignments"": [<assigned_site>, <assigned_site>, ...]
  }
}

selected lists which curbside spots actually get bins installed. assignments lists, for each neighborhood (in the same order as the input), which opened spot that neighborhood will go to. Think of it like a simple form: picked sites up top, then a list saying where each area should drop off their glass.

This JSON is just a sketch of the shape I need back, not the final answer itself. Please make sure all identifiers you use match exactly what's in the instance input — do not rename them and do not invent new labels. 

Valid identifiers look like plain numbers such as “1” or “23”, single capital letters like “A” or “B”, or a capital letter followed by digits like “A1” or “X7”.","{'distance_matrix': [[0, 36, 37, 38, 42, 33], [36, 0, 35, 22, 40, 31], [37, 35, 0, 33, 40, 39], [38, 22, 33, 0, 28, 24], [42, 40, 40, 28, 0, 35], [33, 31, 39, 24, 35, 0]], 'p': 1, 'objective': 145.0}","{'facilities': [3], 'assignments': [3, 3, 3, 3, 3, 3]}",145.0,"{'problem_type': 'PMED', 'num_nodes': 6, 'num_open': 1, 'sites': [{'id': 0, 'distances': {0: 0, 1: 36, 2: 37, 3: 38, 4: 42, 5: 33}}, {'id': 1, 'distances': {0: 36, 1: 0, 2: 35, 3: 22, 4: 40, 5: 31}}, {'id': 2, 'distances': {0: 37, 1: 35, 2: 0, 3: 33, 4: 40, 5: 39}}, {'id': 3, 'distances': {0: 38, 1: 22, 2: 33, 3: 0, 4: 28, 5: 24}}, {'id': 4, 'distances': {0: 42, 1: 40, 2: 40, 3: 28, 4: 0, 5: 35}}, {'id': 5, 'distances': {0: 33, 1: 31, 2: 39, 3: 24, 4: 35, 5: 0}}], 'objective': 145.0}","{'selected': [3], 'assignments': [3, 3, 3, 3, 3, 3]}",16,json,0
PMED,PMED,"We’re juggling limited maintenance crews and can only staff a set number of warming huts across the slopes. The job is to pick which ones to keep open and then assign each lift terminal to exactly one of those open huts — nothing can be skipped and no terminal gets two huts. To see which choice is best, we sum the distances from every terminal to its assigned hut and aim for the lowest possible total. The concrete details follow below.

We have 7 total locations, can keep 2 huts open, and the candidate sites (each a lift terminal) are A, B, C, D, E, F, G.
We record a travel distance of 47 from A to B.
We record a travel distance of 45 from A to C.
We record a travel distance of 12 from A to D.
We record a travel distance of 45 from A to E.
We record a travel distance of 37 from A to F.
We record a travel distance of 39 from A to G.
We record a travel distance of 47 from B to A.
We record a travel distance of 37 from B to C.
We record a travel distance of 45 from B to D.
We record a travel distance of 20 from B to E.
We record a travel distance of 33 from B to F.
We record a travel distance of 38 from B to G.
We record a travel distance of 45 from C to A.
We record a travel distance of 37 from C to B.
We record a travel distance of 41 from C to D.
We record a travel distance of 45 from C to E.
We record a travel distance of 23 from C to F.
We record a travel distance of 39 from C to G.
We record a travel distance of 12 from D to A.
We record a travel distance of 45 from D to B.
We record a travel distance of 41 from D to C.
We record a travel distance of 41 from D to E.
We record a travel distance of 33 from D to F.
We record a travel distance of 27 from D to G.
We record a travel distance of 45 from E to A.
We record a travel distance of 20 from E to B.
We record a travel distance of 45 from E to C.
We record a travel distance of 41 from E to D.
We record a travel distance of 38 from E to F.
We record a travel distance of 40 from E to G.
We record a travel distance of 37 from F to A.
We record a travel distance of 33 from F to B.
We record a travel distance of 23 from F to C.
We record a travel distance of 33 from F to D.
We record a travel distance of 38 from F to E.
We record a travel distance of 29 from F to G.
We record a travel distance of 39 from G to A.
We record a travel distance of 38 from G to B.
We record a travel distance of 39 from G to C.
We record a travel distance of 27 from G to D.
We record a travel distance of 40 from G to E.
We record a travel distance of 29 from G to F.
We’ll pick which 2 huts to staff among the 7 locations above to minimize the total travel distance.

I'll keep the answer shape simple so you can plug values in easily — below is the expected JSON layout you should follow.

{
  ""solution"": {
    ""selected"": [<hut_to_open>, <hut_to_open>, ...],
    ""assignments"": [<assigned_hut>, <assigned_hut>, ...]
  }
}

Pretty straightforward: ""selected"" is the list of warming huts we choose to staff (the ones we leave open), and ""assignments"" lists, in the same order as the terminals in the instance, which open hut each terminal is assigned to. Think of it like a short form: pick your open huts, then for every terminal say which open hut serves it.

This JSON is just a sketch of the shape I need you to return — not the actual solution yet. Also, please use the exact identifiers from the instance input, no renaming and no new labels.
- for example: ""Valid identifiers look like plain numbers such as “1” or “23”, single capital letters like “A” or “B”, or a capital letter followed by digits like “A1” or “X7”.""","{'distance_matrix': [[0, 47, 45, 12, 45, 37, 39], [47, 0, 37, 45, 20, 33, 38], [45, 37, 0, 41, 45, 23, 39], [12, 45, 41, 0, 41, 33, 27], [45, 20, 45, 41, 0, 38, 40], [37, 33, 23, 33, 38, 0, 29], [39, 38, 39, 27, 40, 29, 0]], 'p': 2, 'objective': 129.0}","{'facilities': [1, 3], 'assignments': [3, 1, 1, 3, 1, 3, 3]}",129.0,"{'problem_type': 'PMED', 'num_nodes': 7, 'num_open': 2, 'sites': [{'id': 'A', 'distances': {'A': 0, 'B': 47, 'C': 45, 'D': 12, 'E': 45, 'F': 37, 'G': 39}}, {'id': 'B', 'distances': {'A': 47, 'B': 0, 'C': 37, 'D': 45, 'E': 20, 'F': 33, 'G': 38}}, {'id': 'C', 'distances': {'A': 45, 'B': 37, 'C': 0, 'D': 41, 'E': 45, 'F': 23, 'G': 39}}, {'id': 'D', 'distances': {'A': 12, 'B': 45, 'C': 41, 'D': 0, 'E': 41, 'F': 33, 'G': 27}}, {'id': 'E', 'distances': {'A': 45, 'B': 20, 'C': 45, 'D': 41, 'E': 0, 'F': 38, 'G': 40}}, {'id': 'F', 'distances': {'A': 37, 'B': 33, 'C': 23, 'D': 33, 'E': 38, 'F': 0, 'G': 29}}, {'id': 'G', 'distances': {'A': 39, 'B': 38, 'C': 39, 'D': 27, 'E': 40, 'F': 29, 'G': 0}}], 'objective': 129.0}","{'selected': ['B', 'D'], 'assignments': ['D', 'B', 'B', 'D', 'B', 'D', 'D']}",17,nl,names
PMED,PMED,"I manage the gear and trucks for a construction company, and the puzzle this week is picking a set number of yards to turn into equipment depots. Once those depots are chosen, every job site has to be assigned to one—and only one—of the open depots. The idea is simple: look at the distance from each site to the depot it's tied to, add up all those hauling distances, and try to make that grand total as small as possible. The exact candidate yards, the distances between places, and how many depots we’re allowed to open are listed below.

{
  ""num_locations"": 7,
  ""num_depots_to_open"": 1,
  ""location_ids"": [
    ""A"",
    ""B"",
    ""C"",
    ""D"",
    ""E"",
    ""F"",
    ""G""
  ],
  ""data"": [
    {
      ""origin_location_id"": ""A"",
      ""destination_location_id"": ""B"",
      ""haul_distance"": 42
    },
    {
      ""origin_location_id"": ""A"",
      ""destination_location_id"": ""C"",
      ""haul_distance"": 49
    },
    {
      ""origin_location_id"": ""A"",
      ""destination_location_id"": ""D"",
      ""haul_distance"": 97
    },
    {
      ""origin_location_id"": ""A"",
      ""destination_location_id"": ""E"",
      ""haul_distance"": 151
    },
    {
      ""origin_location_id"": ""A"",
      ""destination_location_id"": ""F"",
      ""haul_distance"": 157
    },
    {
      ""origin_location_id"": ""A"",
      ""destination_location_id"": ""G"",
      ""haul_distance"": 154
    },
    {
      ""origin_location_id"": ""B"",
      ""destination_location_id"": ""A"",
      ""haul_distance"": 42
    },
    {
      ""origin_location_id"": ""B"",
      ""destination_location_id"": ""C"",
      ""haul_distance"": 91
    },
    {
      ""origin_location_id"": ""B"",
      ""destination_location_id"": ""D"",
      ""haul_distance"": 55
    },
    {
      ""origin_location_id"": ""B"",
      ""destination_location_id"": ""E"",
      ""haul_distance"": 109
    },
    {
      ""origin_location_id"": ""B"",
      ""destination_location_id"": ""F"",
      ""haul_distance"": 147
    },
    {
      ""origin_location_id"": ""B"",
      ""destination_location_id"": ""G"",
      ""haul_distance"": 134
    },
    {
      ""origin_location_id"": ""C"",
      ""destination_location_id"": ""A"",
      ""haul_distance"": 49
    },
    {
      ""origin_location_id"": ""C"",
      ""destination_location_id"": ""B"",
      ""haul_distance"": 91
    },
    {
      ""origin_location_id"": ""C"",
      ""destination_location_id"": ""D"",
      ""haul_distance"": 133
    },
    {
      ""origin_location_id"": ""C"",
      ""destination_location_id"": ""E"",
      ""haul_distance"": 139
    },
    {
      ""origin_location_id"": ""C"",
      ""destination_location_id"": ""F"",
      ""haul_distance"": 194
    },
    {
      ""origin_location_id"": ""C"",
      ""destination_location_id"": ""G"",
      ""haul_distance"": 203
    },
    {
      ""origin_location_id"": ""D"",
      ""destination_location_id"": ""A"",
      ""haul_distance"": 97
    },
    {
      ""origin_location_id"": ""D"",
      ""destination_location_id"": ""B"",
      ""haul_distance"": 55
    },
    {
      ""origin_location_id"": ""D"",
      ""destination_location_id"": ""C"",
      ""haul_distance"": 133
    },
    {
      ""origin_location_id"": ""D"",
      ""destination_location_id"": ""E"",
      ""haul_distance"": 54
    },
    {
      ""origin_location_id"": ""D"",
      ""destination_location_id"": ""F"",
      ""haul_distance"": 162
    },
    {
      ""origin_location_id"": ""D"",
      ""destination_location_id"": ""G"",
      ""haul_distance"": 182
    },
    {
      ""origin_location_id"": ""E"",
      ""destination_location_id"": ""A"",
      ""haul_distance"": 151
    },
    {
      ""origin_location_id"": ""E"",
      ""destination_location_id"": ""B"",
      ""haul_distance"": 109
    },
    {
      ""origin_location_id"": ""E"",
      ""destination_location_id"": ""C"",
      ""haul_distance"": 139
    },
    {
      ""origin_location_id"": ""E"",
      ""destination_location_id"": ""D"",
      ""haul_distance"": 54
    },
    {
      ""origin_location_id"": ""E"",
      ""destination_location_id"": ""F"",
      ""haul_distance"": 139
    },
    {
      ""origin_location_id"": ""E"",
      ""destination_location_id"": ""G"",
      ""haul_distance"": 182
    },
    {
      ""origin_location_id"": ""F"",
      ""destination_location_id"": ""A"",
      ""haul_distance"": 157
    },
    {
      ""origin_location_id"": ""F"",
      ""destination_location_id"": ""B"",
      ""haul_distance"": 147
    },
    {
      ""origin_location_id"": ""F"",
      ""destination_location_id"": ""C"",
      ""haul_distance"": 194
    },
    {
      ""origin_location_id"": ""F"",
      ""destination_location_id"": ""D"",
      ""haul_distance"": 162
    },
    {
      ""origin_location_id"": ""F"",
      ""destination_location_id"": ""E"",
      ""haul_distance"": 139
    },
    {
      ""origin_location_id"": ""F"",
      ""destination_location_id"": ""G"",
      ""haul_distance"": 211
    },
    {
      ""origin_location_id"": ""G"",
      ""destination_location_id"": ""A"",
      ""haul_distance"": 154
    },
    {
      ""origin_location_id"": ""G"",
      ""destination_location_id"": ""B"",
      ""haul_distance"": 134
    },
    {
      ""origin_location_id"": ""G"",
      ""destination_location_id"": ""C"",
      ""haul_distance"": 203
    },
    {
      ""origin_location_id"": ""G"",
      ""destination_location_id"": ""D"",
      ""haul_distance"": 182
    },
    {
      ""origin_location_id"": ""G"",
      ""destination_location_id"": ""E"",
      ""haul_distance"": 182
    },
    {
      ""origin_location_id"": ""G"",
      ""destination_location_id"": ""F"",
      ""haul_distance"": 211
    }
  ]
}

I'll keep the answer format simple so you can plug it into whatever tool or checklist you're using — here's the little JSON sketch I'd like the final reply to follow.

{
  ""solution"": {
    ""selected"": [<site_to_open>, <site_to_open>, ...],
    ""assignments"": [<chosen_open_site>, <chosen_open_site>, ...]
  }
}

""selected"" is where you list which yards you decide to open as depots. ""assignments"" is a parallel list that, for each candidate location in the same order as the input, names the open yard that location will use. Think of it like a short form: the first array says which yards are turned into depots, the second array ties every job site to one of those depots.

This JSON is just the shape I want the answer to take — a sketch, not the actual solution values.

Please remember: use the identifiers exactly as they appear in the instance input — do not rename them and do not invent any 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”.""","{'distance_matrix': [[0, 42, 49, 97, 151, 157, 154], [42, 0, 91, 55, 109, 147, 134], [49, 91, 0, 133, 139, 194, 203], [97, 55, 133, 0, 54, 162, 182], [151, 109, 139, 54, 0, 139, 182], [157, 147, 194, 162, 139, 0, 211], [154, 134, 203, 182, 182, 211, 0]], 'p': 1, 'objective': 578.0}","{'facilities': [1], 'assignments': [1, 1, 1, 1, 1, 1, 1]}",578.0,"{'problem_type': 'PMED', 'num_nodes': 7, 'num_open': 1, 'sites': [{'id': 'A', 'distances': {'A': 0, 'B': 42, 'C': 49, 'D': 97, 'E': 151, 'F': 157, 'G': 154}}, {'id': 'B', 'distances': {'A': 42, 'B': 0, 'C': 91, 'D': 55, 'E': 109, 'F': 147, 'G': 134}}, {'id': 'C', 'distances': {'A': 49, 'B': 91, 'C': 0, 'D': 133, 'E': 139, 'F': 194, 'G': 203}}, {'id': 'D', 'distances': {'A': 97, 'B': 55, 'C': 133, 'D': 0, 'E': 54, 'F': 162, 'G': 182}}, {'id': 'E', 'distances': {'A': 151, 'B': 109, 'C': 139, 'D': 54, 'E': 0, 'F': 139, 'G': 182}}, {'id': 'F', 'distances': {'A': 157, 'B': 147, 'C': 194, 'D': 162, 'E': 139, 'F': 0, 'G': 211}}, {'id': 'G', 'distances': {'A': 154, 'B': 134, 'C': 203, 'D': 182, 'E': 182, 'F': 211, 'G': 0}}], 'objective': 578.0}","{'selected': ['B'], 'assignments': ['B', 'B', 'B', 'B', 'B', 'B', 'B']}",18,json,names
PMED,PMED,"Picture this: a map of neighborhoods and potential store windows, and a limit on how many pop‑ups can actually be opened. The task is to decide which storefronts to activate and which single open space each artist neighborhood will go to — every neighborhood must be assigned to exactly one chosen storefront, with no overlaps or gaps. The winning setup is the one that keeps visitors’ journeys short overall — for each neighborhood note the distance to its assigned pop‑up, add all those distances together, and choose the plan with the lowest sum. The detailed data appears below.

# num_candidate_locations=5
# num_popups_to_open=2
# location_ids=1, 2, 3, 4, 5
from_location_id,to_location_id,travel_distance_between_locations
1,2,33
1,3,27
1,4,31
1,5,29
2,1,33
2,3,30
2,4,40
2,5,13
3,1,27
3,2,30
3,4,29
3,5,32
4,1,31
4,2,40
4,3,29
4,5,29
5,1,29
5,2,13
5,3,32
5,4,29

You can just return the plan using a tiny JSON snippet like this — nothing fancy, just that shape so it’s easy to read and check.

{
  ""solution"": {
    ""selected"": [<storefront_to_open>, <storefront_to_open>, ...],
    ""assignments"": [<assigned_storefront>, <assigned_storefront>, ...]
  }
}

""selected"" is the list of storefronts you decide to open. ""assignments"" lists, for each neighborhood in the input (in the same order), which opened storefront that neighborhood will go to. Super casual: think of ""selected"" as the open pop‑ups and ""assignments"" as each neighborhood’s chosen window.

This JSON is just the shape I need — not the real answer itself. Please make sure you use the exact identifiers from the instance input with no renaming and no invented labels. Valid identifiers look like:
- plain numbers such as “1” or “23”
- single capital letters like “A” or “B”
- a capital letter followed by digits like “A1” or “X7”","{'distance_matrix': [[0, 33, 27, 31, 29], [33, 0, 30, 40, 13], [27, 30, 0, 29, 32], [31, 40, 29, 0, 29], [29, 13, 32, 29, 0]], 'p': 2, 'objective': 69.0}","{'facilities': [2, 4], 'assignments': [2, 4, 2, 2, 4]}",69.0,"{'problem_type': 'PMED', 'num_nodes': 5, 'num_open': 2, 'sites': [{'id': 1, 'distances': {1: 0, 2: 33, 3: 27, 4: 31, 5: 29}}, {'id': 2, 'distances': {1: 33, 2: 0, 3: 30, 4: 40, 5: 13}}, {'id': 3, 'distances': {1: 27, 2: 30, 3: 0, 4: 29, 5: 32}}, {'id': 4, 'distances': {1: 31, 2: 40, 3: 29, 4: 0, 5: 29}}, {'id': 5, 'distances': {1: 29, 2: 13, 3: 32, 4: 29, 5: 0}}], 'objective': 69.0}","{'selected': [3, 5], 'assignments': [3, 5, 3, 3, 5]}",19,csv,1
PMED,PMED,"We need to decide where to put a set number of health posts and which village goes to which post so folks don’t travel farther than necessary. Pick exactly the number of clinics allowed, and then give each village one—and only one—clinic to use; nothing is left unassigned and nothing is doubled up. What makes one arrangement better than another is simply the total distance everyone has to travel: compute it by summing each village’s trip to its assigned clinic, and aim for that sum to be as small as possible. The specific villages, possible locations, pairwise distances, and the allowed clinic count are listed below.

We have 7 villages (1, 2, 3, 4, 5, 6, 7) and must open exactly 1 clinics.
From 1 to 2, trip distance is 85.
From 1 to 3, trip distance is 55.
From 1 to 4, trip distance is 97.
From 1 to 5, trip distance is 63.
From 1 to 6, trip distance is 76.
From 1 to 7, trip distance is 100.
From 2 to 1, trip distance is 85.
From 2 to 3, trip distance is 62.
From 2 to 4, trip distance is 112.
From 2 to 5, trip distance is 44.
From 2 to 6, trip distance is 71.
From 2 to 7, trip distance is 94.
From 3 to 1, trip distance is 55.
From 3 to 2, trip distance is 62.
From 3 to 4, trip distance is 86.
From 3 to 5, trip distance is 68.
From 3 to 6, trip distance is 66.
From 3 to 7, trip distance is 83.
From 4 to 1, trip distance is 97.
From 4 to 2, trip distance is 112.
From 4 to 3, trip distance is 86.
From 4 to 5, trip distance is 68.
From 4 to 6, trip distance is 55.
From 4 to 7, trip distance is 85.
From 5 to 1, trip distance is 63.
From 5 to 2, trip distance is 44.
From 5 to 3, trip distance is 68.
From 5 to 4, trip distance is 68.
From 5 to 6, trip distance is 27.
From 5 to 7, trip distance is 71.
From 6 to 1, trip distance is 76.
From 6 to 2, trip distance is 71.
From 6 to 3, trip distance is 66.
From 6 to 4, trip distance is 55.
From 6 to 5, trip distance is 27.
From 6 to 7, trip distance is 69.
From 7 to 1, trip distance is 100.
From 7 to 2, trip distance is 94.
From 7 to 3, trip distance is 83.
From 7 to 4, trip distance is 85.
From 7 to 5, trip distance is 71.
From 7 to 6, trip distance is 69.
Use these distances to sum each village’s trip and choose the 1 clinic locations that minimize total travel.

Oh, and to keep things tidy, please give your answer using this simple JSON layout so it's easy to read and use:

{
  ""solution"": {
    ""selected"": [<site_to_open>, <site_to_open>, ...],
    ""assignments"": [<assigned_site>, <assigned_site>, ...]
  }
}

""selected"" is just the list of clinics you choose to open. ""assignments"" is a list that says which clinic each village will use (in the same order the villages were listed). This is just a sketch of the shape I expect — not the actual solution.

Please make sure you use the exact identifiers from the instance input with no renaming and no new labels.
- for example: ""Valid identifiers look like plain numbers such as “1” or “23”, single capital letters like “A” or “B”, or a capital letter followed by digits like “A1” or “X7”"".","{'distance_matrix': [[0, 85, 55, 97, 63, 76, 100], [85, 0, 62, 112, 44, 71, 94], [55, 62, 0, 86, 68, 66, 83], [97, 112, 86, 0, 68, 55, 85], [63, 44, 68, 68, 0, 27, 71], [76, 71, 66, 55, 27, 0, 69], [100, 94, 83, 85, 71, 69, 0]], 'p': 1, 'objective': 341.0}","{'facilities': [4], 'assignments': [4, 4, 4, 4, 4, 4, 4]}",341.0,"{'problem_type': 'PMED', 'num_nodes': 7, 'num_open': 1, 'sites': [{'id': 1, 'distances': {1: 0, 2: 85, 3: 55, 4: 97, 5: 63, 6: 76, 7: 100}}, {'id': 2, 'distances': {1: 85, 2: 0, 3: 62, 4: 112, 5: 44, 6: 71, 7: 94}}, {'id': 3, 'distances': {1: 55, 2: 62, 3: 0, 4: 86, 5: 68, 6: 66, 7: 83}}, {'id': 4, 'distances': {1: 97, 2: 112, 3: 86, 4: 0, 5: 68, 6: 55, 7: 85}}, {'id': 5, 'distances': {1: 63, 2: 44, 3: 68, 4: 68, 5: 0, 6: 27, 7: 71}}, {'id': 6, 'distances': {1: 76, 2: 71, 3: 66, 4: 55, 5: 27, 6: 0, 7: 69}}, {'id': 7, 'distances': {1: 100, 2: 94, 3: 83, 4: 85, 5: 71, 6: 69, 7: 0}}], 'objective': 341.0}","{'selected': [5], 'assignments': [5, 5, 5, 5, 5, 5, 5]}",20,markdown_table,1
PMED,PMED,"Someone in charge of the chain has to choose a limited set of stores to keep running and then assign each customer zone to a single one of those stores. Each zone gets one, and only one, assigned store — nothing gets skipped or duplicated. The way to measure success is to add together the distance from each zone to its chosen store; the smaller that grand total, the better the decision. See the detailed instance information below.

# total_locations=6
# stores_to_keep_open=2
# location_ids=1, 2, 3, 4, 5, 6
origin_location_id,destination_location_id,travel_distance
1,2,53
1,3,43
1,4,35
1,5,48
1,6,48
2,1,53
2,3,25
2,4,33
2,5,28
2,6,40
3,1,43
3,2,25
3,4,20
3,5,26
3,6,25
4,1,35
4,2,33
4,3,20
4,5,29
4,6,25
5,1,48
5,2,28
5,3,26
5,4,29
5,6,37
6,1,48
6,2,40
6,3,25
6,4,25
6,5,37

Oh, and when you send the solution back, just stick to this simple JSON shape so it's easy to parse:

{
  ""solution"": {
    ""selected"": [<site_to_open>, <site_to_open>, ...],
    ""assignments"": [<site_assigned>, <site_assigned>, ...]
  }
}

Think of ""selected"" as the list of store locations you decide to keep open, and ""assignments"" as, for each customer zone (in the same order as the input), which opened store that zone is assigned to. Super casual — it's just a form to fill, not the real answer yet.

Please use the exact identifiers from the instance input when you fill those placeholders — don't invent new labels or rename them. 

""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”.""","{'distance_matrix': [[0, 53, 43, 35, 48, 48], [53, 0, 25, 33, 28, 40], [43, 25, 0, 20, 26, 25], [35, 33, 20, 0, 29, 25], [48, 28, 26, 29, 0, 37], [48, 40, 25, 25, 37, 0]], 'p': 2, 'objective': 96.0}","{'facilities': [0, 2], 'assignments': [0, 2, 2, 2, 2, 2]}",96.0,"{'problem_type': 'PMED', 'num_nodes': 6, 'num_open': 2, 'sites': [{'id': 1, 'distances': {1: 0, 2: 53, 3: 43, 4: 35, 5: 48, 6: 48}}, {'id': 2, 'distances': {1: 53, 2: 0, 3: 25, 4: 33, 5: 28, 6: 40}}, {'id': 3, 'distances': {1: 43, 2: 25, 3: 0, 4: 20, 5: 26, 6: 25}}, {'id': 4, 'distances': {1: 35, 2: 33, 3: 20, 4: 0, 5: 29, 6: 25}}, {'id': 5, 'distances': {1: 48, 2: 28, 3: 26, 4: 29, 5: 0, 6: 37}}, {'id': 6, 'distances': {1: 48, 2: 40, 3: 25, 4: 25, 5: 37, 6: 0}}], 'objective': 96.0}","{'selected': [1, 3], 'assignments': [1, 3, 3, 3, 3, 3]}",21,csv,1
PMED,PMED,"I was handling the school bus plan for a neighborhood: pick a fixed number of pickup spots from a bunch of possible corners, then tell every home which stop they should use. The trick is to make those choices so kids travel as little as possible overall — add up the distance from each house to its assigned stop, and the plan with the smallest total distance wins. Nobody can be skipped or sent to two different stops: each address gets exactly one assigned pickup. The exact list of addresses, candidate stops, and distances are shown below.

# total_candidate_locations=7
# pickup_points_to_open=1
# location_ids=1, 2, 3, 4, 5, 6, 7
source_location_id,destination_location_id,walking_distance
1,2,38
1,3,45
1,4,38
1,5,48
1,6,43
1,7,41
2,1,38
2,3,23
2,4,32
2,5,35
2,6,28
2,7,19
3,1,45
3,2,23
3,4,39
3,5,39
3,6,29
3,7,20
4,1,38
4,2,32
4,3,39
4,5,37
4,6,40
4,7,35
5,1,48
5,2,35
5,3,39
5,4,37
5,6,29
5,7,33
6,1,43
6,2,28
6,3,29
6,4,40
6,5,29
6,7,25
7,1,41
7,2,19
7,3,20
7,4,35
7,5,33
7,6,25

If you want to send the plan back in a machine-friendly way, a little JSON sketch like this is handy:

{
  ""solution"": {
    ""selected"": [<stop_to_open>, <stop_to_open>, ...],
    ""assignments"": [<assigned_stop>, <assigned_stop>, ...]
  }
}

""selected"" is the list of corners we actually open as pickup stops. ""assignments"" is one entry per home (in the same order as the instance), showing which opened stop that home should use. Super informal: think of ""selected"" as the chosen stops and ""assignments"" as the form you'd fill out to say which stop each house goes to.

This JSON is just a sketch of the shape I expect, not the actual answer.

Please use the exact identifiers from the instance input — no renaming and no new labels.  
Valid identifiers look like plain numbers such as “1” or “23”, single capital letters like “A” or “B”, or a capital letter followed by digits like “A1” or “X7”.","{'distance_matrix': [[0, 38, 45, 38, 48, 43, 41], [38, 0, 23, 32, 35, 28, 19], [45, 23, 0, 39, 39, 29, 20], [38, 32, 39, 0, 37, 40, 35], [48, 35, 39, 37, 0, 29, 33], [43, 28, 29, 40, 29, 0, 25], [41, 19, 20, 35, 33, 25, 0]], 'p': 1, 'objective': 173.0}","{'facilities': [6], 'assignments': [6, 6, 6, 6, 6, 6, 6]}",173.0,"{'problem_type': 'PMED', 'num_nodes': 7, 'num_open': 1, 'sites': [{'id': 1, 'distances': {1: 0, 2: 38, 3: 45, 4: 38, 5: 48, 6: 43, 7: 41}}, {'id': 2, 'distances': {1: 38, 2: 0, 3: 23, 4: 32, 5: 35, 6: 28, 7: 19}}, {'id': 3, 'distances': {1: 45, 2: 23, 3: 0, 4: 39, 5: 39, 6: 29, 7: 20}}, {'id': 4, 'distances': {1: 38, 2: 32, 3: 39, 4: 0, 5: 37, 6: 40, 7: 35}}, {'id': 5, 'distances': {1: 48, 2: 35, 3: 39, 4: 37, 5: 0, 6: 29, 7: 33}}, {'id': 6, 'distances': {1: 43, 2: 28, 3: 29, 4: 40, 5: 29, 6: 0, 7: 25}}, {'id': 7, 'distances': {1: 41, 2: 19, 3: 20, 4: 35, 5: 33, 6: 25, 7: 0}}], 'objective': 173.0}","{'selected': [7], 'assignments': [7, 7, 7, 7, 7, 7, 7]}",22,csv,1
PMED,PMED,"There’s a small puzzle in the library budget: pick a set number of branches to run and then attach every neighborhood to one of those branches. Every neighborhood has to belong to exactly one branch, and the winning setup is the one that keeps the total travel distance for everyone as low as possible. Practically, you measure that by summing the distance from each neighborhood to its assigned branch — smaller totals mean a better fit. The concrete locations and distances are laid out below.

{
  ""num_neighborhoods"": 7,
  ""num_branches_to_open"": 1,
  ""neighborhood_ids"": [
    1,
    2,
    3,
    4,
    5,
    6,
    7
  ],
  ""data"": [
    {
      ""origin_neighborhood_id"": 1,
      ""destination_neighborhood_id"": 2,
      ""travel_distance"": 25
    },
    {
      ""origin_neighborhood_id"": 1,
      ""destination_neighborhood_id"": 3,
      ""travel_distance"": 29
    },
    {
      ""origin_neighborhood_id"": 1,
      ""destination_neighborhood_id"": 4,
      ""travel_distance"": 41
    },
    {
      ""origin_neighborhood_id"": 1,
      ""destination_neighborhood_id"": 5,
      ""travel_distance"": 49
    },
    {
      ""origin_neighborhood_id"": 1,
      ""destination_neighborhood_id"": 6,
      ""travel_distance"": 49
    },
    {
      ""origin_neighborhood_id"": 1,
      ""destination_neighborhood_id"": 7,
      ""travel_distance"": 39
    },
    {
      ""origin_neighborhood_id"": 2,
      ""destination_neighborhood_id"": 1,
      ""travel_distance"": 25
    },
    {
      ""origin_neighborhood_id"": 2,
      ""destination_neighborhood_id"": 3,
      ""travel_distance"": 36
    },
    {
      ""origin_neighborhood_id"": 2,
      ""destination_neighborhood_id"": 4,
      ""travel_distance"": 24
    },
    {
      ""origin_neighborhood_id"": 2,
      ""destination_neighborhood_id"": 5,
      ""travel_distance"": 54
    },
    {
      ""origin_neighborhood_id"": 2,
      ""destination_neighborhood_id"": 6,
      ""travel_distance"": 52
    },
    {
      ""origin_neighborhood_id"": 2,
      ""destination_neighborhood_id"": 7,
      ""travel_distance"": 38
    },
    {
      ""origin_neighborhood_id"": 3,
      ""destination_neighborhood_id"": 1,
      ""travel_distance"": 29
    },
    {
      ""origin_neighborhood_id"": 3,
      ""destination_neighborhood_id"": 2,
      ""travel_distance"": 36
    },
    {
      ""origin_neighborhood_id"": 3,
      ""destination_neighborhood_id"": 4,
      ""travel_distance"": 27
    },
    {
      ""origin_neighborhood_id"": 3,
      ""destination_neighborhood_id"": 5,
      ""travel_distance"": 58
    },
    {
      ""origin_neighborhood_id"": 3,
      ""destination_neighborhood_id"": 6,
      ""travel_distance"": 59
    },
    {
      ""origin_neighborhood_id"": 3,
      ""destination_neighborhood_id"": 7,
      ""travel_distance"": 52
    },
    {
      ""origin_neighborhood_id"": 4,
      ""destination_neighborhood_id"": 1,
      ""travel_distance"": 41
    },
    {
      ""origin_neighborhood_id"": 4,
      ""destination_neighborhood_id"": 2,
      ""travel_distance"": 24
    },
    {
      ""origin_neighborhood_id"": 4,
      ""destination_neighborhood_id"": 3,
      ""travel_distance"": 27
    },
    {
      ""origin_neighborhood_id"": 4,
      ""destination_neighborhood_id"": 5,
      ""travel_distance"": 53
    },
    {
      ""origin_neighborhood_id"": 4,
      ""destination_neighborhood_id"": 6,
      ""travel_distance"": 70
    },
    {
      ""origin_neighborhood_id"": 4,
      ""destination_neighborhood_id"": 7,
      ""travel_distance"": 49
    },
    {
      ""origin_neighborhood_id"": 5,
      ""destination_neighborhood_id"": 1,
      ""travel_distance"": 49
    },
    {
      ""origin_neighborhood_id"": 5,
      ""destination_neighborhood_id"": 2,
      ""travel_distance"": 54
    },
    {
      ""origin_neighborhood_id"": 5,
      ""destination_neighborhood_id"": 3,
      ""travel_distance"": 58
    },
    {
      ""origin_neighborhood_id"": 5,
      ""destination_neighborhood_id"": 4,
      ""travel_distance"": 53
    },
    {
      ""origin_neighborhood_id"": 5,
      ""destination_neighborhood_id"": 6,
      ""travel_distance"": 77
    },
    {
      ""origin_neighborhood_id"": 5,
      ""destination_neighborhood_id"": 7,
      ""travel_distance"": 61
    },
    {
      ""origin_neighborhood_id"": 6,
      ""destination_neighborhood_id"": 1,
      ""travel_distance"": 49
    },
    {
      ""origin_neighborhood_id"": 6,
      ""destination_neighborhood_id"": 2,
      ""travel_distance"": 52
    },
    {
      ""origin_neighborhood_id"": 6,
      ""destination_neighborhood_id"": 3,
      ""travel_distance"": 59
    },
    {
      ""origin_neighborhood_id"": 6,
      ""destination_neighborhood_id"": 4,
      ""travel_distance"": 70
    },
    {
      ""origin_neighborhood_id"": 6,
      ""destination_neighborhood_id"": 5,
      ""travel_distance"": 77
    },
    {
      ""origin_neighborhood_id"": 6,
      ""destination_neighborhood_id"": 7,
      ""travel_distance"": 65
    },
    {
      ""origin_neighborhood_id"": 7,
      ""destination_neighborhood_id"": 1,
      ""travel_distance"": 39
    },
    {
      ""origin_neighborhood_id"": 7,
      ""destination_neighborhood_id"": 2,
      ""travel_distance"": 38
    },
    {
      ""origin_neighborhood_id"": 7,
      ""destination_neighborhood_id"": 3,
      ""travel_distance"": 52
    },
    {
      ""origin_neighborhood_id"": 7,
      ""destination_neighborhood_id"": 4,
      ""travel_distance"": 49
    },
    {
      ""origin_neighborhood_id"": 7,
      ""destination_neighborhood_id"": 5,
      ""travel_distance"": 61
    },
    {
      ""origin_neighborhood_id"": 7,
      ""destination_neighborhood_id"": 6,
      ""travel_distance"": 65
    }
  ]
}

Also, please send the answer using this simple JSON layout so I can read it easily:

{
  ""solution"": {
    ""selected"": [<branch_to_open>, <branch_to_open>, ...],
    ""assignments"": [<assigned_branch>, <assigned_branch>, ...]
  }
}

""selected"" is just the list of branches you decide to keep open (the branch IDs). ""assignments"" is a parallel list that says, for each neighborhood in the instance (in the same order), which open branch that neighborhood is attached to. Think of it like filling out a short form: which branches are run, and then for every neighborhood which branch it goes to.

This JSON is only a sketch of the expected shape — don't treat the placeholders as the real solution. Make sure you use the exact identifiers from the instance input with no renaming or invented 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”.","{'distance_matrix': [[0, 25, 29, 41, 49, 49, 39], [25, 0, 36, 24, 54, 52, 38], [29, 36, 0, 27, 58, 59, 52], [41, 24, 27, 0, 53, 70, 49], [49, 54, 58, 53, 0, 77, 61], [49, 52, 59, 70, 77, 0, 65], [39, 38, 52, 49, 61, 65, 0]], 'p': 1, 'objective': 229.0}","{'facilities': [1], 'assignments': [1, 1, 1, 1, 1, 1, 1]}",229.0,"{'problem_type': 'PMED', 'num_nodes': 7, 'num_open': 1, 'sites': [{'id': 1, 'distances': {1: 0, 2: 25, 3: 29, 4: 41, 5: 49, 6: 49, 7: 39}}, {'id': 2, 'distances': {1: 25, 2: 0, 3: 36, 4: 24, 5: 54, 6: 52, 7: 38}}, {'id': 3, 'distances': {1: 29, 2: 36, 3: 0, 4: 27, 5: 58, 6: 59, 7: 52}}, {'id': 4, 'distances': {1: 41, 2: 24, 3: 27, 4: 0, 5: 53, 6: 70, 7: 49}}, {'id': 5, 'distances': {1: 49, 2: 54, 3: 58, 4: 53, 5: 0, 6: 77, 7: 61}}, {'id': 6, 'distances': {1: 49, 2: 52, 3: 59, 4: 70, 5: 77, 6: 0, 7: 65}}, {'id': 7, 'distances': {1: 39, 2: 38, 3: 52, 4: 49, 5: 61, 6: 65, 7: 0}}], 'objective': 229.0}","{'selected': [2], 'assignments': [2, 2, 2, 2, 2, 2, 2]}",23,json,1
PMED,PMED,"There's a plan to place a limited number of dropoff kiosks and organize the neighborhood so every street segment feeds into one of those kiosks. The decision is simply which locations to open, and success is judged by how small the total hauling distance becomes — calculated by adding together the distance from each street segment to the kiosk it uses. Every street segment must be routed to exactly one open kiosk, with none skipped or doubled up. The detailed list of candidate sites and distances is shown below.

It lists 5 candidate locations A, B, C, D, E, and specifies the fixed number 1 of kiosks to open.
Origin A → destination B, haul distance 123.
Origin A → destination C, haul distance 177.
Origin A → destination D, haul distance 206.
Origin A → destination E, haul distance 117.
Origin B → destination A, haul distance 123.
Origin B → destination C, haul distance 115.
Origin B → destination D, haul distance 135.
Origin B → destination E, haul distance 187.
Origin C → destination A, haul distance 177.
Origin C → destination B, haul distance 115.
Origin C → destination D, haul distance 78.
Origin C → destination E, haul distance 172.
Origin D → destination A, haul distance 206.
Origin D → destination B, haul distance 135.
Origin D → destination C, haul distance 78.
Origin D → destination E, haul distance 155.
Origin E → destination A, haul distance 117.
Origin E → destination B, haul distance 187.
Origin E → destination C, haul distance 172.
Origin E → destination D, haul distance 155.
Treat each record below as the hauling cost for assigning that origin to that destination; use these 5 locations and the 1 kiosk limit to evaluate total hauling distance.

Oh, and when you send the answer back, just put it in this simple JSON shape so I can read it automatically — nothing fancy, just a small object with which sites you opened and where every street segment goes:

{
  ""solution"": {
    ""selected"": [<site_to_open>, <site_to_open>, ...],
    ""assignments"": [<assigned_site>, <assigned_site>, ...]
  }
}

This is just a sketch of the shape I need: ""selected"" is the list of kiosk sites you decide to open, and ""assignments"" lists, for every street segment (in the same order as they appear in the instance), which opened site it uses. Keep it light and exact — that JSON is the form, not the final content.

Please make sure all identifiers you put in those lists are used exactly as they appear in the instance input — no renaming, no made-up 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”.""","{'distance_matrix': [[0, 123, 177, 206, 117], [123, 0, 115, 135, 187], [177, 115, 0, 78, 172], [206, 135, 78, 0, 155], [117, 187, 172, 155, 0]], 'p': 1, 'objective': 542.0}","{'facilities': [2], 'assignments': [2, 2, 2, 2, 2]}",542.0,"{'problem_type': 'PMED', 'num_nodes': 5, 'num_open': 1, 'sites': [{'id': 'A', 'distances': {'A': 0, 'B': 123, 'C': 177, 'D': 206, 'E': 117}}, {'id': 'B', 'distances': {'A': 123, 'B': 0, 'C': 115, 'D': 135, 'E': 187}}, {'id': 'C', 'distances': {'A': 177, 'B': 115, 'C': 0, 'D': 78, 'E': 172}}, {'id': 'D', 'distances': {'A': 206, 'B': 135, 'C': 78, 'D': 0, 'E': 155}}, {'id': 'E', 'distances': {'A': 117, 'B': 187, 'C': 172, 'D': 155, 'E': 0}}], 'objective': 542.0}","{'selected': ['C'], 'assignments': ['C', 'C', 'C', 'C', 'C']}",24,nl,names
PMED,PMED,"Someone in charge of campus housing needs to pick a limited number of service locations and then assign each dorm to exactly one of those locations, with the goal that the total distance students travel for services — obtained by totaling each dorm’s trip to its center — is as low as possible. It’s important that no dorm is left unassigned or assigned to more than one center. The specific instance details are shown below.

{
  ""total_dormitories"": 6,
  ""service_centers_to_open"": 1,
  ""dormitory_ids"": [
    0,
    1,
    2,
    3,
    4,
    5
  ],
  ""data"": [
    {
      ""origin_dorm_id"": 0,
      ""destination_dorm_id"": 1,
      ""travel_distance"": 35
    },
    {
      ""origin_dorm_id"": 0,
      ""destination_dorm_id"": 2,
      ""travel_distance"": 54
    },
    {
      ""origin_dorm_id"": 0,
      ""destination_dorm_id"": 3,
      ""travel_distance"": 50
    },
    {
      ""origin_dorm_id"": 0,
      ""destination_dorm_id"": 4,
      ""travel_distance"": 46
    },
    {
      ""origin_dorm_id"": 0,
      ""destination_dorm_id"": 5,
      ""travel_distance"": 34
    },
    {
      ""origin_dorm_id"": 1,
      ""destination_dorm_id"": 0,
      ""travel_distance"": 35
    },
    {
      ""origin_dorm_id"": 1,
      ""destination_dorm_id"": 2,
      ""travel_distance"": 49
    },
    {
      ""origin_dorm_id"": 1,
      ""destination_dorm_id"": 3,
      ""travel_distance"": 53
    },
    {
      ""origin_dorm_id"": 1,
      ""destination_dorm_id"": 4,
      ""travel_distance"": 46
    },
    {
      ""origin_dorm_id"": 1,
      ""destination_dorm_id"": 5,
      ""travel_distance"": 42
    },
    {
      ""origin_dorm_id"": 2,
      ""destination_dorm_id"": 0,
      ""travel_distance"": 54
    },
    {
      ""origin_dorm_id"": 2,
      ""destination_dorm_id"": 1,
      ""travel_distance"": 49
    },
    {
      ""origin_dorm_id"": 2,
      ""destination_dorm_id"": 3,
      ""travel_distance"": 38
    },
    {
      ""origin_dorm_id"": 2,
      ""destination_dorm_id"": 4,
      ""travel_distance"": 51
    },
    {
      ""origin_dorm_id"": 2,
      ""destination_dorm_id"": 5,
      ""travel_distance"": 30
    },
    {
      ""origin_dorm_id"": 3,
      ""destination_dorm_id"": 0,
      ""travel_distance"": 50
    },
    {
      ""origin_dorm_id"": 3,
      ""destination_dorm_id"": 1,
      ""travel_distance"": 53
    },
    {
      ""origin_dorm_id"": 3,
      ""destination_dorm_id"": 2,
      ""travel_distance"": 38
    },
    {
      ""origin_dorm_id"": 3,
      ""destination_dorm_id"": 4,
      ""travel_distance"": 56
    },
    {
      ""origin_dorm_id"": 3,
      ""destination_dorm_id"": 5,
      ""travel_distance"": 24
    },
    {
      ""origin_dorm_id"": 4,
      ""destination_dorm_id"": 0,
      ""travel_distance"": 46
    },
    {
      ""origin_dorm_id"": 4,
      ""destination_dorm_id"": 1,
      ""travel_distance"": 46
    },
    {
      ""origin_dorm_id"": 4,
      ""destination_dorm_id"": 2,
      ""travel_distance"": 51
    },
    {
      ""origin_dorm_id"": 4,
      ""destination_dorm_id"": 3,
      ""travel_distance"": 56
    },
    {
      ""origin_dorm_id"": 4,
      ""destination_dorm_id"": 5,
      ""travel_distance"": 44
    },
    {
      ""origin_dorm_id"": 5,
      ""destination_dorm_id"": 0,
      ""travel_distance"": 34
    },
    {
      ""origin_dorm_id"": 5,
      ""destination_dorm_id"": 1,
      ""travel_distance"": 42
    },
    {
      ""origin_dorm_id"": 5,
      ""destination_dorm_id"": 2,
      ""travel_distance"": 30
    },
    {
      ""origin_dorm_id"": 5,
      ""destination_dorm_id"": 3,
      ""travel_distance"": 24
    },
    {
      ""origin_dorm_id"": 5,
      ""destination_dorm_id"": 4,
      ""travel_distance"": 44
    }
  ]
}

Oh, and when you send the answer back, keep it in this simple JSON shape so I can read it automatically:

{
  ""solution"": {
    ""selected"": [<site_to_open>, <site_to_open>, ...],
    ""assignments"": [<chosen_open_site>, <chosen_open_site>, ...]
  }
}

Just to explain, real quick: ""selected"" is where you list the locations you decide to open, and ""assignments"" lists, for each dorm (in the same order as the input), which open location that dorm is assigned to. Think of it like filling out a short form — which centers are open, and which center each dorm goes to. This block is just a sketch of the shape I need, not the actual solution.

Please 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”
- a capital letter followed by digits like “A1” or “X7”","{'distance_matrix': [[0, 35, 54, 50, 46, 34], [35, 0, 49, 53, 46, 42], [54, 49, 0, 38, 51, 30], [50, 53, 38, 0, 56, 24], [46, 46, 51, 56, 0, 44], [34, 42, 30, 24, 44, 0]], 'p': 1, 'objective': 174.0}","{'facilities': [5], 'assignments': [5, 5, 5, 5, 5, 5]}",174.0,"{'problem_type': 'PMED', 'num_nodes': 6, 'num_open': 1, 'sites': [{'id': 0, 'distances': {0: 0, 1: 35, 2: 54, 3: 50, 4: 46, 5: 34}}, {'id': 1, 'distances': {0: 35, 1: 0, 2: 49, 3: 53, 4: 46, 5: 42}}, {'id': 2, 'distances': {0: 54, 1: 49, 2: 0, 3: 38, 4: 51, 5: 30}}, {'id': 3, 'distances': {0: 50, 1: 53, 2: 38, 3: 0, 4: 56, 5: 24}}, {'id': 4, 'distances': {0: 46, 1: 46, 2: 51, 3: 56, 4: 0, 5: 44}}, {'id': 5, 'distances': {0: 34, 1: 42, 2: 30, 3: 24, 4: 44, 5: 0}}], 'objective': 174.0}","{'selected': [5], 'assignments': [5, 5, 5, 5, 5, 5]}",25,json,0
PMED,PMED,"I run the small team that plans pickup points for a courier company, and the job is to pick a fixed number of hubs from a list of candidate spots and then link every delivery sector to one of those hubs. The idea is to keep the total driving as low as possible: for each sector, take the distance to the hub it's assigned to, add all those distances up, and the better plan is the one with the smallest total. Every sector has to be assigned to exactly one hub — no sector can be left out or be tied to two hubs. The exact list of candidate locations, sectors, and the distances between them are shown below.

# total_candidate_locations=6
# hubs_to_open=1
# location_identifiers=1, 2, 3, 4, 5, 6
origin_location_id,target_location_id,travel_distance_between_locations
1,2,45
1,3,145
1,4,172
1,5,140
1,6,253
2,1,45
2,3,147
2,4,147
2,5,127
2,6,208
3,1,145
3,2,147
3,4,139
3,5,142
3,6,269
4,1,172
4,2,147
4,3,139
4,5,98
4,6,207
5,1,140
5,2,127
5,3,142
5,4,98
5,6,180
6,1,253
6,2,208
6,3,269
6,4,207
6,5,180

Also, when you send back a plan, please use this simple JSON layout so I can parse it easily — nothing fancy, just the shape below.

{
  ""solution"": {
    ""selected"": [<site_to_open>, <site_to_open>, ...],
    ""assignments"": [<site_assigned>, <site_assigned>, ...]
  }
}

""selected"" is just the list of hubs you choose to open. ""assignments"" is a list that, in the same order as the sectors in the input, says which opened hub each sector is linked to. Think of it like filling out a form: pick which spots are open, then for each sector write the open spot it's assigned to.

This JSON is only a sketch of the expected shape — not the actual answer. Also, all identifiers must be used exactly as they appear in the instance input — do not rename them or invent new labels.

- Valid identifiers look like plain numbers such as “1” or “23”, single capital letters like “A” or “B”, or a capital letter followed by digits like “A1” or “X7”.","{'distance_matrix': [[0, 45, 145, 172, 140, 253], [45, 0, 147, 147, 127, 208], [145, 147, 0, 139, 142, 269], [172, 147, 139, 0, 98, 207], [140, 127, 142, 98, 0, 180], [253, 208, 269, 207, 180, 0]], 'p': 1, 'objective': 674.0}","{'facilities': [1], 'assignments': [1, 1, 1, 1, 1, 1]}",674.0,"{'problem_type': 'PMED', 'num_nodes': 6, 'num_open': 1, 'sites': [{'id': 1, 'distances': {1: 0, 2: 45, 3: 145, 4: 172, 5: 140, 6: 253}}, {'id': 2, 'distances': {1: 45, 2: 0, 3: 147, 4: 147, 5: 127, 6: 208}}, {'id': 3, 'distances': {1: 145, 2: 147, 3: 0, 4: 139, 5: 142, 6: 269}}, {'id': 4, 'distances': {1: 172, 2: 147, 3: 139, 4: 0, 5: 98, 6: 207}}, {'id': 5, 'distances': {1: 140, 2: 127, 3: 142, 4: 98, 5: 0, 6: 180}}, {'id': 6, 'distances': {1: 253, 2: 208, 3: 269, 4: 207, 5: 180, 6: 0}}], 'objective': 674.0}","{'selected': [2], 'assignments': [2, 2, 2, 2, 2, 2]}",26,csv,1
PMED,PMED,"I run the little farmer’s market and need to pick a fixed number of support tents to set up around the stalls. Each vendor has to be linked to one—and only one—of those tents, and the better setup is the one where, if you add up how far every vendor has to walk to their assigned tent, that total is as small as possible. No vendor can be left without a tent or assigned to two tents. The concrete list of stall spots and the distances between them will be shown below.

# num_stalls=8
# num_tents_to_open=1
# stall_ids=A, B, C, D, E, F, G, H
source_stall_id,target_stall_id,walking_distance
A,B,53
A,C,88
A,D,64
A,E,41
A,F,71
A,G,51
A,H,55
B,A,53
B,C,71
B,D,39
B,E,40
B,F,26
B,G,38
B,H,52
C,A,88
C,B,71
C,D,54
C,E,55
C,F,57
C,G,37
C,H,49
D,A,64
D,B,39
D,C,54
D,E,23
D,F,57
D,G,46
D,H,37
E,A,41
E,B,40
E,C,55
E,D,23
E,F,39
E,G,26
E,H,14
F,A,71
F,B,26
F,C,57
F,D,57
F,E,39
F,G,50
F,H,42
G,A,51
G,B,38
G,C,37
G,D,46
G,E,26
G,F,50
G,H,32
H,A,55
H,B,52
H,C,49
H,D,37
H,E,14
H,F,42
H,G,32

Oh, and when you send the answer back, please stick to this JSON layout so it's easy to read and parse:

{
  ""solution"": {
    ""selected"": [<tent_to_open>, <tent_to_open>, ...],
    ""assignments"": [<assigned_tent>, <assigned_tent>, ...]
  }
}

""selected"" is where you list which tent spots you'll actually set up. ""assignments"" is a one-to-one list (in the same order as the stall spots in the instance) saying which tent each vendor is linked to. Super informal sketch — this is the shape I need, not the final picks.

Quick reminder: use the exact identifiers from the instance input — do not rename them or invent new ones. Valid identifiers look like:
- plain numbers such as ""1"" or ""23""
- single capital letters like ""A"" or ""B""
- a capital letter followed by digits like ""A1"" or ""X7""","{'distance_matrix': [[0, 53, 88, 64, 41, 71, 51, 55], [53, 0, 71, 39, 40, 26, 38, 52], [88, 71, 0, 54, 55, 57, 37, 49], [64, 39, 54, 0, 23, 57, 46, 37], [41, 40, 55, 23, 0, 39, 26, 14], [71, 26, 57, 57, 39, 0, 50, 42], [51, 38, 37, 46, 26, 50, 0, 32], [55, 52, 49, 37, 14, 42, 32, 0]], 'p': 1, 'objective': 238.0}","{'facilities': [4], 'assignments': [4, 4, 4, 4, 4, 4, 4, 4]}",238.0,"{'problem_type': 'PMED', 'num_nodes': 8, 'num_open': 1, 'sites': [{'id': 'A', 'distances': {'A': 0, 'B': 53, 'C': 88, 'D': 64, 'E': 41, 'F': 71, 'G': 51, 'H': 55}}, {'id': 'B', 'distances': {'A': 53, 'B': 0, 'C': 71, 'D': 39, 'E': 40, 'F': 26, 'G': 38, 'H': 52}}, {'id': 'C', 'distances': {'A': 88, 'B': 71, 'C': 0, 'D': 54, 'E': 55, 'F': 57, 'G': 37, 'H': 49}}, {'id': 'D', 'distances': {'A': 64, 'B': 39, 'C': 54, 'D': 0, 'E': 23, 'F': 57, 'G': 46, 'H': 37}}, {'id': 'E', 'distances': {'A': 41, 'B': 40, 'C': 55, 'D': 23, 'E': 0, 'F': 39, 'G': 26, 'H': 14}}, {'id': 'F', 'distances': {'A': 71, 'B': 26, 'C': 57, 'D': 57, 'E': 39, 'F': 0, 'G': 50, 'H': 42}}, {'id': 'G', 'distances': {'A': 51, 'B': 38, 'C': 37, 'D': 46, 'E': 26, 'F': 50, 'G': 0, 'H': 32}}, {'id': 'H', 'distances': {'A': 55, 'B': 52, 'C': 49, 'D': 37, 'E': 14, 'F': 42, 'G': 32, 'H': 0}}], 'objective': 238.0}","{'selected': ['E'], 'assignments': ['E', 'E', 'E', 'E', 'E', 'E', 'E', 'E']}",27,csv,names
PMED,PMED,"Many people are waiting for supplies, so the plan is to pick a set number of distribution centers and link each neighborhood to one center for pickups. Nothing can be left unassigned and no neighborhood should be assigned to more than one center, and the aim is to minimize how far people in total must go. You judge each plan by summing up the distance from every neighborhood to its chosen center — the smallest sum means the least overall travel. The precise neighborhood list, candidate centers, and distances are shown below.

There are 5 candidate locations listed as 1, 2, 3, 4, 5, and exactly 1 centers must be opened.
From neighborhood 1 to candidate center 2 the travel distance is 66.
From neighborhood 1 to candidate center 3 the travel distance is 52.
From neighborhood 1 to candidate center 4 the travel distance is 39.
From neighborhood 1 to candidate center 5 the travel distance is 39.
From neighborhood 2 to candidate center 1 the travel distance is 66.
From neighborhood 2 to candidate center 3 the travel distance is 68.
From neighborhood 2 to candidate center 4 the travel distance is 41.
From neighborhood 2 to candidate center 5 the travel distance is 37.
From neighborhood 3 to candidate center 1 the travel distance is 52.
From neighborhood 3 to candidate center 2 the travel distance is 68.
From neighborhood 3 to candidate center 4 the travel distance is 54.
From neighborhood 3 to candidate center 5 the travel distance is 74.
From neighborhood 4 to candidate center 1 the travel distance is 39.
From neighborhood 4 to candidate center 2 the travel distance is 41.
From neighborhood 4 to candidate center 3 the travel distance is 54.
From neighborhood 4 to candidate center 5 the travel distance is 29.
From neighborhood 5 to candidate center 1 the travel distance is 39.
From neighborhood 5 to candidate center 2 the travel distance is 37.
From neighborhood 5 to candidate center 3 the travel distance is 74.
From neighborhood 5 to candidate center 4 the travel distance is 29.
Use these distances to judge assignments and choose the 1 centers that minimize total travel across the 5 locations.

Also, when you send back the plan, just stick to a simple JSON shape so it's easy to parse and check. Something like this is perfect:

{
  ""solution"": {
    ""selected"": [<site_to_open>, <site_to_open>, ...],
    ""assignments"": [<chosen_site>, <chosen_site>, ...]
  }
}

""selected"" is the list of locations you'll open as distribution points. ""assignments"" is a list that, in the same order as the neighborhoods in the instance, says which opened location each neighborhood is assigned to. Think of the JSON as a quick form: which sites are active, and for every neighborhood which active site it should go to. It's just a sketch of the shape I need, not your final answer.

Please make sure to use the exact identifiers from the instance input — do not rename them or invent new ones.  
- Valid identifiers look like plain numbers such as “1” or “23”, single capital letters like “A” or “B”, or a capital letter followed by digits like “A1” or “X7”.","{'distance_matrix': [[0, 66, 52, 39, 39], [66, 0, 68, 41, 37], [52, 68, 0, 54, 74], [39, 41, 54, 0, 29], [39, 37, 74, 29, 0]], 'p': 1, 'objective': 163.0}","{'facilities': [3], 'assignments': [3, 3, 3, 3, 3]}",163.0,"{'problem_type': 'PMED', 'num_nodes': 5, 'num_open': 1, 'sites': [{'id': 1, 'distances': {1: 0, 2: 66, 3: 52, 4: 39, 5: 39}}, {'id': 2, 'distances': {1: 66, 2: 0, 3: 68, 4: 41, 5: 37}}, {'id': 3, 'distances': {1: 52, 2: 68, 3: 0, 4: 54, 5: 74}}, {'id': 4, 'distances': {1: 39, 2: 41, 3: 54, 4: 0, 5: 29}}, {'id': 5, 'distances': {1: 39, 2: 37, 3: 74, 4: 29, 5: 0}}], 'objective': 163.0}","{'selected': [4], 'assignments': [4, 4, 4, 4, 4]}",28,nl,1
PMED,PMED,"Picture this: a few satellite offices need to be opened, and the task is picking which candidate sites to activate and then pairing every team location with one of those open sites. Every team must be assigned to a single opened office — no team unassigned and no double assignments. Judging plans is easy in practice: add up each location’s distance to its assigned office and prefer the arrangement with the smaller total commute. The detailed locations and the distances between them are shown below.

{
  ""total_candidate_locations"": 5,
  ""satellite_offices_to_open"": 1,
  ""location_identifiers"": [
    1,
    2,
    3,
    4,
    5
  ],
  ""data"": [
    {
      ""origin_location_id"": 1,
      ""candidate_office_id"": 2,
      ""commute_distance"": 40
    },
    {
      ""origin_location_id"": 1,
      ""candidate_office_id"": 3,
      ""commute_distance"": 39
    },
    {
      ""origin_location_id"": 1,
      ""candidate_office_id"": 4,
      ""commute_distance"": 37
    },
    {
      ""origin_location_id"": 1,
      ""candidate_office_id"": 5,
      ""commute_distance"": 29
    },
    {
      ""origin_location_id"": 2,
      ""candidate_office_id"": 1,
      ""commute_distance"": 40
    },
    {
      ""origin_location_id"": 2,
      ""candidate_office_id"": 3,
      ""commute_distance"": 32
    },
    {
      ""origin_location_id"": 2,
      ""candidate_office_id"": 4,
      ""commute_distance"": 48
    },
    {
      ""origin_location_id"": 2,
      ""candidate_office_id"": 5,
      ""commute_distance"": 37
    },
    {
      ""origin_location_id"": 3,
      ""candidate_office_id"": 1,
      ""commute_distance"": 39
    },
    {
      ""origin_location_id"": 3,
      ""candidate_office_id"": 2,
      ""commute_distance"": 32
    },
    {
      ""origin_location_id"": 3,
      ""candidate_office_id"": 4,
      ""commute_distance"": 46
    },
    {
      ""origin_location_id"": 3,
      ""candidate_office_id"": 5,
      ""commute_distance"": 40
    },
    {
      ""origin_location_id"": 4,
      ""candidate_office_id"": 1,
      ""commute_distance"": 37
    },
    {
      ""origin_location_id"": 4,
      ""candidate_office_id"": 2,
      ""commute_distance"": 48
    },
    {
      ""origin_location_id"": 4,
      ""candidate_office_id"": 3,
      ""commute_distance"": 46
    },
    {
      ""origin_location_id"": 4,
      ""candidate_office_id"": 5,
      ""commute_distance"": 48
    },
    {
      ""origin_location_id"": 5,
      ""candidate_office_id"": 1,
      ""commute_distance"": 29
    },
    {
      ""origin_location_id"": 5,
      ""candidate_office_id"": 2,
      ""commute_distance"": 37
    },
    {
      ""origin_location_id"": 5,
      ""candidate_office_id"": 3,
      ""commute_distance"": 40
    },
    {
      ""origin_location_id"": 5,
      ""candidate_office_id"": 4,
      ""commute_distance"": 48
    }
  ]
}

And if it helps, just send the final plan in this little JSON shape so it's easy to read and check:

{
  ""solution"": {
    ""selected"": [<site_to_open>, <site_to_open>, ...],
    ""assignments"": [<chosen_open_site>, <chosen_open_site>, ...]
  }
}

Think of it like a simple form: ""selected"" is the list of candidate sites you decide to open, and ""assignments"" lists, for each original location (in the same order as the instance input), which opened site that location is paired with. This JSON is just a sketch of the shape I expect, not the actual answer.

Please use the exact identifiers from 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”.""","{'distance_matrix': [[0, 40, 39, 37, 29], [40, 0, 32, 48, 37], [39, 32, 0, 46, 40], [37, 48, 46, 0, 48], [29, 37, 40, 48, 0]], 'p': 1, 'objective': 145.0}","{'facilities': [0], 'assignments': [0, 0, 0, 0, 0]}",145.0,"{'problem_type': 'PMED', 'num_nodes': 5, 'num_open': 1, 'sites': [{'id': 1, 'distances': {1: 0, 2: 40, 3: 39, 4: 37, 5: 29}}, {'id': 2, 'distances': {1: 40, 2: 0, 3: 32, 4: 48, 5: 37}}, {'id': 3, 'distances': {1: 39, 2: 32, 3: 0, 4: 46, 5: 40}}, {'id': 4, 'distances': {1: 37, 2: 48, 3: 46, 4: 0, 5: 48}}, {'id': 5, 'distances': {1: 29, 2: 37, 3: 40, 4: 48, 5: 0}}], 'objective': 145.0}","{'selected': [1], 'assignments': [1, 1, 1, 1, 1]}",29,json,1
PMED,PMED,"There’s a mobile library route to work out: decide which limited number of stops the van will use, and make sure every community cluster gets assigned to exactly one of those stops so nobody’s missed or doubled up. The measure of success is total visitor travel — add up each cluster’s distance to its chosen stop, and the plan with the lowest total is best. The specific candidate locations and distances are listed below.

There are 6 locations in this instance; open exactly 2 stops chosen from 0, 1, 2, 3, 4, 5.
From 0 to 1: 44.
From 0 to 2: 35.
From 0 to 3: 35.
From 0 to 4: 32.
From 0 to 5: 39.
From 1 to 0: 44.
From 1 to 2: 42.
From 1 to 3: 34.
From 1 to 4: 38.
From 1 to 5: 43.
From 2 to 0: 35.
From 2 to 1: 42.
From 2 to 3: 29.
From 2 to 4: 33.
From 2 to 5: 36.
From 3 to 0: 35.
From 3 to 1: 34.
From 3 to 2: 29.
From 3 to 4: 29.
From 3 to 5: 32.
From 4 to 0: 32.
From 4 to 1: 38.
From 4 to 2: 33.
From 4 to 3: 29.
From 4 to 5: 27.
From 5 to 0: 39.
From 5 to 1: 43.
From 5 to 2: 36.
From 5 to 3: 32.
From 5 to 4: 27.
Assign every community cluster to one chosen stop so the total visitor travel across these 6 locations is minimized.

When you send the final plan, just drop it in this simple JSON shape so everything stays tidy and easy to read:

{
  ""solution"": {
    ""selected"": [<stop_to_open>, <stop_to_open>, ...],
    ""assignments"": [<assigned_stop>, <assigned_stop>, ...]
  }
}

""selected"" is where you list the stops the mobile library will actually use, and ""assignments"" says, for each community cluster in the order they were given, which of those opened stops they should go to. Think of the JSON as a quick form to fill out — it's just the shape I need, not the final filled-in plan.

Please make sure you 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”.","{'distance_matrix': [[0, 44, 35, 35, 32, 39], [44, 0, 42, 34, 38, 43], [35, 42, 0, 29, 33, 36], [35, 34, 29, 0, 29, 32], [32, 38, 33, 29, 0, 27], [39, 43, 36, 32, 27, 0]], 'p': 2, 'objective': 121.0}","{'facilities': [1, 4], 'assignments': [4, 1, 4, 4, 4, 4]}",121.0,"{'problem_type': 'PMED', 'num_nodes': 6, 'num_open': 2, 'sites': [{'id': 0, 'distances': {0: 0, 1: 44, 2: 35, 3: 35, 4: 32, 5: 39}}, {'id': 1, 'distances': {0: 44, 1: 0, 2: 42, 3: 34, 4: 38, 5: 43}}, {'id': 2, 'distances': {0: 35, 1: 42, 2: 0, 3: 29, 4: 33, 5: 36}}, {'id': 3, 'distances': {0: 35, 1: 34, 2: 29, 3: 0, 4: 29, 5: 32}}, {'id': 4, 'distances': {0: 32, 1: 38, 2: 33, 3: 29, 4: 0, 5: 27}}, {'id': 5, 'distances': {0: 39, 1: 43, 2: 36, 3: 32, 4: 27, 5: 0}}], 'objective': 121.0}","{'selected': [1, 4], 'assignments': [4, 1, 4, 4, 4, 4]}",30,nl,0
PMED,PMED,"Recently the district decided to consolidate after-school offerings to a fixed number of campuses, so the superintendent has to pick which schools keep their centers and which ones will go to those centers. Each school must be assigned to a single open center, and every school must be covered. The aim is to cut down the total miles traveled across the whole district — simply add up the distance from each school to its assigned center, and the smaller that total is, the better. The exact school list and pairwise travel distances appear below.

There are 5 schools in total; the superintendent must open exactly 1 centers, and the schools are 1, 2, 3, 4, 5.
From 1 to 2: 56 miles.
From 1 to 3: 17 miles.
From 1 to 4: 45 miles.
From 1 to 5: 52 miles.
From 2 to 1: 56 miles.
From 2 to 3: 45 miles.
From 2 to 4: 54 miles.
From 2 to 5: 56 miles.
From 3 to 1: 17 miles.
From 3 to 2: 45 miles.
From 3 to 4: 34 miles.
From 3 to 5: 38 miles.
From 4 to 1: 45 miles.
From 4 to 2: 54 miles.
From 4 to 3: 34 miles.
From 4 to 5: 42 miles.
From 5 to 1: 52 miles.
From 5 to 2: 56 miles.
From 5 to 3: 38 miles.
From 5 to 4: 42 miles.
Each line gives the travel distance from one origin school to a potential center to inform the superintendent's assignment decisions.

I'll put the output in a simple JSON shape so it's easy to follow. It will look like this:

{
  ""solution"": {
    ""selected"": [<school_to_keep>, <school_to_keep>, ...],
    ""assignments"": [<chosen_kept_school>, <chosen_kept_school>, ...]
  }
}

A quick, casual note on what those bits mean in our school story: ""selected"" is the list of schools that stay open as after-school centers, and ""assignments"" says, for each school (in the same order as the input), which open school it's assigned to. Think of ""selected"" like the checkboxes you tick, and ""assignments"" like the answers that point each school to its center.

This JSON is just a sketch of the expected shape, not the actual solution.

- Please use the identifiers exactly as they appear in the instance input — do not rename or invent new labels. Valid identifiers look like plain numbers such as ""1"" or ""23"", single capital letters like ""A"" or ""B"", or a capital letter followed by digits like ""A1"" or ""X7"".","{'distance_matrix': [[0, 56, 17, 45, 52], [56, 0, 45, 54, 56], [17, 45, 0, 34, 38], [45, 54, 34, 0, 42], [52, 56, 38, 42, 0]], 'p': 1, 'objective': 134.0}","{'facilities': [2], 'assignments': [2, 2, 2, 2, 2]}",134.0,"{'problem_type': 'PMED', 'num_nodes': 5, 'num_open': 1, 'sites': [{'id': 1, 'distances': {1: 0, 2: 56, 3: 17, 4: 45, 5: 52}}, {'id': 2, 'distances': {1: 56, 2: 0, 3: 45, 4: 54, 5: 56}}, {'id': 3, 'distances': {1: 17, 2: 45, 3: 0, 4: 34, 5: 38}}, {'id': 4, 'distances': {1: 45, 2: 54, 3: 34, 4: 0, 5: 42}}, {'id': 5, 'distances': {1: 52, 2: 56, 3: 38, 4: 42, 5: 0}}], 'objective': 134.0}","{'selected': [3], 'assignments': [3, 3, 3, 3, 3]}",31,nl,1
PMED,PMED,"I used to sketch coverage maps: there’s a handful of candidate towers and a bunch of sites that need service, and someone has to pick a fixed number of those towers to switch on. The idea is simple — every site is tied to just one of the towers that get turned on, and nothing gets left out or hooked to two towers at once. The ""best"" choice is the one that keeps the total travel distance as small as possible — add up each site’s distance to its assigned active tower, and that sum should be as low as it can be. The specific list of sites, candidate towers and the distances between them are shown below.

# total_candidate_sites=5
# towers_to_activate=1
# site_identifiers=1, 2, 3, 4, 5
from_site_id,to_site_id,distance_between_sites
1,2,23
1,3,39
1,4,27
1,5,37
2,1,23
2,3,39
2,4,18
2,5,33
3,1,39
3,2,39
3,4,35
3,5,48
4,1,27
4,2,18
4,3,35
4,5,34
5,1,37
5,2,33
5,3,48
5,4,34

Also, when you send the solution back, just stick to this simple JSON shape — nothing fancy, just the fields shown below.

{
  ""solution"": {
    ""selected"": [<site_to_open>, <site_to_open>, ...],
    ""assignments"": [<assigned_open_site>, <assigned_open_site>, ...]
  }
}

It's just a friendly form: ""selected"" is the list of sites you choose to turn on, and ""assignments"" lists, for every site in the instance (in the same order they were given), which opened site it's hooked up to. Think of it like filling out a short form rather than a complex file.

This JSON is only a sketch of the expected shape — not the actual answer. Important: use the exact identifiers from the instance input (no renaming, no new labels). For example: ""Valid identifiers look like plain numbers such as “1” or “23”, single capital letters like “A” or “B”, or a capital letter followed by digits like “A1” or “X7”.""","{'distance_matrix': [[0, 23, 39, 27, 37], [23, 0, 39, 18, 33], [39, 39, 0, 35, 48], [27, 18, 35, 0, 34], [37, 33, 48, 34, 0]], 'p': 1, 'objective': 113.0}","{'facilities': [1], 'assignments': [1, 1, 1, 1, 1]}",113.0,"{'problem_type': 'PMED', 'num_nodes': 5, 'num_open': 1, 'sites': [{'id': 1, 'distances': {1: 0, 2: 23, 3: 39, 4: 27, 5: 37}}, {'id': 2, 'distances': {1: 23, 2: 0, 3: 39, 4: 18, 5: 33}}, {'id': 3, 'distances': {1: 39, 2: 39, 3: 0, 4: 35, 5: 48}}, {'id': 4, 'distances': {1: 27, 2: 18, 3: 35, 4: 0, 5: 34}}, {'id': 5, 'distances': {1: 37, 2: 33, 3: 48, 4: 34, 5: 0}}], 'objective': 113.0}","{'selected': [2], 'assignments': [2, 2, 2, 2, 2]}",32,csv,1
PMED,PMED,"Someone managing maintenance for a bike-share needs to choose a predetermined number of hub locations and connect every station to exactly one hub — no station can be skipped or split between hubs. Since the travel distance between every pair of stations is available, each possible plan can be scored by adding up the distance from each station to its chosen hub, and the plan with the lowest total travel is preferred. The concrete details will be shown below.

# total_stations=6
# num_hubs_to_open=2
# station_ids=0, 1, 2, 3, 4, 5
from_station_id,to_station_id,travel_distance
0,1,47
0,2,39
0,3,40
0,4,15
0,5,44
1,0,47
1,2,56
1,3,41
1,4,51
1,5,63
2,0,39
2,1,56
2,3,38
2,4,26
2,5,62
3,0,40
3,1,41
3,2,38
3,4,37
3,5,40
4,0,15
4,1,51
4,2,26
4,3,37
4,5,58
5,0,44
5,1,63
5,2,62
5,3,40
5,4,58

Also, when you send the plan back, please follow this loose JSON shape so it's easy to read and check. Something like:

{
  ""solution"": {
    ""selected"": [<hub_to_open>, <hub_to_open>, ...],
    ""assignments"": [<assigned_hub>, <assigned_hub>, ...]
  }
}

Quick note on what those fields mean in plain language: ""selected"" is the list of stations you decide to open as hubs, and ""assignments"" lists, for every station in the network, which opened hub it gets connected to (one entry per station). This is just a sketch of the shape I need — not the final answer.

Also, please use the exact station identifiers from the instance input — do not rename them or invent new labels.
- for example: ""Valid identifiers look like plain numbers such as “1” or “23”, single capital letters like “A” or “B”, or a capital letter followed by digits like “A1” or “X7”.""","{'distance_matrix': [[0, 47, 39, 40, 15, 44], [47, 0, 56, 41, 51, 63], [39, 56, 0, 38, 26, 62], [40, 41, 38, 0, 37, 40], [15, 51, 26, 37, 0, 58], [44, 63, 62, 40, 58, 0]], 'p': 2, 'objective': 122.0}","{'facilities': [3, 4], 'assignments': [4, 3, 4, 3, 4, 3]}",122.0,"{'problem_type': 'PMED', 'num_nodes': 6, 'num_open': 2, 'sites': [{'id': 0, 'distances': {0: 0, 1: 47, 2: 39, 3: 40, 4: 15, 5: 44}}, {'id': 1, 'distances': {0: 47, 1: 0, 2: 56, 3: 41, 4: 51, 5: 63}}, {'id': 2, 'distances': {0: 39, 1: 56, 2: 0, 3: 38, 4: 26, 5: 62}}, {'id': 3, 'distances': {0: 40, 1: 41, 2: 38, 3: 0, 4: 37, 5: 40}}, {'id': 4, 'distances': {0: 15, 1: 51, 2: 26, 3: 37, 4: 0, 5: 58}}, {'id': 5, 'distances': {0: 44, 1: 63, 2: 62, 3: 40, 4: 58, 5: 0}}], 'objective': 122.0}","{'selected': [3, 4], 'assignments': [4, 3, 4, 3, 4, 3]}",33,csv,0
PMED,PMED,"Out in the suburbs the energy team mapped every parking lot and the drive between any two of them, then had to choose exactly a handful of lots to host charging stations and link every lot to one chosen station. The better the choice, the less everyone drives overall — you measure that by summing each parking lot’s distance to its assigned hub and looking for the smallest total. Every lot must be assigned once and only once, and the pairwise distances are provided; the concrete details follow below.

They mapped 7 candidate parking lots, must open exactly 1 hubs, and listed the lots as 0, 1, 2, 3, 4, 5, 6.
Drive distance from 0 to 1 is 53.
Drive distance from 0 to 2 is 36.
Drive distance from 0 to 3 is 38.
Drive distance from 0 to 4 is 40.
Drive distance from 0 to 5 is 55.
Drive distance from 0 to 6 is 64.
Drive distance from 1 to 0 is 53.
Drive distance from 1 to 2 is 31.
Drive distance from 1 to 3 is 31.
Drive distance from 1 to 4 is 32.
Drive distance from 1 to 5 is 50.
Drive distance from 1 to 6 is 55.
Drive distance from 2 to 0 is 36.
Drive distance from 2 to 1 is 31.
Drive distance from 2 to 3 is 30.
Drive distance from 2 to 4 is 33.
Drive distance from 2 to 5 is 19.
Drive distance from 2 to 6 is 43.
Drive distance from 3 to 0 is 38.
Drive distance from 3 to 1 is 31.
Drive distance from 3 to 2 is 30.
Drive distance from 3 to 4 is 17.
Drive distance from 3 to 5 is 31.
Drive distance from 3 to 6 is 40.
Drive distance from 4 to 0 is 40.
Drive distance from 4 to 1 is 32.
Drive distance from 4 to 2 is 33.
Drive distance from 4 to 3 is 17.
Drive distance from 4 to 5 is 37.
Drive distance from 4 to 6 is 29.
Drive distance from 5 to 0 is 55.
Drive distance from 5 to 1 is 50.
Drive distance from 5 to 2 is 19.
Drive distance from 5 to 3 is 31.
Drive distance from 5 to 4 is 37.
Drive distance from 5 to 6 is 57.
Drive distance from 6 to 0 is 64.
Drive distance from 6 to 1 is 55.
Drive distance from 6 to 2 is 43.
Drive distance from 6 to 3 is 40.
Drive distance from 6 to 4 is 29.
Drive distance from 6 to 5 is 57.
These pairwise drives will guide the team as they pick the best 1 hubs among the 7 lots.

If you send back a reply, keep it in this little JSON shape so it's easy to read and plug in:

{
  ""solution"": {
    ""selected"": [<lot_to_open>, <lot_to_open>, ...],
    ""assignments"": [<assigned_lot>, <assigned_lot>, ...]
  }
}

This just sketches the form: ""selected"" lists the parking lots you'll open as charging hubs, and ""assignments"" lists, for each lot in the same order as the input, which opened lot it gets tied to. It's just the shape I expect, not the real answer.

Please use the identifiers from the instance exactly as given — 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”.""","{'distance_matrix': [[0, 53, 36, 38, 40, 55, 64], [53, 0, 31, 31, 32, 50, 55], [36, 31, 0, 30, 33, 19, 43], [38, 31, 30, 0, 17, 31, 40], [40, 32, 33, 17, 0, 37, 29], [55, 50, 19, 31, 37, 0, 57], [64, 55, 43, 40, 29, 57, 0]], 'p': 1, 'objective': 187.0}","{'facilities': [3], 'assignments': [3, 3, 3, 3, 3, 3, 3]}",187.0,"{'problem_type': 'PMED', 'num_nodes': 7, 'num_open': 1, 'sites': [{'id': 0, 'distances': {0: 0, 1: 53, 2: 36, 3: 38, 4: 40, 5: 55, 6: 64}}, {'id': 1, 'distances': {0: 53, 1: 0, 2: 31, 3: 31, 4: 32, 5: 50, 6: 55}}, {'id': 2, 'distances': {0: 36, 1: 31, 2: 0, 3: 30, 4: 33, 5: 19, 6: 43}}, {'id': 3, 'distances': {0: 38, 1: 31, 2: 30, 3: 0, 4: 17, 5: 31, 6: 40}}, {'id': 4, 'distances': {0: 40, 1: 32, 2: 33, 3: 17, 4: 0, 5: 37, 6: 29}}, {'id': 5, 'distances': {0: 55, 1: 50, 2: 19, 3: 31, 4: 37, 5: 0, 6: 57}}, {'id': 6, 'distances': {0: 64, 1: 55, 2: 43, 3: 40, 4: 29, 5: 57, 6: 0}}], 'objective': 187.0}","{'selected': [3], 'assignments': [3, 3, 3, 3, 3, 3, 3]}",34,nl,0
PMED,PMED,"Recently the sanitation director sketched out a plan: operate a fixed number of depots, then attach every pickup zone to a single open depot so service is complete and never duplicated. The scorecard was total distance driven — simply sum the distance from each zone to its assigned depot — and the goal was to make that total as low as possible. The exact distances and candidate sites follow below.

There are 5 locations in the instance, exactly 2 depots must be opened, and the ordered location identifiers are 1, 2, 3, 4, 5.
From pickup zone 1 to candidate depot 2, travel distance 62.
From pickup zone 1 to candidate depot 3, travel distance 29.
From pickup zone 1 to candidate depot 4, travel distance 68.
From pickup zone 1 to candidate depot 5, travel distance 100.
From pickup zone 2 to candidate depot 1, travel distance 62.
From pickup zone 2 to candidate depot 3, travel distance 47.
From pickup zone 2 to candidate depot 4, travel distance 34.
From pickup zone 2 to candidate depot 5, travel distance 89.
From pickup zone 3 to candidate depot 1, travel distance 29.
From pickup zone 3 to candidate depot 2, travel distance 47.
From pickup zone 3 to candidate depot 4, travel distance 48.
From pickup zone 3 to candidate depot 5, travel distance 77.
From pickup zone 4 to candidate depot 1, travel distance 68.
From pickup zone 4 to candidate depot 2, travel distance 34.
From pickup zone 4 to candidate depot 3, travel distance 48.
From pickup zone 4 to candidate depot 5, travel distance 80.
From pickup zone 5 to candidate depot 1, travel distance 100.
From pickup zone 5 to candidate depot 2, travel distance 89.
From pickup zone 5 to candidate depot 3, travel distance 77.
From pickup zone 5 to candidate depot 4, travel distance 80.
These distances and site identifiers are provided so the chosen 2 depots can be selected to minimize total travel distance.

If you want to give the solution back, just use this simple JSON shape so I can read it easily — nothing fancy, just a quick form to say which depots you open and which depot each pickup zone belongs to:

{
  ""solution"": {
    ""selected"": [<depot_to_open>, <depot_to_open>, ...],
    ""assignments"": [<assigned_depot>, <assigned_depot>, ...]
  }
}

""selected"" is where you list the depot IDs you decide to open. ""assignments"" is a list (in the same order as the pickup zones in the instance) saying which opened depot each zone is attached to. Think of it like filling out a form: picked depots in one box, and then one line per zone pointing to its depot.

This JSON is just a sketch of the shape I expect, not the actual answer — fill in the real IDs from the instance when you submit.

Please use the identifiers exactly as they appear in the instance input — do not rename them or invent new labels.
- for example: ""Valid identifiers look like plain numbers such as “1” or “23”, single capital letters like “A” or “B”, or a capital letter followed by digits like “A1” or “X7”.""","{'distance_matrix': [[0, 62, 29, 68, 100], [62, 0, 47, 34, 89], [29, 47, 0, 48, 77], [68, 34, 48, 0, 80], [100, 89, 77, 80, 0]], 'p': 2, 'objective': 124.0}","{'facilities': [2, 4], 'assignments': [2, 2, 2, 2, 4]}",124.0,"{'problem_type': 'PMED', 'num_nodes': 5, 'num_open': 2, 'sites': [{'id': 1, 'distances': {1: 0, 2: 62, 3: 29, 4: 68, 5: 100}}, {'id': 2, 'distances': {1: 62, 2: 0, 3: 47, 4: 34, 5: 89}}, {'id': 3, 'distances': {1: 29, 2: 47, 3: 0, 4: 48, 5: 77}}, {'id': 4, 'distances': {1: 68, 2: 34, 3: 48, 4: 0, 5: 80}}, {'id': 5, 'distances': {1: 100, 2: 89, 3: 77, 4: 80, 5: 0}}], 'objective': 124.0}","{'selected': [3, 5], 'assignments': [3, 3, 3, 3, 5]}",35,nl,1
PMED,PMED,"Many neighborhoods depend on a nearby ATM, so the operations group must pick a fixed number of candidate sites to actually host machines. After those sites are picked, every neighborhood must be assigned to one and only one of them — nothing left out and no double assignments. The best setup is the one that keeps overall customer travel as low as possible: add up the distances from each neighborhood to its assigned ATM, and look for the smallest total. The exact list of sites and pairwise distances appears below.

# total_neighborhoods=6
# atms_to_open=1
# neighborhood_ids=0, 1, 2, 3, 4, 5
origin_neighborhood,destination_neighborhood,travel_distance
0,1,62
0,2,66
0,3,85
0,4,54
0,5,54
1,0,62
1,2,66
1,3,75
1,4,38
1,5,56
2,0,66
2,1,66
2,3,93
2,4,60
2,5,53
3,0,85
3,1,75
3,2,93
3,4,76
3,5,57
4,0,54
4,1,38
4,2,60
4,3,76
4,5,43
5,0,54
5,1,56
5,2,53
5,3,57
5,4,43

Also, when you hand in the final picks and which neighborhood goes to which ATM, please stick to this simple JSON layout so it's easy to parse:

{
  ""solution"": {
    ""selected"": [<site_to_open>, <site_to_open>, ...],
    ""assignments"": [<chosen_open_site>, <chosen_open_site>, ...]
  }
}

Think of ""selected"" as the list of sites you're opening, and ""assignments"" as, for each neighborhood in the instance (in the same order the neighborhoods were listed), which opened site it uses. Super informal: selected = the ATMs you turn on, assignments = which ATM each neighborhood walks to.

This JSON is just a sketch of the expected shape — not the actual answer.

Please use the exact identifiers from the instance input when filling this in — don't rename or invent 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”.""","{'distance_matrix': [[0, 62, 66, 85, 54, 54], [62, 0, 66, 75, 38, 56], [66, 66, 0, 93, 60, 53], [85, 75, 93, 0, 76, 57], [54, 38, 60, 76, 0, 43], [54, 56, 53, 57, 43, 0]], 'p': 1, 'objective': 263.0}","{'facilities': [5], 'assignments': [5, 5, 5, 5, 5, 5]}",263.0,"{'problem_type': 'PMED', 'num_nodes': 6, 'num_open': 1, 'sites': [{'id': 0, 'distances': {0: 0, 1: 62, 2: 66, 3: 85, 4: 54, 5: 54}}, {'id': 1, 'distances': {0: 62, 1: 0, 2: 66, 3: 75, 4: 38, 5: 56}}, {'id': 2, 'distances': {0: 66, 1: 66, 2: 0, 3: 93, 4: 60, 5: 53}}, {'id': 3, 'distances': {0: 85, 1: 75, 2: 93, 3: 0, 4: 76, 5: 57}}, {'id': 4, 'distances': {0: 54, 1: 38, 2: 60, 3: 76, 4: 0, 5: 43}}, {'id': 5, 'distances': {0: 54, 1: 56, 2: 53, 3: 57, 4: 43, 5: 0}}], 'objective': 263.0}","{'selected': [5], 'assignments': [5, 5, 5, 5, 5, 5]}",36,csv,0
PMED,PMED,"At the rental shop the crew needs to choose a specific number of trailheads to keep gear at, and then assign each trailhead to one of those stocked spots so nothing is left unassigned or assigned twice. To judge different choices, total the travel distance from each trailhead to the stocked pickup it’s linked with — the plan with the lowest total distance makes the most sense for customers. The detailed list of trailheads and the distances between every pair appear below.

{
  ""num_trailheads"": 6,
  ""num_stocked_pickup_sites"": 2,
  ""trailhead_ids"": [
    0,
    1,
    2,
    3,
    4,
    5
  ],
  ""data"": [
    {
      ""from_trailhead"": 0,
      ""to_trailhead"": 1,
      ""travel_distance"": 33
    },
    {
      ""from_trailhead"": 0,
      ""to_trailhead"": 2,
      ""travel_distance"": 47
    },
    {
      ""from_trailhead"": 0,
      ""to_trailhead"": 3,
      ""travel_distance"": 58
    },
    {
      ""from_trailhead"": 0,
      ""to_trailhead"": 4,
      ""travel_distance"": 51
    },
    {
      ""from_trailhead"": 0,
      ""to_trailhead"": 5,
      ""travel_distance"": 56
    },
    {
      ""from_trailhead"": 1,
      ""to_trailhead"": 0,
      ""travel_distance"": 33
    },
    {
      ""from_trailhead"": 1,
      ""to_trailhead"": 2,
      ""travel_distance"": 31
    },
    {
      ""from_trailhead"": 1,
      ""to_trailhead"": 3,
      ""travel_distance"": 41
    },
    {
      ""from_trailhead"": 1,
      ""to_trailhead"": 4,
      ""travel_distance"": 50
    },
    {
      ""from_trailhead"": 1,
      ""to_trailhead"": 5,
      ""travel_distance"": 26
    },
    {
      ""from_trailhead"": 2,
      ""to_trailhead"": 0,
      ""travel_distance"": 47
    },
    {
      ""from_trailhead"": 2,
      ""to_trailhead"": 1,
      ""travel_distance"": 31
    },
    {
      ""from_trailhead"": 2,
      ""to_trailhead"": 3,
      ""travel_distance"": 43
    },
    {
      ""from_trailhead"": 2,
      ""to_trailhead"": 4,
      ""travel_distance"": 43
    },
    {
      ""from_trailhead"": 2,
      ""to_trailhead"": 5,
      ""travel_distance"": 43
    },
    {
      ""from_trailhead"": 3,
      ""to_trailhead"": 0,
      ""travel_distance"": 58
    },
    {
      ""from_trailhead"": 3,
      ""to_trailhead"": 1,
      ""travel_distance"": 41
    },
    {
      ""from_trailhead"": 3,
      ""to_trailhead"": 2,
      ""travel_distance"": 43
    },
    {
      ""from_trailhead"": 3,
      ""to_trailhead"": 4,
      ""travel_distance"": 45
    },
    {
      ""from_trailhead"": 3,
      ""to_trailhead"": 5,
      ""travel_distance"": 41
    },
    {
      ""from_trailhead"": 4,
      ""to_trailhead"": 0,
      ""travel_distance"": 51
    },
    {
      ""from_trailhead"": 4,
      ""to_trailhead"": 1,
      ""travel_distance"": 50
    },
    {
      ""from_trailhead"": 4,
      ""to_trailhead"": 2,
      ""travel_distance"": 43
    },
    {
      ""from_trailhead"": 4,
      ""to_trailhead"": 3,
      ""travel_distance"": 45
    },
    {
      ""from_trailhead"": 4,
      ""to_trailhead"": 5,
      ""travel_distance"": 32
    },
    {
      ""from_trailhead"": 5,
      ""to_trailhead"": 0,
      ""travel_distance"": 56
    },
    {
      ""from_trailhead"": 5,
      ""to_trailhead"": 1,
      ""travel_distance"": 26
    },
    {
      ""from_trailhead"": 5,
      ""to_trailhead"": 2,
      ""travel_distance"": 43
    },
    {
      ""from_trailhead"": 5,
      ""to_trailhead"": 3,
      ""travel_distance"": 41
    },
    {
      ""from_trailhead"": 5,
      ""to_trailhead"": 4,
      ""travel_distance"": 32
    }
  ]
}

If you want the answer in a neat, machine-friendly way, just follow this little JSON shape when you reply:

{
  ""solution"": {
    ""selected"": [<site_to_open>, <site_to_open>, ...],
    ""assignments"": [<assigned_pickup>, <assigned_pickup>, ...]
  }
}

""selected"" is where you list the trailheads we'll keep stocked (the pickup spots). ""assignments"" says, for each trailhead in the instance, which stocked pickup it's linked to. Super casual: think of ""selected"" as the handful of spots we actually stock, and ""assignments"" mapping every trailhead to one of those stocked spots.

This is just a sketch of the shape I expect, not the final plan.

Please use the exact identifiers from the instance input — do not rename them or invent new labels. 
- for example: ""Valid identifiers look like plain numbers such as “1” or “23”, single capital letters like “A” or “B”, or a capital letter followed by digits like “A1” or “X7”.""","{'distance_matrix': [[0, 33, 47, 58, 51, 56], [33, 0, 31, 41, 50, 26], [47, 31, 0, 43, 43, 43], [58, 41, 43, 0, 45, 41], [51, 50, 43, 45, 0, 32], [56, 26, 43, 41, 32, 0]], 'p': 2, 'objective': 131.0}","{'facilities': [1, 4], 'assignments': [1, 1, 1, 1, 4, 1]}",131.0,"{'problem_type': 'PMED', 'num_nodes': 6, 'num_open': 2, 'sites': [{'id': 0, 'distances': {0: 0, 1: 33, 2: 47, 3: 58, 4: 51, 5: 56}}, {'id': 1, 'distances': {0: 33, 1: 0, 2: 31, 3: 41, 4: 50, 5: 26}}, {'id': 2, 'distances': {0: 47, 1: 31, 2: 0, 3: 43, 4: 43, 5: 43}}, {'id': 3, 'distances': {0: 58, 1: 41, 2: 43, 3: 0, 4: 45, 5: 41}}, {'id': 4, 'distances': {0: 51, 1: 50, 2: 43, 3: 45, 4: 0, 5: 32}}, {'id': 5, 'distances': {0: 56, 1: 26, 2: 43, 3: 41, 4: 32, 5: 0}}], 'objective': 131.0}","{'selected': [1, 4], 'assignments': [1, 1, 1, 1, 4, 1]}",37,json,0
PMED,PMED,"In the neighborhood coordination meeting, the challenge was to pick a fixed number of truck parking locations and then attach every block to one of those live locations, using the known distances between blocks. The aim is to keep customer travel as low as possible — tally the distance from each block to its chosen parking location, add them all up, and the plan with the lowest total is preferred. Every single block must be assigned to exactly one open location; no block can be skipped or assigned to more than one. The specific blocks, candidate spots, and distances are shown below.

# total_blocks=8
# num_parking_locations_to_open=1
# block_ids=0, 1, 2, 3, 4, 5, 6, 7
source_block_id,target_block_id,travel_distance_between_blocks
0,1,53
0,2,54
0,3,47
0,4,27
0,5,47
0,6,62
0,7,12
1,0,53
1,2,58
1,3,59
1,4,45
1,5,10
1,6,30
1,7,50
2,0,54
2,1,58
2,3,33
2,4,56
2,5,55
2,6,61
2,7,49
3,0,47
3,1,59
3,2,33
3,4,51
3,5,49
3,6,55
3,7,35
4,0,27
4,1,45
4,2,56
4,3,51
4,5,40
4,6,60
4,7,38
5,0,47
5,1,10
5,2,55
5,3,49
5,4,40
5,6,20
5,7,50
6,0,62
6,1,30
6,2,61
6,3,55
6,4,60
6,5,20
6,7,62
7,0,12
7,1,50
7,2,49
7,3,35
7,4,38
7,5,50
7,6,62

Also, when you send back the plan, just use a small JSON snippet like this so it's easy to read and machine-friendly:

{
  ""solution"": {
    ""selected"": [<parking_spot_to_open>, <parking_spot_to_open>, ...],
    ""assignments"": [<assigned_parking_spot>, <assigned_parking_spot>, ...]
  }
}

Think of it like a simple form: ""selected"" is the list of parking spots you decide to open, and ""assignments"" lists, for each block in the same order as the input, which open spot that block is attached to. This is just a sketch of the shape I want — not the final plan itself.

Please make sure to use the exact identifiers from the instance input for every spot and block — 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”.""","{'distance_matrix': [[0, 53, 54, 47, 27, 47, 62, 12], [53, 0, 58, 59, 45, 10, 30, 50], [54, 58, 0, 33, 56, 55, 61, 49], [47, 59, 33, 0, 51, 49, 55, 35], [27, 45, 56, 51, 0, 40, 60, 38], [47, 10, 55, 49, 40, 0, 20, 50], [62, 30, 61, 55, 60, 20, 0, 62], [12, 50, 49, 35, 38, 50, 62, 0]], 'p': 1, 'objective': 271.0}","{'facilities': [5], 'assignments': [5, 5, 5, 5, 5, 5, 5, 5]}",271.0,"{'problem_type': 'PMED', 'num_nodes': 8, 'num_open': 1, 'sites': [{'id': 0, 'distances': {0: 0, 1: 53, 2: 54, 3: 47, 4: 27, 5: 47, 6: 62, 7: 12}}, {'id': 1, 'distances': {0: 53, 1: 0, 2: 58, 3: 59, 4: 45, 5: 10, 6: 30, 7: 50}}, {'id': 2, 'distances': {0: 54, 1: 58, 2: 0, 3: 33, 4: 56, 5: 55, 6: 61, 7: 49}}, {'id': 3, 'distances': {0: 47, 1: 59, 2: 33, 3: 0, 4: 51, 5: 49, 6: 55, 7: 35}}, {'id': 4, 'distances': {0: 27, 1: 45, 2: 56, 3: 51, 4: 0, 5: 40, 6: 60, 7: 38}}, {'id': 5, 'distances': {0: 47, 1: 10, 2: 55, 3: 49, 4: 40, 5: 0, 6: 20, 7: 50}}, {'id': 6, 'distances': {0: 62, 1: 30, 2: 61, 3: 55, 4: 60, 5: 20, 6: 0, 7: 62}}, {'id': 7, 'distances': {0: 12, 1: 50, 2: 49, 3: 35, 4: 38, 5: 50, 6: 62, 7: 0}}], 'objective': 271.0}","{'selected': [5], 'assignments': [5, 5, 5, 5, 5, 5, 5, 5]}",38,csv,0
PMED,PMED,"In our town the blood-drive planners need to select a set number of staging hubs and then attach each outreach location to one hub only, so there are no duplicates or misses. We have the travel distance for every pair of locations, so the sensible choice is the one that minimizes overall travel — calculate that by adding up each location’s distance to its assigned hub, and choose the arrangement with the lowest total. Specific candidate sites and pairwise distances are listed below.

There are 5 candidate locations; we must open exactly 2 staging hubs, and the location IDs are 0, 1, 2, 3, 4.
From 0 to 1: we have travel distance 94.
From 0 to 2: we have travel distance 50.
From 0 to 3: we have travel distance 61.
From 0 to 4: we have travel distance 16.
From 1 to 0: we have travel distance 94.
From 1 to 2: we have travel distance 93.
From 1 to 3: we have travel distance 126.
From 1 to 4: we have travel distance 86.
From 2 to 0: we have travel distance 50.
From 2 to 1: we have travel distance 93.
From 2 to 3: we have travel distance 69.
From 2 to 4: we have travel distance 55.
From 3 to 0: we have travel distance 61.
From 3 to 1: we have travel distance 126.
From 3 to 2: we have travel distance 69.
From 3 to 4: we have travel distance 55.
From 4 to 0: we have travel distance 16.
From 4 to 1: we have travel distance 86.
From 4 to 2: we have travel distance 55.
From 4 to 3: we have travel distance 55.
We will choose the assignment that minimizes total travel from outreach locations to their assigned hubs.

If you'd like, you can just return the choices in a little JSON snippet like this—show which sites we open and which open site each outreach location is attached to.

{
  ""solution"": {
    ""selected"": [<site_to_open>, <site_to_open>, ...],
    ""assignments"": [<assigned_site>, <assigned_site>, ...]
  }
}

""selected"" is where you list the staging hubs we decide to open. ""assignments"" is a list, in the same order as the outreach locations appear in the input, saying which opened hub each location is attached to. Think of it like a simple form: a list of open sites and then, for each outreach point, the open site it's signed up with.

This JSON is just 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 introduce new labels.

Valid identifiers look like plain numbers such as ""1"" or ""23"", single capital letters like ""A"" or ""B"", or a capital letter followed by digits like ""A1"" or ""X7"".","{'distance_matrix': [[0, 94, 50, 61, 16], [94, 0, 93, 126, 86], [50, 93, 0, 69, 55], [61, 126, 69, 0, 55], [16, 86, 55, 55, 0]], 'p': 2, 'objective': 126.0}","{'facilities': [1, 4], 'assignments': [4, 1, 4, 4, 4]}",126.0,"{'problem_type': 'PMED', 'num_nodes': 5, 'num_open': 2, 'sites': [{'id': 0, 'distances': {0: 0, 1: 94, 2: 50, 3: 61, 4: 16}}, {'id': 1, 'distances': {0: 94, 1: 0, 2: 93, 3: 126, 4: 86}}, {'id': 2, 'distances': {0: 50, 1: 93, 2: 0, 3: 69, 4: 55}}, {'id': 3, 'distances': {0: 61, 1: 126, 2: 69, 3: 0, 4: 55}}, {'id': 4, 'distances': {0: 16, 1: 86, 2: 55, 3: 55, 4: 0}}], 'objective': 126.0}","{'selected': [1, 4], 'assignments': [4, 1, 4, 4, 4]}",39,markdown_table,0
PMED,PMED,"Someone on the garden committee needs to decide which fixed number of tool-shed locations to open and then connect each garden plot to exactly one of those open sheds. The goal is to minimize the combined walking distance — you calculate that by adding the distance from every plot to its assigned shed, and the lower the total the better. It’s important that every plot is assigned to one shed only, and the full details of plots, candidate locations, and pairwise distances will be shown below.

There are 5 candidate locations, exactly 1 sheds must be opened, and the location identifiers are A, B, C, D, E.
From A to B, the walking distance is 23.
From A to C, the walking distance is 39.
From A to D, the walking distance is 34.
From A to E, the walking distance is 25.
From B to A, the walking distance is 23.
From B to C, the walking distance is 47.
From B to D, the walking distance is 38.
From B to E, the walking distance is 36.
From C to A, the walking distance is 39.
From C to B, the walking distance is 47.
From C to D, the walking distance is 29.
From C to E, the walking distance is 48.
From D to A, the walking distance is 34.
From D to B, the walking distance is 38.
From D to C, the walking distance is 29.
From D to E, the walking distance is 29.
From E to A, the walking distance is 25.
From E to B, the walking distance is 36.
From E to C, the walking distance is 48.
From E to D, the walking distance is 29.
Assign each plot to exactly one of the 1 opened sheds so the summed walking distance is minimized.

If you want to send the result back, just use this simple JSON layout so I can read it easily:

{
  ""solution"": {
    ""selected"": [<shed_to_open>, <shed_to_open>, ...],
    ""assignments"": [<chosen_shed>, <chosen_shed>, ...]
  }
}

Here ""selected"" is where you list the shed locations you decide to open, and ""assignments"" lists, in the same order as the plots appear in the instance, which opened shed each plot is assigned to. Think of it like a short form: which sheds are open, and who goes to which shed.

This is just a sketch of the shape I expect, not the actual answer — fill the placeholders with the real IDs from the instance.

All identifiers must be used exactly as they appear in the instance input — no renaming and no new labels.
- for example: ""Valid identifiers look like plain numbers such as “1” or “23”, single capital letters like “A” or “B”, or a capital letter followed by digits like “A1” or “X7”.""","{'distance_matrix': [[0, 23, 39, 34, 25], [23, 0, 47, 38, 36], [39, 47, 0, 29, 48], [34, 38, 29, 0, 29], [25, 36, 48, 29, 0]], 'p': 1, 'objective': 121.0}","{'facilities': [0], 'assignments': [0, 0, 0, 0, 0]}",121.0,"{'problem_type': 'PMED', 'num_nodes': 5, 'num_open': 1, 'sites': [{'id': 'A', 'distances': {'A': 0, 'B': 23, 'C': 39, 'D': 34, 'E': 25}}, {'id': 'B', 'distances': {'A': 23, 'B': 0, 'C': 47, 'D': 38, 'E': 36}}, {'id': 'C', 'distances': {'A': 39, 'B': 47, 'C': 0, 'D': 29, 'E': 48}}, {'id': 'D', 'distances': {'A': 34, 'B': 38, 'C': 29, 'D': 0, 'E': 29}}, {'id': 'E', 'distances': {'A': 25, 'B': 36, 'C': 48, 'D': 29, 'E': 0}}], 'objective': 121.0}","{'selected': ['A'], 'assignments': ['A', 'A', 'A', 'A', 'A']}",40,nl,names
PMED,PMED,"Many people are helping coordinate mobile food stops, and the trick is selecting a preset number of stops from a list of possibilities. Once those stops are set, every block must be matched to exactly one stop, and the quality of the choice is measured by adding up each block’s distance to its assigned stop — the smaller that grand total, the more efficient the plan. The exact list of locations and distances is given below.

There are 5 candidate locations; the coordinator must open exactly 1 stops chosen from 1, 2, 3, 4, 5.
From 1 to 2, the travel distance is 25.
From 1 to 3, the travel distance is 36.
From 1 to 4, the travel distance is 37.
From 1 to 5, the travel distance is 22.
From 2 to 1, the travel distance is 25.
From 2 to 3, the travel distance is 36.
From 2 to 4, the travel distance is 30.
From 2 to 5, the travel distance is 28.
From 3 to 1, the travel distance is 36.
From 3 to 2, the travel distance is 36.
From 3 to 4, the travel distance is 37.
From 3 to 5, the travel distance is 22.
From 4 to 1, the travel distance is 37.
From 4 to 2, the travel distance is 30.
From 4 to 3, the travel distance is 37.
From 4 to 5, the travel distance is 22.
From 5 to 1, the travel distance is 22.
From 5 to 2, the travel distance is 28.
From 5 to 3, the travel distance is 22.
From 5 to 4, the travel distance is 22.
These distances are used to sum each block’s distance to its assigned stop and compare total costs for different choices of 1 stops among the 5 candidates.

Also, please structure your reply using this little JSON sketch so it's easy to parse:

{
  ""solution"": {
    ""selected"": [<stop_to_open>, <stop_to_open>, ...],
    ""assignments"": [<chosen_open_stop>, <chosen_open_stop>, ...]
  }
}

""selected"" is where you list which stops you decide to open (one placeholder per chosen stop). ""assignments"" is a matching list that, for each block in the original order, gives the open stop that block is assigned to. Think of it like filling out a simple form: which stops are open, and which open stop each block goes to.

This is just the shape I need—not the real answer. Make sure to use the exact identifiers from the instance input when you fill this in — do not rename them or invent new labels.

- for example: ""Valid identifiers look like plain numbers such as “1” or “23”, single capital letters like “A” or “B”, or a capital letter followed by digits like “A1” or “X7”.""","{'distance_matrix': [[0, 25, 36, 37, 22], [25, 0, 36, 30, 28], [36, 36, 0, 37, 22], [37, 30, 37, 0, 22], [22, 28, 22, 22, 0]], 'p': 1, 'objective': 94.0}","{'facilities': [4], 'assignments': [4, 4, 4, 4, 4]}",94.0,"{'problem_type': 'PMED', 'num_nodes': 5, 'num_open': 1, 'sites': [{'id': 1, 'distances': {1: 0, 2: 25, 3: 36, 4: 37, 5: 22}}, {'id': 2, 'distances': {1: 25, 2: 0, 3: 36, 4: 30, 5: 28}}, {'id': 3, 'distances': {1: 36, 2: 36, 3: 0, 4: 37, 5: 22}}, {'id': 4, 'distances': {1: 37, 2: 30, 3: 37, 4: 0, 5: 22}}, {'id': 5, 'distances': {1: 22, 2: 28, 3: 22, 4: 22, 5: 0}}], 'objective': 94.0}","{'selected': [5], 'assignments': [5, 5, 5, 5, 5]}",41,markdown_table,1
PMED,PMED,"A local clinic is planning to open a handful of satellite vaccine spots and needs to make two decisions: which fixed number of candidate locations to use, and which single chosen site each residential area will go to (no area left out, and none sent to more than one place). The practical test is to add up each area’s travel distance to its assigned site; the setup with the lowest total travel wins. See the exact locations and distances below.

There are 5 distinct locations, the clinic must open exactly 1 sites, and the location IDs are 1, 2, 3, 4, 5.
From location 1 to candidate site 2, the travel distance is 33.
From location 1 to candidate site 3, the travel distance is 34.
From location 1 to candidate site 4, the travel distance is 23.
From location 1 to candidate site 5, the travel distance is 22.
From location 2 to candidate site 1, the travel distance is 33.
From location 2 to candidate site 3, the travel distance is 37.
From location 2 to candidate site 4, the travel distance is 19.
From location 2 to candidate site 5, the travel distance is 34.
From location 3 to candidate site 1, the travel distance is 34.
From location 3 to candidate site 2, the travel distance is 37.
From location 3 to candidate site 4, the travel distance is 33.
From location 3 to candidate site 5, the travel distance is 28.
From location 4 to candidate site 1, the travel distance is 23.
From location 4 to candidate site 2, the travel distance is 19.
From location 4 to candidate site 3, the travel distance is 33.
From location 4 to candidate site 5, the travel distance is 23.
From location 5 to candidate site 1, the travel distance is 22.
From location 5 to candidate site 2, the travel distance is 34.
From location 5 to candidate site 3, the travel distance is 28.
From location 5 to candidate site 4, the travel distance is 23.
Evaluate assignments for opening 1 sites by summing each area's listed travel distances; the lowest total wins.

To keep things simple, here's the shape your answer should follow — just a quick JSON sketch of what I expect you to fill in.

{
  ""solution"": {
    ""selected"": [<site_to_open>, <site_to_open>, ...],
    ""assignments"": [<chosen_site>, <chosen_site>, ...]
  }
}

""selected"" is where you list which candidate locations you'll open as vaccine spots. ""assignments"" is a one-to-one list (in the same order as the input areas) saying which opened site each area goes to. This JSON is just a template for the shape I want — not the real solution.

All identifiers in your actual answer must match the instance input exactly — do not rename them or invent new labels.  
Valid identifiers look like plain numbers such as “1” or “23”, single capital letters like “A” or “B”, or a capital letter followed by digits like “A1” or “X7”.","{'distance_matrix': [[0, 33, 34, 23, 22], [33, 0, 37, 19, 34], [34, 37, 0, 33, 28], [23, 19, 33, 0, 23], [22, 34, 28, 23, 0]], 'p': 1, 'objective': 98.0}","{'facilities': [3], 'assignments': [3, 3, 3, 3, 3]}",98.0,"{'problem_type': 'PMED', 'num_nodes': 5, 'num_open': 1, 'sites': [{'id': 1, 'distances': {1: 0, 2: 33, 3: 34, 4: 23, 5: 22}}, {'id': 2, 'distances': {1: 33, 2: 0, 3: 37, 4: 19, 5: 34}}, {'id': 3, 'distances': {1: 34, 2: 37, 3: 0, 4: 33, 5: 28}}, {'id': 4, 'distances': {1: 23, 2: 19, 3: 33, 4: 0, 5: 23}}, {'id': 5, 'distances': {1: 22, 2: 34, 3: 28, 4: 23, 5: 0}}], 'objective': 98.0}","{'selected': [4], 'assignments': [4, 4, 4, 4, 4]}",42,markdown_table,1
PMED,PMED,"A friend on the facilities crew explained they have to pick a limited number of locations for bike repair stands and assign every campus building to one of the opened stands so students’ walks are reasonable. The job is to select those exact-number spots out of the candidates and make sure each building is matched to only one kiosk, then judge the choices by summing the walking distance for every building-to-kiosk pair — smaller sums mean fewer people walking far. The concrete details will be shown below.

There are 7 candidate kiosk spots, they must pick exactly 1 to open, and the location IDs are 0, 1, 2, 3, 4, 5, 6.
From location 0 to candidate kiosk 1, the walking distance is 52.
From location 0 to candidate kiosk 2, the walking distance is 64.
From location 0 to candidate kiosk 3, the walking distance is 79.
From location 0 to candidate kiosk 4, the walking distance is 54.
From location 0 to candidate kiosk 5, the walking distance is 78.
From location 0 to candidate kiosk 6, the walking distance is 58.
From location 1 to candidate kiosk 0, the walking distance is 52.
From location 1 to candidate kiosk 2, the walking distance is 62.
From location 1 to candidate kiosk 3, the walking distance is 77.
From location 1 to candidate kiosk 4, the walking distance is 23.
From location 1 to candidate kiosk 5, the walking distance is 63.
From location 1 to candidate kiosk 6, the walking distance is 70.
From location 2 to candidate kiosk 0, the walking distance is 64.
From location 2 to candidate kiosk 1, the walking distance is 62.
From location 2 to candidate kiosk 3, the walking distance is 15.
From location 2 to candidate kiosk 4, the walking distance is 75.
From location 2 to candidate kiosk 5, the walking distance is 53.
From location 2 to candidate kiosk 6, the walking distance is 57.
From location 3 to candidate kiosk 0, the walking distance is 79.
From location 3 to candidate kiosk 1, the walking distance is 77.
From location 3 to candidate kiosk 2, the walking distance is 15.
From location 3 to candidate kiosk 4, the walking distance is 78.
From location 3 to candidate kiosk 5, the walking distance is 38.
From location 3 to candidate kiosk 6, the walking distance is 72.
From location 4 to candidate kiosk 0, the walking distance is 54.
From location 4 to candidate kiosk 1, the walking distance is 23.
From location 4 to candidate kiosk 2, the walking distance is 75.
From location 4 to candidate kiosk 3, the walking distance is 78.
From location 4 to candidate kiosk 5, the walking distance is 40.
From location 4 to candidate kiosk 6, the walking distance is 54.
From location 5 to candidate kiosk 0, the walking distance is 78.
From location 5 to candidate kiosk 1, the walking distance is 63.
From location 5 to candidate kiosk 2, the walking distance is 53.
From location 5 to candidate kiosk 3, the walking distance is 38.
From location 5 to candidate kiosk 4, the walking distance is 40.
From location 5 to candidate kiosk 6, the walking distance is 92.
From location 6 to candidate kiosk 0, the walking distance is 58.
From location 6 to candidate kiosk 1, the walking distance is 70.
From location 6 to candidate kiosk 2, the walking distance is 57.
From location 6 to candidate kiosk 3, the walking distance is 72.
From location 6 to candidate kiosk 4, the walking distance is 54.
From location 6 to candidate kiosk 5, the walking distance is 92.
They'll sum these distances for every building-to-kiosk assignment to judge how reasonable the choices are.

Also, when you send the picked spots back, it'd be great if you stick to this simple JSON layout so it's easy to load and check:

{
  ""solution"": {
    ""selected"": [<site_to_open>, <site_to_open>, ...],
    ""assignments"": [<chosen_open_site>, <chosen_open_site>, ...]
  }
}

This is just a sketch of the shape I need:
- ""selected"" is the list of kiosk locations you decide to open.
- ""assignments"" lists, for every campus building (in the same order as the instance), which opened kiosk that building is assigned to.

Quick note: that JSON is only the expected shape, not the actual answer — fill in the real identifiers from the instance when you respond. And please use the exact identifiers from the input with no renaming or new labels — they need to match exactly as given. 

- 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"".""","{'distance_matrix': [[0, 52, 64, 79, 54, 78, 58], [52, 0, 62, 77, 23, 63, 70], [64, 62, 0, 15, 75, 53, 57], [79, 77, 15, 0, 78, 38, 72], [54, 23, 75, 78, 0, 40, 54], [78, 63, 53, 38, 40, 0, 92], [58, 70, 57, 72, 54, 92, 0]], 'p': 1, 'objective': 324.0}","{'facilities': [4], 'assignments': [4, 4, 4, 4, 4, 4, 4]}",324.0,"{'problem_type': 'PMED', 'num_nodes': 7, 'num_open': 1, 'sites': [{'id': 0, 'distances': {0: 0, 1: 52, 2: 64, 3: 79, 4: 54, 5: 78, 6: 58}}, {'id': 1, 'distances': {0: 52, 1: 0, 2: 62, 3: 77, 4: 23, 5: 63, 6: 70}}, {'id': 2, 'distances': {0: 64, 1: 62, 2: 0, 3: 15, 4: 75, 5: 53, 6: 57}}, {'id': 3, 'distances': {0: 79, 1: 77, 2: 15, 3: 0, 4: 78, 5: 38, 6: 72}}, {'id': 4, 'distances': {0: 54, 1: 23, 2: 75, 3: 78, 4: 0, 5: 40, 6: 54}}, {'id': 5, 'distances': {0: 78, 1: 63, 2: 53, 3: 38, 4: 40, 5: 0, 6: 92}}, {'id': 6, 'distances': {0: 58, 1: 70, 2: 57, 3: 72, 4: 54, 5: 92, 6: 0}}], 'objective': 324.0}","{'selected': [4], 'assignments': [4, 4, 4, 4, 4, 4, 4]}",43,markdown_table,0
PMED,PMED,"Back at the office the task is to pick a set number of food bank satellite sites from a given list and make one-to-one links between each community zone and an open site. The better arrangement is the one that minimizes how far everyone has to go overall: measure the distance for each zone to its assigned site, add those distances together, and the smallest sum is best. Each zone must be assigned to exactly one open site, and only the listed properties can be used. The exact locations and travel distances are provided below.

# total_locations=8
# satellites_to_open=1
# location_ids=0, 1, 2, 3, 4, 5, 6, 7
from_location_id,to_location_id,travel_distance
0,1,41
0,2,35
0,3,31
0,4,38
0,5,24
0,6,28
0,7,31
1,0,41
1,2,67
1,3,40
1,4,53
1,5,51
1,6,37
1,7,65
2,0,35
2,1,67
2,3,50
2,4,51
2,5,34
2,6,38
2,7,55
3,0,31
3,1,40
3,2,50
3,4,57
3,5,37
3,6,23
3,7,54
4,0,38
4,1,53
4,2,51
4,3,57
4,5,47
4,6,38
4,7,46
5,0,24
5,1,51
5,2,34
5,3,37
5,4,47
5,6,14
5,7,45
6,0,28
6,1,37
6,2,38
6,3,23
6,4,38
6,5,14
6,7,49
7,0,31
7,1,65
7,2,55
7,3,54
7,4,46
7,5,45
7,6,49

Also, to keep things machine-friendly, please return the final choice in this simple JSON shape (just a quick heads-up — it's just the shape, not the answer itself):

{
  ""solution"": {
    ""selected"": [<site_to_open>, <site_to_open>, ...],
    ""assignments"": [<chosen_open_site>, <chosen_open_site>, ...]
  }
}

Think of ""selected"" as the list of satellite sites we decide to open, and ""assignments"" as, for each community zone (in the same order as the input), which open site that zone is linked to. Super casual: picked sites go in the selected list; every zone points to one of those picked sites in the assignments list.

This JSON is just a sketch of the expected shape, not the actual filled-in answer. Please make sure to use the exact identifiers from the instance input — do not rename them or invent new labels. 

Valid identifiers look like plain numbers such as “1” or “23”, single capital letters like “A” or “B”, or a capital letter followed by digits like “A1” or “X7”.","{'distance_matrix': [[0, 41, 35, 31, 38, 24, 28, 31], [41, 0, 67, 40, 53, 51, 37, 65], [35, 67, 0, 50, 51, 34, 38, 55], [31, 40, 50, 0, 57, 37, 23, 54], [38, 53, 51, 57, 0, 47, 38, 46], [24, 51, 34, 37, 47, 0, 14, 45], [28, 37, 38, 23, 38, 14, 0, 49], [31, 65, 55, 54, 46, 45, 49, 0]], 'p': 1, 'objective': 227.0}","{'facilities': [6], 'assignments': [6, 6, 6, 6, 6, 6, 6, 6]}",227.0,"{'problem_type': 'PMED', 'num_nodes': 8, 'num_open': 1, 'sites': [{'id': 0, 'distances': {0: 0, 1: 41, 2: 35, 3: 31, 4: 38, 5: 24, 6: 28, 7: 31}}, {'id': 1, 'distances': {0: 41, 1: 0, 2: 67, 3: 40, 4: 53, 5: 51, 6: 37, 7: 65}}, {'id': 2, 'distances': {0: 35, 1: 67, 2: 0, 3: 50, 4: 51, 5: 34, 6: 38, 7: 55}}, {'id': 3, 'distances': {0: 31, 1: 40, 2: 50, 3: 0, 4: 57, 5: 37, 6: 23, 7: 54}}, {'id': 4, 'distances': {0: 38, 1: 53, 2: 51, 3: 57, 4: 0, 5: 47, 6: 38, 7: 46}}, {'id': 5, 'distances': {0: 24, 1: 51, 2: 34, 3: 37, 4: 47, 5: 0, 6: 14, 7: 45}}, {'id': 6, 'distances': {0: 28, 1: 37, 2: 38, 3: 23, 4: 38, 5: 14, 6: 0, 7: 49}}, {'id': 7, 'distances': {0: 31, 1: 65, 2: 55, 3: 54, 4: 46, 5: 45, 6: 49, 7: 0}}], 'objective': 227.0}","{'selected': [6], 'assignments': [6, 6, 6, 6, 6, 6, 6, 6]}",44,csv,0
PMED,PMED,"I’m the transit planner trying to pick a handful of park-and-ride sites from a bigger list, then link every suburb to one of the opened sites so people can drive there before hopping on transit. The trick is to pick exactly the allowed number of lots and make sure every suburb is sent to one—and only one—of those open lots. A better plan is simply the one where, when all the suburbs’ trips are added up, the total miles (or minutes) people drive to their assigned lot is as small as possible. The actual candidate lots, suburbs and the distances between them are shown below.

# total_locations=6
# num_lots_to_open=1
# location_ids=A, B, C, D, E, F
from_location_id,to_location_id,drive_distance
A,B,36
A,C,4
A,D,34
A,E,29
A,F,30
B,A,36
B,C,37
B,D,34
B,E,51
B,F,41
C,A,4
C,B,37
C,D,33
C,E,33
C,F,32
D,A,34
D,B,34
D,C,33
D,E,43
D,F,38
E,A,29
E,B,51
E,C,33
E,D,43
E,F,46
F,A,30
F,B,41
F,C,32
F,D,38
F,E,46

Also, when you send back the plan, just stick to this simple JSON shape so I can read it automatically:

{
  ""solution"": {
    ""selected"": [<site_to_open>, <site_to_open>, ...],
    ""assignments"": [<chosen_open_site>, <chosen_open_site>, ...]
  }
}

This is just a sketch of the shape I need. ""selected"" is where you list the lots you choose to open (one placeholder per chosen lot), and ""assignments"" lists, for every suburb in the same order as the instance input, which opened lot that suburb is sent to. Keep it casual—think of ""selected"" as the checked boxes and ""assignments"" as the dropdown choices next to each suburb.

Please don’t rename any of the actual identifiers from the instance input when you fill this in — use them exactly as given, and don’t introduce new labels. Valid identifiers look like plain numbers such as “1” or “23”, single capital letters like “A” or “B”, or a capital letter followed by digits like “A1” or “X7”.","{'distance_matrix': [[0, 36, 4, 34, 29, 30], [36, 0, 37, 34, 51, 41], [4, 37, 0, 33, 33, 32], [34, 34, 33, 0, 43, 38], [29, 51, 33, 43, 0, 46], [30, 41, 32, 38, 46, 0]], 'p': 1, 'objective': 133.0}","{'facilities': [0], 'assignments': [0, 0, 0, 0, 0, 0]}",133.0,"{'problem_type': 'PMED', 'num_nodes': 6, 'num_open': 1, 'sites': [{'id': 'A', 'distances': {'A': 0, 'B': 36, 'C': 4, 'D': 34, 'E': 29, 'F': 30}}, {'id': 'B', 'distances': {'A': 36, 'B': 0, 'C': 37, 'D': 34, 'E': 51, 'F': 41}}, {'id': 'C', 'distances': {'A': 4, 'B': 37, 'C': 0, 'D': 33, 'E': 33, 'F': 32}}, {'id': 'D', 'distances': {'A': 34, 'B': 34, 'C': 33, 'D': 0, 'E': 43, 'F': 38}}, {'id': 'E', 'distances': {'A': 29, 'B': 51, 'C': 33, 'D': 43, 'E': 0, 'F': 46}}, {'id': 'F', 'distances': {'A': 30, 'B': 41, 'C': 32, 'D': 38, 'E': 46, 'F': 0}}], 'objective': 133.0}","{'selected': ['A'], 'assignments': ['A', 'A', 'A', 'A', 'A', 'A']}",45,csv,names
PMED,PMED,"Recently the parks team was asked to pick a set number of clearings for dog play areas and to route every neighborhood park to a single chosen site. The aim is to minimize how far everyone walks overall — computed by summing each park’s distance to the play area it’s sent to. Practically, that means opening exactly the allotted number of clearings and assigning each park to one, and only one, open play area so nothing’s left out or doubled. The concrete map and distance numbers follow below.

{
  ""total_locations"": 6,
  ""play_areas_to_open"": 1,
  ""location_ids"": [
    0,
    1,
    2,
    3,
    4,
    5
  ],
  ""data"": [
    {
      ""source_park_id"": 0,
      ""target_clearing_id"": 1,
      ""travel_distance"": 93
    },
    {
      ""source_park_id"": 0,
      ""target_clearing_id"": 2,
      ""travel_distance"": 111
    },
    {
      ""source_park_id"": 0,
      ""target_clearing_id"": 3,
      ""travel_distance"": 53
    },
    {
      ""source_park_id"": 0,
      ""target_clearing_id"": 4,
      ""travel_distance"": 63
    },
    {
      ""source_park_id"": 0,
      ""target_clearing_id"": 5,
      ""travel_distance"": 47
    },
    {
      ""source_park_id"": 1,
      ""target_clearing_id"": 0,
      ""travel_distance"": 93
    },
    {
      ""source_park_id"": 1,
      ""target_clearing_id"": 2,
      ""travel_distance"": 138
    },
    {
      ""source_park_id"": 1,
      ""target_clearing_id"": 3,
      ""travel_distance"": 56
    },
    {
      ""source_park_id"": 1,
      ""target_clearing_id"": 4,
      ""travel_distance"": 30
    },
    {
      ""source_park_id"": 1,
      ""target_clearing_id"": 5,
      ""travel_distance"": 50
    },
    {
      ""source_park_id"": 2,
      ""target_clearing_id"": 0,
      ""travel_distance"": 111
    },
    {
      ""source_park_id"": 2,
      ""target_clearing_id"": 1,
      ""travel_distance"": 138
    },
    {
      ""source_park_id"": 2,
      ""target_clearing_id"": 3,
      ""travel_distance"": 158
    },
    {
      ""source_park_id"": 2,
      ""target_clearing_id"": 4,
      ""travel_distance"": 165
    },
    {
      ""source_park_id"": 2,
      ""target_clearing_id"": 5,
      ""travel_distance"": 152
    },
    {
      ""source_park_id"": 3,
      ""target_clearing_id"": 0,
      ""travel_distance"": 53
    },
    {
      ""source_park_id"": 3,
      ""target_clearing_id"": 1,
      ""travel_distance"": 56
    },
    {
      ""source_park_id"": 3,
      ""target_clearing_id"": 2,
      ""travel_distance"": 158
    },
    {
      ""source_park_id"": 3,
      ""target_clearing_id"": 4,
      ""travel_distance"": 26
    },
    {
      ""source_park_id"": 3,
      ""target_clearing_id"": 5,
      ""travel_distance"": 10
    },
    {
      ""source_park_id"": 4,
      ""target_clearing_id"": 0,
      ""travel_distance"": 63
    },
    {
      ""source_park_id"": 4,
      ""target_clearing_id"": 1,
      ""travel_distance"": 30
    },
    {
      ""source_park_id"": 4,
      ""target_clearing_id"": 2,
      ""travel_distance"": 165
    },
    {
      ""source_park_id"": 4,
      ""target_clearing_id"": 3,
      ""travel_distance"": 26
    },
    {
      ""source_park_id"": 4,
      ""target_clearing_id"": 5,
      ""travel_distance"": 20
    },
    {
      ""source_park_id"": 5,
      ""target_clearing_id"": 0,
      ""travel_distance"": 47
    },
    {
      ""source_park_id"": 5,
      ""target_clearing_id"": 1,
      ""travel_distance"": 50
    },
    {
      ""source_park_id"": 5,
      ""target_clearing_id"": 2,
      ""travel_distance"": 152
    },
    {
      ""source_park_id"": 5,
      ""target_clearing_id"": 3,
      ""travel_distance"": 10
    },
    {
      ""source_park_id"": 5,
      ""target_clearing_id"": 4,
      ""travel_distance"": 20
    }
  ]
}

Also, when you send the actual answer, please follow this simple JSON layout so I can read it easily — just a casual sketch of the shape we expect:

{
  ""solution"": {
    ""selected"": [<site_to_open>, <site_to_open>, ...],
    ""assignments"": [<chosen_open_site>, <chosen_open_site>, ...]
  }
}

""selected"" is where you list which clearings (the play-area sites) you decide to open. ""assignments"" is a parallel list that says, for each park in the same order they appear in the instance, which open site that park is routed to. Super informal: ""selected"" = open spots, ""assignments"" = which open spot each park uses.

This is just the shape I want, not the actual solution values.

Please use the exact identifiers from the instance input — do not rename them or invent new labels. Valid identifiers look like plain numbers such as “1” or “23”, single capital letters like “A” or “B”, or a capital letter followed by digits like “A1” or “X7”.","{'distance_matrix': [[0, 93, 111, 53, 63, 47], [93, 0, 138, 56, 30, 50], [111, 138, 0, 158, 165, 152], [53, 56, 158, 0, 26, 10], [63, 30, 165, 26, 0, 20], [47, 50, 152, 10, 20, 0]], 'p': 1, 'objective': 279.0}","{'facilities': [5], 'assignments': [5, 5, 5, 5, 5, 5]}",279.0,"{'problem_type': 'PMED', 'num_nodes': 6, 'num_open': 1, 'sites': [{'id': 0, 'distances': {0: 0, 1: 93, 2: 111, 3: 53, 4: 63, 5: 47}}, {'id': 1, 'distances': {0: 93, 1: 0, 2: 138, 3: 56, 4: 30, 5: 50}}, {'id': 2, 'distances': {0: 111, 1: 138, 2: 0, 3: 158, 4: 165, 5: 152}}, {'id': 3, 'distances': {0: 53, 1: 56, 2: 158, 3: 0, 4: 26, 5: 10}}, {'id': 4, 'distances': {0: 63, 1: 30, 2: 165, 3: 26, 4: 0, 5: 20}}, {'id': 5, 'distances': {0: 47, 1: 50, 2: 152, 3: 10, 4: 20, 5: 0}}], 'objective': 279.0}","{'selected': [5], 'assignments': [5, 5, 5, 5, 5, 5]}",46,json,0
PMED,PMED,"Out in town there are several possible spots for water refill points, but only a limited number can be activated. The task is to choose which spots to open and assign every block to one of the opened spots so that no block is left without a single assigned station. The best choice is the one that makes the combined travel as small as possible: calculate the plan’s score by adding up the distance from each block to its assigned station, and the lower that sum, the better. The exact site options and pairwise distances are listed below.

There are 5 candidate locations, exactly 1 stations may be activated, and the location identifiers are 0, 1, 2, 3, 4.
Travel distance from 0 to 1 is 32.
Travel distance from 0 to 2 is 26.
Travel distance from 0 to 3 is 9.
Travel distance from 0 to 4 is 29.
Travel distance from 1 to 0 is 32.
Travel distance from 1 to 2 is 8.
Travel distance from 1 to 3 is 25.
Travel distance from 1 to 4 is 32.
Travel distance from 2 to 0 is 26.
Travel distance from 2 to 1 is 8.
Travel distance from 2 to 3 is 18.
Travel distance from 2 to 4 is 27.
Travel distance from 3 to 0 is 9.
Travel distance from 3 to 1 is 25.
Travel distance from 3 to 2 is 18.
Travel distance from 3 to 4 is 27.
Travel distance from 4 to 0 is 29.
Travel distance from 4 to 1 is 32.
Travel distance from 4 to 2 is 27.
Travel distance from 4 to 3 is 27.
Use these distances to sum the travel from every block to its assigned station and obtain the plan’s score for opening 1 stations.

If you want to share a proposed plan, just drop it in this simple JSON shape so I can read it easily — something like:

{
  ""solution"": {
    ""selected"": [<site_to_open>, <site_to_open>, ...],
    ""assignments"": [<chosen_open_site>, <chosen_open_site>, ...]
  }
}

Here ""selected"" is the list of refill spots you decide to open, and ""assignments"" is a matching list that says, for each block, which opened spot it should use. Think of it like filling out a little form: pick the sites to activate, then point every block to one of them. This JSON is just a sketch of the expected shape, not the actual answer — I'll need the real identifiers from the instance to compute the best plan.

Please make sure all identifiers in your reply match exactly what's in the instance input — do not rename or invent 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"".","{'distance_matrix': [[0, 32, 26, 9, 29], [32, 0, 8, 25, 32], [26, 8, 0, 18, 27], [9, 25, 18, 0, 27], [29, 32, 27, 27, 0]], 'p': 1, 'objective': 79.0}","{'facilities': [3], 'assignments': [3, 3, 3, 3, 3]}",79.0,"{'problem_type': 'PMED', 'num_nodes': 5, 'num_open': 1, 'sites': [{'id': 0, 'distances': {0: 0, 1: 32, 2: 26, 3: 9, 4: 29}}, {'id': 1, 'distances': {0: 32, 1: 0, 2: 8, 3: 25, 4: 32}}, {'id': 2, 'distances': {0: 26, 1: 8, 2: 0, 3: 18, 4: 27}}, {'id': 3, 'distances': {0: 9, 1: 25, 2: 18, 3: 0, 4: 27}}, {'id': 4, 'distances': {0: 29, 1: 32, 2: 27, 3: 27, 4: 0}}], 'objective': 79.0}","{'selected': [3], 'assignments': [3, 3, 3, 3, 3]}",47,markdown_table,0
PMED,PMED,"On a slow afternoon the ops manager was sketching a map: pick a fixed number of stroller rental kiosks from the suggested sites and link each entrance area to a single open kiosk (nothing gets left out or doubled up). The practical yardstick is clear — for each entrance figure the walk to its linked kiosk, sum all those walks, and the arrangement with the smallest total walking distance makes shoppers happiest. The detailed site options and distances are given below.

The ops manager recorded 5 total locations, must open 1 kiosks, and listed the locations as 0, 1, 2, 3, 4.
Entrance 0 to kiosk 1: walking distance 120.
Entrance 0 to kiosk 2: walking distance 92.
Entrance 0 to kiosk 3: walking distance 75.
Entrance 0 to kiosk 4: walking distance 91.
Entrance 1 to kiosk 0: walking distance 120.
Entrance 1 to kiosk 2: walking distance 85.
Entrance 1 to kiosk 3: walking distance 106.
Entrance 1 to kiosk 4: walking distance 84.
Entrance 2 to kiosk 0: walking distance 92.
Entrance 2 to kiosk 1: walking distance 85.
Entrance 2 to kiosk 3: walking distance 89.
Entrance 2 to kiosk 4: walking distance 93.
Entrance 3 to kiosk 0: walking distance 75.
Entrance 3 to kiosk 1: walking distance 106.
Entrance 3 to kiosk 2: walking distance 89.
Entrance 3 to kiosk 4: walking distance 97.
Entrance 4 to kiosk 0: walking distance 91.
Entrance 4 to kiosk 1: walking distance 84.
Entrance 4 to kiosk 2: walking distance 93.
Entrance 4 to kiosk 3: walking distance 97.
The ops manager will sum these walking distances to evaluate and choose the 1-kiosk arrangement among the 5 locations that minimizes total walking.

If you want the answer in a neat, machine-friendly shape, just follow this relaxed JSON layout — nothing fancy, just a simple form that matches the story:

{
  ""solution"": {
    ""selected"": [""<site_to_open>"", ""<site_to_open>"", ...],
    ""assignments"": [""<linked_kiosk>"", ""<linked_kiosk>"", ...]
  }
}

""selected"" is where you'd list the kiosk sites you decide to open (placeholders for the actual site identifiers). ""assignments"" lists, for each entrance, which opened kiosk that entrance is linked to — again placeholders showing the shape. Think of it like filling out a little form: which kiosks are open, and which kiosk each entrance walks to.

This JSON is just a sketch of the expected shape, not the real answer.

Please use the exact identifiers from the instance input — do not rename them or invent new labels. Valid identifiers look like plain numbers such as ""1"" or ""23"", single capital letters like ""A"" or ""B"", or a capital letter followed by digits like ""A1"" or ""X7"".","{'distance_matrix': [[0, 120, 92, 75, 91], [120, 0, 85, 106, 84], [92, 85, 0, 89, 93], [75, 106, 89, 0, 97], [91, 84, 93, 97, 0]], 'p': 1, 'objective': 359.0}","{'facilities': [2], 'assignments': [2, 2, 2, 2, 2]}",359.0,"{'problem_type': 'PMED', 'num_nodes': 5, 'num_open': 1, 'sites': [{'id': 0, 'distances': {0: 0, 1: 120, 2: 92, 3: 75, 4: 91}}, {'id': 1, 'distances': {0: 120, 1: 0, 2: 85, 3: 106, 4: 84}}, {'id': 2, 'distances': {0: 92, 1: 85, 2: 0, 3: 89, 4: 93}}, {'id': 3, 'distances': {0: 75, 1: 106, 2: 89, 3: 0, 4: 97}}, {'id': 4, 'distances': {0: 91, 1: 84, 2: 93, 3: 97, 4: 0}}], 'objective': 359.0}","{'selected': [2], 'assignments': [2, 2, 2, 2, 2]}",48,markdown_table,0
PMED,PMED,"Back in the planning meeting the job was to pick a fixed number of pop-up locations from several candidate spots and assign every attending neighborhood to one chosen stall. What counts as a better plan is how little it makes everyone travel overall: for each neighborhood take its distance to the stall it’s assigned to, sum those distances across all neighborhoods, and pick the arrangement with the lowest total. Every neighborhood must be assigned to exactly one open stall, and the number of stalls is set in advance. The detailed list of locations and pairwise distances is provided below.

Below are the 7 locations; exactly 1 stalls must be opened from these identifiers: 1, 2, 3, 4, 5, 6, 7.
Distance from 1 to 2 is 36.
Distance from 1 to 3 is 46.
Distance from 1 to 4 is 47.
Distance from 1 to 5 is 41.
Distance from 1 to 6 is 38.
Distance from 1 to 7 is 38.
Distance from 2 to 1 is 36.
Distance from 2 to 3 is 28.
Distance from 2 to 4 is 28.
Distance from 2 to 5 is 30.
Distance from 2 to 6 is 25.
Distance from 2 to 7 is 9.
Distance from 3 to 1 is 46.
Distance from 3 to 2 is 28.
Distance from 3 to 4 is 28.
Distance from 3 to 5 is 24.
Distance from 3 to 6 is 28.
Distance from 3 to 7 is 27.
Distance from 4 to 1 is 47.
Distance from 4 to 2 is 28.
Distance from 4 to 3 is 28.
Distance from 4 to 5 is 29.
Distance from 4 to 6 is 32.
Distance from 4 to 7 is 28.
Distance from 5 to 1 is 41.
Distance from 5 to 2 is 30.
Distance from 5 to 3 is 24.
Distance from 5 to 4 is 29.
Distance from 5 to 6 is 30.
Distance from 5 to 7 is 33.
Distance from 6 to 1 is 38.
Distance from 6 to 2 is 25.
Distance from 6 to 3 is 28.
Distance from 6 to 4 is 32.
Distance from 6 to 5 is 30.
Distance from 6 to 7 is 22.
Distance from 7 to 1 is 38.
Distance from 7 to 2 is 9.
Distance from 7 to 3 is 27.
Distance from 7 to 4 is 28.
Distance from 7 to 5 is 33.
Distance from 7 to 6 is 22.
Use these pairwise distances to compute the total travel for any arrangement with 1 open stalls among the 7 locations.

If you want the final reply in a simple machine-friendly shape, just follow this little JSON sketch for how I expect the answer to be laid out.

{
  ""solution"": {
    ""selected"": [<site_to_open>, <site_to_open>, ...],
    ""assignments"": [<chosen_site_to_open>, <chosen_site_to_open>, ...]
  }
}

This is just a template showing the shape I expect: ""selected"" lists which pop-up stalls you decide to open, and ""assignments"" lists, for every neighborhood in the same order as the instance input, which opened stall that neighborhood is assigned to. Think of it like a short form: pick the open sites, then say which site each neighborhood goes to.

This JSON is only a sketch of the expected shape, not the actual answer. Also, be sure to use the exact identifiers from the instance input — don't rename them or invent new labels. Valid identifiers look like plain numbers such as “1” or “23”, single capital letters like “A” or “B”, or a capital letter followed by digits like “A1” or “X7”.","{'distance_matrix': [[0, 36, 46, 47, 41, 38, 38], [36, 0, 28, 28, 30, 25, 9], [46, 28, 0, 28, 24, 28, 27], [47, 28, 28, 0, 29, 32, 28], [41, 30, 24, 29, 0, 30, 33], [38, 25, 28, 32, 30, 0, 22], [38, 9, 27, 28, 33, 22, 0]], 'p': 1, 'objective': 156.0}","{'facilities': [1], 'assignments': [1, 1, 1, 1, 1, 1, 1]}",156.0,"{'problem_type': 'PMED', 'num_nodes': 7, 'num_open': 1, 'sites': [{'id': 1, 'distances': {1: 0, 2: 36, 3: 46, 4: 47, 5: 41, 6: 38, 7: 38}}, {'id': 2, 'distances': {1: 36, 2: 0, 3: 28, 4: 28, 5: 30, 6: 25, 7: 9}}, {'id': 3, 'distances': {1: 46, 2: 28, 3: 0, 4: 28, 5: 24, 6: 28, 7: 27}}, {'id': 4, 'distances': {1: 47, 2: 28, 3: 28, 4: 0, 5: 29, 6: 32, 7: 28}}, {'id': 5, 'distances': {1: 41, 2: 30, 3: 24, 4: 29, 5: 0, 6: 30, 7: 33}}, {'id': 6, 'distances': {1: 38, 2: 25, 3: 28, 4: 32, 5: 30, 6: 0, 7: 22}}, {'id': 7, 'distances': {1: 38, 2: 9, 3: 27, 4: 28, 5: 33, 6: 22, 7: 0}}], 'objective': 156.0}","{'selected': [2], 'assignments': [2, 2, 2, 2, 2, 2, 2]}",49,markdown_table,1
PMED,PMED,"Around town the goal is to open a set number of recycling drop‑off sites chosen from several possible places, and then link every residential block to one of the opened sites — every block must have one assignment and only one. The best arrangement is simply the one that keeps the total walking or driving distance lowest: sum the distance for every block to its assigned site, and pick the setup with the smallest total. The full list of candidate locations and the distance data is shown below.

There are 5 locations listed; exactly 1 drop-off centers must be opened, and the location identifiers are 0, 1, 2, 3, 4.
Distance from 0 to 1 is 52.
Distance from 0 to 2 is 66.
Distance from 0 to 3 is 62.
Distance from 0 to 4 is 71.
Distance from 1 to 0 is 52.
Distance from 1 to 2 is 37.
Distance from 1 to 3 is 43.
Distance from 1 to 4 is 49.
Distance from 2 to 0 is 66.
Distance from 2 to 1 is 37.
Distance from 2 to 3 is 60.
Distance from 2 to 4 is 65.
Distance from 3 to 0 is 62.
Distance from 3 to 1 is 43.
Distance from 3 to 2 is 60.
Distance from 3 to 4 is 53.
Distance from 4 to 0 is 71.
Distance from 4 to 1 is 49.
Distance from 4 to 2 is 65.
Distance from 4 to 3 is 53.
These pairwise travel distances are provided to compute assignments and select the arrangement with the lowest total travel.

I'll return the result in a small JSON object so it's easy to read and plug into whatever you use next. Here's the shape I'll follow:

{
  ""solution"": {
    ""selected"": [<site_to_open>, <site_to_open>, ...],
    ""assignments"": [<assigned_site>, <assigned_site>, ...]
  }
}

""selected"" is the list of drop-off sites we decide to open. ""assignments"" is a list that, in order, tells which opened site each residential block is assigned to (one entry per block). This is just a sketch of the expected format, not the actual final answer.

Please use the exact identifiers from the instance input — do not rename them or invent new labels. For example: ""Valid identifiers look like plain numbers such as “1” or “23”, single capital letters like “A” or “B”, or a capital letter followed by digits like “A1” or “X7”.""","{'distance_matrix': [[0, 52, 66, 62, 71], [52, 0, 37, 43, 49], [66, 37, 0, 60, 65], [62, 43, 60, 0, 53], [71, 49, 65, 53, 0]], 'p': 1, 'objective': 181.0}","{'facilities': [1], 'assignments': [1, 1, 1, 1, 1]}",181.0,"{'problem_type': 'PMED', 'num_nodes': 5, 'num_open': 1, 'sites': [{'id': 0, 'distances': {0: 0, 1: 52, 2: 66, 3: 62, 4: 71}}, {'id': 1, 'distances': {0: 52, 1: 0, 2: 37, 3: 43, 4: 49}}, {'id': 2, 'distances': {0: 66, 1: 37, 2: 0, 3: 60, 4: 65}}, {'id': 3, 'distances': {0: 62, 1: 43, 2: 60, 3: 0, 4: 53}}, {'id': 4, 'distances': {0: 71, 1: 49, 2: 65, 3: 53, 4: 0}}], 'objective': 181.0}","{'selected': [1], 'assignments': [1, 1, 1, 1, 1]}",50,markdown_table,0