OSP/OSP_S_context.csv

task_name,problem_type,instruction,instance,solution,obj,instance_variant,solution_variant,context_index,input_format,input_index_base
OSP,OSP,"Recently the kitchen got a big batch of complex orders: each plate needs several different stations, one visit to each, but there’s no set order for those visits. The need is to pick a sequence and start times for each step so stations don’t overlap on different dishes and no dish is split between stations at once — and every required step is done once and only once. The aim is simple in practice: finish the last order as soon as possible, so the schedule is judged by the time the final dish is ready. The detailed breakdown of orders and stations is below.

# orders_count=2
# stations_count=2
# orders=J1, J2
# stations=1, 2
order_id,step_index,station_id,prep_time
J1,0,1,1
J1,1,2,52
J2,0,1,73
J2,1,2,27

Also, just so the reply is easy to parse, please follow this simple JSON layout when you give the schedule — nothing fancy, just a predictable shape. For our kitchen story the placeholders for identifiers have been tweaked to match the language of plates and stations, but otherwise the layout is the same:

{
  ""solution"": [
    {
      ""job"": <plate_id>,
      ""tasks"": [
        {
          ""task"": <step_index>,
          ""start"": <start_time>,
          ""machine"": <station_id>,
          ""duration"": <duration>
        }
      ]
    }
  ]
}

This is just a sketch of the shape I need: ""solution"" is a list of orders (plates), each entry has the plate identifier in ""job"" and a ""tasks"" list. Each task entry lists the task/step index, when it starts, which station (machine) it uses, and how long it takes. Keep it light and straightforward — it's just a form to fill in the schedule.

One more thing: use the identifiers exactly as they appear in 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”.","{'nr_machines': 2, 'nr_jobs': 2, 'jobs': [[[0, 1], [1, 52]], [[0, 73], [1, 27]]]}","[{'job': 0, 'tasks': [{'task': 0, 'start': 73, 'machine': 0, 'duration': 1}, {'task': 1, 'start': 0, 'machine': 1, 'duration': 52}]}, {'job': 1, 'tasks': [{'task': 0, 'start': 0, 'machine': 0, 'duration': 73}, {'task': 1, 'start': 73, 'machine': 1, 'duration': 27}]}]",100.0,"{'problem_type': 'OSP', 'nr_jobs': 2, 'nr_machines': 2, 'jobs': ['J1', 'J2'], 'machines': [1, 2], 'records': [{'job_id': 'J1', 'task_id': 0, 'machine_id': 1, 'duration': 1}, {'job_id': 'J1', 'task_id': 1, 'machine_id': 2, 'duration': 52}, {'job_id': 'J2', 'task_id': 0, 'machine_id': 1, 'duration': 73}, {'job_id': 'J2', 'task_id': 1, 'machine_id': 2, 'duration': 27}]}","[{'job': 'J1', 'tasks': [{'task': 0, 'start': 73, 'machine': 1, 'duration': 1}, {'task': 1, 'start': 0, 'machine': 2, 'duration': 52}]}, {'job': 'J2', 'tasks': [{'task': 0, 'start': 0, 'machine': 1, 'duration': 73}, {'task': 1, 'start': 73, 'machine': 2, 'duration': 27}]}]",1,csv,1
OSP,OSP,"There’s a wedding planner juggling multiple sites, each site expecting a fixed group of vendors to come through exactly once — but the order of those visits is up for grabs. The job is to pick the sequence and start times for each vendor at each site so vendors don’t overlap between venues and no site has two teams working at the same instant. Success is measured by the moment the last site is wrapped up: the earlier that time, the better the schedule. The specific venue requirements and vendor details appear below.

{
  ""nr_venues"": 4,
  ""nr_vendors"": 2,
  ""venue_ids"": [
    ""J1"",
    ""J2"",
    ""J3"",
    ""J4""
  ],
  ""vendor_ids"": [
    ""A"",
    ""B""
  ],
  ""tasks"": [
    {
      ""venue_id"": ""J1"",
      ""task_index"": 0,
      ""vendor_id"": ""A"",
      ""service_duration"": 1
    },
    {
      ""venue_id"": ""J1"",
      ""task_index"": 1,
      ""vendor_id"": ""B"",
      ""service_duration"": 65
    },
    {
      ""venue_id"": ""J2"",
      ""task_index"": 0,
      ""vendor_id"": ""A"",
      ""service_duration"": 49
    },
    {
      ""venue_id"": ""J2"",
      ""task_index"": 1,
      ""vendor_id"": ""B"",
      ""service_duration"": 72
    },
    {
      ""venue_id"": ""J3"",
      ""task_index"": 0,
      ""vendor_id"": ""A"",
      ""service_duration"": 90
    },
    {
      ""venue_id"": ""J3"",
      ""task_index"": 1,
      ""vendor_id"": ""B"",
      ""service_duration"": 42
    },
    {
      ""venue_id"": ""J4"",
      ""task_index"": 0,
      ""vendor_id"": ""A"",
      ""service_duration"": 3
    },
    {
      ""venue_id"": ""J4"",
      ""task_index"": 1,
      ""vendor_id"": ""B"",
      ""service_duration"": 19
    }
  ]
}

And just so we're on the same page about how I’d like the answer formatted, here’s a little sketch of the JSON shape I expect — nothing fancy, just the layout so it’s easy to plug your schedule into.

{
  ""solution"": [
    {
      ""job"": <site_id>,
      ""tasks"": [
        {
          ""task"": <vendor_task_index>,
          ""start"": <start_time>,
          ""machine"": <vendor_id>,
          ""duration"": <duration>
        }
      ]
    }
  ]
}

Think of each entry as one site (job) and its list of vendor visits (tasks). The ""task"" entry names the specific vendor visit, ""start"" is when that visit begins, ""machine"" is the vendor/team handling the task, and ""duration"" is how long they stay. This JSON is just a shape guide — not the actual schedule.

Please be sure to use the exact identifiers from the instance input — don’t 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”.","{'nr_machines': 2, 'nr_jobs': 4, 'jobs': [[[0, 1], [1, 65]], [[0, 49], [1, 72]], [[0, 90], [1, 42]], [[0, 3], [1, 19]]]}","[{'job': 0, 'tasks': [{'task': 0, 'start': 142, 'machine': 0, 'duration': 1}, {'task': 1, 'start': 72, 'machine': 1, 'duration': 65}]}, {'job': 1, 'tasks': [{'task': 0, 'start': 90, 'machine': 0, 'duration': 49}, {'task': 1, 'start': 0, 'machine': 1, 'duration': 72}]}, {'job': 2, 'tasks': [{'task': 0, 'start': 0, 'machine': 0, 'duration': 90}, {'task': 1, 'start': 137, 'machine': 1, 'duration': 42}]}, {'job': 3, 'tasks': [{'task': 0, 'start': 139, 'machine': 0, 'duration': 3}, {'task': 1, 'start': 179, 'machine': 1, 'duration': 19}]}]",198.0,"{'problem_type': 'OSP', 'nr_jobs': 4, 'nr_machines': 2, 'jobs': ['J1', 'J2', 'J3', 'J4'], 'machines': ['A', 'B'], 'records': [{'job_id': 'J1', 'task_id': 0, 'machine_id': 'A', 'duration': 1}, {'job_id': 'J1', 'task_id': 1, 'machine_id': 'B', 'duration': 65}, {'job_id': 'J2', 'task_id': 0, 'machine_id': 'A', 'duration': 49}, {'job_id': 'J2', 'task_id': 1, 'machine_id': 'B', 'duration': 72}, {'job_id': 'J3', 'task_id': 0, 'machine_id': 'A', 'duration': 90}, {'job_id': 'J3', 'task_id': 1, 'machine_id': 'B', 'duration': 42}, {'job_id': 'J4', 'task_id': 0, 'machine_id': 'A', 'duration': 3}, {'job_id': 'J4', 'task_id': 1, 'machine_id': 'B', 'duration': 19}]}","[{'job': 'J1', 'tasks': [{'task': 0, 'start': 142, 'machine': 'A', 'duration': 1}, {'task': 1, 'start': 72, 'machine': 'B', 'duration': 65}]}, {'job': 'J2', 'tasks': [{'task': 0, 'start': 90, 'machine': 'A', 'duration': 49}, {'task': 1, 'start': 0, 'machine': 'B', 'duration': 72}]}, {'job': 'J3', 'tasks': [{'task': 0, 'start': 0, 'machine': 'A', 'duration': 90}, {'task': 1, 'start': 137, 'machine': 'B', 'duration': 42}]}, {'job': 'J4', 'tasks': [{'task': 0, 'start': 139, 'machine': 'A', 'duration': 3}, {'task': 1, 'start': 179, 'machine': 'B', 'duration': 19}]}]",2,json,names
OSP,OSP,"I got a note from the post crew asking for a plan: several reels need to go through a handful of stations (color, sound, VFX, whatever), and for each reel every assigned station has to touch it once — no skipping, no doing the same station twice. The work order for a given reel can be any order, so the trick is picking which station each reel goes to first, second, etc., and when to start each handoff. Better plans are the ones that get the entire batch finished sooner — measured by the clock time when the last reel comes out of its final station. Stations can only work on one reel at a time, and a reel can’t be in two stations at once. Concrete details about the reels and stations are listed below.

# num_reels=3
# num_stations=2
# reel_ids=J1, J2, J3
# station_ids=0, 1
reel_id,task_index,station_id,processing_duration
J1,0,0,1
J1,1,1,78
J2,0,0,25
J2,1,1,18
J3,0,0,44
J3,1,1,63

Also, when you hand me the plan, please use a simple JSON layout like this — just a relaxed sketch of the shape I want so it's easy to read and parse:

{
  ""solution"": [
    {
      ""job"": <reel_id>,
      ""tasks"": [
        {
          ""task"": <touch_index>,
          ""start"": <start_time>,
          ""machine"": <station_id>,
          ""duration"": <duration>
        }
      ]
    }
  ]
}

Think of it like a tiny form for each reel: ""job"" is the reel identifier, ""tasks"" is the ordered list of touches that reel will get, and each task shows which touch it is, when it starts, which station handles it, and how long that touch takes. Super informal — just fill each reel's schedule the same way.

This JSON is only a sketch of the expected shape, not the actual schedule — I'll need the real values to produce the plan.

Please make sure all identifiers are used exactly as they appear in the instance input — no renaming and no new labels.

Valid identifiers look like plain numbers such as “1” or “23”, single capital letters like “A” or “B”, or a capital letter followed by digits like “A1” or “X7”.","{'nr_machines': 2, 'nr_jobs': 3, 'jobs': [[[0, 1], [1, 78]], [[0, 25], [1, 18]], [[0, 44], [1, 63]]]}","[{'job': 0, 'tasks': [{'task': 0, 'start': 78, 'machine': 0, 'duration': 1}, {'task': 1, 'start': 0, 'machine': 1, 'duration': 78}]}, {'job': 1, 'tasks': [{'task': 0, 'start': 44, 'machine': 0, 'duration': 25}, {'task': 1, 'start': 141, 'machine': 1, 'duration': 18}]}, {'job': 2, 'tasks': [{'task': 0, 'start': 0, 'machine': 0, 'duration': 44}, {'task': 1, 'start': 78, 'machine': 1, 'duration': 63}]}]",159.0,"{'problem_type': 'OSP', 'nr_jobs': 3, 'nr_machines': 2, 'jobs': ['J1', 'J2', 'J3'], 'machines': [0, 1], 'records': [{'job_id': 'J1', 'task_id': 0, 'machine_id': 0, 'duration': 1}, {'job_id': 'J1', 'task_id': 1, 'machine_id': 1, 'duration': 78}, {'job_id': 'J2', 'task_id': 0, 'machine_id': 0, 'duration': 25}, {'job_id': 'J2', 'task_id': 1, 'machine_id': 1, 'duration': 18}, {'job_id': 'J3', 'task_id': 0, 'machine_id': 0, 'duration': 44}, {'job_id': 'J3', 'task_id': 1, 'machine_id': 1, 'duration': 63}]}","[{'job': 'J1', 'tasks': [{'task': 0, 'start': 78, 'machine': 0, 'duration': 1}, {'task': 1, 'start': 0, 'machine': 1, 'duration': 78}]}, {'job': 'J2', 'tasks': [{'task': 0, 'start': 44, 'machine': 0, 'duration': 25}, {'task': 1, 'start': 141, 'machine': 1, 'duration': 18}]}, {'job': 'J3', 'tasks': [{'task': 0, 'start': 0, 'machine': 0, 'duration': 44}, {'task': 1, 'start': 78, 'machine': 1, 'duration': 63}]}]",3,csv,0
OSP,OSP,"Back at the depot there’s a practical puzzle: a fleet needs servicing and each truck must visit a few specified bays once apiece, but nobody has fixed the order of those visits. The person scheduling has to pick both the order for each truck and the start times for every service so that bays aren’t double-booked and trucks don’t overlap locations. The success of any plan is measured by the moment the final truck leaves — that latest departure time is what the schedule should minimize. Concrete details are shown below.

There are 2 trucks and 2 bays — trucks: J1, J2; bays: A, B.

| truck_id | service_index | bay_id | service_duration |
|---|---|---|---|
| J1 | 0 | A | 1 |
| J1 | 1 | B | 92 |
| J2 | 0 | A | 1 |
| J2 | 1 | B | 64 |

The person scheduling should pick orders and start times so the latest departure time is minimized.

You can just reply with a little JSON sketch in the shape below — nothing fancy, just that structure so I know which truck (job) and which bay visits (tasks) go where and when.

{
  ""solution"": [
    {
      ""job"": <truck_id>,
      ""tasks"": [
        {
          ""task"": <service_index>,
          ""start"": <start_time>,
          ""machine"": <bay_id>,
          ""duration"": <duration>
        }
      ]
    }
  ]
}

Think of it like a simple form: each ""job"" is one truck, ""tasks"" is the list of services that truck needs to visit, ""task"" is just the index or label for that visit, ""start"" is when that service begins, ""machine"" is the bay where it happens, and ""duration"" is how long it takes. This JSON is just a sketch of the expected shape — not the actual answer.

Please 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”.""","{'nr_machines': 2, 'nr_jobs': 2, 'jobs': [[[0, 1], [1, 92]], [[0, 1], [1, 64]]]}","[{'job': 0, 'tasks': [{'task': 0, 'start': 92, 'machine': 0, 'duration': 1}, {'task': 1, 'start': 0, 'machine': 1, 'duration': 92}]}, {'job': 1, 'tasks': [{'task': 0, 'start': 0, 'machine': 0, 'duration': 1}, {'task': 1, 'start': 92, 'machine': 1, 'duration': 64}]}]",156.0,"{'problem_type': 'OSP', 'nr_jobs': 2, 'nr_machines': 2, 'jobs': ['J1', 'J2'], 'machines': ['A', 'B'], 'records': [{'job_id': 'J1', 'task_id': 0, 'machine_id': 'A', 'duration': 1}, {'job_id': 'J1', 'task_id': 1, 'machine_id': 'B', 'duration': 92}, {'job_id': 'J2', 'task_id': 0, 'machine_id': 'A', 'duration': 1}, {'job_id': 'J2', 'task_id': 1, 'machine_id': 'B', 'duration': 64}]}","[{'job': 'J1', 'tasks': [{'task': 0, 'start': 92, 'machine': 'A', 'duration': 1}, {'task': 1, 'start': 0, 'machine': 'B', 'duration': 92}]}, {'job': 'J2', 'tasks': [{'task': 0, 'start': 0, 'machine': 'A', 'duration': 1}, {'task': 1, 'start': 92, 'machine': 'B', 'duration': 64}]}]",4,markdown_table,names
OSP,OSP,"Many people in the studio are juggling pieces that each require touches at several specialty stations; each piece must visit each listed station one time, but the order of visits can change from piece to piece. Someone needs to decide the order for every piece and when each station should start each step, ensuring stations aren’t double-booked and an item never sits in two places at once. The obvious aim is to have the whole pile done as soon as possible — the schedule’s score is the time the final piece is completed. The instance specifics are given below.

{
  ""total_pieces"": 5,
  ""total_stations"": 2,
  ""piece_ids"": [
    ""J1"",
    ""J2"",
    ""J3"",
    ""J4"",
    ""J5""
  ],
  ""station_ids"": [
    1,
    2
  ],
  ""tasks"": [
    {
      ""piece_id"": ""J1"",
      ""step_index"": 0,
      ""required_station_id"": 1,
      ""processing_time"": 1
    },
    {
      ""piece_id"": ""J1"",
      ""step_index"": 1,
      ""required_station_id"": 2,
      ""processing_time"": 6
    },
    {
      ""piece_id"": ""J2"",
      ""step_index"": 0,
      ""required_station_id"": 1,
      ""processing_time"": 76
    },
    {
      ""piece_id"": ""J2"",
      ""step_index"": 1,
      ""required_station_id"": 2,
      ""processing_time"": 10
    },
    {
      ""piece_id"": ""J3"",
      ""step_index"": 0,
      ""required_station_id"": 1,
      ""processing_time"": 51
    },
    {
      ""piece_id"": ""J3"",
      ""step_index"": 1,
      ""required_station_id"": 2,
      ""processing_time"": 8
    },
    {
      ""piece_id"": ""J4"",
      ""step_index"": 0,
      ""required_station_id"": 1,
      ""processing_time"": 17
    },
    {
      ""piece_id"": ""J4"",
      ""step_index"": 1,
      ""required_station_id"": 2,
      ""processing_time"": 23
    },
    {
      ""piece_id"": ""J5"",
      ""step_index"": 0,
      ""required_station_id"": 1,
      ""processing_time"": 25
    },
    {
      ""piece_id"": ""J5"",
      ""step_index"": 1,
      ""required_station_id"": 2,
      ""processing_time"": 99
    }
  ]
}

Also, to make it easy for whoever's filling this in, here's the little JSON shape I'd like the final schedule to follow — nothing fancy, just a clear outline of each piece (job) and all its steps. Use the exact layout below when you post the schedule.

{
  ""solution"": [
    {
      ""job"": <piece_id>,
      ""tasks"": [
        {
          ""task"": <task_index>,
          ""start"": <start_time>,
          ""machine"": <station_id>,
          ""duration"": <duration>
        }
      ]
    }
  ]
}

Think of it like a simple form: each top-level object in ""solution"" is one piece (job). ""job"" is the piece identifier, ""tasks"" is the list of its steps. For each step, ""task"" is just the step index, ""start"" is when that step begins, ""machine"" is which station does the work, and ""duration"" is how long it takes. This is just a sketch of the expected shape — not the actual answer.

Please remember: when you fill in the real schedule, 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”.""","{'nr_machines': 2, 'nr_jobs': 5, 'jobs': [[[0, 1], [1, 6]], [[0, 76], [1, 10]], [[0, 51], [1, 8]], [[0, 17], [1, 23]], [[0, 25], [1, 99]]]}","[{'job': 0, 'tasks': [{'task': 0, 'start': 169, 'machine': 0, 'duration': 1}, {'task': 1, 'start': 140, 'machine': 1, 'duration': 6}]}, {'job': 1, 'tasks': [{'task': 0, 'start': 0, 'machine': 0, 'duration': 76}, {'task': 1, 'start': 122, 'machine': 1, 'duration': 10}]}, {'job': 2, 'tasks': [{'task': 0, 'start': 76, 'machine': 0, 'duration': 51}, {'task': 1, 'start': 132, 'machine': 1, 'duration': 8}]}, {'job': 3, 'tasks': [{'task': 0, 'start': 152, 'machine': 0, 'duration': 17}, {'task': 1, 'start': 99, 'machine': 1, 'duration': 23}]}, {'job': 4, 'tasks': [{'task': 0, 'start': 127, 'machine': 0, 'duration': 25}, {'task': 1, 'start': 0, 'machine': 1, 'duration': 99}]}]",170.0,"{'problem_type': 'OSP', 'nr_jobs': 5, 'nr_machines': 2, 'jobs': ['J1', 'J2', 'J3', 'J4', 'J5'], 'machines': [1, 2], 'records': [{'job_id': 'J1', 'task_id': 0, 'machine_id': 1, 'duration': 1}, {'job_id': 'J1', 'task_id': 1, 'machine_id': 2, 'duration': 6}, {'job_id': 'J2', 'task_id': 0, 'machine_id': 1, 'duration': 76}, {'job_id': 'J2', 'task_id': 1, 'machine_id': 2, 'duration': 10}, {'job_id': 'J3', 'task_id': 0, 'machine_id': 1, 'duration': 51}, {'job_id': 'J3', 'task_id': 1, 'machine_id': 2, 'duration': 8}, {'job_id': 'J4', 'task_id': 0, 'machine_id': 1, 'duration': 17}, {'job_id': 'J4', 'task_id': 1, 'machine_id': 2, 'duration': 23}, {'job_id': 'J5', 'task_id': 0, 'machine_id': 1, 'duration': 25}, {'job_id': 'J5', 'task_id': 1, 'machine_id': 2, 'duration': 99}]}","[{'job': 'J1', 'tasks': [{'task': 0, 'start': 169, 'machine': 1, 'duration': 1}, {'task': 1, 'start': 140, 'machine': 2, 'duration': 6}]}, {'job': 'J2', 'tasks': [{'task': 0, 'start': 0, 'machine': 1, 'duration': 76}, {'task': 1, 'start': 122, 'machine': 2, 'duration': 10}]}, {'job': 'J3', 'tasks': [{'task': 0, 'start': 76, 'machine': 1, 'duration': 51}, {'task': 1, 'start': 132, 'machine': 2, 'duration': 8}]}, {'job': 'J4', 'tasks': [{'task': 0, 'start': 152, 'machine': 1, 'duration': 17}, {'task': 1, 'start': 99, 'machine': 2, 'duration': 23}]}, {'job': 'J5', 'tasks': [{'task': 0, 'start': 127, 'machine': 1, 'duration': 25}, {'task': 1, 'start': 0, 'machine': 2, 'duration': 99}]}]",5,json,1
OSP,OSP,"I’m the one trying to pull together the testing schedule for a bunch of patients and a set of diagnostic machines — each patient needs to visit every machine they were assigned, exactly once, but there isn’t a fixed order for those visits. I’m deciding both the order their tests happen and the exact start times, making sure no machine handles two patients at once and no one is booked for two tests at the same moment; a better plan is simply the one where the clock time when the very last patient finishes all their tests is as early as possible. The concrete details of the patients, machines, and test lengths are listed below.

{
  ""nr_patients"": 2,
  ""nr_diagnostic_machines"": 2,
  ""patient_ids"": [
    ""J1"",
    ""J2""
  ],
  ""machine_ids"": [
    0,
    1
  ],
  ""tasks"": [
    {
      ""patient_id"": ""J1"",
      ""test_index"": 0,
      ""required_machine_id"": 0,
      ""test_duration"": 1
    },
    {
      ""patient_id"": ""J1"",
      ""test_index"": 1,
      ""required_machine_id"": 1,
      ""test_duration"": 19
    },
    {
      ""patient_id"": ""J2"",
      ""test_index"": 0,
      ""required_machine_id"": 0,
      ""test_duration"": 51
    },
    {
      ""patient_id"": ""J2"",
      ""test_index"": 1,
      ""required_machine_id"": 1,
      ""test_duration"": 56
    }
  ]
}

I'll put the planned schedule into a simple JSON shape like the one below — just a friendly way to show which patient (job) has which tests (tasks), when each test starts, which machine it's on, and how long it takes.

{
  ""solution"": [
    {
      ""job"": <patient_id>,
      ""tasks"": [
        {
          ""task"": <task_index>,
          ""start"": <start_time>,
          ""machine"": <device_id>,
          ""duration"": <duration>
        }
      ]
    }
  ]
}

This is just a sketch of the shape I’ll use for the actual schedule output. In plain terms:
- ""solution"" is the top-level list of patient schedules.
- each object has ""job"" which is the patient identifier.
- ""tasks"" is a list of that patient’s tests; each task shows which test (task), when it starts (start), which diagnostic machine (machine/device), and how long the test lasts (duration).

Please treat the JSON above as an example of the format only, not the actual schedule. Also, use the exact identifiers from the instance input when you supply or expect values — do not rename or invent new identifiers. 

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”.""","{'nr_machines': 2, 'nr_jobs': 2, 'jobs': [[[0, 1], [1, 19]], [[0, 51], [1, 56]]]}","[{'job': 0, 'tasks': [{'task': 0, 'start': 0, 'machine': 0, 'duration': 1}, {'task': 1, 'start': 56, 'machine': 1, 'duration': 19}]}, {'job': 1, 'tasks': [{'task': 0, 'start': 56, 'machine': 0, 'duration': 51}, {'task': 1, 'start': 0, 'machine': 1, 'duration': 56}]}]",107.0,"{'problem_type': 'OSP', 'nr_jobs': 2, 'nr_machines': 2, 'jobs': ['J1', 'J2'], 'machines': [0, 1], 'records': [{'job_id': 'J1', 'task_id': 0, 'machine_id': 0, 'duration': 1}, {'job_id': 'J1', 'task_id': 1, 'machine_id': 1, 'duration': 19}, {'job_id': 'J2', 'task_id': 0, 'machine_id': 0, 'duration': 51}, {'job_id': 'J2', 'task_id': 1, 'machine_id': 1, 'duration': 56}]}","[{'job': 'J1', 'tasks': [{'task': 0, 'start': 0, 'machine': 0, 'duration': 1}, {'task': 1, 'start': 56, 'machine': 1, 'duration': 19}]}, {'job': 'J2', 'tasks': [{'task': 0, 'start': 56, 'machine': 0, 'duration': 51}, {'task': 1, 'start': 0, 'machine': 1, 'duration': 56}]}]",6,json,0
OSP,OSP,"There’s a brewery trying to make the most of its tanks while several brews are in progress. Each brew must visit every process tank listed, once apiece, but the order isn’t fixed, so someone has to choose the order of visits and the timing of each transfer. Since a tank can only work on one brew at a time and a brew can’t be in two tanks at once, the goal is to have the last brew finish as soon as possible — check the time when the final transfer completes to see how good a plan is. The concrete details are shown below.

{
  ""num_batches"": 3,
  ""num_tanks"": 2,
  ""batch_ids"": [
    ""J1"",
    ""J2"",
    ""J3""
  ],
  ""tank_ids"": [
    1,
    2
  ],
  ""tasks"": [
    {
      ""batch_id"": ""J1"",
      ""visit_index"": 0,
      ""tank_id"": 1,
      ""processing_time"": 1
    },
    {
      ""batch_id"": ""J1"",
      ""visit_index"": 1,
      ""tank_id"": 2,
      ""processing_time"": 32
    },
    {
      ""batch_id"": ""J2"",
      ""visit_index"": 0,
      ""tank_id"": 1,
      ""processing_time"": 27
    },
    {
      ""batch_id"": ""J2"",
      ""visit_index"": 1,
      ""tank_id"": 2,
      ""processing_time"": 2
    },
    {
      ""batch_id"": ""J3"",
      ""visit_index"": 0,
      ""tank_id"": 1,
      ""processing_time"": 57
    },
    {
      ""batch_id"": ""J3"",
      ""visit_index"": 1,
      ""tank_id"": 2,
      ""processing_time"": 51
    }
  ]
}

Also, when you send back a plan, keep it in a simple JSON layout so it's easy to read and parse — something like this:

{
  ""solution"": [
    {
      ""job"": <brew_id>,
      ""tasks"": [
        {
          ""task"": <transfer_index>,
          ""start"": <start_time>,
          ""machine"": <tank_id>,
          ""duration"": <duration>
        }
      ]
    }
  ]
}

This little sketch just shows the shape I’m expecting: each top-level entry is a brew (job), inside it you list the brew’s transfers (tasks) with a task index, a start time, which tank (machine) it uses, and how long that step takes. Think of it like a simple form you’d fill out for each brew’s itinerary.

The JSON above is just an example of the expected shape, not the actual schedule. Please also make sure to 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”.""","{'nr_machines': 2, 'nr_jobs': 3, 'jobs': [[[0, 1], [1, 32]], [[0, 27], [1, 2]], [[0, 57], [1, 51]]]}","[{'job': 0, 'tasks': [{'task': 0, 'start': 84, 'machine': 0, 'duration': 1}, {'task': 1, 'start': 0, 'machine': 1, 'duration': 32}]}, {'job': 1, 'tasks': [{'task': 0, 'start': 57, 'machine': 0, 'duration': 27}, {'task': 1, 'start': 32, 'machine': 1, 'duration': 2}]}, {'job': 2, 'tasks': [{'task': 0, 'start': 0, 'machine': 0, 'duration': 57}, {'task': 1, 'start': 57, 'machine': 1, 'duration': 51}]}]",108.0,"{'problem_type': 'OSP', 'nr_jobs': 3, 'nr_machines': 2, 'jobs': ['J1', 'J2', 'J3'], 'machines': [1, 2], 'records': [{'job_id': 'J1', 'task_id': 0, 'machine_id': 1, 'duration': 1}, {'job_id': 'J1', 'task_id': 1, 'machine_id': 2, 'duration': 32}, {'job_id': 'J2', 'task_id': 0, 'machine_id': 1, 'duration': 27}, {'job_id': 'J2', 'task_id': 1, 'machine_id': 2, 'duration': 2}, {'job_id': 'J3', 'task_id': 0, 'machine_id': 1, 'duration': 57}, {'job_id': 'J3', 'task_id': 1, 'machine_id': 2, 'duration': 51}]}","[{'job': 'J1', 'tasks': [{'task': 0, 'start': 84, 'machine': 1, 'duration': 1}, {'task': 1, 'start': 0, 'machine': 2, 'duration': 32}]}, {'job': 'J2', 'tasks': [{'task': 0, 'start': 57, 'machine': 1, 'duration': 27}, {'task': 1, 'start': 32, 'machine': 2, 'duration': 2}]}, {'job': 'J3', 'tasks': [{'task': 0, 'start': 0, 'machine': 1, 'duration': 57}, {'task': 1, 'start': 57, 'machine': 2, 'duration': 51}]}]",7,json,1
OSP,OSP,"Many people don’t realize how much coordination goes into a dry-cleaner’s day: a batch of garments each needs to be processed on several machines exactly once, and the order of those visits can be freely chosen. The task here is to assign the sequence and start times so each machine only handles one garment at a time and no garment is processed in two places simultaneously. The plan is judged by how quickly the last piece is completed — that end time tells how good the schedule is — and every required visit must happen once, without omissions or duplicates. Details about the items and machines follow below.

There are 2 garments and 2 machines; the garment identifiers are J1, J2 and the machine identifiers are A, B.
Garment J1, task 0, requires machine A for 1 time units.
Garment J1, task 1, requires machine B for 45 time units.
Garment J2, task 0, requires machine A for 3 time units.
Garment J2, task 1, requires machine B for 47 time units.
Every required visit must appear once and only once; the objective is to minimize the completion time of the last garment.

Oh, and when you send back the plan, just use a simple JSON shape like this so it's easy to read and check:

{
  ""solution"": [
    {
      ""job"": <garment_id>,
      ""tasks"": [
        {
          ""task"": <visit_index>,
          ""start"": <start_time>,
          ""machine"": <station_id>,
          ""duration"": <duration>
        }
      ]
    }
  ]
}

This block is just a friendly template: ""solution"" holds a list of items (one per garment), each item has a ""job"" id and a ""tasks"" list. Each task entry says which visit it is, when it starts, which machine/station it goes to, and how long it takes. Think of it like a simple schedule form you fill in for each garment. It's only a sketch of the expected shape, not the final answer.

Please make sure you 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”.""","{'nr_machines': 2, 'nr_jobs': 2, 'jobs': [[[0, 1], [1, 45]], [[0, 3], [1, 47]]]}","[{'job': 0, 'tasks': [{'task': 0, 'start': 0, 'machine': 0, 'duration': 1}, {'task': 1, 'start': 47, 'machine': 1, 'duration': 45}]}, {'job': 1, 'tasks': [{'task': 0, 'start': 47, 'machine': 0, 'duration': 3}, {'task': 1, 'start': 0, 'machine': 1, 'duration': 47}]}]",92.0,"{'problem_type': 'OSP', 'nr_jobs': 2, 'nr_machines': 2, 'jobs': ['J1', 'J2'], 'machines': ['A', 'B'], 'records': [{'job_id': 'J1', 'task_id': 0, 'machine_id': 'A', 'duration': 1}, {'job_id': 'J1', 'task_id': 1, 'machine_id': 'B', 'duration': 45}, {'job_id': 'J2', 'task_id': 0, 'machine_id': 'A', 'duration': 3}, {'job_id': 'J2', 'task_id': 1, 'machine_id': 'B', 'duration': 47}]}","[{'job': 'J1', 'tasks': [{'task': 0, 'start': 0, 'machine': 'A', 'duration': 1}, {'task': 1, 'start': 47, 'machine': 'B', 'duration': 45}]}, {'job': 'J2', 'tasks': [{'task': 0, 'start': 47, 'machine': 'A', 'duration': 3}, {'task': 1, 'start': 0, 'machine': 'B', 'duration': 47}]}]",8,nl,names
OSP,OSP,"Back at the office, the release engineer sketched a plan for several builds that all need tests on the same pool of servers and wanted the whole set to finish as quickly as possible. Every build must be tested once on each server in its list, and the order and exact start times of those tests are up for decision. Servers can’t run more than one test at a time, and a build can’t be doing multiple tests simultaneously, so each required test happens exactly once. The timetable is judged by the clock time when the last build is done — take each build’s finish time and the maximum is the final time. The specific builds, servers, and timings are shown below.

{
  ""num_builds"": 5,
  ""num_servers"": 2,
  ""build_ids"": [
    ""J1"",
    ""J2"",
    ""J3"",
    ""J4"",
    ""J5""
  ],
  ""server_ids"": [
    1,
    2
  ],
  ""tasks"": [
    {
      ""build_id"": ""J1"",
      ""test_index"": 0,
      ""server_id"": 1,
      ""test_duration"": 1
    },
    {
      ""build_id"": ""J1"",
      ""test_index"": 1,
      ""server_id"": 2,
      ""test_duration"": 58
    },
    {
      ""build_id"": ""J2"",
      ""test_index"": 0,
      ""server_id"": 1,
      ""test_duration"": 78
    },
    {
      ""build_id"": ""J2"",
      ""test_index"": 1,
      ""server_id"": 2,
      ""test_duration"": 93
    },
    {
      ""build_id"": ""J3"",
      ""test_index"": 0,
      ""server_id"": 1,
      ""test_duration"": 64
    },
    {
      ""build_id"": ""J3"",
      ""test_index"": 1,
      ""server_id"": 2,
      ""test_duration"": 94
    },
    {
      ""build_id"": ""J4"",
      ""test_index"": 0,
      ""server_id"": 1,
      ""test_duration"": 35
    },
    {
      ""build_id"": ""J4"",
      ""test_index"": 1,
      ""server_id"": 2,
      ""test_duration"": 94
    },
    {
      ""build_id"": ""J5"",
      ""test_index"": 0,
      ""server_id"": 1,
      ""test_duration"": 96
    },
    {
      ""build_id"": ""J5"",
      ""test_index"": 1,
      ""server_id"": 2,
      ""test_duration"": 73
    }
  ]
}

And just so we're on the same page about how I'd like the answer formatted, here’s the little JSON shape I expect — nothing heavy, just a simple sketch of the layout you should follow.

{
  ""solution"": [
    {
      ""job"": <build_id>,
      ""tasks"": [
        {
          ""task"": <test_index>,
          ""start"": <start_time>,
          ""machine"": <server_id>,
          ""duration"": <duration>
        }
      ]
    }
  ]
}

Think of it like a filled-in form: each top-level entry in ""solution"" is one build, ""job"" is the build identifier, ""tasks"" is the list of tests that build needs, and each task line says which test (task), when it starts, which server it runs on, and how long it takes. Super casual — it's just to show the shape, not the real schedule.

Please remember that 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 — 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”.""","{'nr_machines': 2, 'nr_jobs': 5, 'jobs': [[[0, 1], [1, 58]], [[0, 78], [1, 93]], [[0, 64], [1, 94]], [[0, 35], [1, 94]], [[0, 96], [1, 73]]]}","[{'job': 0, 'tasks': [{'task': 0, 'start': 273, 'machine': 0, 'duration': 1}, {'task': 1, 'start': 354, 'machine': 1, 'duration': 58}]}, {'job': 1, 'tasks': [{'task': 0, 'start': 96, 'machine': 0, 'duration': 78}, {'task': 1, 'start': 188, 'machine': 1, 'duration': 93}]}, {'job': 2, 'tasks': [{'task': 0, 'start': 209, 'machine': 0, 'duration': 64}, {'task': 1, 'start': 94, 'machine': 1, 'duration': 94}]}, {'job': 3, 'tasks': [{'task': 0, 'start': 174, 'machine': 0, 'duration': 35}, {'task': 1, 'start': 0, 'machine': 1, 'duration': 94}]}, {'job': 4, 'tasks': [{'task': 0, 'start': 0, 'machine': 0, 'duration': 96}, {'task': 1, 'start': 281, 'machine': 1, 'duration': 73}]}]",412.0,"{'problem_type': 'OSP', 'nr_jobs': 5, 'nr_machines': 2, 'jobs': ['J1', 'J2', 'J3', 'J4', 'J5'], 'machines': [1, 2], 'records': [{'job_id': 'J1', 'task_id': 0, 'machine_id': 1, 'duration': 1}, {'job_id': 'J1', 'task_id': 1, 'machine_id': 2, 'duration': 58}, {'job_id': 'J2', 'task_id': 0, 'machine_id': 1, 'duration': 78}, {'job_id': 'J2', 'task_id': 1, 'machine_id': 2, 'duration': 93}, {'job_id': 'J3', 'task_id': 0, 'machine_id': 1, 'duration': 64}, {'job_id': 'J3', 'task_id': 1, 'machine_id': 2, 'duration': 94}, {'job_id': 'J4', 'task_id': 0, 'machine_id': 1, 'duration': 35}, {'job_id': 'J4', 'task_id': 1, 'machine_id': 2, 'duration': 94}, {'job_id': 'J5', 'task_id': 0, 'machine_id': 1, 'duration': 96}, {'job_id': 'J5', 'task_id': 1, 'machine_id': 2, 'duration': 73}]}","[{'job': 'J1', 'tasks': [{'task': 0, 'start': 273, 'machine': 1, 'duration': 1}, {'task': 1, 'start': 354, 'machine': 2, 'duration': 58}]}, {'job': 'J2', 'tasks': [{'task': 0, 'start': 96, 'machine': 1, 'duration': 78}, {'task': 1, 'start': 188, 'machine': 2, 'duration': 93}]}, {'job': 'J3', 'tasks': [{'task': 0, 'start': 209, 'machine': 1, 'duration': 64}, {'task': 1, 'start': 94, 'machine': 2, 'duration': 94}]}, {'job': 'J4', 'tasks': [{'task': 0, 'start': 174, 'machine': 1, 'duration': 35}, {'task': 1, 'start': 0, 'machine': 2, 'duration': 94}]}, {'job': 'J5', 'tasks': [{'task': 0, 'start': 0, 'machine': 1, 'duration': 96}, {'task': 1, 'start': 281, 'machine': 2, 'duration': 73}]}]",9,json,1
OSP,OSP,"Someone at the lab wants a practical schedule: every print batch has its list of machines to visit exactly once, but there’s no fixed route, so the schedule-maker chooses the route and timing. Real-world limits apply — a machine can’t process two batches at once, and a batch can’t be processed on two machines at the same moment — and every required machine visit must happen exactly once. A better plan is the one that gets the entire set done sooner, i.e., the time on the clock when the final operation completes is lower. The exact instance data are shown below.

Instance data: 5 batches, 3 stations; batches = J1, J2, J3, J4, J5; stations = A, B, C.
Batch J1, task 0 requires station A for 1 time units.
Batch J1, task 1 requires station B for 71 time units.
Batch J1, task 2 requires station C for 54 time units.
Batch J2, task 0 requires station A for 39 time units.
Batch J2, task 1 requires station B for 17 time units.
Batch J2, task 2 requires station C for 17 time units.
Batch J3, task 0 requires station A for 40 time units.
Batch J3, task 1 requires station B for 62 time units.
Batch J3, task 2 requires station C for 64 time units.
Batch J4, task 0 requires station A for 67 time units.
Batch J4, task 1 requires station B for 56 time units.
Batch J4, task 2 requires station C for 49 time units.
Batch J5, task 0 requires station A for 38 time units.
Batch J5, task 1 requires station B for 76 time units.
Batch J5, task 2 requires station C for 72 time units.
The schedule-maker must assign each required visit exactly once, respect station and batch exclusivity, and minimize the completion time.

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

{
  ""solution"": [
    {
      ""job"": <job_id>,
      ""tasks"": [
        {
          ""task"": <task_index>,
          ""start"": <start_time>,
          ""machine"": <machine_id>,
          ""duration"": <duration>
        }
      ]
    }
  ]
}

Think of it like a short form: each top-level entry under ""solution"" is one print batch (job). ""tasks"" is the list of all required machine visits for that batch; within each task, ""task"" is just the task index/label, ""start"" is when that step begins (same time units as the instance), ""machine"" is which machine it visits, and ""duration"" is how long that visit takes. Super casual — this is just the shape I expect, not the actual schedule.

Please 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"".""","{'nr_machines': 3, 'nr_jobs': 5, 'jobs': [[[0, 1], [1, 71], [2, 54]], [[0, 39], [1, 17], [2, 17]], [[0, 40], [1, 62], [2, 64]], [[0, 67], [1, 56], [2, 49]], [[0, 38], [1, 76], [2, 72]]]}","[{'job': 0, 'tasks': [{'task': 0, 'start': 228, 'machine': 0, 'duration': 1}, {'task': 1, 'start': 132, 'machine': 1, 'duration': 71}, {'task': 2, 'start': 64, 'machine': 2, 'duration': 54}]}, {'job': 1, 'tasks': [{'task': 0, 'start': 107, 'machine': 0, 'duration': 39}, {'task': 1, 'start': 265, 'machine': 1, 'duration': 17}, {'task': 2, 'start': 239, 'machine': 2, 'duration': 17}]}, {'job': 2, 'tasks': [{'task': 0, 'start': 67, 'machine': 0, 'duration': 40}, {'task': 1, 'start': 203, 'machine': 1, 'duration': 62}, {'task': 2, 'start': 0, 'machine': 2, 'duration': 64}]}, {'job': 3, 'tasks': [{'task': 0, 'start': 0, 'machine': 0, 'duration': 67}, {'task': 1, 'start': 76, 'machine': 1, 'duration': 56}, {'task': 2, 'start': 190, 'machine': 2, 'duration': 49}]}, {'job': 4, 'tasks': [{'task': 0, 'start': 190, 'machine': 0, 'duration': 38}, {'task': 1, 'start': 0, 'machine': 1, 'duration': 76}, {'task': 2, 'start': 118, 'machine': 2, 'duration': 72}]}]",282.0,"{'problem_type': 'OSP', 'nr_jobs': 5, 'nr_machines': 3, 'jobs': ['J1', 'J2', 'J3', 'J4', 'J5'], 'machines': ['A', 'B', 'C'], 'records': [{'job_id': 'J1', 'task_id': 0, 'machine_id': 'A', 'duration': 1}, {'job_id': 'J1', 'task_id': 1, 'machine_id': 'B', 'duration': 71}, {'job_id': 'J1', 'task_id': 2, 'machine_id': 'C', 'duration': 54}, {'job_id': 'J2', 'task_id': 0, 'machine_id': 'A', 'duration': 39}, {'job_id': 'J2', 'task_id': 1, 'machine_id': 'B', 'duration': 17}, {'job_id': 'J2', 'task_id': 2, 'machine_id': 'C', 'duration': 17}, {'job_id': 'J3', 'task_id': 0, 'machine_id': 'A', 'duration': 40}, {'job_id': 'J3', 'task_id': 1, 'machine_id': 'B', 'duration': 62}, {'job_id': 'J3', 'task_id': 2, 'machine_id': 'C', 'duration': 64}, {'job_id': 'J4', 'task_id': 0, 'machine_id': 'A', 'duration': 67}, {'job_id': 'J4', 'task_id': 1, 'machine_id': 'B', 'duration': 56}, {'job_id': 'J4', 'task_id': 2, 'machine_id': 'C', 'duration': 49}, {'job_id': 'J5', 'task_id': 0, 'machine_id': 'A', 'duration': 38}, {'job_id': 'J5', 'task_id': 1, 'machine_id': 'B', 'duration': 76}, {'job_id': 'J5', 'task_id': 2, 'machine_id': 'C', 'duration': 72}]}","[{'job': 'J1', 'tasks': [{'task': 0, 'start': 228, 'machine': 'A', 'duration': 1}, {'task': 1, 'start': 132, 'machine': 'B', 'duration': 71}, {'task': 2, 'start': 64, 'machine': 'C', 'duration': 54}]}, {'job': 'J2', 'tasks': [{'task': 0, 'start': 107, 'machine': 'A', 'duration': 39}, {'task': 1, 'start': 265, 'machine': 'B', 'duration': 17}, {'task': 2, 'start': 239, 'machine': 'C', 'duration': 17}]}, {'job': 'J3', 'tasks': [{'task': 0, 'start': 67, 'machine': 'A', 'duration': 40}, {'task': 1, 'start': 203, 'machine': 'B', 'duration': 62}, {'task': 2, 'start': 0, 'machine': 'C', 'duration': 64}]}, {'job': 'J4', 'tasks': [{'task': 0, 'start': 0, 'machine': 'A', 'duration': 67}, {'task': 1, 'start': 76, 'machine': 'B', 'duration': 56}, {'task': 2, 'start': 190, 'machine': 'C', 'duration': 49}]}, {'job': 'J5', 'tasks': [{'task': 0, 'start': 190, 'machine': 'A', 'duration': 38}, {'task': 1, 'start': 0, 'machine': 'B', 'duration': 76}, {'task': 2, 'start': 118, 'machine': 'C', 'duration': 72}]}]",10,nl,names
OSP,OSP,"I was talking with a construction supervisor who needs a simple timetable: for each wall or room there’s a short list of trades that have to do work exactly once, and the supervisor wants someone to pick which trade goes first, second, etc., and what time each starts. The catch is that each workstation can only have one subcontractor on it at a time, and no single wall or room can be getting two trades at once. The idea is to arrange those orders and start times so the whole job wraps up as soon as possible — judged by the clock time when the last subcontractor finishes on site. The concrete details are shown below.

There are 2 building elements and 2 workstations, listed as J1, J2 and A, B.
For J1, the supervisor listed task 0 to be done by A and it takes 1.
For J1, the supervisor listed task 1 to be done by B and it takes 84.
For J2, the supervisor listed task 0 to be done by A and it takes 29.
For J2, the supervisor listed task 1 to be done by B and it takes 85.
I asked that they be arranged so the whole job wraps up as soon as possible.

If you want the answer in a tidy, machine-friendly form, just follow this small JSON layout — nothing fancy, just a clear shape I can fill in with the schedule.

{
  ""solution"": [
    {
      ""job"": <room_id>,
      ""tasks"": [
        {
          ""task"": <trade_index>,
          ""start"": <start_time>,
          ""machine"": <workstation_id>,
          ""duration"": <duration>
        }
      ]
    }
  ]
}

Briefly, in plain words:
- ""job"" is the wall or room that needs work.
- ""tasks"" is the short list of trades that will visit that room.
- each task object shows which trade (task), when it starts (start), which workstation or resource it uses (machine), and how long it takes (duration).
Think of it as a simple form you can hand to the supervisor — it’s just the shape I expect, not the actual schedule.

Please keep every identifier 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”.","{'nr_machines': 2, 'nr_jobs': 2, 'jobs': [[[0, 1], [1, 84]], [[0, 29], [1, 85]]]}","[{'job': 0, 'tasks': [{'task': 0, 'start': 0, 'machine': 0, 'duration': 1}, {'task': 1, 'start': 85, 'machine': 1, 'duration': 84}]}, {'job': 1, 'tasks': [{'task': 0, 'start': 85, 'machine': 0, 'duration': 29}, {'task': 1, 'start': 0, 'machine': 1, 'duration': 85}]}]",169.0,"{'problem_type': 'OSP', 'nr_jobs': 2, 'nr_machines': 2, 'jobs': ['J1', 'J2'], 'machines': ['A', 'B'], 'records': [{'job_id': 'J1', 'task_id': 0, 'machine_id': 'A', 'duration': 1}, {'job_id': 'J1', 'task_id': 1, 'machine_id': 'B', 'duration': 84}, {'job_id': 'J2', 'task_id': 0, 'machine_id': 'A', 'duration': 29}, {'job_id': 'J2', 'task_id': 1, 'machine_id': 'B', 'duration': 85}]}","[{'job': 'J1', 'tasks': [{'task': 0, 'start': 0, 'machine': 'A', 'duration': 1}, {'task': 1, 'start': 85, 'machine': 'B', 'duration': 84}]}, {'job': 'J2', 'tasks': [{'task': 0, 'start': 85, 'machine': 'A', 'duration': 29}, {'task': 1, 'start': 0, 'machine': 'B', 'duration': 85}]}]",11,nl,names
OSP,OSP,"Recently the press got a backlog and every job needs to go through all the stations exactly once, but the route through those stations isn’t fixed. The planner’s job is to arrange both the order of station visits for each job and the start times, aiming to have the last job wrap up as early as possible. A schedule is better if that final-completion time is smaller. On top of that, each station can only handle one job at a time, a job can’t be split across two stations at once, and no required step can be missed or repeated. The full details are below.

# total_print_jobs=5
# num_press_stations=3
# print_job_ids=J1, J2, J3, J4, J5
# press_station_ids=0, 1, 2
print_job_id,operation_id,station_id,processing_duration
J1,0,0,1
J1,1,1,97
J1,2,2,5
J2,0,0,31
J2,1,1,24
J2,2,2,60
J3,0,0,49
J3,1,1,98
J3,2,2,1
J4,0,0,54
J4,1,1,33
J4,2,2,53
J5,0,0,5
J5,1,1,83
J5,2,2,83

You can just send the answer in a little JSON sketch like this so it's easy to read and parse — nothing fancy, just that shape below.

{
  ""solution"": [
    {
      ""job"": <press_job_id>,
      ""tasks"": [
        {
          ""task"": <step_index>,
          ""start"": <start_time>,
          ""machine"": <station_id>,
          ""duration"": <duration>
        }
      ]
    }
  ]
}

This is just a friendly template of the shape I expect: each top-level ""solution"" entry is one job, ""job"" holds that job's identifier, and ""tasks"" is a list of the steps that job will go through. Each task records which step it is (""task""), when it starts (""start""), which station handles it (""machine""), and how long it runs (""duration""). Super casual — think of it as filling out a simple form rather than a strict data model.

Note: that JSON is only a sketch of the expected shape, not the actual schedule. When you provide the real schedule, 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”.","{'nr_machines': 3, 'nr_jobs': 5, 'jobs': [[[0, 1], [1, 97], [2, 5]], [[0, 31], [1, 24], [2, 60]], [[0, 49], [1, 98], [2, 1]], [[0, 54], [1, 33], [2, 53]], [[0, 5], [1, 83], [2, 83]]]}","[{'job': 0, 'tasks': [{'task': 0, 'start': 90, 'machine': 0, 'duration': 1}, {'task': 1, 'start': 98, 'machine': 1, 'duration': 97}, {'task': 2, 'start': 196, 'machine': 2, 'duration': 5}]}, {'job': 1, 'tasks': [{'task': 0, 'start': 54, 'machine': 0, 'duration': 31}, {'task': 1, 'start': 311, 'machine': 1, 'duration': 24}, {'task': 2, 'start': 136, 'machine': 2, 'duration': 60}]}, {'job': 2, 'tasks': [{'task': 0, 'start': 98, 'machine': 0, 'duration': 49}, {'task': 1, 'start': 0, 'machine': 1, 'duration': 98}, {'task': 2, 'start': 201, 'machine': 2, 'duration': 1}]}, {'job': 3, 'tasks': [{'task': 0, 'start': 0, 'machine': 0, 'duration': 54}, {'task': 1, 'start': 278, 'machine': 1, 'duration': 33}, {'task': 2, 'start': 83, 'machine': 2, 'duration': 53}]}, {'job': 4, 'tasks': [{'task': 0, 'start': 85, 'machine': 0, 'duration': 5}, {'task': 1, 'start': 195, 'machine': 1, 'duration': 83}, {'task': 2, 'start': 0, 'machine': 2, 'duration': 83}]}]",335.0,"{'problem_type': 'OSP', 'nr_jobs': 5, 'nr_machines': 3, 'jobs': ['J1', 'J2', 'J3', 'J4', 'J5'], 'machines': [0, 1, 2], 'records': [{'job_id': 'J1', 'task_id': 0, 'machine_id': 0, 'duration': 1}, {'job_id': 'J1', 'task_id': 1, 'machine_id': 1, 'duration': 97}, {'job_id': 'J1', 'task_id': 2, 'machine_id': 2, 'duration': 5}, {'job_id': 'J2', 'task_id': 0, 'machine_id': 0, 'duration': 31}, {'job_id': 'J2', 'task_id': 1, 'machine_id': 1, 'duration': 24}, {'job_id': 'J2', 'task_id': 2, 'machine_id': 2, 'duration': 60}, {'job_id': 'J3', 'task_id': 0, 'machine_id': 0, 'duration': 49}, {'job_id': 'J3', 'task_id': 1, 'machine_id': 1, 'duration': 98}, {'job_id': 'J3', 'task_id': 2, 'machine_id': 2, 'duration': 1}, {'job_id': 'J4', 'task_id': 0, 'machine_id': 0, 'duration': 54}, {'job_id': 'J4', 'task_id': 1, 'machine_id': 1, 'duration': 33}, {'job_id': 'J4', 'task_id': 2, 'machine_id': 2, 'duration': 53}, {'job_id': 'J5', 'task_id': 0, 'machine_id': 0, 'duration': 5}, {'job_id': 'J5', 'task_id': 1, 'machine_id': 1, 'duration': 83}, {'job_id': 'J5', 'task_id': 2, 'machine_id': 2, 'duration': 83}]}","[{'job': 'J1', 'tasks': [{'task': 0, 'start': 90, 'machine': 0, 'duration': 1}, {'task': 1, 'start': 98, 'machine': 1, 'duration': 97}, {'task': 2, 'start': 196, 'machine': 2, 'duration': 5}]}, {'job': 'J2', 'tasks': [{'task': 0, 'start': 54, 'machine': 0, 'duration': 31}, {'task': 1, 'start': 311, 'machine': 1, 'duration': 24}, {'task': 2, 'start': 136, 'machine': 2, 'duration': 60}]}, {'job': 'J3', 'tasks': [{'task': 0, 'start': 98, 'machine': 0, 'duration': 49}, {'task': 1, 'start': 0, 'machine': 1, 'duration': 98}, {'task': 2, 'start': 201, 'machine': 2, 'duration': 1}]}, {'job': 'J4', 'tasks': [{'task': 0, 'start': 0, 'machine': 0, 'duration': 54}, {'task': 1, 'start': 278, 'machine': 1, 'duration': 33}, {'task': 2, 'start': 83, 'machine': 2, 'duration': 53}]}, {'job': 'J5', 'tasks': [{'task': 0, 'start': 85, 'machine': 0, 'duration': 5}, {'task': 1, 'start': 195, 'machine': 1, 'duration': 83}, {'task': 2, 'start': 0, 'machine': 2, 'duration': 83}]}]",12,csv,0
OSP,OSP,"We’re trying to sort out a day in the lab where several experiments all need a turn on several machines. Every experiment has a menu of instruments it must use exactly once, but there isn’t a preset step order — that ordering is up for grabs and can be different from one experiment to the next. The task is to pick the order and start times for each experiment’s visits so the whole set wraps up as soon as possible — basically, make the finishing time of the last experiment as small as it can be. Along the way, make sure no instrument is booked by two experiments at once, no experiment is split across instruments at the same moment, and nothing required is skipped or duplicated. The specific instruments, run lengths, and experiments are listed below.

They are listed as J1, J2, J3, J4 on A, B; in total there are 4 experiments and 2 instruments.
We list experiment J1, visit 0, which needs instrument A for 1 time units.
We list experiment J1, visit 1, which needs instrument B for 11 time units.
We list experiment J2, visit 0, which needs instrument A for 80 time units.
We list experiment J2, visit 1, which needs instrument B for 76 time units.
We list experiment J3, visit 0, which needs instrument A for 77 time units.
We list experiment J3, visit 1, which needs instrument B for 82 time units.
We list experiment J4, visit 0, which needs instrument A for 54 time units.
We list experiment J4, visit 1, which needs instrument B for 66 time units.
We’ll schedule start times and visit orders to minimize the overall finishing time while avoiding overlapping instrument use or simultaneous activity for any experiment.

Also, when you send the schedule back, please use this JSON layout so I can read it easily — nothing fancy, just that shape.

{
  ""solution"": [
    {
      ""job"": <experiment_id>,
      ""tasks"": [
        {
          ""task"": <visit_index>,
          ""start"": <start_time>,
          ""machine"": <instrument_id>,
          ""duration"": <duration>
        }
      ]
    }
  ]
}

Think of this like a little form: each ""job"" is an experiment, ""tasks"" is the list of instrument visits that experiment needs, each ""task"" is just the visit index, ""start"" is when that visit begins, ""machine"" names the instrument, and ""duration"" is how long the run takes. Super informal sketch — it shows the shape I expect, not the actual schedule.

Please use the exact identifiers from the instance input when you fill this in — don’t rename anything 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”.""","{'nr_machines': 2, 'nr_jobs': 4, 'jobs': [[[0, 1], [1, 11]], [[0, 80], [1, 76]], [[0, 77], [1, 82]], [[0, 54], [1, 66]]]}","[{'job': 0, 'tasks': [{'task': 0, 'start': 211, 'machine': 0, 'duration': 1}, {'task': 1, 'start': 224, 'machine': 1, 'duration': 11}]}, {'job': 1, 'tasks': [{'task': 0, 'start': 0, 'machine': 0, 'duration': 80}, {'task': 1, 'start': 82, 'machine': 1, 'duration': 76}]}, {'job': 2, 'tasks': [{'task': 0, 'start': 134, 'machine': 0, 'duration': 77}, {'task': 1, 'start': 0, 'machine': 1, 'duration': 82}]}, {'job': 3, 'tasks': [{'task': 0, 'start': 80, 'machine': 0, 'duration': 54}, {'task': 1, 'start': 158, 'machine': 1, 'duration': 66}]}]",235.0,"{'problem_type': 'OSP', 'nr_jobs': 4, 'nr_machines': 2, 'jobs': ['J1', 'J2', 'J3', 'J4'], 'machines': ['A', 'B'], 'records': [{'job_id': 'J1', 'task_id': 0, 'machine_id': 'A', 'duration': 1}, {'job_id': 'J1', 'task_id': 1, 'machine_id': 'B', 'duration': 11}, {'job_id': 'J2', 'task_id': 0, 'machine_id': 'A', 'duration': 80}, {'job_id': 'J2', 'task_id': 1, 'machine_id': 'B', 'duration': 76}, {'job_id': 'J3', 'task_id': 0, 'machine_id': 'A', 'duration': 77}, {'job_id': 'J3', 'task_id': 1, 'machine_id': 'B', 'duration': 82}, {'job_id': 'J4', 'task_id': 0, 'machine_id': 'A', 'duration': 54}, {'job_id': 'J4', 'task_id': 1, 'machine_id': 'B', 'duration': 66}]}","[{'job': 'J1', 'tasks': [{'task': 0, 'start': 211, 'machine': 'A', 'duration': 1}, {'task': 1, 'start': 224, 'machine': 'B', 'duration': 11}]}, {'job': 'J2', 'tasks': [{'task': 0, 'start': 0, 'machine': 'A', 'duration': 80}, {'task': 1, 'start': 82, 'machine': 'B', 'duration': 76}]}, {'job': 'J3', 'tasks': [{'task': 0, 'start': 134, 'machine': 'A', 'duration': 77}, {'task': 1, 'start': 0, 'machine': 'B', 'duration': 82}]}, {'job': 'J4', 'tasks': [{'task': 0, 'start': 80, 'machine': 'A', 'duration': 54}, {'task': 1, 'start': 158, 'machine': 'B', 'duration': 66}]}]",13,nl,names
OSP,OSP,"Recently the costume lead described a puzzle: dozens of pieces each need work from several specialty stations, once per station, but there’s no fixed sequence — the order for each piece is up to the planner and their start times must be scheduled. The key rules are that a station can’t work on more than one piece at once and a piece can’t be undergoing two operations simultaneously. What counts as a good plan is how early the entire collection is ready — check the clock when the final piece is finished; sooner is better. The concrete schedule inputs are listed below.

They are: 3 costume pieces, 3 specialty stations; piece IDs J1, J2, J3; station IDs 0, 1, 2.

| piece_id | operation_index | station_id | processing_time |
|---|---|---|---|
| J1 | 0 | 0 | 1 |
| J1 | 1 | 1 | 24 |
| J1 | 2 | 2 | 56 |
| J2 | 0 | 0 | 23 |
| J2 | 1 | 1 | 30 |
| J2 | 2 | 2 | 5 |
| J3 | 0 | 0 | 59 |
| J3 | 1 | 1 | 34 |
| J3 | 2 | 2 | 36 |

The planner must schedule start times respecting station and piece constraints so the collection finishes as early as possible.

If you want to send over a candidate plan, you can just follow this simple JSON layout for each costume piece and its operations:

{
  ""solution"": [
    {
      ""job"": <piece_id>,
      ""tasks"": [
        {
          ""task"": <operation_index>,
          ""start"": <start_time>,
          ""machine"": <station_id>,
          ""duration"": <duration>
        }
      ]
    }
  ]
}

This sketch means: ""solution"" is a list of pieces; each entry has a ""job"" (the piece identifier) and a ""tasks"" list. Each task lists its index, the planned start time, which station handles it, and how long it takes. Think of it like filling out a simple work order form for each piece.

This is just the shape I expect, not the final schedule — please keep the actual IDs exactly as they appear in the instance input, with no renaming or invented 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”.""","{'nr_machines': 3, 'nr_jobs': 3, 'jobs': [[[0, 1], [1, 24], [2, 56]], [[0, 23], [1, 30], [2, 5]], [[0, 59], [1, 34], [2, 36]]]}","[{'job': 0, 'tasks': [{'task': 0, 'start': 82, 'machine': 0, 'duration': 1}, {'task': 1, 'start': 56, 'machine': 1, 'duration': 24}, {'task': 2, 'start': 0, 'machine': 2, 'duration': 56}]}, {'job': 1, 'tasks': [{'task': 0, 'start': 59, 'machine': 0, 'duration': 23}, {'task': 1, 'start': 0, 'machine': 1, 'duration': 30}, {'task': 2, 'start': 95, 'machine': 2, 'duration': 5}]}, {'job': 2, 'tasks': [{'task': 0, 'start': 0, 'machine': 0, 'duration': 59}, {'task': 1, 'start': 95, 'machine': 1, 'duration': 34}, {'task': 2, 'start': 59, 'machine': 2, 'duration': 36}]}]",129.0,"{'problem_type': 'OSP', 'nr_jobs': 3, 'nr_machines': 3, 'jobs': ['J1', 'J2', 'J3'], 'machines': [0, 1, 2], 'records': [{'job_id': 'J1', 'task_id': 0, 'machine_id': 0, 'duration': 1}, {'job_id': 'J1', 'task_id': 1, 'machine_id': 1, 'duration': 24}, {'job_id': 'J1', 'task_id': 2, 'machine_id': 2, 'duration': 56}, {'job_id': 'J2', 'task_id': 0, 'machine_id': 0, 'duration': 23}, {'job_id': 'J2', 'task_id': 1, 'machine_id': 1, 'duration': 30}, {'job_id': 'J2', 'task_id': 2, 'machine_id': 2, 'duration': 5}, {'job_id': 'J3', 'task_id': 0, 'machine_id': 0, 'duration': 59}, {'job_id': 'J3', 'task_id': 1, 'machine_id': 1, 'duration': 34}, {'job_id': 'J3', 'task_id': 2, 'machine_id': 2, 'duration': 36}]}","[{'job': 'J1', 'tasks': [{'task': 0, 'start': 82, 'machine': 0, 'duration': 1}, {'task': 1, 'start': 56, 'machine': 1, 'duration': 24}, {'task': 2, 'start': 0, 'machine': 2, 'duration': 56}]}, {'job': 'J2', 'tasks': [{'task': 0, 'start': 59, 'machine': 0, 'duration': 23}, {'task': 1, 'start': 0, 'machine': 1, 'duration': 30}, {'task': 2, 'start': 95, 'machine': 2, 'duration': 5}]}, {'job': 'J3', 'tasks': [{'task': 0, 'start': 0, 'machine': 0, 'duration': 59}, {'task': 1, 'start': 95, 'machine': 1, 'duration': 34}, {'task': 2, 'start': 59, 'machine': 2, 'duration': 36}]}]",14,markdown_table,0
OSP,OSP,"We’ve got a batch of songs that all need passes in the same set of rooms and with the same set of engineers, exactly one session at each place per song, but there’s complete freedom in what order those sessions happen for each tune. The task is to arrange the sequence and start time of every session so studios and engineers aren’t handling more than one song at once and no song is scheduled in two places at once. A schedule is better if the whole album is done earlier — the clock stops when the last session ends, and the goal is to make that end time as early as possible. Concrete details follow below.

Below are the concrete details for the 2 songs and the 2 resources: the songs are J1, J2 and the resources are 0, 1.

| song_id | session_index | resource_id | session_duration |
|---|---|---|---|
| J1 | 0 | 0 | 1 |
| J1 | 1 | 1 | 37 |
| J2 | 0 | 0 | 32 |
| J2 | 1 | 1 | 68 |

Let's aim to finish all 2 songs across the 2 resources as early as possible.

Also, just so we're on the same page about how I’d like the reply formatted, slip your schedule into this simple JSON shape — nothing fancy, just a neat way to capture which song (job) has which sessions (tasks), when they start, which room they use, and how long each lasts:

{
  ""solution"": [
    {
      ""job"": <song_id>,
      ""tasks"": [
        {
          ""task"": <task_index>,
          ""start"": <start_time>,
          ""machine"": <room_id>,
          ""duration"": <duration>
        }
      ]
    }
  ]
}

Think of it like a little form: ""job"" is the song identifier, ""tasks"" is the list of sessions that song needs, each ""task"" is a session index, ""start"" is when that session begins, ""machine"" is which room it's in, and ""duration"" is how long the session lasts. This block is just a sketch of the shape I expect — not the actual schedule.

Please make sure to 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”.","{'nr_machines': 2, 'nr_jobs': 2, 'jobs': [[[0, 1], [1, 37]], [[0, 32], [1, 68]]]}","[{'job': 0, 'tasks': [{'task': 0, 'start': 0, 'machine': 0, 'duration': 1}, {'task': 1, 'start': 68, 'machine': 1, 'duration': 37}]}, {'job': 1, 'tasks': [{'task': 0, 'start': 68, 'machine': 0, 'duration': 32}, {'task': 1, 'start': 0, 'machine': 1, 'duration': 68}]}]",105.0,"{'problem_type': 'OSP', 'nr_jobs': 2, 'nr_machines': 2, 'jobs': ['J1', 'J2'], 'machines': [0, 1], 'records': [{'job_id': 'J1', 'task_id': 0, 'machine_id': 0, 'duration': 1}, {'job_id': 'J1', 'task_id': 1, 'machine_id': 1, 'duration': 37}, {'job_id': 'J2', 'task_id': 0, 'machine_id': 0, 'duration': 32}, {'job_id': 'J2', 'task_id': 1, 'machine_id': 1, 'duration': 68}]}","[{'job': 'J1', 'tasks': [{'task': 0, 'start': 0, 'machine': 0, 'duration': 1}, {'task': 1, 'start': 68, 'machine': 1, 'duration': 37}]}, {'job': 'J2', 'tasks': [{'task': 0, 'start': 68, 'machine': 0, 'duration': 32}, {'task': 1, 'start': 0, 'machine': 1, 'duration': 68}]}]",15,markdown_table,0
OSP,OSP,"At a small factory the planner has to put together a plan: a number of garments must each go through every machine one time, but there’s freedom about the order. The planner picks the order and when each step begins, ensuring every machine handles a single garment at a time and no garment is active on two machines at once. The aim is straightforward — get the last garment finished as early as possible, i.e., reduce the finishing time of the final task — and make sure every required operation happens exactly once. The concrete details are shown below.

There are 5 garments and 2 machines; garment identifiers are J1, J2, J3, J4, J5 and machine identifiers are A, B.
Garment J1, operation 0: requires machine A for 1.
Garment J1, operation 1: requires machine B for 50.
Garment J2, operation 0: requires machine A for 7.
Garment J2, operation 1: requires machine B for 15.
Garment J3, operation 0: requires machine A for 37.
Garment J3, operation 1: requires machine B for 48.
Garment J4, operation 0: requires machine A for 68.
Garment J4, operation 1: requires machine B for 69.
Garment J5, operation 0: requires machine A for 72.
Garment J5, operation 1: requires machine B for 28.
The planner should use these details to schedule every required operation once and minimize the time when the last garment finishes.

You can just return the plan in a little JSON shape like this — nothing fancy, just a predictable layout so the planner can read it automatically.

{
  ""solution"": [
    {
      ""job"": <garment_id>,
      ""tasks"": [
        {
          ""task"": <task_index>,
          ""start"": <start_time>,
          ""machine"": <machine_station_id>,
          ""duration"": <duration>
        }
      ]
    }
  ]
}

Pretty much: each object in ""solution"" is one garment (the ""job""), ""tasks"" is the list of its operations, ""task"" is a task index so we can refer to each step, ""start"" is when that step begins, ""machine"" says which machine handles it, and ""duration"" is how long it runs. Super casual — think of it like filling in a form for each garment.

This JSON is only a sketch of the expected shape, not the actual schedule. Please make sure to 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”.""","{'nr_machines': 2, 'nr_jobs': 5, 'jobs': [[[0, 1], [1, 50]], [[0, 7], [1, 15]], [[0, 37], [1, 48]], [[0, 68], [1, 69]], [[0, 72], [1, 28]]]}","[{'job': 0, 'tasks': [{'task': 0, 'start': 147, 'machine': 0, 'duration': 1}, {'task': 1, 'start': 69, 'machine': 1, 'duration': 50}]}, {'job': 1, 'tasks': [{'task': 0, 'start': 140, 'machine': 0, 'duration': 7}, {'task': 1, 'start': 195, 'machine': 1, 'duration': 15}]}, {'job': 2, 'tasks': [{'task': 0, 'start': 167, 'machine': 0, 'duration': 37}, {'task': 1, 'start': 119, 'machine': 1, 'duration': 48}]}, {'job': 3, 'tasks': [{'task': 0, 'start': 72, 'machine': 0, 'duration': 68}, {'task': 1, 'start': 0, 'machine': 1, 'duration': 69}]}, {'job': 4, 'tasks': [{'task': 0, 'start': 0, 'machine': 0, 'duration': 72}, {'task': 1, 'start': 167, 'machine': 1, 'duration': 28}]}]",210.0,"{'problem_type': 'OSP', 'nr_jobs': 5, 'nr_machines': 2, 'jobs': ['J1', 'J2', 'J3', 'J4', 'J5'], 'machines': ['A', 'B'], 'records': [{'job_id': 'J1', 'task_id': 0, 'machine_id': 'A', 'duration': 1}, {'job_id': 'J1', 'task_id': 1, 'machine_id': 'B', 'duration': 50}, {'job_id': 'J2', 'task_id': 0, 'machine_id': 'A', 'duration': 7}, {'job_id': 'J2', 'task_id': 1, 'machine_id': 'B', 'duration': 15}, {'job_id': 'J3', 'task_id': 0, 'machine_id': 'A', 'duration': 37}, {'job_id': 'J3', 'task_id': 1, 'machine_id': 'B', 'duration': 48}, {'job_id': 'J4', 'task_id': 0, 'machine_id': 'A', 'duration': 68}, {'job_id': 'J4', 'task_id': 1, 'machine_id': 'B', 'duration': 69}, {'job_id': 'J5', 'task_id': 0, 'machine_id': 'A', 'duration': 72}, {'job_id': 'J5', 'task_id': 1, 'machine_id': 'B', 'duration': 28}]}","[{'job': 'J1', 'tasks': [{'task': 0, 'start': 147, 'machine': 'A', 'duration': 1}, {'task': 1, 'start': 69, 'machine': 'B', 'duration': 50}]}, {'job': 'J2', 'tasks': [{'task': 0, 'start': 140, 'machine': 'A', 'duration': 7}, {'task': 1, 'start': 195, 'machine': 'B', 'duration': 15}]}, {'job': 'J3', 'tasks': [{'task': 0, 'start': 167, 'machine': 'A', 'duration': 37}, {'task': 1, 'start': 119, 'machine': 'B', 'duration': 48}]}, {'job': 'J4', 'tasks': [{'task': 0, 'start': 72, 'machine': 'A', 'duration': 68}, {'task': 1, 'start': 0, 'machine': 'B', 'duration': 69}]}, {'job': 'J5', 'tasks': [{'task': 0, 'start': 0, 'machine': 'A', 'duration': 72}, {'task': 1, 'start': 167, 'machine': 'B', 'duration': 28}]}]",16,nl,names
OSP,OSP,"On the day-of setup there’s a list of stages, and for each stage a set of technicians who each need to do a single task there — each tech must visit each assigned stage once, but which tech goes first is open, and the order can vary between stages. The task is to pick both the sequence of visits and the start times while keeping technicians from being scheduled in two places at once and preventing any stage from having more than one technician working there at the same instant. The plan is judged by how quickly everything is ready: take the finish times for all stages, find the latest one (when the last stage is done), and make that as early as possible; no required visit can be skipped or repeated. The concrete stage and technician details follow below.

# total_stages=4
# total_technicians=3
# stage_ids=J1, J2, J3, J4
# technician_ids=0, 1, 2
stage_id,visit_index,technician_id,task_duration
J1,0,0,1
J1,1,1,63
J1,2,2,82
J2,0,0,60
J2,1,1,90
J2,2,2,70
J3,0,0,73
J3,1,1,38
J3,2,2,40
J4,0,0,22
J4,1,1,25
J4,2,2,13

Also, just so everything is easy to read by people and tools, please reply using this simple JSON layout — nothing fancy, just the shape below.

{
  ""solution"": [
    {
      ""job"": <stage_id>,
      ""tasks"": [
        {
          ""task"": <task_index>,
          ""start"": <start_time>,
          ""machine"": <technician_id>,
          ""duration"": <duration>
        }
      ]
    }
  ]
}

This is just a sketch of the shape I need, not the actual schedule. Plain-language: each top-level object under ""solution"" is one stage (put the stage identifier where it says <stage_id>), ""tasks"" is the list of visits that must happen at that stage, each visit gets a ""task"" index, a ""start"" time, the ""machine"" is the technician doing that visit, and ""duration"" is how long that visit lasts.

Please make sure you 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”.""","{'nr_machines': 3, 'nr_jobs': 4, 'jobs': [[[0, 1], [1, 63], [2, 82]], [[0, 60], [1, 90], [2, 70]], [[0, 73], [1, 38], [2, 40]], [[0, 22], [1, 25], [2, 13]]]}","[{'job': 0, 'tasks': [{'task': 0, 'start': 82, 'machine': 0, 'duration': 1}, {'task': 1, 'start': 90, 'machine': 1, 'duration': 63}, {'task': 2, 'start': 0, 'machine': 2, 'duration': 82}]}, {'job': 1, 'tasks': [{'task': 0, 'start': 90, 'machine': 0, 'duration': 60}, {'task': 1, 'start': 0, 'machine': 1, 'duration': 90}, {'task': 2, 'start': 150, 'machine': 2, 'duration': 70}]}, {'job': 2, 'tasks': [{'task': 0, 'start': 0, 'machine': 0, 'duration': 73}, {'task': 1, 'start': 153, 'machine': 1, 'duration': 38}, {'task': 2, 'start': 82, 'machine': 2, 'duration': 40}]}, {'job': 3, 'tasks': [{'task': 0, 'start': 150, 'machine': 0, 'duration': 22}, {'task': 1, 'start': 191, 'machine': 1, 'duration': 25}, {'task': 2, 'start': 122, 'machine': 2, 'duration': 13}]}]",220.0,"{'problem_type': 'OSP', 'nr_jobs': 4, 'nr_machines': 3, 'jobs': ['J1', 'J2', 'J3', 'J4'], 'machines': [0, 1, 2], 'records': [{'job_id': 'J1', 'task_id': 0, 'machine_id': 0, 'duration': 1}, {'job_id': 'J1', 'task_id': 1, 'machine_id': 1, 'duration': 63}, {'job_id': 'J1', 'task_id': 2, 'machine_id': 2, 'duration': 82}, {'job_id': 'J2', 'task_id': 0, 'machine_id': 0, 'duration': 60}, {'job_id': 'J2', 'task_id': 1, 'machine_id': 1, 'duration': 90}, {'job_id': 'J2', 'task_id': 2, 'machine_id': 2, 'duration': 70}, {'job_id': 'J3', 'task_id': 0, 'machine_id': 0, 'duration': 73}, {'job_id': 'J3', 'task_id': 1, 'machine_id': 1, 'duration': 38}, {'job_id': 'J3', 'task_id': 2, 'machine_id': 2, 'duration': 40}, {'job_id': 'J4', 'task_id': 0, 'machine_id': 0, 'duration': 22}, {'job_id': 'J4', 'task_id': 1, 'machine_id': 1, 'duration': 25}, {'job_id': 'J4', 'task_id': 2, 'machine_id': 2, 'duration': 13}]}","[{'job': 'J1', 'tasks': [{'task': 0, 'start': 82, 'machine': 0, 'duration': 1}, {'task': 1, 'start': 90, 'machine': 1, 'duration': 63}, {'task': 2, 'start': 0, 'machine': 2, 'duration': 82}]}, {'job': 'J2', 'tasks': [{'task': 0, 'start': 90, 'machine': 0, 'duration': 60}, {'task': 1, 'start': 0, 'machine': 1, 'duration': 90}, {'task': 2, 'start': 150, 'machine': 2, 'duration': 70}]}, {'job': 'J3', 'tasks': [{'task': 0, 'start': 0, 'machine': 0, 'duration': 73}, {'task': 1, 'start': 153, 'machine': 1, 'duration': 38}, {'task': 2, 'start': 82, 'machine': 2, 'duration': 40}]}, {'job': 'J4', 'tasks': [{'task': 0, 'start': 150, 'machine': 0, 'duration': 22}, {'task': 1, 'start': 191, 'machine': 1, 'duration': 25}, {'task': 2, 'start': 122, 'machine': 2, 'duration': 13}]}]",17,csv,0
OSP,OSP,"Recently the clinic manager asked for help with a tricky schedule: patients each need multiple procedures, each procedure must use a particular chair or machine exactly one time, and the steps can happen in any order. The work is to pick the sequence of procedures for each patient and when they start, while ensuring each chair or device only treats one person at a time and no patient is booked for two things at once. What makes one plan better than another is how early the whole batch is done — measure it by the time the final procedure finishes. The full set of patients and their required equipment is listed below.

There are 4 patients and 2 devices; the patients are J1, J2, J3, J4 and the devices are A, B.
J1 requires procedure 0 on device A with duration 1.
J1 requires procedure 1 on device B with duration 76.
J2 requires procedure 0 on device A with duration 58.
J2 requires procedure 1 on device B with duration 6.
J3 requires procedure 0 on device A with duration 43.
J3 requires procedure 1 on device B with duration 91.
J4 requires procedure 0 on device A with duration 77.
J4 requires procedure 1 on device B with duration 6.
The objective is to minimize the time the final procedure finishes.

Oh, and one quick note on the reply format — it'd be great if the actual schedule comes back in a simple JSON shape like this so it's easy to read and check:

{
  ""solution"": [
    {
      ""job"": <patient_id>,
      ""tasks"": [
        {
          ""task"": <procedure_index>,
          ""start"": <start_time>,
          ""machine"": <chair_id>,
          ""duration"": <duration>
        }
      ]
    }
  ]
}

This is just a sketch of the shape I expect: each top-level entry in ""solution"" is one patient (job), ""tasks"" lists their procedures, ""task"" is the procedure index, ""start"" is when that procedure begins, ""machine"" says which chair or device it's on, and ""duration"" is how long it takes. Think of it like filling out a little appointment form for each patient.

Please remember that when you fill this in you must 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”.""","{'nr_machines': 2, 'nr_jobs': 4, 'jobs': [[[0, 1], [1, 76]], [[0, 58], [1, 6]], [[0, 43], [1, 91]], [[0, 77], [1, 6]]]}","[{'job': 0, 'tasks': [{'task': 0, 'start': 178, 'machine': 0, 'duration': 1}, {'task': 1, 'start': 91, 'machine': 1, 'duration': 76}]}, {'job': 1, 'tasks': [{'task': 0, 'start': 77, 'machine': 0, 'duration': 58}, {'task': 1, 'start': 167, 'machine': 1, 'duration': 6}]}, {'job': 2, 'tasks': [{'task': 0, 'start': 135, 'machine': 0, 'duration': 43}, {'task': 1, 'start': 0, 'machine': 1, 'duration': 91}]}, {'job': 3, 'tasks': [{'task': 0, 'start': 0, 'machine': 0, 'duration': 77}, {'task': 1, 'start': 173, 'machine': 1, 'duration': 6}]}]",179.0,"{'problem_type': 'OSP', 'nr_jobs': 4, 'nr_machines': 2, 'jobs': ['J1', 'J2', 'J3', 'J4'], 'machines': ['A', 'B'], 'records': [{'job_id': 'J1', 'task_id': 0, 'machine_id': 'A', 'duration': 1}, {'job_id': 'J1', 'task_id': 1, 'machine_id': 'B', 'duration': 76}, {'job_id': 'J2', 'task_id': 0, 'machine_id': 'A', 'duration': 58}, {'job_id': 'J2', 'task_id': 1, 'machine_id': 'B', 'duration': 6}, {'job_id': 'J3', 'task_id': 0, 'machine_id': 'A', 'duration': 43}, {'job_id': 'J3', 'task_id': 1, 'machine_id': 'B', 'duration': 91}, {'job_id': 'J4', 'task_id': 0, 'machine_id': 'A', 'duration': 77}, {'job_id': 'J4', 'task_id': 1, 'machine_id': 'B', 'duration': 6}]}","[{'job': 'J1', 'tasks': [{'task': 0, 'start': 178, 'machine': 'A', 'duration': 1}, {'task': 1, 'start': 91, 'machine': 'B', 'duration': 76}]}, {'job': 'J2', 'tasks': [{'task': 0, 'start': 77, 'machine': 'A', 'duration': 58}, {'task': 1, 'start': 167, 'machine': 'B', 'duration': 6}]}, {'job': 'J3', 'tasks': [{'task': 0, 'start': 135, 'machine': 'A', 'duration': 43}, {'task': 1, 'start': 0, 'machine': 'B', 'duration': 91}]}, {'job': 'J4', 'tasks': [{'task': 0, 'start': 0, 'machine': 'A', 'duration': 77}, {'task': 1, 'start': 173, 'machine': 'B', 'duration': 6}]}]",18,nl,names
OSP,OSP,"At the hub it’s like a small puzzle: every shipment needs to go through a set of docks exactly once, but there’s no required order for those stops. The supervisor must choose both the sequence and the start time of each dock visit, making sure each dock works on only one shipment at a time and no shipment is in two docks simultaneously. The scoreboard is the finishing time of the last shipment — the earlier that finishing time, the better the plan. The concrete shipment and dock information follows below.

There are 5 shipments and 2 docks; the shipments are J1, J2, J3, J4, J5 and the docks are A, B.
Shipment J1, dock-visit 0: requires dock A for 1 time units.
Shipment J1, dock-visit 1: requires dock B for 89 time units.
Shipment J2, dock-visit 0: requires dock A for 34 time units.
Shipment J2, dock-visit 1: requires dock B for 52 time units.
Shipment J3, dock-visit 0: requires dock A for 96 time units.
Shipment J3, dock-visit 1: requires dock B for 14 time units.
Shipment J4, dock-visit 0: requires dock A for 82 time units.
Shipment J4, dock-visit 1: requires dock B for 73 time units.
Shipment J5, dock-visit 0: requires dock A for 76 time units.
Shipment J5, dock-visit 1: requires dock B for 9 time units.
The supervisor will use this list to schedule the visits and start times so the last shipment finishes as early as possible.

Also, to keep things tidy, please give the plan in a small JSON shape like the one below — it’s just the form I’ll expect, nothing filled in with actual times yet.

{
  ""solution"": [
    {
      ""job"": <shipment_id>,
      ""tasks"": [
        {
          ""task"": <visit_index>,
          ""start"": <start_time>,
          ""machine"": <dock_id>,
          ""duration"": <duration>
        }
      ]
    }
  ]
}

Think of this as a simple form: each top-level entry under ""solution"" is one shipment (""job""), ""tasks"" is the list of dock visits that shipment needs, each task has a little record showing which visit it is (""task""), when it starts (""start""), which dock it uses (""machine""), and how long that visit takes (""duration""). Again, this block is just a sketch of the shape I want — not the actual schedule.

Please use the exact identifiers from the instance input with no renaming or adding 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”.""","{'nr_machines': 2, 'nr_jobs': 5, 'jobs': [[[0, 1], [1, 89]], [[0, 34], [1, 52]], [[0, 96], [1, 14]], [[0, 82], [1, 73]], [[0, 76], [1, 9]]]}","[{'job': 0, 'tasks': [{'task': 0, 'start': 288, 'machine': 0, 'duration': 1}, {'task': 1, 'start': 0, 'machine': 1, 'duration': 89}]}, {'job': 1, 'tasks': [{'task': 0, 'start': 254, 'machine': 0, 'duration': 34}, {'task': 1, 'start': 162, 'machine': 1, 'duration': 52}]}, {'job': 2, 'tasks': [{'task': 0, 'start': 0, 'machine': 0, 'duration': 96}, {'task': 1, 'start': 214, 'machine': 1, 'duration': 14}]}, {'job': 3, 'tasks': [{'task': 0, 'start': 172, 'machine': 0, 'duration': 82}, {'task': 1, 'start': 89, 'machine': 1, 'duration': 73}]}, {'job': 4, 'tasks': [{'task': 0, 'start': 96, 'machine': 0, 'duration': 76}, {'task': 1, 'start': 228, 'machine': 1, 'duration': 9}]}]",289.0,"{'problem_type': 'OSP', 'nr_jobs': 5, 'nr_machines': 2, 'jobs': ['J1', 'J2', 'J3', 'J4', 'J5'], 'machines': ['A', 'B'], 'records': [{'job_id': 'J1', 'task_id': 0, 'machine_id': 'A', 'duration': 1}, {'job_id': 'J1', 'task_id': 1, 'machine_id': 'B', 'duration': 89}, {'job_id': 'J2', 'task_id': 0, 'machine_id': 'A', 'duration': 34}, {'job_id': 'J2', 'task_id': 1, 'machine_id': 'B', 'duration': 52}, {'job_id': 'J3', 'task_id': 0, 'machine_id': 'A', 'duration': 96}, {'job_id': 'J3', 'task_id': 1, 'machine_id': 'B', 'duration': 14}, {'job_id': 'J4', 'task_id': 0, 'machine_id': 'A', 'duration': 82}, {'job_id': 'J4', 'task_id': 1, 'machine_id': 'B', 'duration': 73}, {'job_id': 'J5', 'task_id': 0, 'machine_id': 'A', 'duration': 76}, {'job_id': 'J5', 'task_id': 1, 'machine_id': 'B', 'duration': 9}]}","[{'job': 'J1', 'tasks': [{'task': 0, 'start': 288, 'machine': 'A', 'duration': 1}, {'task': 1, 'start': 0, 'machine': 'B', 'duration': 89}]}, {'job': 'J2', 'tasks': [{'task': 0, 'start': 254, 'machine': 'A', 'duration': 34}, {'task': 1, 'start': 162, 'machine': 'B', 'duration': 52}]}, {'job': 'J3', 'tasks': [{'task': 0, 'start': 0, 'machine': 'A', 'duration': 96}, {'task': 1, 'start': 214, 'machine': 'B', 'duration': 14}]}, {'job': 'J4', 'tasks': [{'task': 0, 'start': 172, 'machine': 'A', 'duration': 82}, {'task': 1, 'start': 89, 'machine': 'B', 'duration': 73}]}, {'job': 'J5', 'tasks': [{'task': 0, 'start': 96, 'machine': 'A', 'duration': 76}, {'task': 1, 'start': 228, 'machine': 'B', 'duration': 9}]}]",19,nl,names
OSP,OSP,"Someone dropped off a batch of alterations and the owner asked for a simple plan: each garment needs attention at several stations once each, but the order is up for grabs. The planner must pick the sequence and start times so that stations aren’t double-booked, nothing gets skipped or done twice, and no garment is in two stations at the same time. A better plan is the one that gets every garment finished sooner — look at the time the final garment finishes; the lower that number, the better. The concrete details will be shown below.

There are 5 garments to schedule across 2 stations; garment IDs: J1, J2, J3, J4, J5; station IDs: 0, 1.
Garment J1, operation 0: requires station 0 for 1 time units.
Garment J1, operation 1: requires station 1 for 3 time units.
Garment J2, operation 0: requires station 0 for 10 time units.
Garment J2, operation 1: requires station 1 for 97 time units.
Garment J3, operation 0: requires station 0 for 50 time units.
Garment J3, operation 1: requires station 1 for 36 time units.
Garment J4, operation 0: requires station 0 for 87 time units.
Garment J4, operation 1: requires station 1 for 41 time units.
Garment J5, operation 0: requires station 0 for 44 time units.
Garment J5, operation 1: requires station 1 for 2 time units.
The planner must assign sequences and start times so stations aren't double-booked, nothing is skipped or done twice, no garment is in two stations at once, and the final completion time is minimized.

If you want to give me a plan, use the little JSON shape below so everything lines up neatly on my end — it’s just a friendly template for the fields I expect.

{
  ""solution"": [
    {
      ""job"": <garment_id>,
      ""tasks"": [
        {
          ""task"": <operation_index>,
          ""start"": <start_time>,
          ""machine"": <station_id>,
          ""duration"": <duration>
        }
      ]
    }
  ]
}

Quick note on what those bits mean in plain terms: each top-level object is one garment (job), ""tasks"" is the list of steps that garment needs, ""task"" is the step index for that garment, ""start"" is when that step begins, ""machine"" names the station that step runs at, and ""duration"" is how long it takes. Think of this JSON as a blank form — a sketch of the shape I expect, not the finished schedule.

Please don’t rename any identifiers from the input or invent new ones — use them exactly as they appear in the instance. 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”.","{'nr_machines': 2, 'nr_jobs': 5, 'jobs': [[[0, 1], [1, 3]], [[0, 10], [1, 97]], [[0, 50], [1, 36]], [[0, 87], [1, 41]], [[0, 44], [1, 2]]]}","[{'job': 0, 'tasks': [{'task': 0, 'start': 191, 'machine': 0, 'duration': 1}, {'task': 1, 'start': 174, 'machine': 1, 'duration': 3}]}, {'job': 1, 'tasks': [{'task': 0, 'start': 181, 'machine': 0, 'duration': 10}, {'task': 1, 'start': 0, 'machine': 1, 'duration': 97}]}, {'job': 2, 'tasks': [{'task': 0, 'start': 87, 'machine': 0, 'duration': 50}, {'task': 1, 'start': 138, 'machine': 1, 'duration': 36}]}, {'job': 3, 'tasks': [{'task': 0, 'start': 0, 'machine': 0, 'duration': 87}, {'task': 1, 'start': 97, 'machine': 1, 'duration': 41}]}, {'job': 4, 'tasks': [{'task': 0, 'start': 137, 'machine': 0, 'duration': 44}, {'task': 1, 'start': 181, 'machine': 1, 'duration': 2}]}]",192.0,"{'problem_type': 'OSP', 'nr_jobs': 5, 'nr_machines': 2, 'jobs': ['J1', 'J2', 'J3', 'J4', 'J5'], 'machines': [0, 1], 'records': [{'job_id': 'J1', 'task_id': 0, 'machine_id': 0, 'duration': 1}, {'job_id': 'J1', 'task_id': 1, 'machine_id': 1, 'duration': 3}, {'job_id': 'J2', 'task_id': 0, 'machine_id': 0, 'duration': 10}, {'job_id': 'J2', 'task_id': 1, 'machine_id': 1, 'duration': 97}, {'job_id': 'J3', 'task_id': 0, 'machine_id': 0, 'duration': 50}, {'job_id': 'J3', 'task_id': 1, 'machine_id': 1, 'duration': 36}, {'job_id': 'J4', 'task_id': 0, 'machine_id': 0, 'duration': 87}, {'job_id': 'J4', 'task_id': 1, 'machine_id': 1, 'duration': 41}, {'job_id': 'J5', 'task_id': 0, 'machine_id': 0, 'duration': 44}, {'job_id': 'J5', 'task_id': 1, 'machine_id': 1, 'duration': 2}]}","[{'job': 'J1', 'tasks': [{'task': 0, 'start': 191, 'machine': 0, 'duration': 1}, {'task': 1, 'start': 174, 'machine': 1, 'duration': 3}]}, {'job': 'J2', 'tasks': [{'task': 0, 'start': 181, 'machine': 0, 'duration': 10}, {'task': 1, 'start': 0, 'machine': 1, 'duration': 97}]}, {'job': 'J3', 'tasks': [{'task': 0, 'start': 87, 'machine': 0, 'duration': 50}, {'task': 1, 'start': 138, 'machine': 1, 'duration': 36}]}, {'job': 'J4', 'tasks': [{'task': 0, 'start': 0, 'machine': 0, 'duration': 87}, {'task': 1, 'start': 97, 'machine': 1, 'duration': 41}]}, {'job': 'J5', 'tasks': [{'task': 0, 'start': 137, 'machine': 0, 'duration': 44}, {'task': 1, 'start': 181, 'machine': 1, 'duration': 2}]}]",20,nl,0
OSP,OSP,"Picture this: a handful of patients each need several different imaging tests and there’s no set order they must follow. The task is to map out the order and exact start times for each person’s exams so each necessary machine performs each patient’s required test once, no machine sees more than one patient at a time, and no patient is scheduled to be in two places simultaneously. The schedule is judged by one simple clock reading — the time when the last patient is done — and the goal is to make that time as small as possible. The specific instance information is listed below.

{
  ""nr_patients"": 4,
  ""nr_devices"": 3,
  ""patients"": [
    ""J1"",
    ""J2"",
    ""J3"",
    ""J4""
  ],
  ""devices"": [
    0,
    1,
    2
  ],
  ""tasks"": [
    {
      ""patient_id"": ""J1"",
      ""test_index"": 0,
      ""device_id"": 0,
      ""test_duration"": 1
    },
    {
      ""patient_id"": ""J1"",
      ""test_index"": 1,
      ""device_id"": 1,
      ""test_duration"": 16
    },
    {
      ""patient_id"": ""J1"",
      ""test_index"": 2,
      ""device_id"": 2,
      ""test_duration"": 84
    },
    {
      ""patient_id"": ""J2"",
      ""test_index"": 0,
      ""device_id"": 0,
      ""test_duration"": 44
    },
    {
      ""patient_id"": ""J2"",
      ""test_index"": 1,
      ""device_id"": 1,
      ""test_duration"": 4
    },
    {
      ""patient_id"": ""J2"",
      ""test_index"": 2,
      ""device_id"": 2,
      ""test_duration"": 57
    },
    {
      ""patient_id"": ""J3"",
      ""test_index"": 0,
      ""device_id"": 0,
      ""test_duration"": 91
    },
    {
      ""patient_id"": ""J3"",
      ""test_index"": 1,
      ""device_id"": 1,
      ""test_duration"": 9
    },
    {
      ""patient_id"": ""J3"",
      ""test_index"": 2,
      ""device_id"": 2,
      ""test_duration"": 12
    },
    {
      ""patient_id"": ""J4"",
      ""test_index"": 0,
      ""device_id"": 0,
      ""test_duration"": 95
    },
    {
      ""patient_id"": ""J4"",
      ""test_index"": 1,
      ""device_id"": 1,
      ""test_duration"": 77
    },
    {
      ""patient_id"": ""J4"",
      ""test_index"": 2,
      ""device_id"": 2,
      ""test_duration"": 21
    }
  ]
}

Also, when you’re ready to give the schedule, please use a simple JSON shape like this — nothing fancy, just fill the slots with the right identifiers and times.

{
  ""solution"": [
    {
      ""job"": <patient_id>,
      ""tasks"": [
        {
          ""task"": <exam_index>,
          ""start"": <start_time>,
          ""machine"": <scanner_id>,
          ""duration"": <duration>
        }
      ]
    }
  ]
}

Here’s what those fields mean in plain language: each top-level ""job"" entry is a patient, ""tasks"" is the list of that patient’s exams, each ""task"" is just the exam’s index or identifier, ""start"" is when that exam should begin, ""machine"" tells you which scanner or machine will be used, and ""duration"" is how long the exam takes. It’s just a lightweight template — a sketch of the shape I need, not your final filled-in answer.

Please make sure to 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”.""","{'nr_machines': 3, 'nr_jobs': 4, 'jobs': [[[0, 1], [1, 16], [2, 84]], [[0, 44], [1, 4], [2, 57]], [[0, 91], [1, 9], [2, 12]], [[0, 95], [1, 77], [2, 21]]]}","[{'job': 0, 'tasks': [{'task': 0, 'start': 230, 'machine': 0, 'duration': 1}, {'task': 1, 'start': 84, 'machine': 1, 'duration': 16}, {'task': 2, 'start': 0, 'machine': 2, 'duration': 84}]}, {'job': 1, 'tasks': [{'task': 0, 'start': 186, 'machine': 0, 'duration': 44}, {'task': 1, 'start': 9, 'machine': 1, 'duration': 4}, {'task': 2, 'start': 84, 'machine': 2, 'duration': 57}]}, {'job': 2, 'tasks': [{'task': 0, 'start': 95, 'machine': 0, 'duration': 91}, {'task': 1, 'start': 0, 'machine': 1, 'duration': 9}, {'task': 2, 'start': 198, 'machine': 2, 'duration': 12}]}, {'job': 3, 'tasks': [{'task': 0, 'start': 0, 'machine': 0, 'duration': 95}, {'task': 1, 'start': 100, 'machine': 1, 'duration': 77}, {'task': 2, 'start': 177, 'machine': 2, 'duration': 21}]}]",231.0,"{'problem_type': 'OSP', 'nr_jobs': 4, 'nr_machines': 3, 'jobs': ['J1', 'J2', 'J3', 'J4'], 'machines': [0, 1, 2], 'records': [{'job_id': 'J1', 'task_id': 0, 'machine_id': 0, 'duration': 1}, {'job_id': 'J1', 'task_id': 1, 'machine_id': 1, 'duration': 16}, {'job_id': 'J1', 'task_id': 2, 'machine_id': 2, 'duration': 84}, {'job_id': 'J2', 'task_id': 0, 'machine_id': 0, 'duration': 44}, {'job_id': 'J2', 'task_id': 1, 'machine_id': 1, 'duration': 4}, {'job_id': 'J2', 'task_id': 2, 'machine_id': 2, 'duration': 57}, {'job_id': 'J3', 'task_id': 0, 'machine_id': 0, 'duration': 91}, {'job_id': 'J3', 'task_id': 1, 'machine_id': 1, 'duration': 9}, {'job_id': 'J3', 'task_id': 2, 'machine_id': 2, 'duration': 12}, {'job_id': 'J4', 'task_id': 0, 'machine_id': 0, 'duration': 95}, {'job_id': 'J4', 'task_id': 1, 'machine_id': 1, 'duration': 77}, {'job_id': 'J4', 'task_id': 2, 'machine_id': 2, 'duration': 21}]}","[{'job': 'J1', 'tasks': [{'task': 0, 'start': 230, 'machine': 0, 'duration': 1}, {'task': 1, 'start': 84, 'machine': 1, 'duration': 16}, {'task': 2, 'start': 0, 'machine': 2, 'duration': 84}]}, {'job': 'J2', 'tasks': [{'task': 0, 'start': 186, 'machine': 0, 'duration': 44}, {'task': 1, 'start': 9, 'machine': 1, 'duration': 4}, {'task': 2, 'start': 84, 'machine': 2, 'duration': 57}]}, {'job': 'J3', 'tasks': [{'task': 0, 'start': 95, 'machine': 0, 'duration': 91}, {'task': 1, 'start': 0, 'machine': 1, 'duration': 9}, {'task': 2, 'start': 198, 'machine': 2, 'duration': 12}]}, {'job': 'J4', 'tasks': [{'task': 0, 'start': 0, 'machine': 0, 'duration': 95}, {'task': 1, 'start': 100, 'machine': 1, 'duration': 77}, {'task': 2, 'start': 177, 'machine': 2, 'duration': 21}]}]",21,json,0
OSP,OSP,"I’m picturing a small darkroom where a stack of film rolls all need a handful of different treatments — each roll has to go through the same set of stations, but there’s no fixed recipe saying which station first. The team has to pick the order each roll visits the stations and decide when each step starts, making sure every roll hits each required station exactly once, no station handles two rolls at once, and no roll is in two places at the same time. The trick is to arrange those orders and start times so the whole batch is finished as soon as possible — we’ll keep an eye on the clock and the time when the last roll comes out is the number we want to make as small as possible. Concrete details of the rolls and stations are shown below.

Below we list the 3 rolls and the 2 stations as J1, J2, J3 and A, B.

| roll_id | treatment_index | station_id | processing_duration |
|---|---|---|---|
| J1 | 0 | A | 1 |
| J1 | 1 | B | 29 |
| J2 | 0 | A | 60 |
| J2 | 1 | B | 89 |
| J3 | 0 | A | 56 |
| J3 | 1 | B | 79 |

We'll use these entries to pick the order and start time for each treatment so the whole batch finishes as soon as possible.

I’ll ask for the schedule in a simple JSON shape so it’s easy to read and plug in — nothing fancy, just that structure below.

{
  ""solution"": [
    {
      ""job"": <roll_id>,
      ""tasks"": [
        {
          ""task"": <treatment_index>,
          ""start"": <start_time>,
          ""machine"": <station_id>,
          ""duration"": <duration>
        }
      ]
    }
  ]
}

Think of it as a little form for each film roll: ""job"" is the roll identifier, ""tasks"" is the list of treatments that roll needs, and each task line says which step it is, when it starts, which station handles it, and how long it takes. Super informal — just a sketch of the shape I’m expecting, not the actual schedule.

Please remember to 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”.""","{'nr_machines': 2, 'nr_jobs': 3, 'jobs': [[[0, 1], [1, 29]], [[0, 60], [1, 89]], [[0, 56], [1, 79]]]}","[{'job': 0, 'tasks': [{'task': 0, 'start': 56, 'machine': 0, 'duration': 1}, {'task': 1, 'start': 168, 'machine': 1, 'duration': 29}]}, {'job': 1, 'tasks': [{'task': 0, 'start': 89, 'machine': 0, 'duration': 60}, {'task': 1, 'start': 0, 'machine': 1, 'duration': 89}]}, {'job': 2, 'tasks': [{'task': 0, 'start': 0, 'machine': 0, 'duration': 56}, {'task': 1, 'start': 89, 'machine': 1, 'duration': 79}]}]",197.0,"{'problem_type': 'OSP', 'nr_jobs': 3, 'nr_machines': 2, 'jobs': ['J1', 'J2', 'J3'], 'machines': ['A', 'B'], 'records': [{'job_id': 'J1', 'task_id': 0, 'machine_id': 'A', 'duration': 1}, {'job_id': 'J1', 'task_id': 1, 'machine_id': 'B', 'duration': 29}, {'job_id': 'J2', 'task_id': 0, 'machine_id': 'A', 'duration': 60}, {'job_id': 'J2', 'task_id': 1, 'machine_id': 'B', 'duration': 89}, {'job_id': 'J3', 'task_id': 0, 'machine_id': 'A', 'duration': 56}, {'job_id': 'J3', 'task_id': 1, 'machine_id': 'B', 'duration': 79}]}","[{'job': 'J1', 'tasks': [{'task': 0, 'start': 56, 'machine': 'A', 'duration': 1}, {'task': 1, 'start': 168, 'machine': 'B', 'duration': 29}]}, {'job': 'J2', 'tasks': [{'task': 0, 'start': 89, 'machine': 'A', 'duration': 60}, {'task': 1, 'start': 0, 'machine': 'B', 'duration': 89}]}, {'job': 'J3', 'tasks': [{'task': 0, 'start': 0, 'machine': 'A', 'duration': 56}, {'task': 1, 'start': 89, 'machine': 'B', 'duration': 79}]}]",22,markdown_table,names
OSP,OSP,"Someone in the shop needs to decide the running order and timing for a stack of cabinets that each require work at several stations, figuring out which cabinet goes where and when. Each cabinet has to hit each necessary station a single time, stations can’t process multiple cabinets simultaneously, and a cabinet can’t be at two stations at the same moment. The better the schedule, the earlier the entire batch is wrapped up — measured by the time the last cabinet is completed. The concrete schedule data and durations are shown below.

# num_cabinets=2
# num_stations=2
# cabinet_ids=J1, J2
# station_ids=A, B
cabinet_id,operation_index,station_id,operation_duration
J1,0,A,1
J1,1,B,42
J2,0,A,36
J2,1,B,36

You can just hand me the schedule in a simple JSON form like this — nothing fancy, just the fields we'll need to read and check.

{
  ""solution"": [
    {
      ""job"": <cabinet_id>,
      ""tasks"": [
        {
          ""task"": <step_index>,
          ""start"": <start_time>,
          ""machine"": <station_id>,
          ""duration"": <duration>
        }
      ]
    }
  ]
}

Think of it like a little form: each ""job"" is one cabinet (use the same cabinet IDs from the input), ""tasks"" is the list of station visits for that cabinet, and each task row tells you which step it is, when it starts, which station it uses, and how long it takes. Super casual — just fill in the entries for each cabinet.

This JSON is only a sketch of the expected shape, not the final schedule itself. Please be careful to use the exact identifiers from the instance input — no renaming and no new labels. 

Valid identifiers look like plain numbers such as ""1"" or ""23"", single capital letters like ""A"" or ""B"", or a capital letter followed by digits like ""A1"" or ""X7"".","{'nr_machines': 2, 'nr_jobs': 2, 'jobs': [[[0, 1], [1, 42]], [[0, 36], [1, 36]]]}","[{'job': 0, 'tasks': [{'task': 0, 'start': 42, 'machine': 0, 'duration': 1}, {'task': 1, 'start': 0, 'machine': 1, 'duration': 42}]}, {'job': 1, 'tasks': [{'task': 0, 'start': 0, 'machine': 0, 'duration': 36}, {'task': 1, 'start': 42, 'machine': 1, 'duration': 36}]}]",78.0,"{'problem_type': 'OSP', 'nr_jobs': 2, 'nr_machines': 2, 'jobs': ['J1', 'J2'], 'machines': ['A', 'B'], 'records': [{'job_id': 'J1', 'task_id': 0, 'machine_id': 'A', 'duration': 1}, {'job_id': 'J1', 'task_id': 1, 'machine_id': 'B', 'duration': 42}, {'job_id': 'J2', 'task_id': 0, 'machine_id': 'A', 'duration': 36}, {'job_id': 'J2', 'task_id': 1, 'machine_id': 'B', 'duration': 36}]}","[{'job': 'J1', 'tasks': [{'task': 0, 'start': 42, 'machine': 'A', 'duration': 1}, {'task': 1, 'start': 0, 'machine': 'B', 'duration': 42}]}, {'job': 'J2', 'tasks': [{'task': 0, 'start': 0, 'machine': 'A', 'duration': 36}, {'task': 1, 'start': 42, 'machine': 'B', 'duration': 36}]}]",23,csv,names
OSP,OSP,"Recently the QA team had to sort out how to run a batch of circuit boards through several testing machines: pick the order of tests for each board and schedule exact start times so there are no conflicts. Every board needs each specified tester exactly once, testers can’t handle more than one board at a stretch, and a board can’t be tested in two places at once. The success of a schedule is judged by when the very last board finishes its final required test — the earlier that moment, the better. The concrete details will be shown below.

They had 4 boards, 2 testers, board IDs J1, J2, J3, J4, and tester IDs A, B.
Board J1 needs test 0 on tester A lasting 1.
Board J1 needs test 1 on tester B lasting 55.
Board J2 needs test 0 on tester A lasting 12.
Board J2 needs test 1 on tester B lasting 81.
Board J3 needs test 0 on tester A lasting 63.
Board J3 needs test 1 on tester B lasting 24.
Board J4 needs test 0 on tester A lasting 6.
Board J4 needs test 1 on tester B lasting 13.
Schedule the 4 boards on the 2 testers without overlap so the final completion time is as early as possible.

Also, when you send the schedule back, just use a small JSON shape so it's easy to parse. Something like this:

{
  ""solution"": [
    {
      ""job"": <board_id>,
      ""tasks"": [
        {
          ""task"": <task_index>,
          ""start"": <start_time>,
          ""machine"": <tester_id>,
          ""duration"": <duration>
        }
      ]
    }
  ]
}

This sketch just shows the expected parts: each top-level entry under ""solution"" is one board (job), ""tasks"" lists that board’s tests, each task line has which test it is, when it starts, which tester (machine) it uses, and how long that test lasts. It’s just a template for the shape I need, not the actual scheduled values.

Please be sure to use the exact identifiers from the instance input — don’t invent new labels or rename existing 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”.""","{'nr_machines': 2, 'nr_jobs': 4, 'jobs': [[[0, 1], [1, 55]], [[0, 12], [1, 81]], [[0, 63], [1, 24]], [[0, 6], [1, 13]]]}","[{'job': 0, 'tasks': [{'task': 0, 'start': 69, 'machine': 0, 'duration': 1}, {'task': 1, 'start': 81, 'machine': 1, 'duration': 55}]}, {'job': 1, 'tasks': [{'task': 0, 'start': 81, 'machine': 0, 'duration': 12}, {'task': 1, 'start': 0, 'machine': 1, 'duration': 81}]}, {'job': 2, 'tasks': [{'task': 0, 'start': 0, 'machine': 0, 'duration': 63}, {'task': 1, 'start': 136, 'machine': 1, 'duration': 24}]}, {'job': 3, 'tasks': [{'task': 0, 'start': 63, 'machine': 0, 'duration': 6}, {'task': 1, 'start': 160, 'machine': 1, 'duration': 13}]}]",173.0,"{'problem_type': 'OSP', 'nr_jobs': 4, 'nr_machines': 2, 'jobs': ['J1', 'J2', 'J3', 'J4'], 'machines': ['A', 'B'], 'records': [{'job_id': 'J1', 'task_id': 0, 'machine_id': 'A', 'duration': 1}, {'job_id': 'J1', 'task_id': 1, 'machine_id': 'B', 'duration': 55}, {'job_id': 'J2', 'task_id': 0, 'machine_id': 'A', 'duration': 12}, {'job_id': 'J2', 'task_id': 1, 'machine_id': 'B', 'duration': 81}, {'job_id': 'J3', 'task_id': 0, 'machine_id': 'A', 'duration': 63}, {'job_id': 'J3', 'task_id': 1, 'machine_id': 'B', 'duration': 24}, {'job_id': 'J4', 'task_id': 0, 'machine_id': 'A', 'duration': 6}, {'job_id': 'J4', 'task_id': 1, 'machine_id': 'B', 'duration': 13}]}","[{'job': 'J1', 'tasks': [{'task': 0, 'start': 69, 'machine': 'A', 'duration': 1}, {'task': 1, 'start': 81, 'machine': 'B', 'duration': 55}]}, {'job': 'J2', 'tasks': [{'task': 0, 'start': 81, 'machine': 'A', 'duration': 12}, {'task': 1, 'start': 0, 'machine': 'B', 'duration': 81}]}, {'job': 'J3', 'tasks': [{'task': 0, 'start': 0, 'machine': 'A', 'duration': 63}, {'task': 1, 'start': 136, 'machine': 'B', 'duration': 24}]}, {'job': 'J4', 'tasks': [{'task': 0, 'start': 63, 'machine': 'A', 'duration': 6}, {'task': 1, 'start': 160, 'machine': 'B', 'duration': 13}]}]",24,nl,names
OSP,OSP,"Many people booked several services and the salon scheduler needed to line up the order and the starting times for each person’s appointments so the day would run smoothly. Each client has to visit each required station exactly once, stations can’t serve more than one client at a time, and no one can be scheduled in two places simultaneously. The better the plan, the sooner the last client walks out; so compare schedules by the time the final appointment finishes and choose the earliest. The exact bookings and times are shown below.

# nr_clients=3
# nr_stations=2
# clients=J1, J2, J3
# stations=0, 1
client_id,service_index,station_id,service_duration
J1,0,0,1
J1,1,1,68
J2,0,0,87
J2,1,1,27
J3,0,0,17
J3,1,1,45

When I give you the actual schedule, I'll keep it in a simple JSON shape so it's easy to read and reuse. Here's the shape I’ll follow:

{
  ""solution"": [
    {
      ""job"": <client_id>,
      ""tasks"": [
        {
          ""task"": <service_index>,
          ""start"": <start_time>,
          ""machine"": <station_id>,
          ""duration"": <duration>
        }
      ]
    }
  ]
}

This is just a sketch of the fields — think of ""job"" as the client, ""tasks"" as that client's list of appointments, ""task"" as the specific service slot, ""start"" as when the appointment begins, ""machine"" as the salon station or chair being used, and ""duration"" as how long that service takes. It’s informal, like filling out a little form.

Please remember that when filling in the actual schedule you must 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”.","{'nr_machines': 2, 'nr_jobs': 3, 'jobs': [[[0, 1], [1, 68]], [[0, 87], [1, 27]], [[0, 17], [1, 45]]]}","[{'job': 0, 'tasks': [{'task': 0, 'start': 87, 'machine': 0, 'duration': 1}, {'task': 1, 'start': 0, 'machine': 1, 'duration': 68}]}, {'job': 1, 'tasks': [{'task': 0, 'start': 0, 'machine': 0, 'duration': 87}, {'task': 1, 'start': 113, 'machine': 1, 'duration': 27}]}, {'job': 2, 'tasks': [{'task': 0, 'start': 113, 'machine': 0, 'duration': 17}, {'task': 1, 'start': 68, 'machine': 1, 'duration': 45}]}]",140.0,"{'problem_type': 'OSP', 'nr_jobs': 3, 'nr_machines': 2, 'jobs': ['J1', 'J2', 'J3'], 'machines': [0, 1], 'records': [{'job_id': 'J1', 'task_id': 0, 'machine_id': 0, 'duration': 1}, {'job_id': 'J1', 'task_id': 1, 'machine_id': 1, 'duration': 68}, {'job_id': 'J2', 'task_id': 0, 'machine_id': 0, 'duration': 87}, {'job_id': 'J2', 'task_id': 1, 'machine_id': 1, 'duration': 27}, {'job_id': 'J3', 'task_id': 0, 'machine_id': 0, 'duration': 17}, {'job_id': 'J3', 'task_id': 1, 'machine_id': 1, 'duration': 45}]}","[{'job': 'J1', 'tasks': [{'task': 0, 'start': 87, 'machine': 0, 'duration': 1}, {'task': 1, 'start': 0, 'machine': 1, 'duration': 68}]}, {'job': 'J2', 'tasks': [{'task': 0, 'start': 0, 'machine': 0, 'duration': 87}, {'task': 1, 'start': 113, 'machine': 1, 'duration': 27}]}, {'job': 'J3', 'tasks': [{'task': 0, 'start': 113, 'machine': 0, 'duration': 17}, {'task': 1, 'start': 68, 'machine': 1, 'duration': 45}]}]",25,csv,0
OSP,OSP,"In a small bindery the team needs to process a batch where each book needs several different operations, but there’s no preset order for those steps. The task is to choose the order and timing for each book’s operations so each required station is visited once, no station works on two books at the same time, and no book is worked on in two places at once. The “best” way is simply the one that gets the final book done first — compute every book’s finish time and take the latest as the batch’s completion time. The concrete details are shown below.

# nr_books=5
# nr_stations=3
# books=J1, J2, J3, J4, J5
# stations=1, 2, 3
book_id,operation_index,station_id,processing_time
J1,0,1,1
J1,1,2,81
J1,2,3,62
J2,0,1,73
J2,1,2,69
J2,2,3,67
J3,0,1,16
J3,1,2,48
J3,2,3,51
J4,0,1,62
J4,1,2,69
J4,2,3,80
J5,0,1,67
J5,1,2,32
J5,2,3,58

Also, when you send the schedule back, just use a relaxed JSON layout like this so it's easy to parse and read:

{
  ""solution"": [
    {
      ""job"": <book_id>,
      ""tasks"": [
        {
          ""task"": <operation_index>,
          ""start"": <start_time>,
          ""machine"": <station_id>,
          ""duration"": <duration>
        }
      ]
    }
  ]
}

Think of that as a little form: each item in ""solution"" is one book, and ""tasks"" is the list of operations that book needs. For every operation you give an operation index, a start time, which station (machine) it visits, and how long that step takes. Super informal — just a sketch of the shape I want, not the final schedule.

Please make sure to use the exact identifiers that appear in the instance input — don't rename them or invent new labels. 
- for example: ""Valid identifiers look like plain numbers such as “1” or “23”, single capital letters like “A” or “B”, or a capital letter followed by digits like “A1” or “X7”.""","{'nr_machines': 3, 'nr_jobs': 5, 'jobs': [[[0, 1], [1, 81], [2, 62]], [[0, 73], [1, 69], [2, 67]], [[0, 16], [1, 48], [2, 51]], [[0, 62], [1, 69], [2, 80]], [[0, 67], [1, 32], [2, 58]]]}","[{'job': 0, 'tasks': [{'task': 0, 'start': 218, 'machine': 0, 'duration': 1}, {'task': 1, 'start': 0, 'machine': 1, 'duration': 81}, {'task': 2, 'start': 147, 'machine': 2, 'duration': 62}]}, {'job': 1, 'tasks': [{'task': 0, 'start': 0, 'machine': 0, 'duration': 73}, {'task': 1, 'start': 150, 'machine': 1, 'duration': 69}, {'task': 2, 'start': 80, 'machine': 2, 'duration': 67}]}, {'job': 2, 'tasks': [{'task': 0, 'start': 140, 'machine': 0, 'duration': 16}, {'task': 1, 'start': 219, 'machine': 1, 'duration': 48}, {'task': 2, 'start': 267, 'machine': 2, 'duration': 51}]}, {'job': 3, 'tasks': [{'task': 0, 'start': 156, 'machine': 0, 'duration': 62}, {'task': 1, 'start': 81, 'machine': 1, 'duration': 69}, {'task': 2, 'start': 0, 'machine': 2, 'duration': 80}]}, {'job': 4, 'tasks': [{'task': 0, 'start': 73, 'machine': 0, 'duration': 67}, {'task': 1, 'start': 267, 'machine': 1, 'duration': 32}, {'task': 2, 'start': 209, 'machine': 2, 'duration': 58}]}]",318.0,"{'problem_type': 'OSP', 'nr_jobs': 5, 'nr_machines': 3, 'jobs': ['J1', 'J2', 'J3', 'J4', 'J5'], 'machines': [1, 2, 3], 'records': [{'job_id': 'J1', 'task_id': 0, 'machine_id': 1, 'duration': 1}, {'job_id': 'J1', 'task_id': 1, 'machine_id': 2, 'duration': 81}, {'job_id': 'J1', 'task_id': 2, 'machine_id': 3, 'duration': 62}, {'job_id': 'J2', 'task_id': 0, 'machine_id': 1, 'duration': 73}, {'job_id': 'J2', 'task_id': 1, 'machine_id': 2, 'duration': 69}, {'job_id': 'J2', 'task_id': 2, 'machine_id': 3, 'duration': 67}, {'job_id': 'J3', 'task_id': 0, 'machine_id': 1, 'duration': 16}, {'job_id': 'J3', 'task_id': 1, 'machine_id': 2, 'duration': 48}, {'job_id': 'J3', 'task_id': 2, 'machine_id': 3, 'duration': 51}, {'job_id': 'J4', 'task_id': 0, 'machine_id': 1, 'duration': 62}, {'job_id': 'J4', 'task_id': 1, 'machine_id': 2, 'duration': 69}, {'job_id': 'J4', 'task_id': 2, 'machine_id': 3, 'duration': 80}, {'job_id': 'J5', 'task_id': 0, 'machine_id': 1, 'duration': 67}, {'job_id': 'J5', 'task_id': 1, 'machine_id': 2, 'duration': 32}, {'job_id': 'J5', 'task_id': 2, 'machine_id': 3, 'duration': 58}]}","[{'job': 'J1', 'tasks': [{'task': 0, 'start': 218, 'machine': 1, 'duration': 1}, {'task': 1, 'start': 0, 'machine': 2, 'duration': 81}, {'task': 2, 'start': 147, 'machine': 3, 'duration': 62}]}, {'job': 'J2', 'tasks': [{'task': 0, 'start': 0, 'machine': 1, 'duration': 73}, {'task': 1, 'start': 150, 'machine': 2, 'duration': 69}, {'task': 2, 'start': 80, 'machine': 3, 'duration': 67}]}, {'job': 'J3', 'tasks': [{'task': 0, 'start': 140, 'machine': 1, 'duration': 16}, {'task': 1, 'start': 219, 'machine': 2, 'duration': 48}, {'task': 2, 'start': 267, 'machine': 3, 'duration': 51}]}, {'job': 'J4', 'tasks': [{'task': 0, 'start': 156, 'machine': 1, 'duration': 62}, {'task': 1, 'start': 81, 'machine': 2, 'duration': 69}, {'task': 2, 'start': 0, 'machine': 3, 'duration': 80}]}, {'job': 'J5', 'tasks': [{'task': 0, 'start': 73, 'machine': 1, 'duration': 67}, {'task': 1, 'start': 267, 'machine': 2, 'duration': 32}, {'task': 2, 'start': 209, 'machine': 3, 'duration': 58}]}]",26,csv,1
OSP,OSP,"Someone dropped off a dozen phones, each needing several distinct operations across the shop’s benches, and those operations can be done in any order for each phone. The challenge is to decide when and in which order each phone sees each bench, ensuring every required operation is performed exactly once, each bench handles a single phone at a time, and no phone is scheduled at two benches simultaneously. The best way to judge any plan is simple: look at the clock time when the last phone is done — the earlier, the better. Details about the phones and benches appear below.

Here are the specifics for the drop-off: 5 phones, 3 benches — phones: J1, J2, J3, J4, J5; benches: 1, 2, 3.

| phone_id | operation_index | bench_id | operation_duration |
|---|---|---|---|
| J1 | 0 | 1 | 1 |
| J1 | 1 | 2 | 94 |
| J1 | 2 | 3 | 38 |
| J2 | 0 | 1 | 19 |
| J2 | 1 | 2 | 23 |
| J2 | 2 | 3 | 89 |
| J3 | 0 | 1 | 20 |
| J3 | 1 | 2 | 17 |
| J3 | 2 | 3 | 20 |
| J4 | 0 | 1 | 56 |
| J4 | 1 | 2 | 8 |
| J4 | 2 | 3 | 32 |
| J5 | 0 | 1 | 51 |
| J5 | 1 | 2 | 35 |
| J5 | 2 | 3 | 63 |

Aim to minimize the clock time when the last of the 5 phones is finished.

I’ll lay out the shape I expect the answer to take so it’s easy to fill in: think of it as a little form you’ll populate. Use this JSON layout, keeping the keys exactly the same, and swapping the angle-bracket placeholders for the real values from the instance.

{
  ""solution"": [
    {
      ""job"": <phone_id>,
      ""tasks"": [
        {
          ""task"": <operation_index>,
          ""start"": <start_time>,
          ""machine"": <bench_id>,
          ""duration"": <duration>
        }
      ]
    }
  ]
}

Pretty straightforward: each top-level ""job"" entry is one phone, ""tasks"" is the list of operations that phone needs. For each task you give its index, the start time, which bench (machine) it goes to, and how long that task takes. This is just the expected shape — a sketch, not the filled-in schedule.

Please make sure to use the exact identifiers from the instance input — don’t rename them and don’t 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”.""","{'nr_machines': 3, 'nr_jobs': 5, 'jobs': [[[0, 1], [1, 94], [2, 38]], [[0, 19], [1, 23], [2, 89]], [[0, 20], [1, 17], [2, 20]], [[0, 56], [1, 8], [2, 32]], [[0, 51], [1, 35], [2, 63]]]}","[{'job': 0, 'tasks': [{'task': 0, 'start': 159, 'machine': 0, 'duration': 1}, {'task': 1, 'start': 0, 'machine': 1, 'duration': 94}, {'task': 2, 'start': 121, 'machine': 2, 'duration': 38}]}, {'job': 1, 'tasks': [{'task': 0, 'start': 127, 'machine': 0, 'duration': 19}, {'task': 1, 'start': 94, 'machine': 1, 'duration': 23}, {'task': 2, 'start': 0, 'machine': 2, 'duration': 89}]}, {'job': 2, 'tasks': [{'task': 0, 'start': 107, 'machine': 0, 'duration': 20}, {'task': 1, 'start': 152, 'machine': 1, 'duration': 17}, {'task': 2, 'start': 222, 'machine': 2, 'duration': 20}]}, {'job': 3, 'tasks': [{'task': 0, 'start': 0, 'machine': 0, 'duration': 56}, {'task': 1, 'start': 169, 'machine': 1, 'duration': 8}, {'task': 2, 'start': 89, 'machine': 2, 'duration': 32}]}, {'job': 4, 'tasks': [{'task': 0, 'start': 56, 'machine': 0, 'duration': 51}, {'task': 1, 'start': 117, 'machine': 1, 'duration': 35}, {'task': 2, 'start': 159, 'machine': 2, 'duration': 63}]}]",242.0,"{'problem_type': 'OSP', 'nr_jobs': 5, 'nr_machines': 3, 'jobs': ['J1', 'J2', 'J3', 'J4', 'J5'], 'machines': [1, 2, 3], 'records': [{'job_id': 'J1', 'task_id': 0, 'machine_id': 1, 'duration': 1}, {'job_id': 'J1', 'task_id': 1, 'machine_id': 2, 'duration': 94}, {'job_id': 'J1', 'task_id': 2, 'machine_id': 3, 'duration': 38}, {'job_id': 'J2', 'task_id': 0, 'machine_id': 1, 'duration': 19}, {'job_id': 'J2', 'task_id': 1, 'machine_id': 2, 'duration': 23}, {'job_id': 'J2', 'task_id': 2, 'machine_id': 3, 'duration': 89}, {'job_id': 'J3', 'task_id': 0, 'machine_id': 1, 'duration': 20}, {'job_id': 'J3', 'task_id': 1, 'machine_id': 2, 'duration': 17}, {'job_id': 'J3', 'task_id': 2, 'machine_id': 3, 'duration': 20}, {'job_id': 'J4', 'task_id': 0, 'machine_id': 1, 'duration': 56}, {'job_id': 'J4', 'task_id': 1, 'machine_id': 2, 'duration': 8}, {'job_id': 'J4', 'task_id': 2, 'machine_id': 3, 'duration': 32}, {'job_id': 'J5', 'task_id': 0, 'machine_id': 1, 'duration': 51}, {'job_id': 'J5', 'task_id': 1, 'machine_id': 2, 'duration': 35}, {'job_id': 'J5', 'task_id': 2, 'machine_id': 3, 'duration': 63}]}","[{'job': 'J1', 'tasks': [{'task': 0, 'start': 159, 'machine': 1, 'duration': 1}, {'task': 1, 'start': 0, 'machine': 2, 'duration': 94}, {'task': 2, 'start': 121, 'machine': 3, 'duration': 38}]}, {'job': 'J2', 'tasks': [{'task': 0, 'start': 127, 'machine': 1, 'duration': 19}, {'task': 1, 'start': 94, 'machine': 2, 'duration': 23}, {'task': 2, 'start': 0, 'machine': 3, 'duration': 89}]}, {'job': 'J3', 'tasks': [{'task': 0, 'start': 107, 'machine': 1, 'duration': 20}, {'task': 1, 'start': 152, 'machine': 2, 'duration': 17}, {'task': 2, 'start': 222, 'machine': 3, 'duration': 20}]}, {'job': 'J4', 'tasks': [{'task': 0, 'start': 0, 'machine': 1, 'duration': 56}, {'task': 1, 'start': 169, 'machine': 2, 'duration': 8}, {'task': 2, 'start': 89, 'machine': 3, 'duration': 32}]}, {'job': 'J5', 'tasks': [{'task': 0, 'start': 56, 'machine': 1, 'duration': 51}, {'task': 1, 'start': 117, 'machine': 2, 'duration': 35}, {'task': 2, 'start': 159, 'machine': 3, 'duration': 63}]}]",27,markdown_table,1
OSP,OSP,"Someone at the shipping dock is trying to clear a backlog: every parcel has a short checklist of packing stations it must visit, exactly one visit per station, but there’s no required order. The job is to schedule when each parcel hits each station and in what order, with the simple rules that a station only works on one parcel at a time and a parcel can’t be in two stations at once. Better schedules are those that complete the whole batch earlier — you read success as the time when the very last parcel finishes. The detailed list of parcels and station times is given below.

There are 3 parcels and 3 packing stations; parcel ids are J1, J2, J3 and station ids are 1, 2, 3.

| parcel_id | visit_index | station_id | processing_time |
|---|---|---|---|
| J1 | 0 | 1 | 1 |
| J1 | 1 | 2 | 8 |
| J1 | 2 | 3 | 14 |
| J2 | 0 | 1 | 65 |
| J2 | 1 | 2 | 76 |
| J2 | 2 | 3 | 11 |
| J3 | 0 | 1 | 25 |
| J3 | 1 | 2 | 84 |
| J3 | 2 | 3 | 87 |

Better schedules finish the whole batch earlier — you read success as the time when the very last parcel finishes.

Oh, and when you return the schedule, it helps to follow a simple JSON layout so everything's easy to read. Here's the shape I expect:

{
  ""solution"": [
    {
      ""job"": <parcel_id>,
      ""tasks"": [
        {
          ""task"": <task_index>,
          ""start"": <start_time>,
          ""machine"": <station_id>,
          ""duration"": <duration>
        }
      ]
    }
  ]
}

Think of it like a little form: ""solution"" holds a list of parcels, each parcel's ""job"" is its ID, ""tasks"" is the checklist of station visits, and for each task you give the task index, when it starts, which station it goes to, and how long it takes. Super casual — just the shape, not the actual schedule.

Please remember: all identifiers must be used 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”.""","{'nr_machines': 3, 'nr_jobs': 3, 'jobs': [[[0, 1], [1, 8], [2, 14]], [[0, 65], [1, 76], [2, 11]], [[0, 25], [1, 84], [2, 87]]]}","[{'job': 0, 'tasks': [{'task': 0, 'start': 0, 'machine': 0, 'duration': 1}, {'task': 1, 'start': 76, 'machine': 1, 'duration': 8}, {'task': 2, 'start': 87, 'machine': 2, 'duration': 14}]}, {'job': 1, 'tasks': [{'task': 0, 'start': 76, 'machine': 0, 'duration': 65}, {'task': 1, 'start': 0, 'machine': 1, 'duration': 76}, {'task': 2, 'start': 141, 'machine': 2, 'duration': 11}]}, {'job': 2, 'tasks': [{'task': 0, 'start': 171, 'machine': 0, 'duration': 25}, {'task': 1, 'start': 87, 'machine': 1, 'duration': 84}, {'task': 2, 'start': 0, 'machine': 2, 'duration': 87}]}]",196.0,"{'problem_type': 'OSP', 'nr_jobs': 3, 'nr_machines': 3, 'jobs': ['J1', 'J2', 'J3'], 'machines': [1, 2, 3], 'records': [{'job_id': 'J1', 'task_id': 0, 'machine_id': 1, 'duration': 1}, {'job_id': 'J1', 'task_id': 1, 'machine_id': 2, 'duration': 8}, {'job_id': 'J1', 'task_id': 2, 'machine_id': 3, 'duration': 14}, {'job_id': 'J2', 'task_id': 0, 'machine_id': 1, 'duration': 65}, {'job_id': 'J2', 'task_id': 1, 'machine_id': 2, 'duration': 76}, {'job_id': 'J2', 'task_id': 2, 'machine_id': 3, 'duration': 11}, {'job_id': 'J3', 'task_id': 0, 'machine_id': 1, 'duration': 25}, {'job_id': 'J3', 'task_id': 1, 'machine_id': 2, 'duration': 84}, {'job_id': 'J3', 'task_id': 2, 'machine_id': 3, 'duration': 87}]}","[{'job': 'J1', 'tasks': [{'task': 0, 'start': 0, 'machine': 1, 'duration': 1}, {'task': 1, 'start': 76, 'machine': 2, 'duration': 8}, {'task': 2, 'start': 87, 'machine': 3, 'duration': 14}]}, {'job': 'J2', 'tasks': [{'task': 0, 'start': 76, 'machine': 1, 'duration': 65}, {'task': 1, 'start': 0, 'machine': 2, 'duration': 76}, {'task': 2, 'start': 141, 'machine': 3, 'duration': 11}]}, {'job': 'J3', 'tasks': [{'task': 0, 'start': 171, 'machine': 1, 'duration': 25}, {'task': 1, 'start': 87, 'machine': 2, 'duration': 84}, {'task': 2, 'start': 0, 'machine': 3, 'duration': 87}]}]",28,markdown_table,1
OSP,OSP,"Someone at the front desk is trying to plan a day where every animal gets all its required treatments across several rooms, exactly once per room, and no room repeats work on the same pet. That person must choose both the order pets move between rooms and when each treatment starts, making sure rooms aren’t double-booked and pets aren’t double-tasked. The measure of a good plan is how soon the whole day ends — it’s simply the time when the final procedure finishes, and earlier is better. The specific animals, rooms and procedure lengths appear below.

They must schedule 4 pets across 2 rooms, with pet identifiers J1, J2, J3, J4 and room identifiers 1, 2.

| pet_id | procedure_index | room_id | procedure_duration |
|---|---|---|---|
| J1 | 0 | 1 | 1 |
| J1 | 1 | 2 | 21 |
| J2 | 0 | 1 | 89 |
| J2 | 1 | 2 | 11 |
| J3 | 0 | 1 | 30 |
| J3 | 1 | 2 | 33 |
| J4 | 0 | 1 | 30 |
| J4 | 1 | 2 | 52 |

These entries list the required procedures so the front-desk person can arrange them to have all 4 pets finish as early as possible.

Also, to keep things tidy, it's easiest if the plan you send back follows a small JSON layout — just a simple list of pets and their treatments with start times and rooms. Something like this:

{
  ""solution"": [
    {
      ""job"": <pet_id>,
      ""tasks"": [
        {
          ""task"": <procedure_id>,
          ""start"": <start_time>,
          ""machine"": <room_id>,
          ""duration"": <duration>
        }
      ]
    }
  ]
}

Think of that as a little form: each top-level object under ""solution"" is one pet (""job""), ""tasks"" is the list of procedures that pet needs, and each procedure shows which room (""machine"") it uses, when it starts (""start"") and how long it takes (""duration""). This JSON is just a sketch of the shape I expect — not your actual answer.

Please make sure you 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”.""","{'nr_machines': 2, 'nr_jobs': 4, 'jobs': [[[0, 1], [1, 21]], [[0, 89], [1, 11]], [[0, 30], [1, 33]], [[0, 30], [1, 52]]]}","[{'job': 0, 'tasks': [{'task': 0, 'start': 149, 'machine': 0, 'duration': 1}, {'task': 1, 'start': 85, 'machine': 1, 'duration': 21}]}, {'job': 1, 'tasks': [{'task': 0, 'start': 0, 'machine': 0, 'duration': 89}, {'task': 1, 'start': 106, 'machine': 1, 'duration': 11}]}, {'job': 2, 'tasks': [{'task': 0, 'start': 119, 'machine': 0, 'duration': 30}, {'task': 1, 'start': 52, 'machine': 1, 'duration': 33}]}, {'job': 3, 'tasks': [{'task': 0, 'start': 89, 'machine': 0, 'duration': 30}, {'task': 1, 'start': 0, 'machine': 1, 'duration': 52}]}]",150.0,"{'problem_type': 'OSP', 'nr_jobs': 4, 'nr_machines': 2, 'jobs': ['J1', 'J2', 'J3', 'J4'], 'machines': [1, 2], 'records': [{'job_id': 'J1', 'task_id': 0, 'machine_id': 1, 'duration': 1}, {'job_id': 'J1', 'task_id': 1, 'machine_id': 2, 'duration': 21}, {'job_id': 'J2', 'task_id': 0, 'machine_id': 1, 'duration': 89}, {'job_id': 'J2', 'task_id': 1, 'machine_id': 2, 'duration': 11}, {'job_id': 'J3', 'task_id': 0, 'machine_id': 1, 'duration': 30}, {'job_id': 'J3', 'task_id': 1, 'machine_id': 2, 'duration': 33}, {'job_id': 'J4', 'task_id': 0, 'machine_id': 1, 'duration': 30}, {'job_id': 'J4', 'task_id': 1, 'machine_id': 2, 'duration': 52}]}","[{'job': 'J1', 'tasks': [{'task': 0, 'start': 149, 'machine': 1, 'duration': 1}, {'task': 1, 'start': 85, 'machine': 2, 'duration': 21}]}, {'job': 'J2', 'tasks': [{'task': 0, 'start': 0, 'machine': 1, 'duration': 89}, {'task': 1, 'start': 106, 'machine': 2, 'duration': 11}]}, {'job': 'J3', 'tasks': [{'task': 0, 'start': 119, 'machine': 1, 'duration': 30}, {'task': 1, 'start': 52, 'machine': 2, 'duration': 33}]}, {'job': 'J4', 'tasks': [{'task': 0, 'start': 89, 'machine': 1, 'duration': 30}, {'task': 1, 'start': 0, 'machine': 2, 'duration': 52}]}]",29,markdown_table,1
OSP,OSP,"Back at the shop, the checklist says each server wants several tests across multiple rigs, but there isn’t a fixed path each server must follow. Coordination means choosing the visit order and exact start times for every server’s tests, while ensuring every test is applied once per server, no rig runs more than a single server at the same moment, and no server is scheduled simultaneously on two rigs. The measure of success is straightforward: finish all maintenance as soon as possible — the time to watch is when the last server finishes. The instance details are presented below.

# num_servers=4
# num_rigs=2
# server_ids=J1, J2, J3, J4
# rig_ids=1, 2
server_id,test_index,required_rig_id,test_duration
J1,0,1,1
J1,1,2,34
J2,0,1,65
J2,1,2,56
J3,0,1,82
J3,1,2,55
J4,0,1,34
J4,1,2,20

I'll keep the actual answer in that simple JSON shape below — just a relaxed sketch of how I expect the schedule to be returned.

{
  ""solution"": [
    {
      ""job"": <server_id>,
      ""tasks"": [
        {
          ""task"": <test_index>,
          ""start"": <start_time>,
          ""machine"": <rig_id>,
          ""duration"": <duration>
        }
      ]
    }
  ]
}

Here’s what the fields mean in plain terms: each top-level object under ""solution"" is one server (the ""job""); ""tasks"" is the list of tests that server needs; for each test you record which test it is (""task""), when it starts (""start""), which rig it uses (""machine""), and how long it runs (""duration""). This is just the expected shape — I’m not filling in the real IDs or times here.

Please use the exact identifiers given in the instance input — don't rename them or invent new labels. 
- for example: ""Valid identifiers look like plain numbers such as “1” or “23”, single capital letters like “A” or “B”, or a capital letter followed by digits like “A1” or “X7”.""","{'nr_machines': 2, 'nr_jobs': 4, 'jobs': [[[0, 1], [1, 34]], [[0, 65], [1, 56]], [[0, 82], [1, 55]], [[0, 34], [1, 20]]]}","[{'job': 0, 'tasks': [{'task': 0, 'start': 147, 'machine': 0, 'duration': 1}, {'task': 1, 'start': 148, 'machine': 1, 'duration': 34}]}, {'job': 1, 'tasks': [{'task': 0, 'start': 82, 'machine': 0, 'duration': 65}, {'task': 1, 'start': 0, 'machine': 1, 'duration': 56}]}, {'job': 2, 'tasks': [{'task': 0, 'start': 0, 'machine': 0, 'duration': 82}, {'task': 1, 'start': 82, 'machine': 1, 'duration': 55}]}, {'job': 3, 'tasks': [{'task': 0, 'start': 148, 'machine': 0, 'duration': 34}, {'task': 1, 'start': 56, 'machine': 1, 'duration': 20}]}]",182.0,"{'problem_type': 'OSP', 'nr_jobs': 4, 'nr_machines': 2, 'jobs': ['J1', 'J2', 'J3', 'J4'], 'machines': [1, 2], 'records': [{'job_id': 'J1', 'task_id': 0, 'machine_id': 1, 'duration': 1}, {'job_id': 'J1', 'task_id': 1, 'machine_id': 2, 'duration': 34}, {'job_id': 'J2', 'task_id': 0, 'machine_id': 1, 'duration': 65}, {'job_id': 'J2', 'task_id': 1, 'machine_id': 2, 'duration': 56}, {'job_id': 'J3', 'task_id': 0, 'machine_id': 1, 'duration': 82}, {'job_id': 'J3', 'task_id': 1, 'machine_id': 2, 'duration': 55}, {'job_id': 'J4', 'task_id': 0, 'machine_id': 1, 'duration': 34}, {'job_id': 'J4', 'task_id': 1, 'machine_id': 2, 'duration': 20}]}","[{'job': 'J1', 'tasks': [{'task': 0, 'start': 147, 'machine': 1, 'duration': 1}, {'task': 1, 'start': 148, 'machine': 2, 'duration': 34}]}, {'job': 'J2', 'tasks': [{'task': 0, 'start': 82, 'machine': 1, 'duration': 65}, {'task': 1, 'start': 0, 'machine': 2, 'duration': 56}]}, {'job': 'J3', 'tasks': [{'task': 0, 'start': 0, 'machine': 1, 'duration': 82}, {'task': 1, 'start': 82, 'machine': 2, 'duration': 55}]}, {'job': 'J4', 'tasks': [{'task': 0, 'start': 148, 'machine': 1, 'duration': 34}, {'task': 1, 'start': 56, 'machine': 2, 'duration': 20}]}]",30,csv,1
OSP,OSP,"Out in the community garden it was obvious every raised bed needed a few different stops, but there was freedom in the sequence: who goes to the compost pile first, who waters next, and so on. The planning job was to set the order and start time of each bed’s visits so each required station is visited once per bed, stations aren’t double-booked, and no bed is scheduled for overlapping treatments. The measure of success is straightforward — how early the entire batch of beds is finished, i.e., the clock time when the last bed finishes. The concrete bed and station data come next.

{
  ""num_beds"": 3,
  ""num_stations"": 2,
  ""beds"": [
    ""J1"",
    ""J2"",
    ""J3""
  ],
  ""stations"": [
    1,
    2
  ],
  ""tasks"": [
    {
      ""bed_id"": ""J1"",
      ""visit_index"": 0,
      ""station_id"": 1,
      ""service_duration"": 1
    },
    {
      ""bed_id"": ""J1"",
      ""visit_index"": 1,
      ""station_id"": 2,
      ""service_duration"": 47
    },
    {
      ""bed_id"": ""J2"",
      ""visit_index"": 0,
      ""station_id"": 1,
      ""service_duration"": 40
    },
    {
      ""bed_id"": ""J2"",
      ""visit_index"": 1,
      ""station_id"": 2,
      ""service_duration"": 3
    },
    {
      ""bed_id"": ""J3"",
      ""visit_index"": 0,
      ""station_id"": 1,
      ""service_duration"": 36
    },
    {
      ""bed_id"": ""J3"",
      ""visit_index"": 1,
      ""station_id"": 2,
      ""service_duration"": 76
    }
  ]
}

If you want to hand the plan back in a tidy, machine-friendly way, you can use this relaxed JSON shape — it's just a little form that lists each bed and its stops:

{
  ""solution"": [
    {
      ""job"": <bed_id>,
      ""tasks"": [
        {
          ""task"": <task_index>,
          ""start"": <start_time>,
          ""machine"": <station_id>,
          ""duration"": <duration>
        }
      ]
    }
  ]
}

This is just a sketch of the shape I expect: ""solution"" holds a list of jobs (beds). Each job entry has a job identifier (the bed), and a ""tasks"" list. Each task line says which task it is (an index), when it starts, which machine/station it's visiting, and how long that stop takes. Think of it like a little checklist for each raised bed: task number, start time, station, and duration.

The block above is only the expected shape, not the actual schedule. 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”.","{'nr_machines': 2, 'nr_jobs': 3, 'jobs': [[[0, 1], [1, 47]], [[0, 40], [1, 3]], [[0, 36], [1, 76]]]}","[{'job': 0, 'tasks': [{'task': 0, 'start': 40, 'machine': 0, 'duration': 1}, {'task': 1, 'start': 76, 'machine': 1, 'duration': 47}]}, {'job': 1, 'tasks': [{'task': 0, 'start': 0, 'machine': 0, 'duration': 40}, {'task': 1, 'start': 123, 'machine': 1, 'duration': 3}]}, {'job': 2, 'tasks': [{'task': 0, 'start': 76, 'machine': 0, 'duration': 36}, {'task': 1, 'start': 0, 'machine': 1, 'duration': 76}]}]",126.0,"{'problem_type': 'OSP', 'nr_jobs': 3, 'nr_machines': 2, 'jobs': ['J1', 'J2', 'J3'], 'machines': [1, 2], 'records': [{'job_id': 'J1', 'task_id': 0, 'machine_id': 1, 'duration': 1}, {'job_id': 'J1', 'task_id': 1, 'machine_id': 2, 'duration': 47}, {'job_id': 'J2', 'task_id': 0, 'machine_id': 1, 'duration': 40}, {'job_id': 'J2', 'task_id': 1, 'machine_id': 2, 'duration': 3}, {'job_id': 'J3', 'task_id': 0, 'machine_id': 1, 'duration': 36}, {'job_id': 'J3', 'task_id': 1, 'machine_id': 2, 'duration': 76}]}","[{'job': 'J1', 'tasks': [{'task': 0, 'start': 40, 'machine': 1, 'duration': 1}, {'task': 1, 'start': 76, 'machine': 2, 'duration': 47}]}, {'job': 'J2', 'tasks': [{'task': 0, 'start': 0, 'machine': 1, 'duration': 40}, {'task': 1, 'start': 123, 'machine': 2, 'duration': 3}]}, {'job': 'J3', 'tasks': [{'task': 0, 'start': 76, 'machine': 1, 'duration': 36}, {'task': 1, 'start': 0, 'machine': 2, 'duration': 76}]}]",31,json,1
OSP,OSP,"Many people working in small factories know this: a set of items (in this case bike frames) needs several specific operations, and someone must decide the order and the start times for each item’s steps. Each frame must visit each necessary station once and only once, a station can only handle one frame at any moment, and no frame can be processed in two places at once. The preferable schedule is the one where the last frame finishes earlier — the finish time of that last frame is what’s compared across plans. The detailed instance info is listed below.

{
  ""nr_frames"": 3,
  ""nr_stations"": 3,
  ""frames"": [
    ""J1"",
    ""J2"",
    ""J3""
  ],
  ""stations"": [
    1,
    2,
    3
  ],
  ""tasks"": [
    {
      ""frame_id"": ""J1"",
      ""operation_index"": 0,
      ""station_id"": 1,
      ""processing_time"": 1
    },
    {
      ""frame_id"": ""J1"",
      ""operation_index"": 1,
      ""station_id"": 2,
      ""processing_time"": 60
    },
    {
      ""frame_id"": ""J1"",
      ""operation_index"": 2,
      ""station_id"": 3,
      ""processing_time"": 16
    },
    {
      ""frame_id"": ""J2"",
      ""operation_index"": 0,
      ""station_id"": 1,
      ""processing_time"": 48
    },
    {
      ""frame_id"": ""J2"",
      ""operation_index"": 1,
      ""station_id"": 2,
      ""processing_time"": 89
    },
    {
      ""frame_id"": ""J2"",
      ""operation_index"": 2,
      ""station_id"": 3,
      ""processing_time"": 98
    },
    {
      ""frame_id"": ""J3"",
      ""operation_index"": 0,
      ""station_id"": 1,
      ""processing_time"": 43
    },
    {
      ""frame_id"": ""J3"",
      ""operation_index"": 1,
      ""station_id"": 2,
      ""processing_time"": 56
    },
    {
      ""frame_id"": ""J3"",
      ""operation_index"": 2,
      ""station_id"": 3,
      ""processing_time"": 59
    }
  ]
}

Oh, and one more practical bit: when you send the schedule back, please follow this little JSON layout so it's easy for everyone to read and import. Just a simple structure showing each job (frame) and its tasks with start times, which station handles them, and how long they take.

{
  ""solution"": [
    {
      ""job"": <frame_id>,
      ""tasks"": [
        {
          ""task"": <operation_index>,
          ""start"": <start_time>,
          ""machine"": <station_id>,
          ""duration"": <duration>
        }
      ]
    }
  ]
}

This is just a sketch of the shape I need. In plain terms: each ""job"" entry is one bike frame, ""tasks"" is the list of operations that frame goes through, each task has an operation index, a start time, the station (machine) that does it, and how long that step takes. Keep it light and exact — it's just a form.

Please remember: use the identifiers 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”.","{'nr_machines': 3, 'nr_jobs': 3, 'jobs': [[[0, 1], [1, 60], [2, 16]], [[0, 48], [1, 89], [2, 98]], [[0, 43], [1, 56], [2, 59]]]}","[{'job': 0, 'tasks': [{'task': 0, 'start': 60, 'machine': 0, 'duration': 1}, {'task': 1, 'start': 0, 'machine': 1, 'duration': 60}, {'task': 2, 'start': 98, 'machine': 2, 'duration': 16}]}, {'job': 1, 'tasks': [{'task': 0, 'start': 98, 'machine': 0, 'duration': 48}, {'task': 1, 'start': 146, 'machine': 1, 'duration': 89}, {'task': 2, 'start': 0, 'machine': 2, 'duration': 98}]}, {'job': 2, 'tasks': [{'task': 0, 'start': 0, 'machine': 0, 'duration': 43}, {'task': 1, 'start': 60, 'machine': 1, 'duration': 56}, {'task': 2, 'start': 116, 'machine': 2, 'duration': 59}]}]",235.0,"{'problem_type': 'OSP', 'nr_jobs': 3, 'nr_machines': 3, 'jobs': ['J1', 'J2', 'J3'], 'machines': [1, 2, 3], 'records': [{'job_id': 'J1', 'task_id': 0, 'machine_id': 1, 'duration': 1}, {'job_id': 'J1', 'task_id': 1, 'machine_id': 2, 'duration': 60}, {'job_id': 'J1', 'task_id': 2, 'machine_id': 3, 'duration': 16}, {'job_id': 'J2', 'task_id': 0, 'machine_id': 1, 'duration': 48}, {'job_id': 'J2', 'task_id': 1, 'machine_id': 2, 'duration': 89}, {'job_id': 'J2', 'task_id': 2, 'machine_id': 3, 'duration': 98}, {'job_id': 'J3', 'task_id': 0, 'machine_id': 1, 'duration': 43}, {'job_id': 'J3', 'task_id': 1, 'machine_id': 2, 'duration': 56}, {'job_id': 'J3', 'task_id': 2, 'machine_id': 3, 'duration': 59}]}","[{'job': 'J1', 'tasks': [{'task': 0, 'start': 60, 'machine': 1, 'duration': 1}, {'task': 1, 'start': 0, 'machine': 2, 'duration': 60}, {'task': 2, 'start': 98, 'machine': 3, 'duration': 16}]}, {'job': 'J2', 'tasks': [{'task': 0, 'start': 98, 'machine': 1, 'duration': 48}, {'task': 1, 'start': 146, 'machine': 2, 'duration': 89}, {'task': 2, 'start': 0, 'machine': 3, 'duration': 98}]}, {'job': 'J3', 'tasks': [{'task': 0, 'start': 0, 'machine': 1, 'duration': 43}, {'task': 1, 'start': 60, 'machine': 2, 'duration': 56}, {'task': 2, 'start': 116, 'machine': 3, 'duration': 59}]}]",32,json,1
OSP,OSP,"Back when deadlines piled up, the team had to route manuscripts through editing, layout, and proofreading so each manuscript hit every station once — no skipping, no repeats — and the order could be different for each book. The choice was about which station each manuscript goes to first and when each step starts, with the constraint that a station only takes one manuscript at a time and a manuscript can’t be worked on in two places at once. A good arrangement is simply the one that gets the entire set done sooner; you figure that out by noting the time the last manuscript finishes, and smaller is better. The specific details are shown below.

{
  ""num_manuscripts"": 5,
  ""num_stations"": 3,
  ""manuscript_ids"": [
    ""J1"",
    ""J2"",
    ""J3"",
    ""J4"",
    ""J5""
  ],
  ""station_ids"": [
    1,
    2,
    3
  ],
  ""tasks"": [
    {
      ""manuscript_id"": ""J1"",
      ""manuscript_task_index"": 0,
      ""required_station_id"": 1,
      ""processing_duration"": 1
    },
    {
      ""manuscript_id"": ""J1"",
      ""manuscript_task_index"": 1,
      ""required_station_id"": 2,
      ""processing_duration"": 73
    },
    {
      ""manuscript_id"": ""J1"",
      ""manuscript_task_index"": 2,
      ""required_station_id"": 3,
      ""processing_duration"": 91
    },
    {
      ""manuscript_id"": ""J2"",
      ""manuscript_task_index"": 0,
      ""required_station_id"": 1,
      ""processing_duration"": 94
    },
    {
      ""manuscript_id"": ""J2"",
      ""manuscript_task_index"": 1,
      ""required_station_id"": 2,
      ""processing_duration"": 43
    },
    {
      ""manuscript_id"": ""J2"",
      ""manuscript_task_index"": 2,
      ""required_station_id"": 3,
      ""processing_duration"": 21
    },
    {
      ""manuscript_id"": ""J3"",
      ""manuscript_task_index"": 0,
      ""required_station_id"": 1,
      ""processing_duration"": 48
    },
    {
      ""manuscript_id"": ""J3"",
      ""manuscript_task_index"": 1,
      ""required_station_id"": 2,
      ""processing_duration"": 24
    },
    {
      ""manuscript_id"": ""J3"",
      ""manuscript_task_index"": 2,
      ""required_station_id"": 3,
      ""processing_duration"": 27
    },
    {
      ""manuscript_id"": ""J4"",
      ""manuscript_task_index"": 0,
      ""required_station_id"": 1,
      ""processing_duration"": 17
    },
    {
      ""manuscript_id"": ""J4"",
      ""manuscript_task_index"": 1,
      ""required_station_id"": 2,
      ""processing_duration"": 38
    },
    {
      ""manuscript_id"": ""J4"",
      ""manuscript_task_index"": 2,
      ""required_station_id"": 3,
      ""processing_duration"": 44
    },
    {
      ""manuscript_id"": ""J5"",
      ""manuscript_task_index"": 0,
      ""required_station_id"": 1,
      ""processing_duration"": 49
    },
    {
      ""manuscript_id"": ""J5"",
      ""manuscript_task_index"": 1,
      ""required_station_id"": 2,
      ""processing_duration"": 56
    },
    {
      ""manuscript_id"": ""J5"",
      ""manuscript_task_index"": 2,
      ""required_station_id"": 3,
      ""processing_duration"": 95
    }
  ]
}

And hey — when you send the schedule back, just follow a simple JSON shape so it's easy to read and check. Here's the little template I like to use for this manuscript-station story:

{
  ""solution"": [
    {
      ""job"": <manuscript_id>,
      ""tasks"": [
        {
          ""task"": <task_index>,
          ""start"": <start_time>,
          ""machine"": <station_id>,
          ""duration"": <duration>
        }
      ]
    }
  ]
}

This is just a sketch of the shape I expect: ""solution"" is the list of manuscripts, each ""job"" is the manuscript identifier, and ""tasks"" lists that manuscript’s steps. For each step, ""task"" is a local step index, ""start"" is when that step begins, ""machine"" is the station it visits, and ""duration"" is how long that station works on it. Keep it light — think of it like filling out a short form for each manuscript’s route through the stations.

One important note: use the exact identifiers given in the instance input — don’t rename 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”.","{'nr_machines': 3, 'nr_jobs': 5, 'jobs': [[[0, 1], [1, 73], [2, 91]], [[0, 94], [1, 43], [2, 21]], [[0, 48], [1, 24], [2, 27]], [[0, 17], [1, 38], [2, 44]], [[0, 49], [1, 56], [2, 95]]]}","[{'job': 0, 'tasks': [{'task': 0, 'start': 216, 'machine': 0, 'duration': 1}, {'task': 1, 'start': 0, 'machine': 1, 'duration': 73}, {'task': 2, 'start': 95, 'machine': 2, 'duration': 91}]}, {'job': 1, 'tasks': [{'task': 0, 'start': 0, 'machine': 0, 'duration': 94}, {'task': 1, 'start': 167, 'machine': 1, 'duration': 43}, {'task': 2, 'start': 230, 'machine': 2, 'duration': 21}]}, {'job': 2, 'tasks': [{'task': 0, 'start': 94, 'machine': 0, 'duration': 48}, {'task': 1, 'start': 210, 'machine': 1, 'duration': 24}, {'task': 2, 'start': 251, 'machine': 2, 'duration': 27}]}, {'job': 3, 'tasks': [{'task': 0, 'start': 142, 'machine': 0, 'duration': 17}, {'task': 1, 'start': 73, 'machine': 1, 'duration': 38}, {'task': 2, 'start': 186, 'machine': 2, 'duration': 44}]}, {'job': 4, 'tasks': [{'task': 0, 'start': 167, 'machine': 0, 'duration': 49}, {'task': 1, 'start': 111, 'machine': 1, 'duration': 56}, {'task': 2, 'start': 0, 'machine': 2, 'duration': 95}]}]",278.0,"{'problem_type': 'OSP', 'nr_jobs': 5, 'nr_machines': 3, 'jobs': ['J1', 'J2', 'J3', 'J4', 'J5'], 'machines': [1, 2, 3], 'records': [{'job_id': 'J1', 'task_id': 0, 'machine_id': 1, 'duration': 1}, {'job_id': 'J1', 'task_id': 1, 'machine_id': 2, 'duration': 73}, {'job_id': 'J1', 'task_id': 2, 'machine_id': 3, 'duration': 91}, {'job_id': 'J2', 'task_id': 0, 'machine_id': 1, 'duration': 94}, {'job_id': 'J2', 'task_id': 1, 'machine_id': 2, 'duration': 43}, {'job_id': 'J2', 'task_id': 2, 'machine_id': 3, 'duration': 21}, {'job_id': 'J3', 'task_id': 0, 'machine_id': 1, 'duration': 48}, {'job_id': 'J3', 'task_id': 1, 'machine_id': 2, 'duration': 24}, {'job_id': 'J3', 'task_id': 2, 'machine_id': 3, 'duration': 27}, {'job_id': 'J4', 'task_id': 0, 'machine_id': 1, 'duration': 17}, {'job_id': 'J4', 'task_id': 1, 'machine_id': 2, 'duration': 38}, {'job_id': 'J4', 'task_id': 2, 'machine_id': 3, 'duration': 44}, {'job_id': 'J5', 'task_id': 0, 'machine_id': 1, 'duration': 49}, {'job_id': 'J5', 'task_id': 1, 'machine_id': 2, 'duration': 56}, {'job_id': 'J5', 'task_id': 2, 'machine_id': 3, 'duration': 95}]}","[{'job': 'J1', 'tasks': [{'task': 0, 'start': 216, 'machine': 1, 'duration': 1}, {'task': 1, 'start': 0, 'machine': 2, 'duration': 73}, {'task': 2, 'start': 95, 'machine': 3, 'duration': 91}]}, {'job': 'J2', 'tasks': [{'task': 0, 'start': 0, 'machine': 1, 'duration': 94}, {'task': 1, 'start': 167, 'machine': 2, 'duration': 43}, {'task': 2, 'start': 230, 'machine': 3, 'duration': 21}]}, {'job': 'J3', 'tasks': [{'task': 0, 'start': 94, 'machine': 1, 'duration': 48}, {'task': 1, 'start': 210, 'machine': 2, 'duration': 24}, {'task': 2, 'start': 251, 'machine': 3, 'duration': 27}]}, {'job': 'J4', 'tasks': [{'task': 0, 'start': 142, 'machine': 1, 'duration': 17}, {'task': 1, 'start': 73, 'machine': 2, 'duration': 38}, {'task': 2, 'start': 186, 'machine': 3, 'duration': 44}]}, {'job': 'J5', 'tasks': [{'task': 0, 'start': 167, 'machine': 1, 'duration': 49}, {'task': 1, 'start': 111, 'machine': 2, 'duration': 56}, {'task': 2, 'start': 0, 'machine': 3, 'duration': 95}]}]",33,json,1
OSP,OSP,"Picture this: a stack of files must pass through different review booths, each file needing a single check from each assigned booth, and there’s no fixed route so the route and timing are up to planning. The planner decides the order of visits and when each review starts, with the simple ground rules that a booth can only serve one file at a time and a file can’t be in two booths at once. A plan is better if it gets the entire stack cleared sooner — just look at the time the last file finishes to see which plan wins. The exact items and booths are shown below.

# total_cases=3
# total_panels=3
# case_ids=J1, J2, J3
# panel_ids=0, 1, 2
case_id,review_task_index,panel_id,review_duration
J1,0,0,1
J1,1,1,86
J1,2,2,67
J2,0,0,40
J2,1,1,95
J2,2,2,42
J3,0,0,53
J3,1,1,91
J3,2,2,94

Also, if you want to hand me a plan, the easiest way is to follow a little JSON sketch so everything’s consistent — nothing fancy, just a small object that lists each job and the tasks (when they start, which booth handles them, and how long they take). Here’s the shape I expect:

{
  ""solution"": [
    {
      ""job"": <file_id>,
      ""tasks"": [
        {
          ""task"": <review_index>,
          ""start"": <start_time>,
          ""machine"": <booth_id>,
          ""duration"": <duration>
        }
      ]
    }
  ]
}

Think of that like a simple form: each entry in ""solution"" is one file (the ""job"" field is its id), ""tasks"" is the list of checks that file needs, and each check has a small record for which check it is (""task""), when it starts (""start""), which booth handles it (""machine""), and how long it runs (""duration""). Super casual — just a template so we both know what to expect.

This is only a sketch of the expected shape, not the actual schedule — fill it in with the real ids and numbers from the instance.

Please make 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"".","{'nr_machines': 3, 'nr_jobs': 3, 'jobs': [[[0, 1], [1, 86], [2, 67]], [[0, 40], [1, 95], [2, 42]], [[0, 53], [1, 91], [2, 94]]]}","[{'job': 0, 'tasks': [{'task': 0, 'start': 0, 'machine': 0, 'duration': 1}, {'task': 1, 'start': 186, 'machine': 1, 'duration': 86}, {'task': 2, 'start': 94, 'machine': 2, 'duration': 67}]}, {'job': 1, 'tasks': [{'task': 0, 'start': 95, 'machine': 0, 'duration': 40}, {'task': 1, 'start': 0, 'machine': 1, 'duration': 95}, {'task': 2, 'start': 161, 'machine': 2, 'duration': 42}]}, {'job': 2, 'tasks': [{'task': 0, 'start': 186, 'machine': 0, 'duration': 53}, {'task': 1, 'start': 95, 'machine': 1, 'duration': 91}, {'task': 2, 'start': 0, 'machine': 2, 'duration': 94}]}]",272.0,"{'problem_type': 'OSP', 'nr_jobs': 3, 'nr_machines': 3, 'jobs': ['J1', 'J2', 'J3'], 'machines': [0, 1, 2], 'records': [{'job_id': 'J1', 'task_id': 0, 'machine_id': 0, 'duration': 1}, {'job_id': 'J1', 'task_id': 1, 'machine_id': 1, 'duration': 86}, {'job_id': 'J1', 'task_id': 2, 'machine_id': 2, 'duration': 67}, {'job_id': 'J2', 'task_id': 0, 'machine_id': 0, 'duration': 40}, {'job_id': 'J2', 'task_id': 1, 'machine_id': 1, 'duration': 95}, {'job_id': 'J2', 'task_id': 2, 'machine_id': 2, 'duration': 42}, {'job_id': 'J3', 'task_id': 0, 'machine_id': 0, 'duration': 53}, {'job_id': 'J3', 'task_id': 1, 'machine_id': 1, 'duration': 91}, {'job_id': 'J3', 'task_id': 2, 'machine_id': 2, 'duration': 94}]}","[{'job': 'J1', 'tasks': [{'task': 0, 'start': 0, 'machine': 0, 'duration': 1}, {'task': 1, 'start': 186, 'machine': 1, 'duration': 86}, {'task': 2, 'start': 94, 'machine': 2, 'duration': 67}]}, {'job': 'J2', 'tasks': [{'task': 0, 'start': 95, 'machine': 0, 'duration': 40}, {'task': 1, 'start': 0, 'machine': 1, 'duration': 95}, {'task': 2, 'start': 161, 'machine': 2, 'duration': 42}]}, {'job': 'J3', 'tasks': [{'task': 0, 'start': 186, 'machine': 0, 'duration': 53}, {'task': 1, 'start': 95, 'machine': 1, 'duration': 91}, {'task': 2, 'start': 0, 'machine': 2, 'duration': 94}]}]",34,csv,0
OSP,OSP,"Many bakers face a juggling problem: choose when and in what order each loaf uses the mixer, the proofer, and the oven so each loaf visits each piece once, but with no fixed step order. Machines only do one loaf at a time, and a loaf can’t be doing two steps simultaneously. The win here is getting the final loaf out sooner than any other plan — check each plan by the time the last loaf completes its final step. The concrete timing and loaf details appear below.

{
  ""nr_loaves"": 2,
  ""nr_equipment_pieces"": 2,
  ""loaf_ids"": [
    ""J1"",
    ""J2""
  ],
  ""equipment_ids"": [
    ""A"",
    ""B""
  ],
  ""tasks"": [
    {
      ""loaf_id"": ""J1"",
      ""step_index"": 0,
      ""equipment_id"": ""A"",
      ""process_duration"": 1
    },
    {
      ""loaf_id"": ""J1"",
      ""step_index"": 1,
      ""equipment_id"": ""B"",
      ""process_duration"": 99
    },
    {
      ""loaf_id"": ""J2"",
      ""step_index"": 0,
      ""equipment_id"": ""A"",
      ""process_duration"": 43
    },
    {
      ""loaf_id"": ""J2"",
      ""step_index"": 1,
      ""equipment_id"": ""B"",
      ""process_duration"": 85
    }
  ]
}

If you want to hand me a plan, a nice compact JSON sketch is perfect — something that follows this shape so it's easy to read and check.

{
  ""solution"": [
    {
      ""job"": <loaf_id>,
      ""tasks"": [
        {
          ""task"": <step_index>,
          ""start"": <start_time>,
          ""machine"": <station_id>,
          ""duration"": <duration>
        }
      ]
    }
  ]
}

This little form just says: each entry in ""solution"" is one loaf (job), with a list of its steps (""tasks""). For each step you give a task index, the start time, which station/machine it uses, and how long that step takes. Think of it like filling out a schedule card for each loaf — nothing fussy.

This is just the expected shape, not the actual schedule — fill in the real identifiers and times when you submit your plan. Please make sure you 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”.","{'nr_machines': 2, 'nr_jobs': 2, 'jobs': [[[0, 1], [1, 99]], [[0, 43], [1, 85]]]}","[{'job': 0, 'tasks': [{'task': 0, 'start': 99, 'machine': 0, 'duration': 1}, {'task': 1, 'start': 0, 'machine': 1, 'duration': 99}]}, {'job': 1, 'tasks': [{'task': 0, 'start': 0, 'machine': 0, 'duration': 43}, {'task': 1, 'start': 99, 'machine': 1, 'duration': 85}]}]",184.0,"{'problem_type': 'OSP', 'nr_jobs': 2, 'nr_machines': 2, 'jobs': ['J1', 'J2'], 'machines': ['A', 'B'], 'records': [{'job_id': 'J1', 'task_id': 0, 'machine_id': 'A', 'duration': 1}, {'job_id': 'J1', 'task_id': 1, 'machine_id': 'B', 'duration': 99}, {'job_id': 'J2', 'task_id': 0, 'machine_id': 'A', 'duration': 43}, {'job_id': 'J2', 'task_id': 1, 'machine_id': 'B', 'duration': 85}]}","[{'job': 'J1', 'tasks': [{'task': 0, 'start': 99, 'machine': 'A', 'duration': 1}, {'task': 1, 'start': 0, 'machine': 'B', 'duration': 99}]}, {'job': 'J2', 'tasks': [{'task': 0, 'start': 0, 'machine': 'A', 'duration': 43}, {'task': 1, 'start': 99, 'machine': 'B', 'duration': 85}]}]",35,json,names
OSP,OSP,"There’s a small workshop juggling a batch of canvases that all need framing, a coat of varnish, and a quick inspection — every canvas needs all three, but none of them have to follow the same order. The trick is to map out for each canvas which station it goes to when, making sure each station only handles one canvas at a time and no canvas is in two places simultaneously. Nothing can be skipped or repeated, and success is judged by the time the last canvas is finished — the earlier that finishing moment, the better the plan. The exact work list and station info are shown below.

{
  ""nr_artworks"": 2,
  ""nr_stations"": 3,
  ""artwork_ids"": [
    ""J1"",
    ""J2""
  ],
  ""station_ids"": [
    ""A"",
    ""B"",
    ""C""
  ],
  ""tasks"": [
    {
      ""artwork_id"": ""J1"",
      ""service_index"": 0,
      ""station_id"": ""A"",
      ""processing_time"": 1
    },
    {
      ""artwork_id"": ""J1"",
      ""service_index"": 1,
      ""station_id"": ""B"",
      ""processing_time"": 13
    },
    {
      ""artwork_id"": ""J1"",
      ""service_index"": 2,
      ""station_id"": ""C"",
      ""processing_time"": 18
    },
    {
      ""artwork_id"": ""J2"",
      ""service_index"": 0,
      ""station_id"": ""A"",
      ""processing_time"": 32
    },
    {
      ""artwork_id"": ""J2"",
      ""service_index"": 1,
      ""station_id"": ""B"",
      ""processing_time"": 3
    },
    {
      ""artwork_id"": ""J2"",
      ""service_index"": 2,
      ""station_id"": ""C"",
      ""processing_time"": 86
    }
  ]
}

Also, when you hand me the plan, keep it in a simple JSON shape — nothing fancy — just like this:

{
  ""solution"": [
    {
      ""job"": <canvas_id>,
      ""tasks"": [
        {
          ""task"": <canvas_task_index>,
          ""start"": <start_time>,
          ""machine"": <station_id>,
          ""duration"": <duration>
        }
      ]
    }
  ]
}

This little sketch maps directly onto the workshop story: each top-level object in ""solution"" is one canvas (""job""), its ""tasks"" list the steps that canvas will go through, ""start"" is when a step begins, ""machine"" is the station handling that step, and ""duration"" is how long it takes. Think of it as a simple form to fill out — the layout matters more than the placeholders here.

This JSON is only the expected shape, not the actual 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”.""","{'nr_machines': 3, 'nr_jobs': 2, 'jobs': [[[0, 1], [1, 13], [2, 18]], [[0, 32], [1, 3], [2, 86]]]}","[{'job': 0, 'tasks': [{'task': 0, 'start': 13, 'machine': 0, 'duration': 1}, {'task': 1, 'start': 0, 'machine': 1, 'duration': 13}, {'task': 2, 'start': 86, 'machine': 2, 'duration': 18}]}, {'job': 1, 'tasks': [{'task': 0, 'start': 86, 'machine': 0, 'duration': 32}, {'task': 1, 'start': 118, 'machine': 1, 'duration': 3}, {'task': 2, 'start': 0, 'machine': 2, 'duration': 86}]}]",121.0,"{'problem_type': 'OSP', 'nr_jobs': 2, 'nr_machines': 3, 'jobs': ['J1', 'J2'], 'machines': ['A', 'B', 'C'], 'records': [{'job_id': 'J1', 'task_id': 0, 'machine_id': 'A', 'duration': 1}, {'job_id': 'J1', 'task_id': 1, 'machine_id': 'B', 'duration': 13}, {'job_id': 'J1', 'task_id': 2, 'machine_id': 'C', 'duration': 18}, {'job_id': 'J2', 'task_id': 0, 'machine_id': 'A', 'duration': 32}, {'job_id': 'J2', 'task_id': 1, 'machine_id': 'B', 'duration': 3}, {'job_id': 'J2', 'task_id': 2, 'machine_id': 'C', 'duration': 86}]}","[{'job': 'J1', 'tasks': [{'task': 0, 'start': 13, 'machine': 'A', 'duration': 1}, {'task': 1, 'start': 0, 'machine': 'B', 'duration': 13}, {'task': 2, 'start': 86, 'machine': 'C', 'duration': 18}]}, {'job': 'J2', 'tasks': [{'task': 0, 'start': 86, 'machine': 'A', 'duration': 32}, {'task': 1, 'start': 118, 'machine': 'B', 'duration': 3}, {'task': 2, 'start': 0, 'machine': 'C', 'duration': 86}]}]",36,json,names
OSP,OSP,"Picture this: a stack of patient samples and a handful of instruments, each sample needing to visit each instrument once but with no fixed sequence. The planner must set the order and timing for each test so every device handles only one sample at a time and no sample is in two tests simultaneously. A good plan simply leaves the lab with everything completed sooner — check the completion time for every sample, pick the largest of those times, and the smaller that largest time is, the better the plan. The detailed instance information is shown below.

{
  ""nr_samples"": 5,
  ""nr_devices"": 3,
  ""sample_ids"": [
    ""J1"",
    ""J2"",
    ""J3"",
    ""J4"",
    ""J5""
  ],
  ""device_ids"": [
    0,
    1,
    2
  ],
  ""tasks"": [
    {
      ""sample_id"": ""J1"",
      ""test_index"": 0,
      ""device_id"": 0,
      ""processing_time"": 1
    },
    {
      ""sample_id"": ""J1"",
      ""test_index"": 1,
      ""device_id"": 1,
      ""processing_time"": 26
    },
    {
      ""sample_id"": ""J1"",
      ""test_index"": 2,
      ""device_id"": 2,
      ""processing_time"": 93
    },
    {
      ""sample_id"": ""J2"",
      ""test_index"": 0,
      ""device_id"": 0,
      ""processing_time"": 77
    },
    {
      ""sample_id"": ""J2"",
      ""test_index"": 1,
      ""device_id"": 1,
      ""processing_time"": 56
    },
    {
      ""sample_id"": ""J2"",
      ""test_index"": 2,
      ""device_id"": 2,
      ""processing_time"": 8
    },
    {
      ""sample_id"": ""J3"",
      ""test_index"": 0,
      ""device_id"": 0,
      ""processing_time"": 67
    },
    {
      ""sample_id"": ""J3"",
      ""test_index"": 1,
      ""device_id"": 1,
      ""processing_time"": 95
    },
    {
      ""sample_id"": ""J3"",
      ""test_index"": 2,
      ""device_id"": 2,
      ""processing_time"": 98
    },
    {
      ""sample_id"": ""J4"",
      ""test_index"": 0,
      ""device_id"": 0,
      ""processing_time"": 90
    },
    {
      ""sample_id"": ""J4"",
      ""test_index"": 1,
      ""device_id"": 1,
      ""processing_time"": 91
    },
    {
      ""sample_id"": ""J4"",
      ""test_index"": 2,
      ""device_id"": 2,
      ""processing_time"": 51
    },
    {
      ""sample_id"": ""J5"",
      ""test_index"": 0,
      ""device_id"": 0,
      ""processing_time"": 81
    },
    {
      ""sample_id"": ""J5"",
      ""test_index"": 1,
      ""device_id"": 1,
      ""processing_time"": 69
    },
    {
      ""sample_id"": ""J5"",
      ""test_index"": 2,
      ""device_id"": 2,
      ""processing_time"": 17
    }
  ]
}

If you want to hand me the plan in a simple format, here’s the layout I expect — just a tiny JSON sketch:

{
  ""solution"": [
    {
      ""job"": <sample_id>,
      ""tasks"": [
        {
          ""task"": <task_index>,
          ""start"": <start_time>,
          ""machine"": <instrument_id>,
          ""duration"": <duration>
        }
      ]
    }
  ]
}

Think of it like a little form: ""solution"" is the list of jobs (each job is one sample), ""job"" is that sample’s id, and ""tasks"" is the list of tests for that sample. Each task entry says which task it is, when it starts, which instrument (machine) it uses, and how long it takes. It’s just a sketch of the shape I want — not the real answer.

Quick reminder: when you fill this in, 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”.""","{'nr_machines': 3, 'nr_jobs': 5, 'jobs': [[[0, 1], [1, 26], [2, 93]], [[0, 77], [1, 56], [2, 8]], [[0, 67], [1, 95], [2, 98]], [[0, 90], [1, 91], [2, 51]], [[0, 81], [1, 69], [2, 17]]]}","[{'job': 0, 'tasks': [{'task': 0, 'start': 248, 'machine': 0, 'duration': 1}, {'task': 1, 'start': 311, 'machine': 1, 'duration': 26}, {'task': 2, 'start': 98, 'machine': 2, 'duration': 93}]}, {'job': 1, 'tasks': [{'task': 0, 'start': 81, 'machine': 0, 'duration': 77}, {'task': 1, 'start': 255, 'machine': 1, 'duration': 56}, {'task': 2, 'start': 208, 'machine': 2, 'duration': 8}]}, {'job': 2, 'tasks': [{'task': 0, 'start': 255, 'machine': 0, 'duration': 67}, {'task': 1, 'start': 160, 'machine': 1, 'duration': 95}, {'task': 2, 'start': 0, 'machine': 2, 'duration': 98}]}, {'job': 3, 'tasks': [{'task': 0, 'start': 158, 'machine': 0, 'duration': 90}, {'task': 1, 'start': 0, 'machine': 1, 'duration': 91}, {'task': 2, 'start': 248, 'machine': 2, 'duration': 51}]}, {'job': 4, 'tasks': [{'task': 0, 'start': 0, 'machine': 0, 'duration': 81}, {'task': 1, 'start': 91, 'machine': 1, 'duration': 69}, {'task': 2, 'start': 191, 'machine': 2, 'duration': 17}]}]",337.0,"{'problem_type': 'OSP', 'nr_jobs': 5, 'nr_machines': 3, 'jobs': ['J1', 'J2', 'J3', 'J4', 'J5'], 'machines': [0, 1, 2], 'records': [{'job_id': 'J1', 'task_id': 0, 'machine_id': 0, 'duration': 1}, {'job_id': 'J1', 'task_id': 1, 'machine_id': 1, 'duration': 26}, {'job_id': 'J1', 'task_id': 2, 'machine_id': 2, 'duration': 93}, {'job_id': 'J2', 'task_id': 0, 'machine_id': 0, 'duration': 77}, {'job_id': 'J2', 'task_id': 1, 'machine_id': 1, 'duration': 56}, {'job_id': 'J2', 'task_id': 2, 'machine_id': 2, 'duration': 8}, {'job_id': 'J3', 'task_id': 0, 'machine_id': 0, 'duration': 67}, {'job_id': 'J3', 'task_id': 1, 'machine_id': 1, 'duration': 95}, {'job_id': 'J3', 'task_id': 2, 'machine_id': 2, 'duration': 98}, {'job_id': 'J4', 'task_id': 0, 'machine_id': 0, 'duration': 90}, {'job_id': 'J4', 'task_id': 1, 'machine_id': 1, 'duration': 91}, {'job_id': 'J4', 'task_id': 2, 'machine_id': 2, 'duration': 51}, {'job_id': 'J5', 'task_id': 0, 'machine_id': 0, 'duration': 81}, {'job_id': 'J5', 'task_id': 1, 'machine_id': 1, 'duration': 69}, {'job_id': 'J5', 'task_id': 2, 'machine_id': 2, 'duration': 17}]}","[{'job': 'J1', 'tasks': [{'task': 0, 'start': 248, 'machine': 0, 'duration': 1}, {'task': 1, 'start': 311, 'machine': 1, 'duration': 26}, {'task': 2, 'start': 98, 'machine': 2, 'duration': 93}]}, {'job': 'J2', 'tasks': [{'task': 0, 'start': 81, 'machine': 0, 'duration': 77}, {'task': 1, 'start': 255, 'machine': 1, 'duration': 56}, {'task': 2, 'start': 208, 'machine': 2, 'duration': 8}]}, {'job': 'J3', 'tasks': [{'task': 0, 'start': 255, 'machine': 0, 'duration': 67}, {'task': 1, 'start': 160, 'machine': 1, 'duration': 95}, {'task': 2, 'start': 0, 'machine': 2, 'duration': 98}]}, {'job': 'J4', 'tasks': [{'task': 0, 'start': 158, 'machine': 0, 'duration': 90}, {'task': 1, 'start': 0, 'machine': 1, 'duration': 91}, {'task': 2, 'start': 248, 'machine': 2, 'duration': 51}]}, {'job': 'J5', 'tasks': [{'task': 0, 'start': 0, 'machine': 0, 'duration': 81}, {'task': 1, 'start': 91, 'machine': 1, 'duration': 69}, {'task': 2, 'start': 191, 'machine': 2, 'duration': 17}]}]",37,json,0
OSP,OSP,"There’s a busy service floor where every piece of equipment has to see several different shops, but nobody told the pieces which shop to visit first. Someone needs to arrange the sequence of stops for each piece and the start times for those stops, while ensuring each shop handles only one piece at a time and each piece gets serviced at every required shop exactly once, never being serviced in two shops at the same time. The better the arrangement, the earlier the whole crew is done — the finish time is simply the time when the last service completes. The exact shop assignments and durations follow below.

They are listed here for 2 pieces and 2 shops: piece ids J1, J2, shop ids 0, 1.
Piece J1, service 0 must visit shop 0 and requires 1.
Piece J1, service 1 must visit shop 1 and requires 39.
Piece J2, service 0 must visit shop 0 and requires 69.
Piece J2, service 1 must visit shop 1 and requires 24.
Someone should arrange sequences and start times so every required service is scheduled once and the crew finishes as early as possible.

If you want to hand me the plan, just stick to this little JSON shape so I know what goes where — nothing fancy, just the same fields filled in:

{
  ""solution"": [
    {
      ""job"": <piece_id>,
      ""tasks"": [
        {
          ""task"": <stop_index>,
          ""start"": <start_time>,
          ""machine"": <shop_id>,
          ""duration"": <duration>
        }
      ]
    }
  ]
}

Think of it like a simple form: each ""job"" is a piece that needs service, ""tasks"" is the list of stops for that piece, and each task entry tells you which stop number it is (""task""), when that stop begins (""start""), which shop handles it (""machine""), and how long it takes (""duration""). This JSON is just a sketch of the shape I expect — not the actual schedule.

Please remember: 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”.","{'nr_machines': 2, 'nr_jobs': 2, 'jobs': [[[0, 1], [1, 39]], [[0, 69], [1, 24]]]}","[{'job': 0, 'tasks': [{'task': 0, 'start': 69, 'machine': 0, 'duration': 1}, {'task': 1, 'start': 0, 'machine': 1, 'duration': 39}]}, {'job': 1, 'tasks': [{'task': 0, 'start': 0, 'machine': 0, 'duration': 69}, {'task': 1, 'start': 69, 'machine': 1, 'duration': 24}]}]",93.0,"{'problem_type': 'OSP', 'nr_jobs': 2, 'nr_machines': 2, 'jobs': ['J1', 'J2'], 'machines': [0, 1], 'records': [{'job_id': 'J1', 'task_id': 0, 'machine_id': 0, 'duration': 1}, {'job_id': 'J1', 'task_id': 1, 'machine_id': 1, 'duration': 39}, {'job_id': 'J2', 'task_id': 0, 'machine_id': 0, 'duration': 69}, {'job_id': 'J2', 'task_id': 1, 'machine_id': 1, 'duration': 24}]}","[{'job': 'J1', 'tasks': [{'task': 0, 'start': 69, 'machine': 0, 'duration': 1}, {'task': 1, 'start': 0, 'machine': 1, 'duration': 39}]}, {'job': 'J2', 'tasks': [{'task': 0, 'start': 0, 'machine': 0, 'duration': 69}, {'task': 1, 'start': 69, 'machine': 1, 'duration': 24}]}]",38,nl,0
OSP,OSP,"Picture this: a bench of edit, color, and sound stations and a pile of clips that each need all three services, but there’s no rule about which comes first for any given clip. The job is to schedule when each clip goes to each station and in what order, making sure every clip gets edited, graded, and mixed exactly once, stations aren’t double-booked, and no clip is worked on in two places at the same time. The quality of a schedule is judged by when the very last clip is done — look at every clip’s completion time and take the latest one; the goal is to make that time as early as possible. The concrete details are shown below.

{
  ""nr_clips"": 4,
  ""nr_stations"": 2,
  ""clip_ids"": [
    ""J1"",
    ""J2"",
    ""J3"",
    ""J4""
  ],
  ""station_ids"": [
    0,
    1
  ],
  ""tasks"": [
    {
      ""clip_id"": ""J1"",
      ""service_step"": 0,
      ""station_id"": 0,
      ""processing_time"": 1
    },
    {
      ""clip_id"": ""J1"",
      ""service_step"": 1,
      ""station_id"": 1,
      ""processing_time"": 52
    },
    {
      ""clip_id"": ""J2"",
      ""service_step"": 0,
      ""station_id"": 0,
      ""processing_time"": 45
    },
    {
      ""clip_id"": ""J2"",
      ""service_step"": 1,
      ""station_id"": 1,
      ""processing_time"": 69
    },
    {
      ""clip_id"": ""J3"",
      ""service_step"": 0,
      ""station_id"": 0,
      ""processing_time"": 62
    },
    {
      ""clip_id"": ""J3"",
      ""service_step"": 1,
      ""station_id"": 1,
      ""processing_time"": 52
    },
    {
      ""clip_id"": ""J4"",
      ""service_step"": 0,
      ""station_id"": 0,
      ""processing_time"": 76
    },
    {
      ""clip_id"": ""J4"",
      ""service_step"": 1,
      ""station_id"": 1,
      ""processing_time"": 31
    }
  ]
}

Oh, and to make things easy to consume, here's the simple JSON shape I'd like the schedule in:

{
  ""solution"": [
    {
      ""job"": <job_id>,
      ""tasks"": [
        {
          ""task"": <task_index>,
          ""start"": <start_time>,
          ""machine"": <machine_id>,
          ""duration"": <duration>
        }
      ]
    }
  ]
}

This is just a sketch of the shape I expect: ""solution"" is a list of jobs; each job entry gives the job identifier and a list of its tasks; each task shows which task it is (an index), when it starts, which machine/station it runs on, and how long it takes. Think of ""start"" as the minute a clip arrives at a station, ""machine"" as the station name, and ""duration"" as how long the work takes.

This JSON is only the expected shape — not the final schedule itself.

Please make sure to 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”.""","{'nr_machines': 2, 'nr_jobs': 4, 'jobs': [[[0, 1], [1, 52]], [[0, 45], [1, 69]], [[0, 62], [1, 52]], [[0, 76], [1, 31]]]}","[{'job': 0, 'tasks': [{'task': 0, 'start': 183, 'machine': 0, 'duration': 1}, {'task': 1, 'start': 121, 'machine': 1, 'duration': 52}]}, {'job': 1, 'tasks': [{'task': 0, 'start': 76, 'machine': 0, 'duration': 45}, {'task': 1, 'start': 0, 'machine': 1, 'duration': 69}]}, {'job': 2, 'tasks': [{'task': 0, 'start': 121, 'machine': 0, 'duration': 62}, {'task': 1, 'start': 69, 'machine': 1, 'duration': 52}]}, {'job': 3, 'tasks': [{'task': 0, 'start': 0, 'machine': 0, 'duration': 76}, {'task': 1, 'start': 173, 'machine': 1, 'duration': 31}]}]",204.0,"{'problem_type': 'OSP', 'nr_jobs': 4, 'nr_machines': 2, 'jobs': ['J1', 'J2', 'J3', 'J4'], 'machines': [0, 1], 'records': [{'job_id': 'J1', 'task_id': 0, 'machine_id': 0, 'duration': 1}, {'job_id': 'J1', 'task_id': 1, 'machine_id': 1, 'duration': 52}, {'job_id': 'J2', 'task_id': 0, 'machine_id': 0, 'duration': 45}, {'job_id': 'J2', 'task_id': 1, 'machine_id': 1, 'duration': 69}, {'job_id': 'J3', 'task_id': 0, 'machine_id': 0, 'duration': 62}, {'job_id': 'J3', 'task_id': 1, 'machine_id': 1, 'duration': 52}, {'job_id': 'J4', 'task_id': 0, 'machine_id': 0, 'duration': 76}, {'job_id': 'J4', 'task_id': 1, 'machine_id': 1, 'duration': 31}]}","[{'job': 'J1', 'tasks': [{'task': 0, 'start': 183, 'machine': 0, 'duration': 1}, {'task': 1, 'start': 121, 'machine': 1, 'duration': 52}]}, {'job': 'J2', 'tasks': [{'task': 0, 'start': 76, 'machine': 0, 'duration': 45}, {'task': 1, 'start': 0, 'machine': 1, 'duration': 69}]}, {'job': 'J3', 'tasks': [{'task': 0, 'start': 121, 'machine': 0, 'duration': 62}, {'task': 1, 'start': 69, 'machine': 1, 'duration': 52}]}, {'job': 'J4', 'tasks': [{'task': 0, 'start': 0, 'machine': 0, 'duration': 76}, {'task': 1, 'start': 173, 'machine': 1, 'duration': 31}]}]",39,json,0
OSP,OSP,"On the assembly line a batch of boards needs soldering, inspection, and testing, and each board has to go to each station once but in any order. The job is to pick both the order for each board and the exact start time for each of its operations so the benches don’t clash. Better choices are the ones that bring the moment when the very last board finishes earlier — the time when the final board completes its last step is the single measure to beat. The basic rules: every board must visit each bench exactly once, each bench works on only one board at a time, and a board can’t be in two places at once. The concrete processing details are shown below.

There are 5 boards and 3 benches, with board IDs J1, J2, J3, J4, J5 and bench IDs 1, 2, 3.
Board J1, operation 0: requires bench 1 for 1 time units.
Board J1, operation 1: requires bench 2 for 65 time units.
Board J1, operation 2: requires bench 3 for 21 time units.
Board J2, operation 0: requires bench 1 for 15 time units.
Board J2, operation 1: requires bench 2 for 16 time units.
Board J2, operation 2: requires bench 3 for 73 time units.
Board J3, operation 0: requires bench 1 for 81 time units.
Board J3, operation 1: requires bench 2 for 98 time units.
Board J3, operation 2: requires bench 3 for 3 time units.
Board J4, operation 0: requires bench 1 for 71 time units.
Board J4, operation 1: requires bench 2 for 7 time units.
Board J4, operation 2: requires bench 3 for 8 time units.
Board J5, operation 0: requires bench 1 for 31 time units.
Board J5, operation 1: requires bench 2 for 80 time units.
Board J5, operation 2: requires bench 3 for 33 time units.
Schedule start times and visit orders to minimize the completion time for these 5 boards on the 3 benches.

If you want to hand me a proposed plan, a simple JSON shape like this is easiest — just fill in the placeholders with the actual identifiers and numbers from the instance.

{
  ""solution"": [
    {
      ""job"": <board_id>,
      ""tasks"": [
        {
          ""task"": <operation_index>,
          ""start"": <start_time>,
          ""machine"": <bench_id>,
          ""duration"": <duration>
        }
      ]
    }
  ]
}

This little sketch says: for each board (job) list the operations (tasks) with when they start, which bench (machine) they use, and how long they take. I renamed the identifier-style placeholders to match the board/bench story (for example <board_id> and <bench_id>), but left time and duration placeholders unchanged. It's just the shape I expect — not the actual answer.

Please use the exact identifiers from the problem input with no renaming and no extra labels — they must 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”.""","{'nr_machines': 3, 'nr_jobs': 5, 'jobs': [[[0, 1], [1, 65], [2, 21]], [[0, 15], [1, 16], [2, 73]], [[0, 81], [1, 98], [2, 3]], [[0, 71], [1, 7], [2, 8]], [[0, 31], [1, 80], [2, 33]]]}","[{'job': 0, 'tasks': [{'task': 0, 'start': 198, 'machine': 0, 'duration': 1}, {'task': 1, 'start': 98, 'machine': 1, 'duration': 65}, {'task': 2, 'start': 73, 'machine': 2, 'duration': 21}]}, {'job': 1, 'tasks': [{'task': 0, 'start': 183, 'machine': 0, 'duration': 15}, {'task': 1, 'start': 243, 'machine': 1, 'duration': 16}, {'task': 2, 'start': 0, 'machine': 2, 'duration': 73}]}, {'job': 2, 'tasks': [{'task': 0, 'start': 102, 'machine': 0, 'duration': 81}, {'task': 1, 'start': 0, 'machine': 1, 'duration': 98}, {'task': 2, 'start': 183, 'machine': 2, 'duration': 3}]}, {'job': 3, 'tasks': [{'task': 0, 'start': 0, 'machine': 0, 'duration': 71}, {'task': 1, 'start': 259, 'machine': 1, 'duration': 7}, {'task': 2, 'start': 94, 'machine': 2, 'duration': 8}]}, {'job': 4, 'tasks': [{'task': 0, 'start': 71, 'machine': 0, 'duration': 31}, {'task': 1, 'start': 163, 'machine': 1, 'duration': 80}, {'task': 2, 'start': 102, 'machine': 2, 'duration': 33}]}]",266.0,"{'problem_type': 'OSP', 'nr_jobs': 5, 'nr_machines': 3, 'jobs': ['J1', 'J2', 'J3', 'J4', 'J5'], 'machines': [1, 2, 3], 'records': [{'job_id': 'J1', 'task_id': 0, 'machine_id': 1, 'duration': 1}, {'job_id': 'J1', 'task_id': 1, 'machine_id': 2, 'duration': 65}, {'job_id': 'J1', 'task_id': 2, 'machine_id': 3, 'duration': 21}, {'job_id': 'J2', 'task_id': 0, 'machine_id': 1, 'duration': 15}, {'job_id': 'J2', 'task_id': 1, 'machine_id': 2, 'duration': 16}, {'job_id': 'J2', 'task_id': 2, 'machine_id': 3, 'duration': 73}, {'job_id': 'J3', 'task_id': 0, 'machine_id': 1, 'duration': 81}, {'job_id': 'J3', 'task_id': 1, 'machine_id': 2, 'duration': 98}, {'job_id': 'J3', 'task_id': 2, 'machine_id': 3, 'duration': 3}, {'job_id': 'J4', 'task_id': 0, 'machine_id': 1, 'duration': 71}, {'job_id': 'J4', 'task_id': 1, 'machine_id': 2, 'duration': 7}, {'job_id': 'J4', 'task_id': 2, 'machine_id': 3, 'duration': 8}, {'job_id': 'J5', 'task_id': 0, 'machine_id': 1, 'duration': 31}, {'job_id': 'J5', 'task_id': 1, 'machine_id': 2, 'duration': 80}, {'job_id': 'J5', 'task_id': 2, 'machine_id': 3, 'duration': 33}]}","[{'job': 'J1', 'tasks': [{'task': 0, 'start': 198, 'machine': 1, 'duration': 1}, {'task': 1, 'start': 98, 'machine': 2, 'duration': 65}, {'task': 2, 'start': 73, 'machine': 3, 'duration': 21}]}, {'job': 'J2', 'tasks': [{'task': 0, 'start': 183, 'machine': 1, 'duration': 15}, {'task': 1, 'start': 243, 'machine': 2, 'duration': 16}, {'task': 2, 'start': 0, 'machine': 3, 'duration': 73}]}, {'job': 'J3', 'tasks': [{'task': 0, 'start': 102, 'machine': 1, 'duration': 81}, {'task': 1, 'start': 0, 'machine': 2, 'duration': 98}, {'task': 2, 'start': 183, 'machine': 3, 'duration': 3}]}, {'job': 'J4', 'tasks': [{'task': 0, 'start': 0, 'machine': 1, 'duration': 71}, {'task': 1, 'start': 259, 'machine': 2, 'duration': 7}, {'task': 2, 'start': 94, 'machine': 3, 'duration': 8}]}, {'job': 'J5', 'tasks': [{'task': 0, 'start': 71, 'machine': 1, 'duration': 31}, {'task': 1, 'start': 163, 'machine': 2, 'duration': 80}, {'task': 2, 'start': 102, 'machine': 3, 'duration': 33}]}]",40,nl,1
OSP,OSP,"There’s a little weekend rush: every cake must be shaped, decorated, and packaged once, but there’s no fixed order — a cake might be decorated before it’s packaged or vice versa. The job is to work out both the sequence of stations for each cake and the start times for those steps so that the whole batch finishes sooner rather than later; success is measured by the clock time when the last cake is done. Keep in mind each station serves only one cake at a time, and a cake can’t be in two stations at once. The concrete details follow below.

{
  ""number_of_cakes"": 5,
  ""number_of_stations"": 2,
  ""cake_ids"": [
    ""J1"",
    ""J2"",
    ""J3"",
    ""J4"",
    ""J5""
  ],
  ""station_ids"": [
    0,
    1
  ],
  ""tasks"": [
    {
      ""cake_id"": ""J1"",
      ""visit_label"": 0,
      ""station_id"": 0,
      ""processing_time"": 1
    },
    {
      ""cake_id"": ""J1"",
      ""visit_label"": 1,
      ""station_id"": 1,
      ""processing_time"": 78
    },
    {
      ""cake_id"": ""J2"",
      ""visit_label"": 0,
      ""station_id"": 0,
      ""processing_time"": 96
    },
    {
      ""cake_id"": ""J2"",
      ""visit_label"": 1,
      ""station_id"": 1,
      ""processing_time"": 61
    },
    {
      ""cake_id"": ""J3"",
      ""visit_label"": 0,
      ""station_id"": 0,
      ""processing_time"": 69
    },
    {
      ""cake_id"": ""J3"",
      ""visit_label"": 1,
      ""station_id"": 1,
      ""processing_time"": 95
    },
    {
      ""cake_id"": ""J4"",
      ""visit_label"": 0,
      ""station_id"": 0,
      ""processing_time"": 85
    },
    {
      ""cake_id"": ""J4"",
      ""visit_label"": 1,
      ""station_id"": 1,
      ""processing_time"": 67
    },
    {
      ""cake_id"": ""J5"",
      ""visit_label"": 0,
      ""station_id"": 0,
      ""processing_time"": 70
    },
    {
      ""cake_id"": ""J5"",
      ""visit_label"": 1,
      ""station_id"": 1,
      ""processing_time"": 64
    }
  ]
}

If you want to hand me a schedule, a neat way to lay it out is this simple JSON shape — just follow the same structure and I'll know how to read it.

{
  ""solution"": [
    {
      ""job"": <cake_id>,
      ""tasks"": [
        {
          ""task"": <step_index>,
          ""start"": <start_time>,
          ""machine"": <station_id>,
          ""duration"": <duration>
        }
      ]
    }
  ]
}

Think of that like a little form: each top-level entry is one cake, ""tasks"" is the list of steps that cake needs (shaping, decorating, packaging — in whatever order you choose), ""task"" is just that step’s index, ""start"" is when the step begins, ""machine"" is which station handles it, and ""duration"" is how long it takes. Super casual — this JSON is just a sketch of the shape I expect, not the actual plan itself.

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”.""","{'nr_machines': 2, 'nr_jobs': 5, 'jobs': [[[0, 1], [1, 78]], [[0, 96], [1, 61]], [[0, 69], [1, 95]], [[0, 85], [1, 67]], [[0, 70], [1, 64]]]}","[{'job': 0, 'tasks': [{'task': 0, 'start': 320, 'machine': 0, 'duration': 1}, {'task': 1, 'start': 95, 'machine': 1, 'duration': 78}]}, {'job': 1, 'tasks': [{'task': 0, 'start': 0, 'machine': 0, 'duration': 96}, {'task': 1, 'start': 304, 'machine': 1, 'duration': 61}]}, {'job': 2, 'tasks': [{'task': 0, 'start': 181, 'machine': 0, 'duration': 69}, {'task': 1, 'start': 0, 'machine': 1, 'duration': 95}]}, {'job': 3, 'tasks': [{'task': 0, 'start': 96, 'machine': 0, 'duration': 85}, {'task': 1, 'start': 237, 'machine': 1, 'duration': 67}]}, {'job': 4, 'tasks': [{'task': 0, 'start': 250, 'machine': 0, 'duration': 70}, {'task': 1, 'start': 173, 'machine': 1, 'duration': 64}]}]",365.0,"{'problem_type': 'OSP', 'nr_jobs': 5, 'nr_machines': 2, 'jobs': ['J1', 'J2', 'J3', 'J4', 'J5'], 'machines': [0, 1], 'records': [{'job_id': 'J1', 'task_id': 0, 'machine_id': 0, 'duration': 1}, {'job_id': 'J1', 'task_id': 1, 'machine_id': 1, 'duration': 78}, {'job_id': 'J2', 'task_id': 0, 'machine_id': 0, 'duration': 96}, {'job_id': 'J2', 'task_id': 1, 'machine_id': 1, 'duration': 61}, {'job_id': 'J3', 'task_id': 0, 'machine_id': 0, 'duration': 69}, {'job_id': 'J3', 'task_id': 1, 'machine_id': 1, 'duration': 95}, {'job_id': 'J4', 'task_id': 0, 'machine_id': 0, 'duration': 85}, {'job_id': 'J4', 'task_id': 1, 'machine_id': 1, 'duration': 67}, {'job_id': 'J5', 'task_id': 0, 'machine_id': 0, 'duration': 70}, {'job_id': 'J5', 'task_id': 1, 'machine_id': 1, 'duration': 64}]}","[{'job': 'J1', 'tasks': [{'task': 0, 'start': 320, 'machine': 0, 'duration': 1}, {'task': 1, 'start': 95, 'machine': 1, 'duration': 78}]}, {'job': 'J2', 'tasks': [{'task': 0, 'start': 0, 'machine': 0, 'duration': 96}, {'task': 1, 'start': 304, 'machine': 1, 'duration': 61}]}, {'job': 'J3', 'tasks': [{'task': 0, 'start': 181, 'machine': 0, 'duration': 69}, {'task': 1, 'start': 0, 'machine': 1, 'duration': 95}]}, {'job': 'J4', 'tasks': [{'task': 0, 'start': 96, 'machine': 0, 'duration': 85}, {'task': 1, 'start': 237, 'machine': 1, 'duration': 67}]}, {'job': 'J5', 'tasks': [{'task': 0, 'start': 250, 'machine': 0, 'duration': 70}, {'task': 1, 'start': 173, 'machine': 1, 'duration': 64}]}]",41,json,0
OSP,OSP,"Picture a shift where every car must stop at a few specific stations once each, but the order is flexible — the supervisor must pick when each service starts and in what order each car visits stations so nothing is missed or repeated. The important bit is to finish the whole queue quickly; the finish time of the last car is the measure of success, and all along no station can handle more than one car and no car can be in two spots at once. The concrete details are shown below.

There are 4 cars and 2 stations; the cars are J1, J2, J3, J4 and the stations are 0, 1.
Car J1, task 0: visit station 0 for 1.
Car J1, task 1: visit station 1 for 91.
Car J2, task 0: visit station 0 for 71.
Car J2, task 1: visit station 1 for 7.
Car J3, task 0: visit station 0 for 22.
Car J3, task 1: visit station 1 for 18.
Car J4, task 0: visit station 0 for 90.
Car J4, task 1: visit station 1 for 35.
Schedule start times and visit order so the last car finishes as early as possible.

Oh, and to keep things tidy, please give the plan in this simple JSON shape so I can read it programmatically or by eye:

{
  ""solution"": [
    {
      ""job"": <car_id>,
      ""tasks"": [
        {
          ""task"": <service_index>,
          ""start"": <start_time>,
          ""machine"": <station_id>,
          ""duration"": <duration>
        }
      ]
    }
  ]
}

This is just a sketch of the shape I expect: each top-level entry under ""solution"" is one car (the ""job""), ""tasks"" is the list of station visits for that car, ""task"" is a short label/index for each visit, ""start"" is when that visit begins, ""machine"" names the station, and ""duration"" is how long the service takes. Keep it casual — like filling out a form for each car's stops.

A 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”, or a capital letter followed by digits like “A1” or “X7”.","{'nr_machines': 2, 'nr_jobs': 4, 'jobs': [[[0, 1], [1, 91]], [[0, 71], [1, 7]], [[0, 22], [1, 18]], [[0, 90], [1, 35]]]}","[{'job': 0, 'tasks': [{'task': 0, 'start': 183, 'machine': 0, 'duration': 1}, {'task': 1, 'start': 0, 'machine': 1, 'duration': 91}]}, {'job': 1, 'tasks': [{'task': 0, 'start': 90, 'machine': 0, 'duration': 71}, {'task': 1, 'start': 161, 'machine': 1, 'duration': 7}]}, {'job': 2, 'tasks': [{'task': 0, 'start': 161, 'machine': 0, 'duration': 22}, {'task': 1, 'start': 126, 'machine': 1, 'duration': 18}]}, {'job': 3, 'tasks': [{'task': 0, 'start': 0, 'machine': 0, 'duration': 90}, {'task': 1, 'start': 91, 'machine': 1, 'duration': 35}]}]",184.0,"{'problem_type': 'OSP', 'nr_jobs': 4, 'nr_machines': 2, 'jobs': ['J1', 'J2', 'J3', 'J4'], 'machines': [0, 1], 'records': [{'job_id': 'J1', 'task_id': 0, 'machine_id': 0, 'duration': 1}, {'job_id': 'J1', 'task_id': 1, 'machine_id': 1, 'duration': 91}, {'job_id': 'J2', 'task_id': 0, 'machine_id': 0, 'duration': 71}, {'job_id': 'J2', 'task_id': 1, 'machine_id': 1, 'duration': 7}, {'job_id': 'J3', 'task_id': 0, 'machine_id': 0, 'duration': 22}, {'job_id': 'J3', 'task_id': 1, 'machine_id': 1, 'duration': 18}, {'job_id': 'J4', 'task_id': 0, 'machine_id': 0, 'duration': 90}, {'job_id': 'J4', 'task_id': 1, 'machine_id': 1, 'duration': 35}]}","[{'job': 'J1', 'tasks': [{'task': 0, 'start': 183, 'machine': 0, 'duration': 1}, {'task': 1, 'start': 0, 'machine': 1, 'duration': 91}]}, {'job': 'J2', 'tasks': [{'task': 0, 'start': 90, 'machine': 0, 'duration': 71}, {'task': 1, 'start': 161, 'machine': 1, 'duration': 7}]}, {'job': 'J3', 'tasks': [{'task': 0, 'start': 161, 'machine': 0, 'duration': 22}, {'task': 1, 'start': 126, 'machine': 1, 'duration': 18}]}, {'job': 'J4', 'tasks': [{'task': 0, 'start': 0, 'machine': 0, 'duration': 90}, {'task': 1, 'start': 91, 'machine': 1, 'duration': 35}]}]",42,nl,0
OSP,OSP,"We saw the house calendar full of tasks, and the person in charge needs to schedule each task through every area it requires — once per area, in whatever order makes sense for each task. Each area can only handle one task at a time, and a task can’t be split between two areas simultaneously, so the manager must pick start times and sequences that respect that. The goal is to wrap up all the chores as quickly as possible; measure success by the clock moment when the last job is done, and the earlier that moment, the better the plan. The concrete chores, rooms, and durations are listed below.

{
  ""nr_chores"": 3,
  ""nr_areas"": 3,
  ""chores"": [
    ""J1"",
    ""J2"",
    ""J3""
  ],
  ""areas"": [
    1,
    2,
    3
  ],
  ""tasks"": [
    {
      ""chore_id"": ""J1"",
      ""chore_task_index"": 0,
      ""area_id"": 1,
      ""attention_duration"": 1
    },
    {
      ""chore_id"": ""J1"",
      ""chore_task_index"": 1,
      ""area_id"": 2,
      ""attention_duration"": 5
    },
    {
      ""chore_id"": ""J1"",
      ""chore_task_index"": 2,
      ""area_id"": 3,
      ""attention_duration"": 47
    },
    {
      ""chore_id"": ""J2"",
      ""chore_task_index"": 0,
      ""area_id"": 1,
      ""attention_duration"": 53
    },
    {
      ""chore_id"": ""J2"",
      ""chore_task_index"": 1,
      ""area_id"": 2,
      ""attention_duration"": 75
    },
    {
      ""chore_id"": ""J2"",
      ""chore_task_index"": 2,
      ""area_id"": 3,
      ""attention_duration"": 39
    },
    {
      ""chore_id"": ""J3"",
      ""chore_task_index"": 0,
      ""area_id"": 1,
      ""attention_duration"": 95
    },
    {
      ""chore_id"": ""J3"",
      ""chore_task_index"": 1,
      ""area_id"": 2,
      ""attention_duration"": 3
    },
    {
      ""chore_id"": ""J3"",
      ""chore_task_index"": 2,
      ""area_id"": 3,
      ""attention_duration"": 7
    }
  ]
}

Also, a quick note — it's easiest for me to read your plan if you give it in a simple JSON shape like this. Below is a tiny sketch of the exact layout I'd expect:

{
  ""solution"": [
    {
      ""job"": <chore_id>,
      ""tasks"": [
        {
          ""task"": <task_index>,
          ""start"": <start_time>,
          ""machine"": <room_id>,
          ""duration"": <duration>
        }
      ]
    }
  ]
}

This just shows the form: ""solution"" is a list of jobs (here, chores), each job entry has a job identifier and a list of its tasks, and each task entry lists a task index, the start time, which room (machine) it uses, and how long it takes. It's just a sketch of the expected shape — not the actual schedule.

Please make sure to use the exact identifiers from the instance input when you fill this in — don't rename them or invent new ones. Valid identifiers look like plain numbers such as “1” or “23”, single capital letters like “A” or “B”, or a capital letter followed by digits like “A1” or “X7”.","{'nr_machines': 3, 'nr_jobs': 3, 'jobs': [[[0, 1], [1, 5], [2, 47]], [[0, 53], [1, 75], [2, 39]], [[0, 95], [1, 3], [2, 7]]]}","[{'job': 0, 'tasks': [{'task': 0, 'start': 95, 'machine': 0, 'duration': 1}, {'task': 1, 'start': 75, 'machine': 1, 'duration': 5}, {'task': 2, 'start': 0, 'machine': 2, 'duration': 47}]}, {'job': 1, 'tasks': [{'task': 0, 'start': 114, 'machine': 0, 'duration': 53}, {'task': 1, 'start': 0, 'machine': 1, 'duration': 75}, {'task': 2, 'start': 75, 'machine': 2, 'duration': 39}]}, {'job': 2, 'tasks': [{'task': 0, 'start': 0, 'machine': 0, 'duration': 95}, {'task': 1, 'start': 95, 'machine': 1, 'duration': 3}, {'task': 2, 'start': 114, 'machine': 2, 'duration': 7}]}]",167.0,"{'problem_type': 'OSP', 'nr_jobs': 3, 'nr_machines': 3, 'jobs': ['J1', 'J2', 'J3'], 'machines': [1, 2, 3], 'records': [{'job_id': 'J1', 'task_id': 0, 'machine_id': 1, 'duration': 1}, {'job_id': 'J1', 'task_id': 1, 'machine_id': 2, 'duration': 5}, {'job_id': 'J1', 'task_id': 2, 'machine_id': 3, 'duration': 47}, {'job_id': 'J2', 'task_id': 0, 'machine_id': 1, 'duration': 53}, {'job_id': 'J2', 'task_id': 1, 'machine_id': 2, 'duration': 75}, {'job_id': 'J2', 'task_id': 2, 'machine_id': 3, 'duration': 39}, {'job_id': 'J3', 'task_id': 0, 'machine_id': 1, 'duration': 95}, {'job_id': 'J3', 'task_id': 1, 'machine_id': 2, 'duration': 3}, {'job_id': 'J3', 'task_id': 2, 'machine_id': 3, 'duration': 7}]}","[{'job': 'J1', 'tasks': [{'task': 0, 'start': 95, 'machine': 1, 'duration': 1}, {'task': 1, 'start': 75, 'machine': 2, 'duration': 5}, {'task': 2, 'start': 0, 'machine': 3, 'duration': 47}]}, {'job': 'J2', 'tasks': [{'task': 0, 'start': 114, 'machine': 1, 'duration': 53}, {'task': 1, 'start': 0, 'machine': 2, 'duration': 75}, {'task': 2, 'start': 75, 'machine': 3, 'duration': 39}]}, {'job': 'J3', 'tasks': [{'task': 0, 'start': 0, 'machine': 1, 'duration': 95}, {'task': 1, 'start': 95, 'machine': 2, 'duration': 3}, {'task': 2, 'start': 114, 'machine': 3, 'duration': 7}]}]",43,json,1
OSP,OSP,"There’s a scheduling puzzle in the ops team: each application needs to be touched on several specific servers, exactly once per server, but there’s freedom in which server update happens first. The team must choose the sequence and timing for each update while respecting that a server can’t handle more than one update at once and an application can’t be updated in two places at the same time, with no update skipped or repeated. The aim is to have everything done as quickly as possible — the time to beat is the moment when the last update finishes. The concrete details appear below.

There are 5 applications and 3 servers; the application IDs are J1, J2, J3, J4, J5 and the server IDs are 1, 2, 3.

| application_id | update_index | server_id | update_duration |
|---|---|---|---|
| J1 | 0 | 1 | 1 |
| J1 | 1 | 2 | 18 |
| J1 | 2 | 3 | 23 |
| J2 | 0 | 1 | 98 |
| J2 | 1 | 2 | 29 |
| J2 | 2 | 3 | 61 |
| J3 | 0 | 1 | 99 |
| J3 | 1 | 2 | 70 |
| J3 | 2 | 3 | 74 |
| J4 | 0 | 1 | 45 |
| J4 | 1 | 2 | 60 |
| J4 | 2 | 3 | 15 |
| J5 | 0 | 1 | 63 |
| J5 | 1 | 2 | 93 |
| J5 | 2 | 3 | 54 |

List each required update on its own line so the team can choose sequences and timings to minimize the overall completion time.

Also, please return the plan in a simple JSON shape so it's easy to read and ingest. Just follow this layout when you fill it in:

{
  ""solution"": [
    {
      ""job"": <app_id>,
      ""tasks"": [
        {
          ""task"": <update_index>,
          ""start"": <start_time>,
          ""machine"": <server_id>,
          ""duration"": <duration>
        }
      ]
    }
  ]
}

This is just a friendly template: ""solution"" is the list of applications (jobs), each entry's ""job"" is the application id, ""tasks"" is the list of updates that need to happen for that app. Each task line tells you the task index, when it starts, which server it's on, and how long it takes. Treat it like a simple form to fill out — it's an example of the shape I expect, not the final answer.

Please make sure to 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”.","{'nr_machines': 3, 'nr_jobs': 5, 'jobs': [[[0, 1], [1, 18], [2, 23]], [[0, 98], [1, 29], [2, 61]], [[0, 99], [1, 70], [2, 74]], [[0, 45], [1, 60], [2, 15]], [[0, 63], [1, 93], [2, 54]]]}","[{'job': 0, 'tasks': [{'task': 0, 'start': 305, 'machine': 0, 'duration': 1}, {'task': 1, 'start': 252, 'machine': 1, 'duration': 18}, {'task': 2, 'start': 61, 'machine': 2, 'duration': 23}]}, {'job': 1, 'tasks': [{'task': 0, 'start': 162, 'machine': 0, 'duration': 98}, {'task': 1, 'start': 93, 'machine': 1, 'duration': 29}, {'task': 2, 'start': 0, 'machine': 2, 'duration': 61}]}, {'job': 2, 'tasks': [{'task': 0, 'start': 0, 'machine': 0, 'duration': 99}, {'task': 1, 'start': 182, 'machine': 1, 'duration': 70}, {'task': 2, 'start': 99, 'machine': 2, 'duration': 74}]}, {'job': 3, 'tasks': [{'task': 0, 'start': 260, 'machine': 0, 'duration': 45}, {'task': 1, 'start': 122, 'machine': 1, 'duration': 60}, {'task': 2, 'start': 84, 'machine': 2, 'duration': 15}]}, {'job': 4, 'tasks': [{'task': 0, 'start': 99, 'machine': 0, 'duration': 63}, {'task': 1, 'start': 0, 'machine': 1, 'duration': 93}, {'task': 2, 'start': 173, 'machine': 2, 'duration': 54}]}]",306.0,"{'problem_type': 'OSP', 'nr_jobs': 5, 'nr_machines': 3, 'jobs': ['J1', 'J2', 'J3', 'J4', 'J5'], 'machines': [1, 2, 3], 'records': [{'job_id': 'J1', 'task_id': 0, 'machine_id': 1, 'duration': 1}, {'job_id': 'J1', 'task_id': 1, 'machine_id': 2, 'duration': 18}, {'job_id': 'J1', 'task_id': 2, 'machine_id': 3, 'duration': 23}, {'job_id': 'J2', 'task_id': 0, 'machine_id': 1, 'duration': 98}, {'job_id': 'J2', 'task_id': 1, 'machine_id': 2, 'duration': 29}, {'job_id': 'J2', 'task_id': 2, 'machine_id': 3, 'duration': 61}, {'job_id': 'J3', 'task_id': 0, 'machine_id': 1, 'duration': 99}, {'job_id': 'J3', 'task_id': 1, 'machine_id': 2, 'duration': 70}, {'job_id': 'J3', 'task_id': 2, 'machine_id': 3, 'duration': 74}, {'job_id': 'J4', 'task_id': 0, 'machine_id': 1, 'duration': 45}, {'job_id': 'J4', 'task_id': 1, 'machine_id': 2, 'duration': 60}, {'job_id': 'J4', 'task_id': 2, 'machine_id': 3, 'duration': 15}, {'job_id': 'J5', 'task_id': 0, 'machine_id': 1, 'duration': 63}, {'job_id': 'J5', 'task_id': 1, 'machine_id': 2, 'duration': 93}, {'job_id': 'J5', 'task_id': 2, 'machine_id': 3, 'duration': 54}]}","[{'job': 'J1', 'tasks': [{'task': 0, 'start': 305, 'machine': 1, 'duration': 1}, {'task': 1, 'start': 252, 'machine': 2, 'duration': 18}, {'task': 2, 'start': 61, 'machine': 3, 'duration': 23}]}, {'job': 'J2', 'tasks': [{'task': 0, 'start': 162, 'machine': 1, 'duration': 98}, {'task': 1, 'start': 93, 'machine': 2, 'duration': 29}, {'task': 2, 'start': 0, 'machine': 3, 'duration': 61}]}, {'job': 'J3', 'tasks': [{'task': 0, 'start': 0, 'machine': 1, 'duration': 99}, {'task': 1, 'start': 182, 'machine': 2, 'duration': 70}, {'task': 2, 'start': 99, 'machine': 3, 'duration': 74}]}, {'job': 'J4', 'tasks': [{'task': 0, 'start': 260, 'machine': 1, 'duration': 45}, {'task': 1, 'start': 122, 'machine': 2, 'duration': 60}, {'task': 2, 'start': 84, 'machine': 3, 'duration': 15}]}, {'job': 'J5', 'tasks': [{'task': 0, 'start': 99, 'machine': 1, 'duration': 63}, {'task': 1, 'start': 0, 'machine': 2, 'duration': 93}, {'task': 2, 'start': 173, 'machine': 3, 'duration': 54}]}]",44,markdown_table,1
OSP,OSP,"We’ve got a backlog of returns and repairs and a handful of desks that each do specific tasks; the trick is to schedule when each book visits which desk. Every book has to go to each of its assigned desks exactly once, nothing gets omitted or duplicated, each desk can only work on one book at a time, and a book can’t be at two desks simultaneously. What makes one way of doing it better than another is simply the clock time when the very last book finishes all its work — compare plans by that finishing time and aim for the earliest one. The exact instance details are shown below.

Here are the instance details: 4 books, 2 desks, book ids J1, J2, J3, J4, desk ids A, B.

| book_id | service_index | desk_id | processing_time |
|---|---|---|---|
| J1 | 0 | A | 1 |
| J1 | 1 | B | 31 |
| J2 | 0 | A | 98 |
| J2 | 1 | B | 44 |
| J3 | 0 | A | 81 |
| J3 | 1 | B | 83 |
| J4 | 0 | A | 5 |
| J4 | 1 | B | 38 |

Let’s aim to minimize the finishing time of the last book.

Also, when you send the final plan back, just use a simple JSON shape so it's easy to read and (if needed) parse — something like this will do.

{
  ""solution"": [
    {
      ""job"": <book_id>,
      ""tasks"": [
        {
          ""task"": <visit_index>,
          ""start"": <start_time>,
          ""machine"": <desk_id>,
          ""duration"": <duration>
        }
      ]
    }
  ]
}

Think of it as a little form: the solution is a list of books, each book has a list of visits (tasks). For each visit you say which visit number it is, when it starts, which desk it goes to, and how long that visit takes. This is just the sketch of the expected shape — not the actual schedule.

Please make sure you 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”.""","{'nr_machines': 2, 'nr_jobs': 4, 'jobs': [[[0, 1], [1, 31]], [[0, 98], [1, 44]], [[0, 81], [1, 83]], [[0, 5], [1, 38]]]}","[{'job': 0, 'tasks': [{'task': 0, 'start': 184, 'machine': 0, 'duration': 1}, {'task': 1, 'start': 83, 'machine': 1, 'duration': 31}]}, {'job': 1, 'tasks': [{'task': 0, 'start': 0, 'machine': 0, 'duration': 98}, {'task': 1, 'start': 114, 'machine': 1, 'duration': 44}]}, {'job': 2, 'tasks': [{'task': 0, 'start': 103, 'machine': 0, 'duration': 81}, {'task': 1, 'start': 0, 'machine': 1, 'duration': 83}]}, {'job': 3, 'tasks': [{'task': 0, 'start': 98, 'machine': 0, 'duration': 5}, {'task': 1, 'start': 158, 'machine': 1, 'duration': 38}]}]",196.0,"{'problem_type': 'OSP', 'nr_jobs': 4, 'nr_machines': 2, 'jobs': ['J1', 'J2', 'J3', 'J4'], 'machines': ['A', 'B'], 'records': [{'job_id': 'J1', 'task_id': 0, 'machine_id': 'A', 'duration': 1}, {'job_id': 'J1', 'task_id': 1, 'machine_id': 'B', 'duration': 31}, {'job_id': 'J2', 'task_id': 0, 'machine_id': 'A', 'duration': 98}, {'job_id': 'J2', 'task_id': 1, 'machine_id': 'B', 'duration': 44}, {'job_id': 'J3', 'task_id': 0, 'machine_id': 'A', 'duration': 81}, {'job_id': 'J3', 'task_id': 1, 'machine_id': 'B', 'duration': 83}, {'job_id': 'J4', 'task_id': 0, 'machine_id': 'A', 'duration': 5}, {'job_id': 'J4', 'task_id': 1, 'machine_id': 'B', 'duration': 38}]}","[{'job': 'J1', 'tasks': [{'task': 0, 'start': 184, 'machine': 'A', 'duration': 1}, {'task': 1, 'start': 83, 'machine': 'B', 'duration': 31}]}, {'job': 'J2', 'tasks': [{'task': 0, 'start': 0, 'machine': 'A', 'duration': 98}, {'task': 1, 'start': 114, 'machine': 'B', 'duration': 44}]}, {'job': 'J3', 'tasks': [{'task': 0, 'start': 103, 'machine': 'A', 'duration': 81}, {'task': 1, 'start': 0, 'machine': 'B', 'duration': 83}]}, {'job': 'J4', 'tasks': [{'task': 0, 'start': 98, 'machine': 'A', 'duration': 5}, {'task': 1, 'start': 158, 'machine': 'B', 'duration': 38}]}]",45,markdown_table,names
OSP,OSP,"Out at the school, the facilities coordinator is trying to schedule crews so every classroom gets its full checklist of services — each service happens once at its designated spot, and rooms can be serviced in any order. The trick is arranging who goes where and when so service points aren’t used by two jobs at the same time and a classroom never has overlapping work. A better arrangement is the one where the last completed service across the school happens sooner rather than later — the finish time of that last task is what’s being minimized. The concrete instance details are shown below.

# num_classrooms=3
# num_service_points=3
# classroom_list=J1, J2, J3
# service_point_list=A, B, C
classroom_id,service_index,service_point_id,service_duration
J1,0,A,1
J1,1,B,44
J1,2,C,74
J2,0,A,90
J2,1,B,35
J2,2,C,5
J3,0,A,10
J3,1,B,7
J3,2,C,10

Also, to keep things consistent, please send the schedule in this simple JSON shape — nothing fancy, just following the same little layout below.

{
  ""solution"": [
    {
      ""job"": <room_id>,
      ""tasks"": [
        {
          ""task"": <service_task>,
          ""start"": <start_time>,
          ""machine"": <crew_id>,
          ""duration"": <duration>
        }
      ]
    }
  ]
}

This is just a sketch of the shape I need. In story terms: each top-level ""job"" is a classroom (so use the classroom identifier from the instance), the ""tasks"" array lists the checklist items to be done in that room, ""task"" is the task index/label, ""start"" is when that particular service begins, ""machine"" is the crew or service team doing it, and ""duration"" is how long that task takes. Keep it casual — think of it like filling out a short form for each room.

Also, a quick reminder: use the exact identifiers given in 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”.","{'nr_machines': 3, 'nr_jobs': 3, 'jobs': [[[0, 1], [1, 44], [2, 74]], [[0, 90], [1, 35], [2, 5]], [[0, 10], [1, 7], [2, 10]]]}","[{'job': 0, 'tasks': [{'task': 0, 'start': 118, 'machine': 0, 'duration': 1}, {'task': 1, 'start': 0, 'machine': 1, 'duration': 44}, {'task': 2, 'start': 44, 'machine': 2, 'duration': 74}]}, {'job': 1, 'tasks': [{'task': 0, 'start': 0, 'machine': 0, 'duration': 90}, {'task': 1, 'start': 90, 'machine': 1, 'duration': 35}, {'task': 2, 'start': 125, 'machine': 2, 'duration': 5}]}, {'job': 2, 'tasks': [{'task': 0, 'start': 90, 'machine': 0, 'duration': 10}, {'task': 1, 'start': 44, 'machine': 1, 'duration': 7}, {'task': 2, 'start': 0, 'machine': 2, 'duration': 10}]}]",130.0,"{'problem_type': 'OSP', 'nr_jobs': 3, 'nr_machines': 3, 'jobs': ['J1', 'J2', 'J3'], 'machines': ['A', 'B', 'C'], 'records': [{'job_id': 'J1', 'task_id': 0, 'machine_id': 'A', 'duration': 1}, {'job_id': 'J1', 'task_id': 1, 'machine_id': 'B', 'duration': 44}, {'job_id': 'J1', 'task_id': 2, 'machine_id': 'C', 'duration': 74}, {'job_id': 'J2', 'task_id': 0, 'machine_id': 'A', 'duration': 90}, {'job_id': 'J2', 'task_id': 1, 'machine_id': 'B', 'duration': 35}, {'job_id': 'J2', 'task_id': 2, 'machine_id': 'C', 'duration': 5}, {'job_id': 'J3', 'task_id': 0, 'machine_id': 'A', 'duration': 10}, {'job_id': 'J3', 'task_id': 1, 'machine_id': 'B', 'duration': 7}, {'job_id': 'J3', 'task_id': 2, 'machine_id': 'C', 'duration': 10}]}","[{'job': 'J1', 'tasks': [{'task': 0, 'start': 118, 'machine': 'A', 'duration': 1}, {'task': 1, 'start': 0, 'machine': 'B', 'duration': 44}, {'task': 2, 'start': 44, 'machine': 'C', 'duration': 74}]}, {'job': 'J2', 'tasks': [{'task': 0, 'start': 0, 'machine': 'A', 'duration': 90}, {'task': 1, 'start': 90, 'machine': 'B', 'duration': 35}, {'task': 2, 'start': 125, 'machine': 'C', 'duration': 5}]}, {'job': 'J3', 'tasks': [{'task': 0, 'start': 90, 'machine': 'A', 'duration': 10}, {'task': 1, 'start': 44, 'machine': 'B', 'duration': 7}, {'task': 2, 'start': 0, 'machine': 'C', 'duration': 10}]}]",46,csv,names
OSP,OSP,"Someone needs to schedule the room-turnover work so every patient space gets every required service exactly once, and the order of those services can vary from room to room. The job is to decide the sequence and start times for each room’s services, with the rule that each service point works on only one room at a time and a room can’t be handled by two points simultaneously. A good schedule is the one that makes the last room finish as early as possible — measured by the clock time when that final service wraps up. The concrete details follow below.

{
  ""nr_rooms"": 2,
  ""nr_service_points"": 2,
  ""room_ids"": [
    ""J1"",
    ""J2""
  ],
  ""service_point_ids"": [
    ""A"",
    ""B""
  ],
  ""tasks"": [
    {
      ""room_id"": ""J1"",
      ""service_task_id"": 0,
      ""service_point_id"": ""A"",
      ""service_duration"": 1
    },
    {
      ""room_id"": ""J1"",
      ""service_task_id"": 1,
      ""service_point_id"": ""B"",
      ""service_duration"": 57
    },
    {
      ""room_id"": ""J2"",
      ""service_task_id"": 0,
      ""service_point_id"": ""A"",
      ""service_duration"": 49
    },
    {
      ""room_id"": ""J2"",
      ""service_task_id"": 1,
      ""service_point_id"": ""B"",
      ""service_duration"": 36
    }
  ]
}

If you want to give the schedule back to me, just follow this little JSON shape — nothing fancy, just a predictable form I can read easily:

{
  ""solution"": [
    {
      ""job"": <room_id>,
      ""tasks"": [
        {
          ""task"": <task_index>,
          ""start"": <start_time>,
          ""machine"": <service_point_id>,
          ""duration"": <duration>
        }
      ]
    }
  ]
}

Think of it like a simple form: ""solution"" is a list of rooms, each ""job"" entry names the room (room_id), and ""tasks"" is the list of services that room needs. Each task shows which numbered step it is, when that step starts, which service point does it, and how long it takes. This is just a sketch of the shape I expect — not the actual schedule itself.

Please make sure to 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”.""","{'nr_machines': 2, 'nr_jobs': 2, 'jobs': [[[0, 1], [1, 57]], [[0, 49], [1, 36]]]}","[{'job': 0, 'tasks': [{'task': 0, 'start': 57, 'machine': 0, 'duration': 1}, {'task': 1, 'start': 0, 'machine': 1, 'duration': 57}]}, {'job': 1, 'tasks': [{'task': 0, 'start': 0, 'machine': 0, 'duration': 49}, {'task': 1, 'start': 57, 'machine': 1, 'duration': 36}]}]",93.0,"{'problem_type': 'OSP', 'nr_jobs': 2, 'nr_machines': 2, 'jobs': ['J1', 'J2'], 'machines': ['A', 'B'], 'records': [{'job_id': 'J1', 'task_id': 0, 'machine_id': 'A', 'duration': 1}, {'job_id': 'J1', 'task_id': 1, 'machine_id': 'B', 'duration': 57}, {'job_id': 'J2', 'task_id': 0, 'machine_id': 'A', 'duration': 49}, {'job_id': 'J2', 'task_id': 1, 'machine_id': 'B', 'duration': 36}]}","[{'job': 'J1', 'tasks': [{'task': 0, 'start': 57, 'machine': 'A', 'duration': 1}, {'task': 1, 'start': 0, 'machine': 'B', 'duration': 57}]}, {'job': 'J2', 'tasks': [{'task': 0, 'start': 0, 'machine': 'A', 'duration': 49}, {'task': 1, 'start': 57, 'machine': 'B', 'duration': 36}]}]",47,json,names
OSP,OSP,"At the garden office they’re figuring out a schedule: each section of the grounds needs a specific list of services, one visit at each designated station, but the sequence can vary by section. The scheduler’s job is to pick when and in what order each section goes to its stations, making sure no station serves two sections at the same time and no section is undergoing two services simultaneously. The goal is to get everything done sooner rather than later — the success is measured by the timestamp when the last service finishes anywhere on the property. The detailed breakdown is below.

There are 2 sections and 2 stations: the sections are J1, J2 and the stations are 0, 1.
Section J1 needs service 0 at station 0 for 1 time units.
Section J1 needs service 1 at station 1 for 70 time units.
Section J2 needs service 0 at station 0 for 25 time units.
Section J2 needs service 1 at station 1 for 82 time units.
The scheduler will sequence these visits so the last service finishes as early as possible across the grounds.

Also, when you send the schedule back, a simple JSON sketch like this is great — the shape below is what I expect:

{
  ""solution"": [
    {
      ""job"": <job_id>,
      ""tasks"": [
        {
          ""task"": <task_index>,
          ""start"": <start_time>,
          ""machine"": <machine_id>,
          ""duration"": <duration>
        }
      ]
    }
  ]
}

This is just a quick guide to the fields: each top-level ""job"" is one section of the grounds, ""tasks"" is the list of station visits for that section, and each task entry tells you which service it is (task), when it starts (start), which station handles it (machine), and how long it takes (duration). Think of it like filling out a little appointment sheet for each section.

This JSON block is only a sketch of the expected shape — not the actual schedule. Please make sure you use the exact identifiers given in the instance input (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”.""","{'nr_machines': 2, 'nr_jobs': 2, 'jobs': [[[0, 1], [1, 70]], [[0, 25], [1, 82]]]}","[{'job': 0, 'tasks': [{'task': 0, 'start': 0, 'machine': 0, 'duration': 1}, {'task': 1, 'start': 82, 'machine': 1, 'duration': 70}]}, {'job': 1, 'tasks': [{'task': 0, 'start': 82, 'machine': 0, 'duration': 25}, {'task': 1, 'start': 0, 'machine': 1, 'duration': 82}]}]",152.0,"{'problem_type': 'OSP', 'nr_jobs': 2, 'nr_machines': 2, 'jobs': ['J1', 'J2'], 'machines': [0, 1], 'records': [{'job_id': 'J1', 'task_id': 0, 'machine_id': 0, 'duration': 1}, {'job_id': 'J1', 'task_id': 1, 'machine_id': 1, 'duration': 70}, {'job_id': 'J2', 'task_id': 0, 'machine_id': 0, 'duration': 25}, {'job_id': 'J2', 'task_id': 1, 'machine_id': 1, 'duration': 82}]}","[{'job': 'J1', 'tasks': [{'task': 0, 'start': 0, 'machine': 0, 'duration': 1}, {'task': 1, 'start': 82, 'machine': 1, 'duration': 70}]}, {'job': 'J2', 'tasks': [{'task': 0, 'start': 82, 'machine': 0, 'duration': 25}, {'task': 1, 'start': 0, 'machine': 1, 'duration': 82}]}]",48,nl,0
OSP,OSP,"There’s a cook juggling several plates and a handful of appliances, and the challenge was to schedule each component so service doesn’t drag on. Each plate needs certain appliances once each — maybe the grill, then the microwave, maybe the blender — but the order can be chosen freely per plate; the planner must pick both the ordering and the start moments. The way to tell which plan is better is simple: find when each plate is done, and the plan with the earliest of the latest finish time wins. No appliance can run two tasks at once, no plate can be in two places at once, and nothing on the ingredient list can be skipped or repeated. The concrete details will be shown below.

Below are the 3 plates and the 3 appliances to schedule — plate ids J1, J2, J3, appliance ids 1, 2, 3.
Plate J1, operation 0: requires appliance 1 for 1 time units.
Plate J1, operation 1: requires appliance 2 for 84 time units.
Plate J1, operation 2: requires appliance 3 for 1 time units.
Plate J2, operation 0: requires appliance 1 for 28 time units.
Plate J2, operation 1: requires appliance 2 for 94 time units.
Plate J2, operation 2: requires appliance 3 for 70 time units.
Plate J3, operation 0: requires appliance 1 for 24 time units.
Plate J3, operation 1: requires appliance 2 for 10 time units.
Plate J3, operation 2: requires appliance 3 for 14 time units.
That’s the setup; schedule the operations to minimize the latest plate completion time so service doesn’t drag on.

I'll sketch the shape of the reply as a JSON object so it's clear what to fill in — think of each ""job"" as a plate and each ""machine"" as an appliance.

{
  ""solution"": [
    {
      ""job"": <plate_id>,
      ""tasks"": [
        {
          ""task"": <step_index>,
          ""start"": <start_time>,
          ""machine"": <appliance_id>,
          ""duration"": <duration>
        }
      ]
    }
  ]
}

This little example means: each top-level entry in ""solution"" is one plate (job). Inside that, ""tasks"" is the list of steps that plate needs; for each step you give its index, when it starts, which appliance it uses, and how long it runs. It's just a sketch of the shape I want, not the actual schedule.

Please use the exact identifiers from the instance input — don't 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”.","{'nr_machines': 3, 'nr_jobs': 3, 'jobs': [[[0, 1], [1, 84], [2, 1]], [[0, 28], [1, 94], [2, 70]], [[0, 24], [1, 10], [2, 14]]]}","[{'job': 0, 'tasks': [{'task': 0, 'start': 24, 'machine': 0, 'duration': 1}, {'task': 1, 'start': 94, 'machine': 1, 'duration': 84}, {'task': 2, 'start': 0, 'machine': 2, 'duration': 1}]}, {'job': 1, 'tasks': [{'task': 0, 'start': 164, 'machine': 0, 'duration': 28}, {'task': 1, 'start': 0, 'machine': 1, 'duration': 94}, {'task': 2, 'start': 94, 'machine': 2, 'duration': 70}]}, {'job': 2, 'tasks': [{'task': 0, 'start': 0, 'machine': 0, 'duration': 24}, {'task': 1, 'start': 178, 'machine': 1, 'duration': 10}, {'task': 2, 'start': 24, 'machine': 2, 'duration': 14}]}]",192.0,"{'problem_type': 'OSP', 'nr_jobs': 3, 'nr_machines': 3, 'jobs': ['J1', 'J2', 'J3'], 'machines': [1, 2, 3], 'records': [{'job_id': 'J1', 'task_id': 0, 'machine_id': 1, 'duration': 1}, {'job_id': 'J1', 'task_id': 1, 'machine_id': 2, 'duration': 84}, {'job_id': 'J1', 'task_id': 2, 'machine_id': 3, 'duration': 1}, {'job_id': 'J2', 'task_id': 0, 'machine_id': 1, 'duration': 28}, {'job_id': 'J2', 'task_id': 1, 'machine_id': 2, 'duration': 94}, {'job_id': 'J2', 'task_id': 2, 'machine_id': 3, 'duration': 70}, {'job_id': 'J3', 'task_id': 0, 'machine_id': 1, 'duration': 24}, {'job_id': 'J3', 'task_id': 1, 'machine_id': 2, 'duration': 10}, {'job_id': 'J3', 'task_id': 2, 'machine_id': 3, 'duration': 14}]}","[{'job': 'J1', 'tasks': [{'task': 0, 'start': 24, 'machine': 1, 'duration': 1}, {'task': 1, 'start': 94, 'machine': 2, 'duration': 84}, {'task': 2, 'start': 0, 'machine': 3, 'duration': 1}]}, {'job': 'J2', 'tasks': [{'task': 0, 'start': 164, 'machine': 1, 'duration': 28}, {'task': 1, 'start': 0, 'machine': 2, 'duration': 94}, {'task': 2, 'start': 94, 'machine': 3, 'duration': 70}]}, {'job': 'J3', 'tasks': [{'task': 0, 'start': 0, 'machine': 1, 'duration': 24}, {'task': 1, 'start': 178, 'machine': 2, 'duration': 10}, {'task': 2, 'start': 24, 'machine': 3, 'duration': 14}]}]",49,nl,1
OSP,OSP,"There’s a foreman juggling a stack of tables and chairs that all need sanding, staining, and then drying, and the challenge is to lay out who goes where and when. The decision is about ordering those three operations for each piece and timing them so machines aren’t handling more than one piece at a time and no piece is split between stations. What makes one routing smarter than another is how quickly the whole batch completes—the key number is the time the last piece is finished. Nothing can be skipped or duplicated: every piece visits each station exactly once, and the concrete details are listed below.

Here are the 2 pieces (J1, J2) and the 3 stations (1, 2, 3):

| piece_id | operation_index | station_id | processing_duration |
|---|---|---|---|
| J1 | 0 | 1 | 1 |
| J1 | 1 | 2 | 97 |
| J1 | 2 | 3 | 76 |
| J2 | 0 | 1 | 73 |
| J2 | 1 | 2 | 48 |
| J2 | 2 | 3 | 92 |

Keep in mind every piece must visit each station exactly once, no station handles more than one piece at a time, and the aim is to minimize the time the last piece finishes.

If you want to hand back a schedule, just drop it into this simple JSON shape so I can read it reliably:

{
  ""solution"": [
    {
      ""job"": <piece_id>,
      ""tasks"": [
        {
          ""task"": <operation_index>,
          ""start"": <start_time>,
          ""machine"": <station_id>,
          ""duration"": <duration>
        }
      ]
    }
  ]
}

Think of that as a little form: each top-level ""job"" is one piece (table or chair), ""tasks"" is the list of operations that piece will go through, each task has an index, a start time, the machine (station) it uses, and how long it takes. It’s just a sketch of the shape I expect, not the actual schedule itself.

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”.""","{'nr_machines': 3, 'nr_jobs': 2, 'jobs': [[[0, 1], [1, 97], [2, 76]], [[0, 73], [1, 48], [2, 92]]]}","[{'job': 0, 'tasks': [{'task': 0, 'start': 173, 'machine': 0, 'duration': 1}, {'task': 1, 'start': 0, 'machine': 1, 'duration': 97}, {'task': 2, 'start': 97, 'machine': 2, 'duration': 76}]}, {'job': 1, 'tasks': [{'task': 0, 'start': 92, 'machine': 0, 'duration': 73}, {'task': 1, 'start': 165, 'machine': 1, 'duration': 48}, {'task': 2, 'start': 0, 'machine': 2, 'duration': 92}]}]",213.0,"{'problem_type': 'OSP', 'nr_jobs': 2, 'nr_machines': 3, 'jobs': ['J1', 'J2'], 'machines': [1, 2, 3], 'records': [{'job_id': 'J1', 'task_id': 0, 'machine_id': 1, 'duration': 1}, {'job_id': 'J1', 'task_id': 1, 'machine_id': 2, 'duration': 97}, {'job_id': 'J1', 'task_id': 2, 'machine_id': 3, 'duration': 76}, {'job_id': 'J2', 'task_id': 0, 'machine_id': 1, 'duration': 73}, {'job_id': 'J2', 'task_id': 1, 'machine_id': 2, 'duration': 48}, {'job_id': 'J2', 'task_id': 2, 'machine_id': 3, 'duration': 92}]}","[{'job': 'J1', 'tasks': [{'task': 0, 'start': 173, 'machine': 1, 'duration': 1}, {'task': 1, 'start': 0, 'machine': 2, 'duration': 97}, {'task': 2, 'start': 97, 'machine': 3, 'duration': 76}]}, {'job': 'J2', 'tasks': [{'task': 0, 'start': 92, 'machine': 1, 'duration': 73}, {'task': 1, 'start': 165, 'machine': 2, 'duration': 48}, {'task': 2, 'start': 0, 'machine': 3, 'duration': 92}]}]",50,markdown_table,1