JSP/JSP_S_context.csv

task_name,problem_type,instruction,instance,solution,obj,instance_variant,solution_variant,context_index,input_format,input_index_base
JSP,JSP,"Recently the kitchen got busier, so the head chef started sketching start times for every recipe step, making sure each step sits on its assigned counter or oven for the exact time, that steps for a dish follow one after another, and that no appliance is doing two jobs at once. The point is to get every order out as soon as possible — check when each dish is completed, pick the latest completion time as the end of the shift, and try to make that latest time as small as possible. Nothing can be skipped or duplicated in the plan, and the concrete details will be shown below.

# nr_dishes=2
# nr_stations=2
# dishes=J1, J2
# stations=0, 1
dish_id,step_index,station_id,step_duration
J1,0,1,1
J1,1,0,52
J2,0,0,73
J2,1,1,27

Also, when you send the schedule back, please stick to a simple JSON layout — something like this:

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

This shows the shape I’m expecting: ""solution"" is a list of jobs (dishes), each job has an id and a list of tasks (steps). For each task you give its index in the job, the planned start time, which machine (counter/oven) it uses, and how long it runs. Think of it as a simple form: one object per dish, and an ordered list of the steps with times and machines.

This JSON is only a sketch of the expected shape, not the actual schedule. Please use the exact identifiers from the instance input — do not rename them or invent new labels.

Valid identifiers look like plain numbers such as “1” or “23”, single capital letters like “A” or “B”, or a capital letter followed by digits like “A1” or “X7”.","{'nr_machines': 2, 'nr_jobs': 2, 'jobs': [[[1, 1], [0, 52]], [[0, 73], [1, 27]]]}","[{'job': 0, 'tasks': [{'task': 0, 'start': 0, 'machine': 1, 'duration': 1}, {'task': 1, 'start': 73, 'machine': 0, 'duration': 52}]}, {'job': 1, 'tasks': [{'task': 0, 'start': 0, 'machine': 0, 'duration': 73}, {'task': 1, 'start': 73, 'machine': 1, 'duration': 27}]}]",125.0,"{'problem_type': 'JSP', 'nr_jobs': 2, 'nr_machines': 2, 'jobs': ['J1', 'J2'], 'machines': [0, 1], 'records': [{'job_id': 'J1', 'task_id': 0, 'machine_id': 1, 'duration': 1}, {'job_id': 'J1', 'task_id': 1, 'machine_id': 0, 'duration': 52}, {'job_id': 'J2', 'task_id': 0, 'machine_id': 0, 'duration': 73}, {'job_id': 'J2', 'task_id': 1, 'machine_id': 1, 'duration': 27}]}","[{'job': 'J1', 'tasks': [{'task': 0, 'start': 0, 'machine': 1, 'duration': 1}, {'task': 1, 'start': 73, 'machine': 0, 'duration': 52}]}, {'job': 'J2', 'tasks': [{'task': 0, 'start': 0, 'machine': 0, 'duration': 73}, {'task': 1, 'start': 73, 'machine': 1, 'duration': 27}]}]",1,csv,0
JSP,JSP,"Recently the team was handed several rooms to renovate, each with a step-by-step checklist, and the role was to place each step on its proper machine and time slot. The rules were simple in practice: don’t let a machine handle overlapping tasks, keep the room steps in their given sequence, and don’t skip or repeat any tasks. The success of a schedule is judged by how soon the last job completes — check the clock when the final task ends to see which plan is better. The concrete breakdown of tasks and durations is listed below.

There were 4 rooms to renovate across 2 machines; the rooms were J1, J2, J3, J4 and the machines were A, B.

| room_id | task_index | required_machine_id | task_duration |
|---|---|---|---|
| J1 | 0 | B | 1 |
| J1 | 1 | A | 65 |
| J2 | 0 | B | 49 |
| J2 | 1 | A | 72 |
| J3 | 0 | A | 90 |
| J3 | 1 | B | 42 |
| J4 | 0 | B | 3 |
| J4 | 1 | A | 19 |

The team judged schedules by checking the clock when the final task completed for the 4 rooms.

Also, to keep things neat when you send back a plan, please follow this simple JSON layout for the schedule:

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

Think of it like a little form: ""solution"" holds all the rooms (jobs), each job entry names the job and then lists its steps. Each step shows which numbered step it is, when it starts, which machine it's on, and how long it runs. It's just a sketch of the shape I need, not the final schedule itself.

Please make sure to use the exact identifiers from the instance input — no renaming and no inventing new labels.
- for example: ""Valid identifiers look like plain numbers such as “1” or “23”, single capital letters like “A” or “B”, or a capital letter followed by digits like “A1” or “X7”.""","{'nr_machines': 2, 'nr_jobs': 4, 'jobs': [[[1, 1], [0, 65]], [[1, 49], [0, 72]], [[0, 90], [1, 42]], [[1, 3], [0, 19]]]}","[{'job': 0, 'tasks': [{'task': 0, 'start': 49, 'machine': 1, 'duration': 1}, {'task': 1, 'start': 162, 'machine': 0, 'duration': 65}]}, {'job': 1, 'tasks': [{'task': 0, 'start': 0, 'machine': 1, 'duration': 49}, {'task': 1, 'start': 90, 'machine': 0, 'duration': 72}]}, {'job': 2, 'tasks': [{'task': 0, 'start': 0, 'machine': 0, 'duration': 90}, {'task': 1, 'start': 90, 'machine': 1, 'duration': 42}]}, {'job': 3, 'tasks': [{'task': 0, 'start': 50, 'machine': 1, 'duration': 3}, {'task': 1, 'start': 227, 'machine': 0, 'duration': 19}]}]",246.0,"{'problem_type': 'JSP', 'nr_jobs': 4, 'nr_machines': 2, 'jobs': ['J1', 'J2', 'J3', 'J4'], 'machines': ['A', 'B'], 'records': [{'job_id': 'J1', 'task_id': 0, 'machine_id': 'B', 'duration': 1}, {'job_id': 'J1', 'task_id': 1, 'machine_id': 'A', 'duration': 65}, {'job_id': 'J2', 'task_id': 0, 'machine_id': 'B', 'duration': 49}, {'job_id': 'J2', 'task_id': 1, 'machine_id': 'A', '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': 'B', 'duration': 3}, {'job_id': 'J4', 'task_id': 1, 'machine_id': 'A', 'duration': 19}]}","[{'job': 'J1', 'tasks': [{'task': 0, 'start': 49, 'machine': 'B', 'duration': 1}, {'task': 1, 'start': 162, 'machine': 'A', 'duration': 65}]}, {'job': 'J2', 'tasks': [{'task': 0, 'start': 0, 'machine': 'B', 'duration': 49}, {'task': 1, 'start': 90, 'machine': 'A', 'duration': 72}]}, {'job': 'J3', 'tasks': [{'task': 0, 'start': 0, 'machine': 'A', 'duration': 90}, {'task': 1, 'start': 90, 'machine': 'B', 'duration': 42}]}, {'job': 'J4', 'tasks': [{'task': 0, 'start': 50, 'machine': 'B', 'duration': 3}, {'task': 1, 'start': 227, 'machine': 'A', 'duration': 19}]}]",2,markdown_table,names
JSP,JSP,"Lately the shop has been trying to speed things up: every coat and dress has a fixed series of treatments on particular machines for specific times, and none of those steps can be rearranged. The job is to schedule those treatments so machines aren’t double-booked and every step for every garment occurs once and in order. What counts is the clock reading when the final garment is finished — the earlier, the better. The exact instance details are listed below.

{
  ""num_garments"": 3,
  ""num_machines"": 2,
  ""garment_ids"": [
    ""J1"",
    ""J2"",
    ""J3""
  ],
  ""machine_ids"": [
    ""A"",
    ""B""
  ],
  ""tasks"": [
    {
      ""garment_id"": ""J1"",
      ""treatment_index"": 0,
      ""required_machine_id"": ""B"",
      ""treatment_duration"": 1
    },
    {
      ""garment_id"": ""J1"",
      ""treatment_index"": 1,
      ""required_machine_id"": ""A"",
      ""treatment_duration"": 78
    },
    {
      ""garment_id"": ""J2"",
      ""treatment_index"": 0,
      ""required_machine_id"": ""B"",
      ""treatment_duration"": 25
    },
    {
      ""garment_id"": ""J2"",
      ""treatment_index"": 1,
      ""required_machine_id"": ""A"",
      ""treatment_duration"": 18
    },
    {
      ""garment_id"": ""J3"",
      ""treatment_index"": 0,
      ""required_machine_id"": ""B"",
      ""treatment_duration"": 44
    },
    {
      ""garment_id"": ""J3"",
      ""treatment_index"": 1,
      ""required_machine_id"": ""A"",
      ""treatment_duration"": 63
    }
  ]
}

Also, when you send back the schedule, please use a simple JSON layout so it's easy to parse and check — something that looks like this:

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

Think of it like a little form: each top-level entry is a job, ""job"" is the job identifier, ""tasks"" is the ordered list of steps for that job, and each step shows which task number it is, when it starts, which machine it runs on, and how long it lasts. It's just the shape I expect — not the real schedule yet.

Please be sure to use the exact identifiers from the instance input — do not rename them or invent new labels. Valid identifiers look like plain numbers such as “1” or “23”, single capital letters like “A” or “B”, or a capital letter followed by digits like “A1” or “X7”.","{'nr_machines': 2, 'nr_jobs': 3, 'jobs': [[[1, 1], [0, 78]], [[1, 25], [0, 18]], [[1, 44], [0, 63]]]}","[{'job': 0, 'tasks': [{'task': 0, 'start': 0, 'machine': 1, 'duration': 1}, {'task': 1, 'start': 1, 'machine': 0, 'duration': 78}]}, {'job': 1, 'tasks': [{'task': 0, 'start': 1, 'machine': 1, 'duration': 25}, {'task': 1, 'start': 142, 'machine': 0, 'duration': 18}]}, {'job': 2, 'tasks': [{'task': 0, 'start': 26, 'machine': 1, 'duration': 44}, {'task': 1, 'start': 79, 'machine': 0, 'duration': 63}]}]",160.0,"{'problem_type': 'JSP', 'nr_jobs': 3, 'nr_machines': 2, 'jobs': ['J1', 'J2', 'J3'], 'machines': ['A', 'B'], 'records': [{'job_id': 'J1', 'task_id': 0, 'machine_id': 'B', 'duration': 1}, {'job_id': 'J1', 'task_id': 1, 'machine_id': 'A', 'duration': 78}, {'job_id': 'J2', 'task_id': 0, 'machine_id': 'B', 'duration': 25}, {'job_id': 'J2', 'task_id': 1, 'machine_id': 'A', 'duration': 18}, {'job_id': 'J3', 'task_id': 0, 'machine_id': 'B', 'duration': 44}, {'job_id': 'J3', 'task_id': 1, 'machine_id': 'A', 'duration': 63}]}","[{'job': 'J1', 'tasks': [{'task': 0, 'start': 0, 'machine': 'B', 'duration': 1}, {'task': 1, 'start': 1, 'machine': 'A', 'duration': 78}]}, {'job': 'J2', 'tasks': [{'task': 0, 'start': 1, 'machine': 'B', 'duration': 25}, {'task': 1, 'start': 142, 'machine': 'A', 'duration': 18}]}, {'job': 'J3', 'tasks': [{'task': 0, 'start': 26, 'machine': 'B', 'duration': 44}, {'task': 1, 'start': 79, 'machine': 'A', 'duration': 63}]}]",3,json,names
JSP,JSP,"I’m coordinating the bays today: each car has a set route through the shop — a defined order of tasks, each bound to a particular bay or tool for a set duration. The job is to pick start times so that no bay or tool is handling overlapping work, each vehicle’s steps happen in sequence, and every required operation is scheduled once. The aim is to have the last car leave as quickly as possible; the time when that last car finishes is the single number used to judge plans, and smaller is better. The concrete details are listed below.

I have 2 vehicles and 2 bays to schedule: J1, J2 are the vehicles and 1, 2 are the bays.

| vehicle_id | step_index | bay_id | step_duration |
|---|---|---|---|
| J1 | 0 | 2 | 1 |
| J1 | 1 | 1 | 92 |
| J2 | 0 | 2 | 1 |
| J2 | 1 | 1 | 64 |

I'll schedule these steps to minimize when the last car leaves.

If you want to give me the plan in a tidy, machine-friendly way, just follow this relaxed JSON layout — something like this will do:

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

This is just a little form to fill in: ""solution"" holds all the cars, each entry names the job, and inside ""tasks"" you list each step with which numbered task it is, when it starts, which bay/tool (machine) it uses, and how long it runs. Think of it like filling out a work order for each car — nothing fancy, just the basic fields. It’s only a sketch of the expected shape, not the actual schedule.

Please use the exact identifiers from the instance input — don’t rename jobs or machines 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': [[[1, 1], [0, 92]], [[1, 1], [0, 64]]]}","[{'job': 0, 'tasks': [{'task': 0, 'start': 0, 'machine': 1, 'duration': 1}, {'task': 1, 'start': 1, 'machine': 0, 'duration': 92}]}, {'job': 1, 'tasks': [{'task': 0, 'start': 1, 'machine': 1, 'duration': 1}, {'task': 1, 'start': 93, 'machine': 0, 'duration': 64}]}]",157.0,"{'problem_type': 'JSP', 'nr_jobs': 2, 'nr_machines': 2, 'jobs': ['J1', 'J2'], 'machines': [1, 2], 'records': [{'job_id': 'J1', 'task_id': 0, 'machine_id': 2, 'duration': 1}, {'job_id': 'J1', 'task_id': 1, 'machine_id': 1, 'duration': 92}, {'job_id': 'J2', 'task_id': 0, 'machine_id': 2, 'duration': 1}, {'job_id': 'J2', 'task_id': 1, 'machine_id': 1, 'duration': 64}]}","[{'job': 'J1', 'tasks': [{'task': 0, 'start': 0, 'machine': 2, 'duration': 1}, {'task': 1, 'start': 1, 'machine': 1, 'duration': 92}]}, {'job': 'J2', 'tasks': [{'task': 0, 'start': 1, 'machine': 2, 'duration': 1}, {'task': 1, 'start': 93, 'machine': 1, 'duration': 64}]}]",4,markdown_table,1
JSP,JSP,"We treat the OR board like a slow-motion relay: every patient must run through a fixed chain of phases, each phase needs a particular room or machine for a set duration, and that room can’t be doing anything else at the same time. The task is to slot each phase into its assigned space, in order, without overlaps or repeats, so every phase happens exactly once in the right sequence. The thing that makes one schedule better than another is simple — how early does the final patient leave? The time when the last procedure ends is the number to minimize. The concrete list of cases and times follows below.

# number_of_patients=5
# number_of_rooms_and_equipment=2
# patient_ids=J1, J2, J3, J4, J5
# room_equipment_ids=0, 1
patient_id,phase_index,room_equipment_id,phase_duration_minutes
J1,0,1,1
J1,1,0,6
J2,0,1,76
J2,1,0,10
J3,0,0,51
J3,1,1,8
J4,0,0,17
J4,1,1,23
J5,0,1,25
J5,1,0,99

You can hand the schedule back to me in a simple JSON shape — nothing fancy, just that structure so I can read it straight away. Here’s the exact layout I expect:

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

Think of it like a little form: ""solution"" is the whole set of plans; each entry under it is one job (use the job's exact identifier), and inside each job you list its tasks in order. For each task you give the task index (which step it is in that job), the start time, the machine it runs on, and how long it runs. This is just a sketch of the shape I need, not the finished schedule.

Please make sure to use the exact identifiers from the instance — don't rename machines or jobs 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': [[[1, 1], [0, 6]], [[1, 76], [0, 10]], [[0, 51], [1, 8]], [[0, 17], [1, 23]], [[1, 25], [0, 99]]]}","[{'job': 0, 'tasks': [{'task': 0, 'start': 25, 'machine': 1, 'duration': 1}, {'task': 1, 'start': 51, 'machine': 0, 'duration': 6}]}, {'job': 1, 'tasks': [{'task': 0, 'start': 59, 'machine': 1, 'duration': 76}, {'task': 1, 'start': 173, 'machine': 0, 'duration': 10}]}, {'job': 2, 'tasks': [{'task': 0, 'start': 0, 'machine': 0, 'duration': 51}, {'task': 1, 'start': 51, 'machine': 1, 'duration': 8}]}, {'job': 3, 'tasks': [{'task': 0, 'start': 57, 'machine': 0, 'duration': 17}, {'task': 1, 'start': 135, 'machine': 1, 'duration': 23}]}, {'job': 4, 'tasks': [{'task': 0, 'start': 0, 'machine': 1, 'duration': 25}, {'task': 1, 'start': 74, 'machine': 0, 'duration': 99}]}]",183.0,"{'problem_type': 'JSP', 'nr_jobs': 5, 'nr_machines': 2, 'jobs': ['J1', 'J2', 'J3', 'J4', 'J5'], 'machines': [0, 1], 'records': [{'job_id': 'J1', 'task_id': 0, 'machine_id': 1, 'duration': 1}, {'job_id': 'J1', 'task_id': 1, 'machine_id': 0, 'duration': 6}, {'job_id': 'J2', 'task_id': 0, 'machine_id': 1, 'duration': 76}, {'job_id': 'J2', 'task_id': 1, 'machine_id': 0, 'duration': 10}, {'job_id': 'J3', 'task_id': 0, 'machine_id': 0, 'duration': 51}, {'job_id': 'J3', 'task_id': 1, 'machine_id': 1, 'duration': 8}, {'job_id': 'J4', 'task_id': 0, 'machine_id': 0, 'duration': 17}, {'job_id': 'J4', 'task_id': 1, 'machine_id': 1, 'duration': 23}, {'job_id': 'J5', 'task_id': 0, 'machine_id': 1, 'duration': 25}, {'job_id': 'J5', 'task_id': 1, 'machine_id': 0, 'duration': 99}]}","[{'job': 'J1', 'tasks': [{'task': 0, 'start': 25, 'machine': 1, 'duration': 1}, {'task': 1, 'start': 51, 'machine': 0, 'duration': 6}]}, {'job': 'J2', 'tasks': [{'task': 0, 'start': 59, 'machine': 1, 'duration': 76}, {'task': 1, 'start': 173, 'machine': 0, 'duration': 10}]}, {'job': 'J3', 'tasks': [{'task': 0, 'start': 0, 'machine': 0, 'duration': 51}, {'task': 1, 'start': 51, 'machine': 1, 'duration': 8}]}, {'job': 'J4', 'tasks': [{'task': 0, 'start': 57, 'machine': 0, 'duration': 17}, {'task': 1, 'start': 135, 'machine': 1, 'duration': 23}]}, {'job': 'J5', 'tasks': [{'task': 0, 'start': 0, 'machine': 1, 'duration': 25}, {'task': 1, 'start': 74, 'machine': 0, 'duration': 99}]}]",5,csv,0
JSP,JSP,"Many people think booking is just filling empty slots, but a salon schedule is really about sequencing fixed step-by-step treatments at specific stations for set durations. The plan needs to keep each client’s steps in order, make sure each step uses its assigned chair for its required minutes, and never put two treatments on the same chair at once. The better the plan, the sooner the final customer is finished — that final finish time is how the whole day is judged. The concrete details are shown below.

There are 2 clients and 2 stations; client IDs: J1, J2; station IDs: A, B.

| client_id | step_index | station_id | duration_minutes |
|---|---|---|---|
| J1 | 0 | B | 1 |
| J1 | 1 | A | 19 |
| J2 | 0 | A | 51 |
| J2 | 1 | B | 56 |

Keep every client's steps in order and prevent any station overlap; the day's quality is judged by when the last customer finishes.

If you’d like the result in a tidy, machine-friendly shape, I usually sketch it out like this:

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

Think of that as a simple form: ""solution"" holds every client’s plan; each entry has the job id and a list of tasks. Each task says which step it is, when it starts, which chair/station (machine) it needs, and how long it runs. It’s just the shape I expect the final schedule to follow — not the actual schedule itself.

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': [[[1, 1], [0, 19]], [[0, 51], [1, 56]]]}","[{'job': 0, 'tasks': [{'task': 0, 'start': 0, 'machine': 1, 'duration': 1}, {'task': 1, 'start': 51, 'machine': 0, 'duration': 19}]}, {'job': 1, 'tasks': [{'task': 0, 'start': 0, 'machine': 0, 'duration': 51}, {'task': 1, 'start': 51, 'machine': 1, 'duration': 56}]}]",107.0,"{'problem_type': 'JSP', 'nr_jobs': 2, 'nr_machines': 2, 'jobs': ['J1', 'J2'], 'machines': ['A', 'B'], 'records': [{'job_id': 'J1', 'task_id': 0, 'machine_id': 'B', 'duration': 1}, {'job_id': 'J1', 'task_id': 1, 'machine_id': 'A', 'duration': 19}, {'job_id': 'J2', 'task_id': 0, 'machine_id': 'A', 'duration': 51}, {'job_id': 'J2', 'task_id': 1, 'machine_id': 'B', 'duration': 56}]}","[{'job': 'J1', 'tasks': [{'task': 0, 'start': 0, 'machine': 'B', 'duration': 1}, {'task': 1, 'start': 51, 'machine': 'A', 'duration': 19}]}, {'job': 'J2', 'tasks': [{'task': 0, 'start': 0, 'machine': 'A', 'duration': 51}, {'task': 1, 'start': 51, 'machine': 'B', 'duration': 56}]}]",6,markdown_table,names
JSP,JSP,"I run the print shop and have a stack of jobs that each need a set sequence of steps — print, dry, trim, bind — and every step has to happen on a specific press or binder and takes a known amount of time. The job is to pick when each machine does each step so that no press is doing two things at once, every step for each job happens in the right order, and nothing is skipped or duplicated. A better schedule gets the whole batch finished earlier; the success is simply the clock time when the final operation finishes, and the aim is to make that finish time as small as possible. The exact jobs, machines and times are listed below.

{
  ""total_print_jobs"": 3,
  ""total_stations"": 2,
  ""print_job_ids"": [
    ""J1"",
    ""J2"",
    ""J3""
  ],
  ""station_ids"": [
    ""A"",
    ""B""
  ],
  ""tasks"": [
    {
      ""print_job_id"": ""J1"",
      ""operation_index"": 0,
      ""station_id"": ""B"",
      ""processing_duration"": 1
    },
    {
      ""print_job_id"": ""J1"",
      ""operation_index"": 1,
      ""station_id"": ""A"",
      ""processing_duration"": 32
    },
    {
      ""print_job_id"": ""J2"",
      ""operation_index"": 0,
      ""station_id"": ""A"",
      ""processing_duration"": 27
    },
    {
      ""print_job_id"": ""J2"",
      ""operation_index"": 1,
      ""station_id"": ""B"",
      ""processing_duration"": 2
    },
    {
      ""print_job_id"": ""J3"",
      ""operation_index"": 0,
      ""station_id"": ""B"",
      ""processing_duration"": 57
    },
    {
      ""print_job_id"": ""J3"",
      ""operation_index"": 1,
      ""station_id"": ""A"",
      ""processing_duration"": 51
    }
  ]
}

Also, when you give the schedule back, keep it in a simple JSON layout so it's easy to parse — something like this:

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

This just means: top-level ""solution"" is a list of jobs. For each job, put its job identifier under ""job"" and a ""tasks"" list with one entry per operation. Each task entry says which step number it is (""task""), when that step starts (""start""), which machine it runs on (""machine""), and how long it runs (""duration""). Think of it like filling out a little form for each job and each step.

Note: that JSON is only a sketch of the shape I expect, not the actual answer — you'll need to fill in the real values from the instance. Also, please use the exact identifiers from the instance input with no renaming and no new labels. 
- for example: ""Valid identifiers look like plain numbers such as “1” or “23”, single capital letters like “A” or “B”, or a capital letter followed by digits like “A1” or “X7”.""","{'nr_machines': 2, 'nr_jobs': 3, 'jobs': [[[1, 1], [0, 32]], [[0, 27], [1, 2]], [[1, 57], [0, 51]]]}","[{'job': 0, 'tasks': [{'task': 0, 'start': 0, 'machine': 1, 'duration': 1}, {'task': 1, 'start': 27, 'machine': 0, 'duration': 32}]}, {'job': 1, 'tasks': [{'task': 0, 'start': 0, 'machine': 0, 'duration': 27}, {'task': 1, 'start': 58, 'machine': 1, 'duration': 2}]}, {'job': 2, 'tasks': [{'task': 0, 'start': 1, 'machine': 1, 'duration': 57}, {'task': 1, 'start': 59, 'machine': 0, 'duration': 51}]}]",110.0,"{'problem_type': 'JSP', 'nr_jobs': 3, 'nr_machines': 2, 'jobs': ['J1', 'J2', 'J3'], 'machines': ['A', 'B'], 'records': [{'job_id': 'J1', 'task_id': 0, 'machine_id': 'B', 'duration': 1}, {'job_id': 'J1', 'task_id': 1, 'machine_id': 'A', 'duration': 32}, {'job_id': 'J2', 'task_id': 0, 'machine_id': 'A', 'duration': 27}, {'job_id': 'J2', 'task_id': 1, 'machine_id': 'B', 'duration': 2}, {'job_id': 'J3', 'task_id': 0, 'machine_id': 'B', 'duration': 57}, {'job_id': 'J3', 'task_id': 1, 'machine_id': 'A', 'duration': 51}]}","[{'job': 'J1', 'tasks': [{'task': 0, 'start': 0, 'machine': 'B', 'duration': 1}, {'task': 1, 'start': 27, 'machine': 'A', 'duration': 32}]}, {'job': 'J2', 'tasks': [{'task': 0, 'start': 0, 'machine': 'A', 'duration': 27}, {'task': 1, 'start': 58, 'machine': 'B', 'duration': 2}]}, {'job': 'J3', 'tasks': [{'task': 0, 'start': 1, 'machine': 'B', 'duration': 57}, {'task': 1, 'start': 59, 'machine': 'A', 'duration': 51}]}]",7,json,names
JSP,JSP,"Someone has to be the shop scheduler: line up the development, drying, trimming and other steps for each print on their assigned machines, respect the order of steps, and never let a machine do two steps at once. The decision is choosing the timing for each step so nothing’s missed or duplicated and the whole batch finishes as quickly as possible. Performance is measured by the time the last print completes — you find every print’s end time and take the maximum; lower is preferable. The concrete job list and timings appear below.

There are 2 print runs and 2 processing stations; print run IDs: J1, J2; station IDs: A, B.
Print J1, step 0 on station B for 1 time units.
Print J1, step 1 on station A for 45 time units.
Print J2, step 0 on station A for 3 time units.
Print J2, step 1 on station B for 47 time units.
Arrange these steps so the last print finishes as early as possible.

When you hand me the schedule, just use a simple JSON shape — nothing fancy. Something like this will do:

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

Think of that as a little form: ""solution"" holds a list of jobs; each job has its id and a list of tasks; each task records which step it is, when it starts, which machine it uses, and how long it runs. Super casual — like filling in a schedule sheet.

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

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': 2, 'jobs': [[[1, 1], [0, 45]], [[0, 3], [1, 47]]]}","[{'job': 0, 'tasks': [{'task': 0, 'start': 0, 'machine': 1, 'duration': 1}, {'task': 1, 'start': 3, 'machine': 0, 'duration': 45}]}, {'job': 1, 'tasks': [{'task': 0, 'start': 0, 'machine': 0, 'duration': 3}, {'task': 1, 'start': 3, 'machine': 1, 'duration': 47}]}]",50.0,"{'problem_type': 'JSP', 'nr_jobs': 2, 'nr_machines': 2, 'jobs': ['J1', 'J2'], 'machines': ['A', 'B'], 'records': [{'job_id': 'J1', 'task_id': 0, 'machine_id': 'B', 'duration': 1}, {'job_id': 'J1', 'task_id': 1, 'machine_id': 'A', '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': 'B', 'duration': 1}, {'task': 1, 'start': 3, 'machine': 'A', 'duration': 45}]}, {'job': 'J2', 'tasks': [{'task': 0, 'start': 0, 'machine': 'A', 'duration': 3}, {'task': 1, 'start': 3, 'machine': 'B', 'duration': 47}]}]",8,nl,names
JSP,JSP,"There’s a line of orders waiting and every pastry needs a chain of steps on specific machines, each taking a fixed amount of time. The trick is arranging those steps in time so each recipe’s sequence is preserved, no machine is asked to do two things at once, and nothing is skipped or duplicated. Success is judged by the moment the last item is done — that end time tells how efficient the plan was. The exact details of items, machines, and durations are shown below.

Below are the 5 orders and the 2 machines: order IDs J1, J2, J3, J4, J5 and machine IDs 1, 2.
Order J1, step 0 — requires machine 2 for 1 minutes.
Order J1, step 1 — requires machine 1 for 58 minutes.
Order J2, step 0 — requires machine 1 for 78 minutes.
Order J2, step 1 — requires machine 2 for 93 minutes.
Order J3, step 0 — requires machine 1 for 64 minutes.
Order J3, step 1 — requires machine 2 for 94 minutes.
Order J4, step 0 — requires machine 2 for 35 minutes.
Order J4, step 1 — requires machine 1 for 94 minutes.
Order J5, step 0 — requires machine 2 for 96 minutes.
Order J5, step 1 — requires machine 1 for 73 minutes.
They should be arranged so each recipe runs in sequence and no machine is double-booked.

Also, when you hand the schedule back, just follow this simple JSON shape so it's easy to read and check:

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

This is just a sketch of the expected shape — each top-level entry is one job, and each job lists its tasks in order. For each task you give the task index (which task in the job), the planned start time, the machine it runs on, and how long it runs. Keep it simple and human-readable, like filling out a tiny form.

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': 5, 'jobs': [[[1, 1], [0, 58]], [[0, 78], [1, 93]], [[0, 64], [1, 94]], [[1, 35], [0, 94]], [[1, 96], [0, 73]]]}","[{'job': 0, 'tasks': [{'task': 0, 'start': 0, 'machine': 1, 'duration': 1}, {'task': 1, 'start': 78, 'machine': 0, 'duration': 58}]}, {'job': 1, 'tasks': [{'task': 0, 'start': 0, 'machine': 0, 'duration': 78}, {'task': 1, 'start': 97, 'machine': 1, 'duration': 93}]}, {'job': 2, 'tasks': [{'task': 0, 'start': 209, 'machine': 0, 'duration': 64}, {'task': 1, 'start': 273, 'machine': 1, 'duration': 94}]}, {'job': 3, 'tasks': [{'task': 0, 'start': 190, 'machine': 1, 'duration': 35}, {'task': 1, 'start': 273, 'machine': 0, 'duration': 94}]}, {'job': 4, 'tasks': [{'task': 0, 'start': 1, 'machine': 1, 'duration': 96}, {'task': 1, 'start': 136, 'machine': 0, 'duration': 73}]}]",367.0,"{'problem_type': 'JSP', 'nr_jobs': 5, 'nr_machines': 2, 'jobs': ['J1', 'J2', 'J3', 'J4', 'J5'], 'machines': [1, 2], 'records': [{'job_id': 'J1', 'task_id': 0, 'machine_id': 2, 'duration': 1}, {'job_id': 'J1', 'task_id': 1, 'machine_id': 1, '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': 2, 'duration': 35}, {'job_id': 'J4', 'task_id': 1, 'machine_id': 1, 'duration': 94}, {'job_id': 'J5', 'task_id': 0, 'machine_id': 2, 'duration': 96}, {'job_id': 'J5', 'task_id': 1, 'machine_id': 1, 'duration': 73}]}","[{'job': 'J1', 'tasks': [{'task': 0, 'start': 0, 'machine': 2, 'duration': 1}, {'task': 1, 'start': 78, 'machine': 1, 'duration': 58}]}, {'job': 'J2', 'tasks': [{'task': 0, 'start': 0, 'machine': 1, 'duration': 78}, {'task': 1, 'start': 97, 'machine': 2, 'duration': 93}]}, {'job': 'J3', 'tasks': [{'task': 0, 'start': 209, 'machine': 1, 'duration': 64}, {'task': 1, 'start': 273, 'machine': 2, 'duration': 94}]}, {'job': 'J4', 'tasks': [{'task': 0, 'start': 190, 'machine': 2, 'duration': 35}, {'task': 1, 'start': 273, 'machine': 1, 'duration': 94}]}, {'job': 'J5', 'tasks': [{'task': 0, 'start': 1, 'machine': 2, 'duration': 96}, {'task': 1, 'start': 136, 'machine': 1, 'duration': 73}]}]",9,nl,1
JSP,JSP,"I run the render farm and my job is to pick start times for every little scene task so each one runs on its assigned server for however long it needs. Each shot is a chain of steps that have to happen in order, every task has to be scheduled exactly once, and no server can be asked to do two things at once. A better plan is simply the one that gets the whole project finished sooner — to check that, look at the finish times of all tasks and take the latest one; the smaller that time, the better. The concrete scene-by-scene details and runtimes are listed below.

There are 5 shots (J1, J2, J3, J4, J5) and 3 servers (1, 2, 3).
I must schedule shot J1 step 0 on server 2 for 1.
I must schedule shot J1 step 1 on server 3 for 71.
I must schedule shot J1 step 2 on server 1 for 54.
I must schedule shot J2 step 0 on server 1 for 39.
I must schedule shot J2 step 1 on server 3 for 17.
I must schedule shot J2 step 2 on server 2 for 17.
I must schedule shot J3 step 0 on server 1 for 40.
I must schedule shot J3 step 1 on server 2 for 62.
I must schedule shot J3 step 2 on server 3 for 64.
I must schedule shot J4 step 0 on server 2 for 67.
I must schedule shot J4 step 1 on server 1 for 56.
I must schedule shot J4 step 2 on server 3 for 49.
I must schedule shot J5 step 0 on server 1 for 38.
I must schedule shot J5 step 1 on server 3 for 76.
I must schedule shot J5 step 2 on server 2 for 72.
I'll use these details to pick start times that minimize the overall finish time.

When you send the schedule back, just use this simple JSON shape so I can pick up the info cleanly:

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

Think of it like a little form: the top-level ""solution"" holds one entry per shot (job). Each job entry names the job and then lists its tasks in order. For each task you give which step it is (""task""), when it starts (""start""), which server it runs on (""machine""), and how long it runs (""duration""). This block is just a sketch of the shape I expect, not the actual schedule — fill it with the real IDs and times when you reply.

Please use the exact identifiers from the instance input — do not rename or invent labels. Valid identifiers look like plain numbers such as “1” or “23”, single capital letters like “A” or “B”, or a capital letter followed by digits like “A1” or “X7”.","{'nr_machines': 3, 'nr_jobs': 5, 'jobs': [[[1, 1], [2, 71], [0, 54]], [[0, 39], [2, 17], [1, 17]], [[0, 40], [1, 62], [2, 64]], [[1, 67], [0, 56], [2, 49]], [[0, 38], [2, 76], [1, 72]]]}","[{'job': 0, 'tasks': [{'task': 0, 'start': 0, 'machine': 1, 'duration': 1}, {'task': 1, 'start': 1, 'machine': 2, 'duration': 71}, {'task': 2, 'start': 173, 'machine': 0, 'duration': 54}]}, {'job': 1, 'tasks': [{'task': 0, 'start': 78, 'machine': 0, 'duration': 39}, {'task': 1, 'start': 148, 'machine': 2, 'duration': 17}, {'task': 2, 'start': 220, 'machine': 1, 'duration': 17}]}, {'job': 2, 'tasks': [{'task': 0, 'start': 38, 'machine': 0, 'duration': 40}, {'task': 1, 'start': 78, 'machine': 1, 'duration': 62}, {'task': 2, 'start': 165, 'machine': 2, 'duration': 64}]}, {'job': 3, 'tasks': [{'task': 0, 'start': 1, 'machine': 1, 'duration': 67}, {'task': 1, 'start': 117, 'machine': 0, 'duration': 56}, {'task': 2, 'start': 229, 'machine': 2, 'duration': 49}]}, {'job': 4, 'tasks': [{'task': 0, 'start': 0, 'machine': 0, 'duration': 38}, {'task': 1, 'start': 72, 'machine': 2, 'duration': 76}, {'task': 2, 'start': 148, 'machine': 1, 'duration': 72}]}]",278.0,"{'problem_type': 'JSP', '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': 2, 'duration': 1}, {'job_id': 'J1', 'task_id': 1, 'machine_id': 3, 'duration': 71}, {'job_id': 'J1', 'task_id': 2, 'machine_id': 1, 'duration': 54}, {'job_id': 'J2', 'task_id': 0, 'machine_id': 1, 'duration': 39}, {'job_id': 'J2', 'task_id': 1, 'machine_id': 3, 'duration': 17}, {'job_id': 'J2', 'task_id': 2, 'machine_id': 2, 'duration': 17}, {'job_id': 'J3', 'task_id': 0, 'machine_id': 1, 'duration': 40}, {'job_id': 'J3', 'task_id': 1, 'machine_id': 2, 'duration': 62}, {'job_id': 'J3', 'task_id': 2, 'machine_id': 3, 'duration': 64}, {'job_id': 'J4', 'task_id': 0, 'machine_id': 2, 'duration': 67}, {'job_id': 'J4', 'task_id': 1, 'machine_id': 1, 'duration': 56}, {'job_id': 'J4', 'task_id': 2, 'machine_id': 3, 'duration': 49}, {'job_id': 'J5', 'task_id': 0, 'machine_id': 1, 'duration': 38}, {'job_id': 'J5', 'task_id': 1, 'machine_id': 3, 'duration': 76}, {'job_id': 'J5', 'task_id': 2, 'machine_id': 2, 'duration': 72}]}","[{'job': 'J1', 'tasks': [{'task': 0, 'start': 0, 'machine': 2, 'duration': 1}, {'task': 1, 'start': 1, 'machine': 3, 'duration': 71}, {'task': 2, 'start': 173, 'machine': 1, 'duration': 54}]}, {'job': 'J2', 'tasks': [{'task': 0, 'start': 78, 'machine': 1, 'duration': 39}, {'task': 1, 'start': 148, 'machine': 3, 'duration': 17}, {'task': 2, 'start': 220, 'machine': 2, 'duration': 17}]}, {'job': 'J3', 'tasks': [{'task': 0, 'start': 38, 'machine': 1, 'duration': 40}, {'task': 1, 'start': 78, 'machine': 2, 'duration': 62}, {'task': 2, 'start': 165, 'machine': 3, 'duration': 64}]}, {'job': 'J4', 'tasks': [{'task': 0, 'start': 1, 'machine': 2, 'duration': 67}, {'task': 1, 'start': 117, 'machine': 1, 'duration': 56}, {'task': 2, 'start': 229, 'machine': 3, 'duration': 49}]}, {'job': 'J5', 'tasks': [{'task': 0, 'start': 0, 'machine': 1, 'duration': 38}, {'task': 1, 'start': 72, 'machine': 3, 'duration': 76}, {'task': 2, 'start': 148, 'machine': 2, 'duration': 72}]}]",10,nl,1
JSP,JSP,"I’m the lab coordinator trying to line up a stack of experiments so every procedure uses the right instrument for its listed time, with each experiment’s steps done in the order they’re written. The choice to make is when to book each instrument for each step so nothing overlaps and every step happens exactly once. The good schedules are the ones that get all the experiments finished sooner — measure that by the clock time when the last experiment wraps up, and the earlier that finish time, the better. The specific experiments, steps, instruments, and durations are shown below.

{
  ""nr_experiments"": 2,
  ""nr_instruments"": 2,
  ""experiment_ids"": [
    ""J1"",
    ""J2""
  ],
  ""instrument_ids"": [
    ""A"",
    ""B""
  ],
  ""tasks"": [
    {
      ""experiment_id"": ""J1"",
      ""step_index"": 0,
      ""instrument_id"": ""B"",
      ""step_duration"": 1
    },
    {
      ""experiment_id"": ""J1"",
      ""step_index"": 1,
      ""instrument_id"": ""A"",
      ""step_duration"": 84
    },
    {
      ""experiment_id"": ""J2"",
      ""step_index"": 0,
      ""instrument_id"": ""B"",
      ""step_duration"": 29
    },
    {
      ""experiment_id"": ""J2"",
      ""step_index"": 1,
      ""instrument_id"": ""A"",
      ""step_duration"": 85
    }
  ]
}

Also, when you send the schedule back, a handy way to format it is with a simple JSON shape so I can read each experiment (job) and its ordered steps. Something like this:

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

Think of that JSON as a little form: each top-level ""job"" is one experiment, ""tasks"" is the ordered list of steps, ""task"" is the step number, ""start"" is the clock time that step begins, ""machine"" is which instrument it uses, and ""duration"" is how long that step runs. It's just a sketch of the shape I need — not the actual schedule yet.

Please make sure to use the exact identifiers from the instance input — no renaming and no new labels.

""Valid identifiers look like plain numbers such as “1” or “23”, single capital letters like “A” or “B”, or a capital letter followed by digits like “A1” or “X7”.""","{'nr_machines': 2, 'nr_jobs': 2, 'jobs': [[[1, 1], [0, 84]], [[1, 29], [0, 85]]]}","[{'job': 0, 'tasks': [{'task': 0, 'start': 0, 'machine': 1, 'duration': 1}, {'task': 1, 'start': 1, 'machine': 0, 'duration': 84}]}, {'job': 1, 'tasks': [{'task': 0, 'start': 1, 'machine': 1, 'duration': 29}, {'task': 1, 'start': 85, 'machine': 0, 'duration': 85}]}]",170.0,"{'problem_type': 'JSP', 'nr_jobs': 2, 'nr_machines': 2, 'jobs': ['J1', 'J2'], 'machines': ['A', 'B'], 'records': [{'job_id': 'J1', 'task_id': 0, 'machine_id': 'B', 'duration': 1}, {'job_id': 'J1', 'task_id': 1, 'machine_id': 'A', 'duration': 84}, {'job_id': 'J2', 'task_id': 0, 'machine_id': 'B', 'duration': 29}, {'job_id': 'J2', 'task_id': 1, 'machine_id': 'A', 'duration': 85}]}","[{'job': 'J1', 'tasks': [{'task': 0, 'start': 0, 'machine': 'B', 'duration': 1}, {'task': 1, 'start': 1, 'machine': 'A', 'duration': 84}]}, {'job': 'J2', 'tasks': [{'task': 0, 'start': 1, 'machine': 'B', 'duration': 29}, {'task': 1, 'start': 85, 'machine': 'A', 'duration': 85}]}]",11,json,names
JSP,JSP,"Late one night the operations lead described the situation like a game: batches move through a fixed series of stations, each station is a certain server and each stop takes a set time, and a server can only serve one stop at a time. The game is to time every start so each stop gets its right server for the allotted time, the stops in a batch occur in their given order, nothing is left out or done twice, and the entire game ends as fast as possible — tracked by the moment the last stop finishes on the clock. The exact job and server specifics are shown below.

{
  ""total_batch_jobs"": 5,
  ""total_servers"": 3,
  ""batch_job_ids"": [
    ""J1"",
    ""J2"",
    ""J3"",
    ""J4"",
    ""J5""
  ],
  ""server_ids"": [
    1,
    2,
    3
  ],
  ""tasks"": [
    {
      ""batch_id"": ""J1"",
      ""stage_index"": 0,
      ""required_server_id"": 2,
      ""expected_runtime"": 1
    },
    {
      ""batch_id"": ""J1"",
      ""stage_index"": 1,
      ""required_server_id"": 3,
      ""expected_runtime"": 97
    },
    {
      ""batch_id"": ""J1"",
      ""stage_index"": 2,
      ""required_server_id"": 1,
      ""expected_runtime"": 5
    },
    {
      ""batch_id"": ""J2"",
      ""stage_index"": 0,
      ""required_server_id"": 3,
      ""expected_runtime"": 31
    },
    {
      ""batch_id"": ""J2"",
      ""stage_index"": 1,
      ""required_server_id"": 2,
      ""expected_runtime"": 24
    },
    {
      ""batch_id"": ""J2"",
      ""stage_index"": 2,
      ""required_server_id"": 1,
      ""expected_runtime"": 60
    },
    {
      ""batch_id"": ""J3"",
      ""stage_index"": 0,
      ""required_server_id"": 2,
      ""expected_runtime"": 49
    },
    {
      ""batch_id"": ""J3"",
      ""stage_index"": 1,
      ""required_server_id"": 1,
      ""expected_runtime"": 98
    },
    {
      ""batch_id"": ""J3"",
      ""stage_index"": 2,
      ""required_server_id"": 3,
      ""expected_runtime"": 1
    },
    {
      ""batch_id"": ""J4"",
      ""stage_index"": 0,
      ""required_server_id"": 1,
      ""expected_runtime"": 54
    },
    {
      ""batch_id"": ""J4"",
      ""stage_index"": 1,
      ""required_server_id"": 2,
      ""expected_runtime"": 33
    },
    {
      ""batch_id"": ""J4"",
      ""stage_index"": 2,
      ""required_server_id"": 3,
      ""expected_runtime"": 53
    },
    {
      ""batch_id"": ""J5"",
      ""stage_index"": 0,
      ""required_server_id"": 2,
      ""expected_runtime"": 5
    },
    {
      ""batch_id"": ""J5"",
      ""stage_index"": 1,
      ""required_server_id"": 1,
      ""expected_runtime"": 83
    },
    {
      ""batch_id"": ""J5"",
      ""stage_index"": 2,
      ""required_server_id"": 3,
      ""expected_runtime"": 83
    }
  ]
}

Also, to keep things tidy when you send the schedule back, just follow this simple JSON shape:

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

Think of it as a little form: ""solution"" is the list of jobs, each job has its id and a list of tasks, and each task entry says which numbered stop it is, the clock time it starts, which server (machine) it uses, and how long it runs. This is just the sketch of the shape I need — not the actual schedule itself.

Please make sure to use the exact identifiers from the instance input — don’t rename them and don’t 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': [[[1, 1], [2, 97], [0, 5]], [[2, 31], [1, 24], [0, 60]], [[1, 49], [0, 98], [2, 1]], [[0, 54], [1, 33], [2, 53]], [[1, 5], [0, 83], [2, 83]]]}","[{'job': 0, 'tasks': [{'task': 0, 'start': 54, 'machine': 1, 'duration': 1}, {'task': 1, 'start': 55, 'machine': 2, 'duration': 97}, {'task': 2, 'start': 295, 'machine': 0, 'duration': 5}]}, {'job': 1, 'tasks': [{'task': 0, 'start': 0, 'machine': 2, 'duration': 31}, {'task': 1, 'start': 88, 'machine': 1, 'duration': 24}, {'task': 2, 'start': 235, 'machine': 0, 'duration': 60}]}, {'job': 2, 'tasks': [{'task': 0, 'start': 5, 'machine': 1, 'duration': 49}, {'task': 1, 'start': 137, 'machine': 0, 'duration': 98}, {'task': 2, 'start': 288, 'machine': 2, 'duration': 1}]}, {'job': 3, 'tasks': [{'task': 0, 'start': 0, 'machine': 0, 'duration': 54}, {'task': 1, 'start': 55, 'machine': 1, 'duration': 33}, {'task': 2, 'start': 235, 'machine': 2, 'duration': 53}]}, {'job': 4, 'tasks': [{'task': 0, 'start': 0, 'machine': 1, 'duration': 5}, {'task': 1, 'start': 54, 'machine': 0, 'duration': 83}, {'task': 2, 'start': 152, 'machine': 2, 'duration': 83}]}]",300.0,"{'problem_type': 'JSP', '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': 2, 'duration': 1}, {'job_id': 'J1', 'task_id': 1, 'machine_id': 3, 'duration': 97}, {'job_id': 'J1', 'task_id': 2, 'machine_id': 1, 'duration': 5}, {'job_id': 'J2', 'task_id': 0, 'machine_id': 3, 'duration': 31}, {'job_id': 'J2', 'task_id': 1, 'machine_id': 2, 'duration': 24}, {'job_id': 'J2', 'task_id': 2, 'machine_id': 1, 'duration': 60}, {'job_id': 'J3', 'task_id': 0, 'machine_id': 2, 'duration': 49}, {'job_id': 'J3', 'task_id': 1, 'machine_id': 1, 'duration': 98}, {'job_id': 'J3', 'task_id': 2, 'machine_id': 3, 'duration': 1}, {'job_id': 'J4', 'task_id': 0, 'machine_id': 1, 'duration': 54}, {'job_id': 'J4', 'task_id': 1, 'machine_id': 2, 'duration': 33}, {'job_id': 'J4', 'task_id': 2, 'machine_id': 3, 'duration': 53}, {'job_id': 'J5', 'task_id': 0, 'machine_id': 2, 'duration': 5}, {'job_id': 'J5', 'task_id': 1, 'machine_id': 1, 'duration': 83}, {'job_id': 'J5', 'task_id': 2, 'machine_id': 3, 'duration': 83}]}","[{'job': 'J1', 'tasks': [{'task': 0, 'start': 54, 'machine': 2, 'duration': 1}, {'task': 1, 'start': 55, 'machine': 3, 'duration': 97}, {'task': 2, 'start': 295, 'machine': 1, 'duration': 5}]}, {'job': 'J2', 'tasks': [{'task': 0, 'start': 0, 'machine': 3, 'duration': 31}, {'task': 1, 'start': 88, 'machine': 2, 'duration': 24}, {'task': 2, 'start': 235, 'machine': 1, 'duration': 60}]}, {'job': 'J3', 'tasks': [{'task': 0, 'start': 5, 'machine': 2, 'duration': 49}, {'task': 1, 'start': 137, 'machine': 1, 'duration': 98}, {'task': 2, 'start': 288, 'machine': 3, 'duration': 1}]}, {'job': 'J4', 'tasks': [{'task': 0, 'start': 0, 'machine': 1, 'duration': 54}, {'task': 1, 'start': 55, 'machine': 2, 'duration': 33}, {'task': 2, 'start': 235, 'machine': 3, 'duration': 53}]}, {'job': 'J5', 'tasks': [{'task': 0, 'start': 0, 'machine': 2, 'duration': 5}, {'task': 1, 'start': 54, 'machine': 1, 'duration': 83}, {'task': 2, 'start': 152, 'machine': 3, 'duration': 83}]}]",12,json,1
JSP,JSP,"In the edit bay it’s down to sequencing: each scene needs a lineup of tasks done one after another, each task tied to a particular station and taking a fixed amount of time. Stations can’t do two tasks at once, and every required task must occur once and only once. The whole exercise is about getting the project fully wrapped ASAP — measured by the moment the last task finishes — so plans are judged by how early that finishing moment is. The concrete scene list and durations follow below.

{
  ""nr_scenes"": 4,
  ""nr_stations"": 2,
  ""scenes"": [
    ""J1"",
    ""J2"",
    ""J3"",
    ""J4""
  ],
  ""stations"": [
    1,
    2
  ],
  ""tasks"": [
    {
      ""scene_id"": ""J1"",
      ""step_index"": 0,
      ""station_id"": 2,
      ""step_duration"": 1
    },
    {
      ""scene_id"": ""J1"",
      ""step_index"": 1,
      ""station_id"": 1,
      ""step_duration"": 11
    },
    {
      ""scene_id"": ""J2"",
      ""step_index"": 0,
      ""station_id"": 2,
      ""step_duration"": 80
    },
    {
      ""scene_id"": ""J2"",
      ""step_index"": 1,
      ""station_id"": 1,
      ""step_duration"": 76
    },
    {
      ""scene_id"": ""J3"",
      ""step_index"": 0,
      ""station_id"": 1,
      ""step_duration"": 77
    },
    {
      ""scene_id"": ""J3"",
      ""step_index"": 1,
      ""station_id"": 2,
      ""step_duration"": 82
    },
    {
      ""scene_id"": ""J4"",
      ""step_index"": 0,
      ""station_id"": 2,
      ""step_duration"": 54
    },
    {
      ""scene_id"": ""J4"",
      ""step_index"": 1,
      ""station_id"": 1,
      ""step_duration"": 66
    }
  ]
}

Oh, and to keep things tidy, please shape your plan like 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 little form: each ""job"" is one of the scenes, ""tasks"" lists the steps for that scene, ""task"" is the step index, ""start"" is when that step begins, ""machine"" is the station that does the work, and ""duration"" is how long that step runs. Super casual — the JSON is just a sketch of the shape I need, not the actual answer itself.

Please also make sure to use the exact identifiers from the instance input — don't rename them or invent new ones. 
- For example: ""Valid identifiers look like plain numbers such as “1” or “23”, single capital letters like “A” or “B”, or a capital letter followed by digits like “A1” or “X7”.""","{'nr_machines': 2, 'nr_jobs': 4, 'jobs': [[[1, 1], [0, 11]], [[1, 80], [0, 76]], [[0, 77], [1, 82]], [[1, 54], [0, 66]]]}","[{'job': 0, 'tasks': [{'task': 0, 'start': 0, 'machine': 1, 'duration': 1}, {'task': 1, 'start': 77, 'machine': 0, 'duration': 11}]}, {'job': 1, 'tasks': [{'task': 0, 'start': 1, 'machine': 1, 'duration': 80}, {'task': 1, 'start': 88, 'machine': 0, 'duration': 76}]}, {'job': 2, 'tasks': [{'task': 0, 'start': 0, 'machine': 0, 'duration': 77}, {'task': 1, 'start': 135, 'machine': 1, 'duration': 82}]}, {'job': 3, 'tasks': [{'task': 0, 'start': 81, 'machine': 1, 'duration': 54}, {'task': 1, 'start': 164, 'machine': 0, 'duration': 66}]}]",230.0,"{'problem_type': 'JSP', 'nr_jobs': 4, 'nr_machines': 2, 'jobs': ['J1', 'J2', 'J3', 'J4'], 'machines': [1, 2], 'records': [{'job_id': 'J1', 'task_id': 0, 'machine_id': 2, 'duration': 1}, {'job_id': 'J1', 'task_id': 1, 'machine_id': 1, 'duration': 11}, {'job_id': 'J2', 'task_id': 0, 'machine_id': 2, 'duration': 80}, {'job_id': 'J2', 'task_id': 1, 'machine_id': 1, 'duration': 76}, {'job_id': 'J3', 'task_id': 0, 'machine_id': 1, 'duration': 77}, {'job_id': 'J3', 'task_id': 1, 'machine_id': 2, 'duration': 82}, {'job_id': 'J4', 'task_id': 0, 'machine_id': 2, 'duration': 54}, {'job_id': 'J4', 'task_id': 1, 'machine_id': 1, 'duration': 66}]}","[{'job': 'J1', 'tasks': [{'task': 0, 'start': 0, 'machine': 2, 'duration': 1}, {'task': 1, 'start': 77, 'machine': 1, 'duration': 11}]}, {'job': 'J2', 'tasks': [{'task': 0, 'start': 1, 'machine': 2, 'duration': 80}, {'task': 1, 'start': 88, 'machine': 1, 'duration': 76}]}, {'job': 'J3', 'tasks': [{'task': 0, 'start': 0, 'machine': 1, 'duration': 77}, {'task': 1, 'start': 135, 'machine': 2, 'duration': 82}]}, {'job': 'J4', 'tasks': [{'task': 0, 'start': 81, 'machine': 2, 'duration': 54}, {'task': 1, 'start': 164, 'machine': 1, 'duration': 66}]}]",13,json,1
JSP,JSP,"On a normal morning at the workshop, every piece of clothing must pass through a fixed chain of stations, each taking its expected time on a particular machine. The task for the manager is to line up those stations across all garments so machines don’t collide, each operation occurs exactly once and in order, and the entire load is finished quickly. The straightforward way to judge two different line-ups is to look at the clock when the last garment is done — whichever clock time is earlier is the better line-up. The concrete details are shown below.

There are 3 garments to schedule across 3 stations; the garment identifiers are J1, J2, J3 and the station identifiers are 0, 1, 2.

| garment_id | step_index | station_id | step_duration |
|---|---|---|---|
| J1 | 0 | 2 | 1 |
| J1 | 1 | 1 | 24 |
| J1 | 2 | 0 | 56 |
| J2 | 0 | 0 | 23 |
| J2 | 1 | 2 | 30 |
| J2 | 2 | 1 | 5 |
| J3 | 0 | 0 | 59 |
| J3 | 1 | 1 | 34 |
| J3 | 2 | 2 | 36 |

The manager will judge alternative line-ups by the clock time when the last garment finishes.

And just so we're on the same page about how I'd like the final reply to look, here's a relaxed sketch of the exact JSON layout I expect you to follow when you give the schedule:

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

Think of it like a simple form: each top-level entry is a job (a garment), and under each job there's a list of tasks in the order they must happen. For each task you record which operation it is (task), when it starts (start), which machine it uses (machine), and how long it runs (duration). This is just the shape I want — a sketch, not the actual filled-in schedule.

Please make sure all identifiers in your real schedule match the instance input exactly — no renaming, 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': 3, 'nr_jobs': 3, 'jobs': [[[2, 1], [1, 24], [0, 56]], [[0, 23], [2, 30], [1, 5]], [[0, 59], [1, 34], [2, 36]]]}","[{'job': 0, 'tasks': [{'task': 0, 'start': 0, 'machine': 2, 'duration': 1}, {'task': 1, 'start': 1, 'machine': 1, 'duration': 24}, {'task': 2, 'start': 82, 'machine': 0, 'duration': 56}]}, {'job': 1, 'tasks': [{'task': 0, 'start': 59, 'machine': 0, 'duration': 23}, {'task': 1, 'start': 82, 'machine': 2, 'duration': 30}, {'task': 2, 'start': 112, 'machine': 1, 'duration': 5}]}, {'job': 2, 'tasks': [{'task': 0, 'start': 0, 'machine': 0, 'duration': 59}, {'task': 1, 'start': 59, 'machine': 1, 'duration': 34}, {'task': 2, 'start': 112, 'machine': 2, 'duration': 36}]}]",148.0,"{'problem_type': 'JSP', 'nr_jobs': 3, 'nr_machines': 3, 'jobs': ['J1', 'J2', 'J3'], 'machines': [0, 1, 2], 'records': [{'job_id': 'J1', 'task_id': 0, 'machine_id': 2, 'duration': 1}, {'job_id': 'J1', 'task_id': 1, 'machine_id': 1, 'duration': 24}, {'job_id': 'J1', 'task_id': 2, 'machine_id': 0, 'duration': 56}, {'job_id': 'J2', 'task_id': 0, 'machine_id': 0, 'duration': 23}, {'job_id': 'J2', 'task_id': 1, 'machine_id': 2, 'duration': 30}, {'job_id': 'J2', 'task_id': 2, 'machine_id': 1, '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': 0, 'machine': 2, 'duration': 1}, {'task': 1, 'start': 1, 'machine': 1, 'duration': 24}, {'task': 2, 'start': 82, 'machine': 0, 'duration': 56}]}, {'job': 'J2', 'tasks': [{'task': 0, 'start': 59, 'machine': 0, 'duration': 23}, {'task': 1, 'start': 82, 'machine': 2, 'duration': 30}, {'task': 2, 'start': 112, 'machine': 1, 'duration': 5}]}, {'job': 'J3', 'tasks': [{'task': 0, 'start': 0, 'machine': 0, 'duration': 59}, {'task': 1, 'start': 59, 'machine': 1, 'duration': 34}, {'task': 2, 'start': 112, 'machine': 2, 'duration': 36}]}]",14,markdown_table,0
JSP,JSP,"We’re juggling several landscaping jobs at once, and the task is to slot each site activity onto its assigned machine and pick start times so things move smoothly. Each job has a fixed sequence of steps that must happen in order, machines can’t do overlapping work, and every step must be scheduled exactly once for its full duration. A schedule is judged by when the very last job wraps up — just check each job’s finish time and use the latest one; the sooner that is, the better. The concrete project details and timings are shown below.

There are 2 projects and 2 machines — project IDs: J1, J2; machine IDs: 0, 1.
We must schedule project J1 activity 0 on machine 1 for 1.
We must schedule project J1 activity 1 on machine 0 for 37.
We must schedule project J2 activity 0 on machine 0 for 32.
We must schedule project J2 activity 1 on machine 1 for 68.
We’ll fit these activities onto the 2 machines and pick start times so the overall finish time is as early as possible.

When you hand me the schedule, just drop it into a small JSON snippet like this so I can parse it easily:

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

This shows the shape I expect: a top-level ""solution"" list with one entry per job, each job saying which job it is and listing its tasks; each task lists its index in the job, the start time, which machine it runs on, and how long it takes. Think of it like filling out a simple form for each job step — nothing fussy.

This JSON is only a sketch of the expected shape, not the actual answer. Please use the exact identifiers from the instance input — do not rename jobs or machines 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': [[[1, 1], [0, 37]], [[0, 32], [1, 68]]]}","[{'job': 0, 'tasks': [{'task': 0, 'start': 0, 'machine': 1, 'duration': 1}, {'task': 1, 'start': 32, 'machine': 0, 'duration': 37}]}, {'job': 1, 'tasks': [{'task': 0, 'start': 0, 'machine': 0, 'duration': 32}, {'task': 1, 'start': 32, 'machine': 1, 'duration': 68}]}]",100.0,"{'problem_type': 'JSP', 'nr_jobs': 2, 'nr_machines': 2, 'jobs': ['J1', 'J2'], 'machines': [0, 1], 'records': [{'job_id': 'J1', 'task_id': 0, 'machine_id': 1, 'duration': 1}, {'job_id': 'J1', 'task_id': 1, 'machine_id': 0, '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': 1, 'duration': 1}, {'task': 1, 'start': 32, 'machine': 0, 'duration': 37}]}, {'job': 'J2', 'tasks': [{'task': 0, 'start': 0, 'machine': 0, 'duration': 32}, {'task': 1, 'start': 32, 'machine': 1, 'duration': 68}]}]",15,nl,0
JSP,JSP,"We have a pile of circuit boards waiting and each board needs a fixed sequence of operations on specific stations — pick-and-place, solder, test, whatever — each taking a set time. Stations can’t be in two places at once and the operations for any individual board must happen in the order they’re listed, so the challenge is arranging who goes where and when so the entire batch comes off the line as soon as possible; the score is simply the time when the final board is finished. Concrete details about which board needs which steps and how long they take appear below.

We have 5 boards and 2 stations; the board identifiers are J1, J2, J3, J4, J5 and the station identifiers are 1, 2.
We need board J1, operation 0 to run on station 2 for 1 time units.
We need board J1, operation 1 to run on station 1 for 50 time units.
We need board J2, operation 0 to run on station 1 for 7 time units.
We need board J2, operation 1 to run on station 2 for 15 time units.
We need board J3, operation 0 to run on station 2 for 37 time units.
We need board J3, operation 1 to run on station 1 for 48 time units.
We need board J4, operation 0 to run on station 1 for 68 time units.
We need board J4, operation 1 to run on station 2 for 69 time units.
We need board J5, operation 0 to run on station 2 for 72 time units.
We need board J5, operation 1 to run on station 1 for 28 time units.
We should arrange these operations so the entire batch finishes as soon as possible.

Also, when you send the actual schedule back, please stick to this JSON layout so everything lines up cleanly — nothing fancy, just that shape.

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

Think of this like a simple form: ""solution"" is a list of boards (jobs). Each board entry has a job identifier and a list of its tasks. For each task you give the task index (which step it is for that board), the start time you schedule it, which machine/station it runs on, and how long it runs. Super casual — just fill in those fields for every job and task.

This JSON is only a sketch of the expected shape, not the actual schedule — fill it with the real numbers and ids when you submit the solution.

Make sure all identifiers match the instance input exactly — 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': 5, 'jobs': [[[1, 1], [0, 50]], [[0, 7], [1, 15]], [[1, 37], [0, 48]], [[0, 68], [1, 69]], [[1, 72], [0, 28]]]}","[{'job': 0, 'tasks': [{'task': 0, 'start': 72, 'machine': 1, 'duration': 1}, {'task': 1, 'start': 75, 'machine': 0, 'duration': 50}]}, {'job': 1, 'tasks': [{'task': 0, 'start': 68, 'machine': 0, 'duration': 7}, {'task': 1, 'start': 179, 'machine': 1, 'duration': 15}]}, {'job': 2, 'tasks': [{'task': 0, 'start': 73, 'machine': 1, 'duration': 37}, {'task': 1, 'start': 125, 'machine': 0, 'duration': 48}]}, {'job': 3, 'tasks': [{'task': 0, 'start': 0, 'machine': 0, 'duration': 68}, {'task': 1, 'start': 110, 'machine': 1, 'duration': 69}]}, {'job': 4, 'tasks': [{'task': 0, 'start': 0, 'machine': 1, 'duration': 72}, {'task': 1, 'start': 173, 'machine': 0, 'duration': 28}]}]",201.0,"{'problem_type': 'JSP', 'nr_jobs': 5, 'nr_machines': 2, 'jobs': ['J1', 'J2', 'J3', 'J4', 'J5'], 'machines': [1, 2], 'records': [{'job_id': 'J1', 'task_id': 0, 'machine_id': 2, 'duration': 1}, {'job_id': 'J1', 'task_id': 1, 'machine_id': 1, 'duration': 50}, {'job_id': 'J2', 'task_id': 0, 'machine_id': 1, 'duration': 7}, {'job_id': 'J2', 'task_id': 1, 'machine_id': 2, 'duration': 15}, {'job_id': 'J3', 'task_id': 0, 'machine_id': 2, 'duration': 37}, {'job_id': 'J3', 'task_id': 1, 'machine_id': 1, 'duration': 48}, {'job_id': 'J4', 'task_id': 0, 'machine_id': 1, 'duration': 68}, {'job_id': 'J4', 'task_id': 1, 'machine_id': 2, 'duration': 69}, {'job_id': 'J5', 'task_id': 0, 'machine_id': 2, 'duration': 72}, {'job_id': 'J5', 'task_id': 1, 'machine_id': 1, 'duration': 28}]}","[{'job': 'J1', 'tasks': [{'task': 0, 'start': 72, 'machine': 2, 'duration': 1}, {'task': 1, 'start': 75, 'machine': 1, 'duration': 50}]}, {'job': 'J2', 'tasks': [{'task': 0, 'start': 68, 'machine': 1, 'duration': 7}, {'task': 1, 'start': 179, 'machine': 2, 'duration': 15}]}, {'job': 'J3', 'tasks': [{'task': 0, 'start': 73, 'machine': 2, 'duration': 37}, {'task': 1, 'start': 125, 'machine': 1, 'duration': 48}]}, {'job': 'J4', 'tasks': [{'task': 0, 'start': 0, 'machine': 1, 'duration': 68}, {'task': 1, 'start': 110, 'machine': 2, 'duration': 69}]}, {'job': 'J5', 'tasks': [{'task': 0, 'start': 0, 'machine': 2, 'duration': 72}, {'task': 1, 'start': 173, 'machine': 1, 'duration': 28}]}]",16,nl,1
JSP,JSP,"We juggle a bunch of tabletops and chairs through three stations: saw, sander, and finishing bench. The choice to make is when to start each cut, sand, and finish so every operation uses its designated machine for its full time, follows the piece’s required order, and never shares a machine with another overlapping job. A good plan gets everything off the floor fast — judged by the moment the final job is completed; lower is better. Concrete details about items and times appear below.

We have 4 pieces and 3 stations; the pieces are J1, J2, J3, J4 and the stations are 1, 2, 3.
Piece J1, step 0 needs 2 for 1 time units.
Piece J1, step 1 needs 3 for 63 time units.
Piece J1, step 2 needs 1 for 82 time units.
Piece J2, step 0 needs 2 for 60 time units.
Piece J2, step 1 needs 1 for 90 time units.
Piece J2, step 2 needs 3 for 70 time units.
Piece J3, step 0 needs 3 for 73 time units.
Piece J3, step 1 needs 1 for 38 time units.
Piece J3, step 2 needs 2 for 40 time units.
Piece J4, step 0 needs 2 for 22 time units.
Piece J4, step 1 needs 3 for 25 time units.
Piece J4, step 2 needs 1 for 13 time units.
We keep start times conflict-free and aim to clear the shop as fast as possible.

Also, when you send the schedule back, just drop it in this JSON shape — easy to read and easy to check. Here's the exact layout I expect:

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

Quick, informal guide to the fields: ""solution"" is a list of pieces we need to schedule. Each item has a ""job"" id and a ""tasks"" list. Each task entry says which step of the job it is (""task""), when that step begins (""start""), which machine it runs on (""machine""), and how long it takes (""duration""). Think of it like filling out a simple form for each operation.

This JSON is just the sketch of the shape I want — fill it with the actual ids and numbers from the instance when you respond. 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': 3, 'nr_jobs': 4, 'jobs': [[[1, 1], [2, 63], [0, 82]], [[1, 60], [0, 90], [2, 70]], [[2, 73], [0, 38], [1, 40]], [[1, 22], [2, 25], [0, 13]]]}","[{'job': 0, 'tasks': [{'task': 0, 'start': 60, 'machine': 1, 'duration': 1}, {'task': 1, 'start': 73, 'machine': 2, 'duration': 63}, {'task': 2, 'start': 188, 'machine': 0, 'duration': 82}]}, {'job': 1, 'tasks': [{'task': 0, 'start': 0, 'machine': 1, 'duration': 60}, {'task': 1, 'start': 60, 'machine': 0, 'duration': 90}, {'task': 2, 'start': 161, 'machine': 2, 'duration': 70}]}, {'job': 2, 'tasks': [{'task': 0, 'start': 0, 'machine': 2, 'duration': 73}, {'task': 1, 'start': 150, 'machine': 0, 'duration': 38}, {'task': 2, 'start': 188, 'machine': 1, 'duration': 40}]}, {'job': 3, 'tasks': [{'task': 0, 'start': 61, 'machine': 1, 'duration': 22}, {'task': 1, 'start': 136, 'machine': 2, 'duration': 25}, {'task': 2, 'start': 270, 'machine': 0, 'duration': 13}]}]",283.0,"{'problem_type': 'JSP', 'nr_jobs': 4, 'nr_machines': 3, 'jobs': ['J1', 'J2', 'J3', 'J4'], 'machines': [1, 2, 3], 'records': [{'job_id': 'J1', 'task_id': 0, 'machine_id': 2, 'duration': 1}, {'job_id': 'J1', 'task_id': 1, 'machine_id': 3, 'duration': 63}, {'job_id': 'J1', 'task_id': 2, 'machine_id': 1, 'duration': 82}, {'job_id': 'J2', 'task_id': 0, 'machine_id': 2, 'duration': 60}, {'job_id': 'J2', 'task_id': 1, 'machine_id': 1, 'duration': 90}, {'job_id': 'J2', 'task_id': 2, 'machine_id': 3, 'duration': 70}, {'job_id': 'J3', 'task_id': 0, 'machine_id': 3, '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': 2, 'duration': 22}, {'job_id': 'J4', 'task_id': 1, 'machine_id': 3, 'duration': 25}, {'job_id': 'J4', 'task_id': 2, 'machine_id': 1, 'duration': 13}]}","[{'job': 'J1', 'tasks': [{'task': 0, 'start': 60, 'machine': 2, 'duration': 1}, {'task': 1, 'start': 73, 'machine': 3, 'duration': 63}, {'task': 2, 'start': 188, 'machine': 1, 'duration': 82}]}, {'job': 'J2', 'tasks': [{'task': 0, 'start': 0, 'machine': 2, 'duration': 60}, {'task': 1, 'start': 60, 'machine': 1, 'duration': 90}, {'task': 2, 'start': 161, 'machine': 3, 'duration': 70}]}, {'job': 'J3', 'tasks': [{'task': 0, 'start': 0, 'machine': 3, 'duration': 73}, {'task': 1, 'start': 150, 'machine': 1, 'duration': 38}, {'task': 2, 'start': 188, 'machine': 2, 'duration': 40}]}, {'job': 'J4', 'tasks': [{'task': 0, 'start': 61, 'machine': 2, 'duration': 22}, {'task': 1, 'start': 136, 'machine': 3, 'duration': 25}, {'task': 2, 'start': 270, 'machine': 1, 'duration': 13}]}]",17,nl,1
JSP,JSP,"We’re juggling a pile of parcels through a handful of pieces of equipment; each parcel has its own to-do list of scans and handling actions that must happen one after another on specific gear for set amounts of time. The decision is about the order and timing: arrange those actions so the moment the final parcel leaves the line is as early as possible — in other words, minimize the finish time of the last parcel. Every required step for each parcel must be done exactly once, and a machine can only run one step at a time. The exact parcel steps and timings are listed below.

{
  ""nr_parcels"": 4,
  ""nr_equipment"": 2,
  ""parcel_ids"": [
    ""J1"",
    ""J2"",
    ""J3"",
    ""J4""
  ],
  ""equipment_ids"": [
    1,
    2
  ],
  ""tasks"": [
    {
      ""parcel_id"": ""J1"",
      ""step_index"": 0,
      ""equipment_id"": 2,
      ""operation_duration"": 1
    },
    {
      ""parcel_id"": ""J1"",
      ""step_index"": 1,
      ""equipment_id"": 1,
      ""operation_duration"": 76
    },
    {
      ""parcel_id"": ""J2"",
      ""step_index"": 0,
      ""equipment_id"": 2,
      ""operation_duration"": 58
    },
    {
      ""parcel_id"": ""J2"",
      ""step_index"": 1,
      ""equipment_id"": 1,
      ""operation_duration"": 6
    },
    {
      ""parcel_id"": ""J3"",
      ""step_index"": 0,
      ""equipment_id"": 1,
      ""operation_duration"": 43
    },
    {
      ""parcel_id"": ""J3"",
      ""step_index"": 1,
      ""equipment_id"": 2,
      ""operation_duration"": 91
    },
    {
      ""parcel_id"": ""J4"",
      ""step_index"": 0,
      ""equipment_id"": 1,
      ""operation_duration"": 77
    },
    {
      ""parcel_id"": ""J4"",
      ""step_index"": 1,
      ""equipment_id"": 2,
      ""operation_duration"": 6
    }
  ]
}

Also, when you send back the schedule, please use this simple JSON shape so everything lines up with the rest of the system:

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

Think of it as a little form: ""solution"" is a list of the parcels (jobs) and, for each one, the ""tasks"" array lists its ordered steps. Each task entry just says which step it is (""task""), when it starts (""start""), which piece of equipment it uses (""machine""), and how long it runs (""duration""). Super simple — this block is just the expected shape, not the actual schedule.

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': 2, 'nr_jobs': 4, 'jobs': [[[1, 1], [0, 76]], [[1, 58], [0, 6]], [[0, 43], [1, 91]], [[0, 77], [1, 6]]]}","[{'job': 0, 'tasks': [{'task': 0, 'start': 0, 'machine': 1, 'duration': 1}, {'task': 1, 'start': 120, 'machine': 0, 'duration': 76}]}, {'job': 1, 'tasks': [{'task': 0, 'start': 1, 'machine': 1, 'duration': 58}, {'task': 1, 'start': 196, 'machine': 0, 'duration': 6}]}, {'job': 2, 'tasks': [{'task': 0, 'start': 0, 'machine': 0, 'duration': 43}, {'task': 1, 'start': 59, 'machine': 1, 'duration': 91}]}, {'job': 3, 'tasks': [{'task': 0, 'start': 43, 'machine': 0, 'duration': 77}, {'task': 1, 'start': 150, 'machine': 1, 'duration': 6}]}]",202.0,"{'problem_type': 'JSP', 'nr_jobs': 4, 'nr_machines': 2, 'jobs': ['J1', 'J2', 'J3', 'J4'], 'machines': [1, 2], 'records': [{'job_id': 'J1', 'task_id': 0, 'machine_id': 2, 'duration': 1}, {'job_id': 'J1', 'task_id': 1, 'machine_id': 1, 'duration': 76}, {'job_id': 'J2', 'task_id': 0, 'machine_id': 2, 'duration': 58}, {'job_id': 'J2', 'task_id': 1, 'machine_id': 1, 'duration': 6}, {'job_id': 'J3', 'task_id': 0, 'machine_id': 1, 'duration': 43}, {'job_id': 'J3', 'task_id': 1, 'machine_id': 2, 'duration': 91}, {'job_id': 'J4', 'task_id': 0, 'machine_id': 1, 'duration': 77}, {'job_id': 'J4', 'task_id': 1, 'machine_id': 2, 'duration': 6}]}","[{'job': 'J1', 'tasks': [{'task': 0, 'start': 0, 'machine': 2, 'duration': 1}, {'task': 1, 'start': 120, 'machine': 1, 'duration': 76}]}, {'job': 'J2', 'tasks': [{'task': 0, 'start': 1, 'machine': 2, 'duration': 58}, {'task': 1, 'start': 196, 'machine': 1, 'duration': 6}]}, {'job': 'J3', 'tasks': [{'task': 0, 'start': 0, 'machine': 1, 'duration': 43}, {'task': 1, 'start': 59, 'machine': 2, 'duration': 91}]}, {'job': 'J4', 'tasks': [{'task': 0, 'start': 43, 'machine': 1, 'duration': 77}, {'task': 1, 'start': 150, 'machine': 2, 'duration': 6}]}]",18,json,1
JSP,JSP,"Recently the setup team needed a clear plan: each booth has a fixed run of assembly jobs, every job uses a named lift or tool for a fixed time, and no two jobs can use the same gear at once. The task was to set start times so every booth’s steps stay in order, nothing’s missed or duplicated, and the entire exhibition is ready as fast as possible — judged by the instant the last booth is finished. The concrete booth-task lists and durations follow below.

# num_booths=5
# num_tools_lifts=2
# booth_ids=J1, J2, J3, J4, J5
# tool_lift_ids=0, 1
booth_id,step_index,tool_or_lift_id,assembly_duration
J1,0,1,1
J1,1,0,89
J2,0,1,34
J2,1,0,52
J3,0,1,96
J3,1,0,14
J4,0,1,82
J4,1,0,73
J5,0,0,76
J5,1,1,9

Also, when you send the actual schedule back, please use this simple JSON layout so it’s easy to parse and check:

{
  ""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 need. In plain terms: each entry in ""solution"" is one booth/job; ""tasks"" is the ordered list of steps for that job; ""task"" is the step index within the job; ""start"" is the planned start time for that step; ""machine"" is which lift/tool it needs; and ""duration"" is how long that step runs. Keep it informal — think of it as filling out a little form for each job.

Please make sure you use the exact identifiers from the instance input — don’t rename them or invent new labels. Valid identifiers look like plain numbers such as “1” or “23”, single capital letters like “A” or “B”, or a capital letter followed by digits like “A1” or “X7”.","{'nr_machines': 2, 'nr_jobs': 5, 'jobs': [[[1, 1], [0, 89]], [[1, 34], [0, 52]], [[1, 96], [0, 14]], [[1, 82], [0, 73]], [[0, 76], [1, 9]]]}","[{'job': 0, 'tasks': [{'task': 0, 'start': 34, 'machine': 1, 'duration': 1}, {'task': 1, 'start': 76, 'machine': 0, 'duration': 89}]}, {'job': 1, 'tasks': [{'task': 0, 'start': 0, 'machine': 1, 'duration': 34}, {'task': 1, 'start': 165, 'machine': 0, 'duration': 52}]}, {'job': 2, 'tasks': [{'task': 0, 'start': 167, 'machine': 1, 'duration': 96}, {'task': 1, 'start': 290, 'machine': 0, 'duration': 14}]}, {'job': 3, 'tasks': [{'task': 0, 'start': 85, 'machine': 1, 'duration': 82}, {'task': 1, 'start': 217, 'machine': 0, 'duration': 73}]}, {'job': 4, 'tasks': [{'task': 0, 'start': 0, 'machine': 0, 'duration': 76}, {'task': 1, 'start': 76, 'machine': 1, 'duration': 9}]}]",304.0,"{'problem_type': 'JSP', 'nr_jobs': 5, 'nr_machines': 2, 'jobs': ['J1', 'J2', 'J3', 'J4', 'J5'], 'machines': [0, 1], 'records': [{'job_id': 'J1', 'task_id': 0, 'machine_id': 1, 'duration': 1}, {'job_id': 'J1', 'task_id': 1, 'machine_id': 0, 'duration': 89}, {'job_id': 'J2', 'task_id': 0, 'machine_id': 1, 'duration': 34}, {'job_id': 'J2', 'task_id': 1, 'machine_id': 0, 'duration': 52}, {'job_id': 'J3', 'task_id': 0, 'machine_id': 1, 'duration': 96}, {'job_id': 'J3', 'task_id': 1, 'machine_id': 0, 'duration': 14}, {'job_id': 'J4', 'task_id': 0, 'machine_id': 1, 'duration': 82}, {'job_id': 'J4', 'task_id': 1, 'machine_id': 0, 'duration': 73}, {'job_id': 'J5', 'task_id': 0, 'machine_id': 0, 'duration': 76}, {'job_id': 'J5', 'task_id': 1, 'machine_id': 1, 'duration': 9}]}","[{'job': 'J1', 'tasks': [{'task': 0, 'start': 34, 'machine': 1, 'duration': 1}, {'task': 1, 'start': 76, 'machine': 0, 'duration': 89}]}, {'job': 'J2', 'tasks': [{'task': 0, 'start': 0, 'machine': 1, 'duration': 34}, {'task': 1, 'start': 165, 'machine': 0, 'duration': 52}]}, {'job': 'J3', 'tasks': [{'task': 0, 'start': 167, 'machine': 1, 'duration': 96}, {'task': 1, 'start': 290, 'machine': 0, 'duration': 14}]}, {'job': 'J4', 'tasks': [{'task': 0, 'start': 85, 'machine': 1, 'duration': 82}, {'task': 1, 'start': 217, 'machine': 0, 'duration': 73}]}, {'job': 'J5', 'tasks': [{'task': 0, 'start': 0, 'machine': 0, 'duration': 76}, {'task': 1, 'start': 76, 'machine': 1, 'duration': 9}]}]",19,csv,0
JSP,JSP,"I once tried to get three different dinners out of a tiny kitchen at the same time: each recipe has its own list of steps that must happen in order, and each step needs a certain appliance for a set amount of time. The choice to make is who uses which appliance when so all dishes finish as soon as possible — the success of a plan is simply the time when the last dish is done (so the lower that time, the better). Every step has to be done exactly once, in its recipe order, and an appliance can only run one step at a time. The exact recipes, step times, and appliance availability are listed below.

Here are the 5 recipes and 2 appliances I had: recipes J1, J2, J3, J4, J5; appliances A, B.
Recipe J1, step 0: I need appliance B for 1 time units.
Recipe J1, step 1: I need appliance A for 3 time units.
Recipe J2, step 0: I need appliance B for 10 time units.
Recipe J2, step 1: I need appliance A for 97 time units.
Recipe J3, step 0: I need appliance B for 50 time units.
Recipe J3, step 1: I need appliance A for 36 time units.
Recipe J4, step 0: I need appliance B for 87 time units.
Recipe J4, step 1: I need appliance A for 41 time units.
Recipe J5, step 0: I need appliance B for 44 time units.
Recipe J5, step 1: I need appliance A for 2 time units.
I'll try to schedule the 5 recipes on the 2 appliances so everything finishes as early as possible.

Oh, and when you send the schedule back, a little JSON like this is perfect — just a simple shape to fill 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’m expecting, not the actual schedule. In plain terms: the top-level ""solution"" is a list of dishes (jobs). Each dish object says which job it is and then lists its steps. Each step has the step number (""task""), when that step starts (""start""), which appliance it needs (""machine""), and how long it runs (""duration""). Keep it simple and human-readable.

Please use the exact identifiers from the instance input — don’t rename anything 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': 5, 'jobs': [[[1, 1], [0, 3]], [[1, 10], [0, 97]], [[1, 50], [0, 36]], [[1, 87], [0, 41]], [[1, 44], [0, 2]]]}","[{'job': 0, 'tasks': [{'task': 0, 'start': 147, 'machine': 1, 'duration': 1}, {'task': 1, 'start': 184, 'machine': 0, 'duration': 3}]}, {'job': 1, 'tasks': [{'task': 0, 'start': 0, 'machine': 1, 'duration': 10}, {'task': 1, 'start': 10, 'machine': 0, 'duration': 97}]}, {'job': 2, 'tasks': [{'task': 0, 'start': 97, 'machine': 1, 'duration': 50}, {'task': 1, 'start': 148, 'machine': 0, 'duration': 36}]}, {'job': 3, 'tasks': [{'task': 0, 'start': 10, 'machine': 1, 'duration': 87}, {'task': 1, 'start': 107, 'machine': 0, 'duration': 41}]}, {'job': 4, 'tasks': [{'task': 0, 'start': 148, 'machine': 1, 'duration': 44}, {'task': 1, 'start': 192, 'machine': 0, 'duration': 2}]}]",194.0,"{'problem_type': 'JSP', 'nr_jobs': 5, 'nr_machines': 2, 'jobs': ['J1', 'J2', 'J3', 'J4', 'J5'], 'machines': ['A', 'B'], 'records': [{'job_id': 'J1', 'task_id': 0, 'machine_id': 'B', 'duration': 1}, {'job_id': 'J1', 'task_id': 1, 'machine_id': 'A', 'duration': 3}, {'job_id': 'J2', 'task_id': 0, 'machine_id': 'B', 'duration': 10}, {'job_id': 'J2', 'task_id': 1, 'machine_id': 'A', 'duration': 97}, {'job_id': 'J3', 'task_id': 0, 'machine_id': 'B', 'duration': 50}, {'job_id': 'J3', 'task_id': 1, 'machine_id': 'A', 'duration': 36}, {'job_id': 'J4', 'task_id': 0, 'machine_id': 'B', 'duration': 87}, {'job_id': 'J4', 'task_id': 1, 'machine_id': 'A', 'duration': 41}, {'job_id': 'J5', 'task_id': 0, 'machine_id': 'B', 'duration': 44}, {'job_id': 'J5', 'task_id': 1, 'machine_id': 'A', 'duration': 2}]}","[{'job': 'J1', 'tasks': [{'task': 0, 'start': 147, 'machine': 'B', 'duration': 1}, {'task': 1, 'start': 184, 'machine': 'A', 'duration': 3}]}, {'job': 'J2', 'tasks': [{'task': 0, 'start': 0, 'machine': 'B', 'duration': 10}, {'task': 1, 'start': 10, 'machine': 'A', 'duration': 97}]}, {'job': 'J3', 'tasks': [{'task': 0, 'start': 97, 'machine': 'B', 'duration': 50}, {'task': 1, 'start': 148, 'machine': 'A', 'duration': 36}]}, {'job': 'J4', 'tasks': [{'task': 0, 'start': 10, 'machine': 'B', 'duration': 87}, {'task': 1, 'start': 107, 'machine': 'A', 'duration': 41}]}, {'job': 'J5', 'tasks': [{'task': 0, 'start': 148, 'machine': 'B', 'duration': 44}, {'task': 1, 'start': 192, 'machine': 'A', 'duration': 2}]}]",20,nl,names
JSP,JSP,"Recently the team wondered how to tighten up turnover: each patient has a set list of stages to go through, every stage takes a fixed amount of time, and rooms can’t be double-booked. The question is how to slot everyone into the rooms over the day so the whole group is done with recovery as soon as possible — the plan is judged by the time the last person finishes recovery — and every required stage must occur once for each patient, in sequence, with no overlaps in a room. The full case and timing details are shown below.

# nr_patients=4
# nr_rooms=3
# patient_ids=J1, J2, J3, J4
# room_ids=1, 2, 3
patient_id,stage_index,required_room_id,stage_duration
J1,0,3,1
J1,1,2,16
J1,2,1,84
J2,0,1,44
J2,1,2,4
J2,2,3,57
J3,0,2,91
J3,1,1,9
J3,2,3,12
J4,0,1,95
J4,1,3,77
J4,2,2,21

If you want the schedule back in a tidy, machine-friendly way, just send it in this little JSON shape — nothing fancy, just a list of each job and its tasks with start times and machines. Here's the shape I expect:

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

Think of it like a simple form: ""solution"" is a list of patients (jobs), each patient entry has a ""tasks"" list, and each task says which step it is, when it starts, which room (machine) it's in, and how long it lasts. This is just a sketch of the shape I need — not the real schedule yet.

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': 3, 'nr_jobs': 4, 'jobs': [[[2, 1], [1, 16], [0, 84]], [[0, 44], [1, 4], [2, 57]], [[1, 91], [0, 9], [2, 12]], [[0, 95], [2, 77], [1, 21]]]}","[{'job': 0, 'tasks': [{'task': 0, 'start': 0, 'machine': 2, 'duration': 1}, {'task': 1, 'start': 1, 'machine': 1, 'duration': 16}, {'task': 2, 'start': 148, 'machine': 0, 'duration': 84}]}, {'job': 1, 'tasks': [{'task': 0, 'start': 0, 'machine': 0, 'duration': 44}, {'task': 1, 'start': 44, 'machine': 1, 'duration': 4}, {'task': 2, 'start': 48, 'machine': 2, 'duration': 57}]}, {'job': 2, 'tasks': [{'task': 0, 'start': 48, 'machine': 1, 'duration': 91}, {'task': 1, 'start': 139, 'machine': 0, 'duration': 9}, {'task': 2, 'start': 216, 'machine': 2, 'duration': 12}]}, {'job': 3, 'tasks': [{'task': 0, 'start': 44, 'machine': 0, 'duration': 95}, {'task': 1, 'start': 139, 'machine': 2, 'duration': 77}, {'task': 2, 'start': 216, 'machine': 1, 'duration': 21}]}]",237.0,"{'problem_type': 'JSP', 'nr_jobs': 4, 'nr_machines': 3, 'jobs': ['J1', 'J2', 'J3', 'J4'], 'machines': [1, 2, 3], 'records': [{'job_id': 'J1', 'task_id': 0, 'machine_id': 3, 'duration': 1}, {'job_id': 'J1', 'task_id': 1, 'machine_id': 2, 'duration': 16}, {'job_id': 'J1', 'task_id': 2, 'machine_id': 1, 'duration': 84}, {'job_id': 'J2', 'task_id': 0, 'machine_id': 1, 'duration': 44}, {'job_id': 'J2', 'task_id': 1, 'machine_id': 2, 'duration': 4}, {'job_id': 'J2', 'task_id': 2, 'machine_id': 3, 'duration': 57}, {'job_id': 'J3', 'task_id': 0, 'machine_id': 2, 'duration': 91}, {'job_id': 'J3', 'task_id': 1, 'machine_id': 1, 'duration': 9}, {'job_id': 'J3', 'task_id': 2, 'machine_id': 3, 'duration': 12}, {'job_id': 'J4', 'task_id': 0, 'machine_id': 1, 'duration': 95}, {'job_id': 'J4', 'task_id': 1, 'machine_id': 3, 'duration': 77}, {'job_id': 'J4', 'task_id': 2, 'machine_id': 2, 'duration': 21}]}","[{'job': 'J1', 'tasks': [{'task': 0, 'start': 0, 'machine': 3, 'duration': 1}, {'task': 1, 'start': 1, 'machine': 2, 'duration': 16}, {'task': 2, 'start': 148, 'machine': 1, 'duration': 84}]}, {'job': 'J2', 'tasks': [{'task': 0, 'start': 0, 'machine': 1, 'duration': 44}, {'task': 1, 'start': 44, 'machine': 2, 'duration': 4}, {'task': 2, 'start': 48, 'machine': 3, 'duration': 57}]}, {'job': 'J3', 'tasks': [{'task': 0, 'start': 48, 'machine': 2, 'duration': 91}, {'task': 1, 'start': 139, 'machine': 1, 'duration': 9}, {'task': 2, 'start': 216, 'machine': 3, 'duration': 12}]}, {'job': 'J4', 'tasks': [{'task': 0, 'start': 44, 'machine': 1, 'duration': 95}, {'task': 1, 'start': 139, 'machine': 3, 'duration': 77}, {'task': 2, 'start': 216, 'machine': 2, 'duration': 21}]}]",21,csv,1
JSP,JSP,"We had to map out the crew and equipment so several construction units could get finished without wasting time: each operation on a unit has a fixed duration, machines can’t split themselves between tasks, and the steps for every unit must happen in the order they’re laid out. The decision is the sequence and timing of assignments across crews and machines so the last unit is completed as soon as possible — the key metric is the time stamp when the final job ends. The exact numbers and tasks are listed below.

# num_construction_units=3
# num_heavy_equipment=2
# construction_unit_ids=J1, J2, J3
# equipment_ids=A, B
unit_id,step_index,required_equipment_id,operation_duration
J1,0,B,1
J1,1,A,29
J2,0,A,60
J2,1,B,89
J3,0,A,56
J3,1,B,79

Also, to keep things tidy, please return the planned schedule in this simple JSON shape when you submit the solution:

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

Think of it like a small form: ""solution"" is a list of jobs, each job entry names which job it is and then lists its tasks; every task line just says which step it is, when it starts, which machine it runs on, and how long it takes. Super casual — it's just the shape I need, not the actual schedule yet.

This JSON is only a sketch of the expected format, not the final answer. Please make sure all identifiers are 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': 3, 'jobs': [[[1, 1], [0, 29]], [[0, 60], [1, 89]], [[0, 56], [1, 79]]]}","[{'job': 0, 'tasks': [{'task': 0, 'start': 0, 'machine': 1, 'duration': 1}, {'task': 1, 'start': 116, 'machine': 0, 'duration': 29}]}, {'job': 1, 'tasks': [{'task': 0, 'start': 56, 'machine': 0, 'duration': 60}, {'task': 1, 'start': 135, 'machine': 1, 'duration': 89}]}, {'job': 2, 'tasks': [{'task': 0, 'start': 0, 'machine': 0, 'duration': 56}, {'task': 1, 'start': 56, 'machine': 1, 'duration': 79}]}]",224.0,"{'problem_type': 'JSP', 'nr_jobs': 3, 'nr_machines': 2, 'jobs': ['J1', 'J2', 'J3'], 'machines': ['A', 'B'], 'records': [{'job_id': 'J1', 'task_id': 0, 'machine_id': 'B', 'duration': 1}, {'job_id': 'J1', 'task_id': 1, 'machine_id': 'A', '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': 0, 'machine': 'B', 'duration': 1}, {'task': 1, 'start': 116, 'machine': 'A', 'duration': 29}]}, {'job': 'J2', 'tasks': [{'task': 0, 'start': 56, 'machine': 'A', 'duration': 60}, {'task': 1, 'start': 135, 'machine': 'B', 'duration': 89}]}, {'job': 'J3', 'tasks': [{'task': 0, 'start': 0, 'machine': 'A', 'duration': 56}, {'task': 1, 'start': 56, 'machine': 'B', 'duration': 79}]}]",22,csv,names
JSP,JSP,"I’m juggling a stack of feature builds, each one made of a fixed line-up of steps that have to happen in order. Each step needs a specific server and a known amount of time, and a server can only handle one step at a time. The job is to pick when and in what order those steps run so the whole batch is done as early as possible — measured by the time the last feature finishes (so look at every feature’s completion time and the biggest one is the score). Nothing can be skipped or done twice, every step must run on its assigned server, and the steps for a feature must keep their given order. The exact servers, step times, and feature sequences are listed below.

# nr_features=2
# nr_servers=2
# features_list=J1, J2
# servers_list=A, B
feature_id,step_index,server_id,step_duration
J1,0,B,1
J1,1,A,42
J2,0,A,36
J2,1,B,36

Also, when you send back a schedule, it'd be great if you follow a simple JSON layout so I can read it reliably. Something like this shows the shape I expect:

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

Think of it as a little form: ""solution"" is the list of features (jobs), each entry names the job and lists its steps (tasks). For each step you give which step index it is, when it starts, which server (machine) it runs on, and how long it takes. Super casual — just the fields shown, nothing fancy.

This block is just a sketch of the expected shape, not the actual schedule — I'll need the real numbers and the exact job/machine identifiers from the instance.

Please use the identifiers exactly as they appear in the instance input — no renaming and no new labels. For example: Valid identifiers look like plain numbers such as ""1"" or ""23"", single capital letters like ""A"" or ""B"", or a capital letter followed by digits like ""A1"" or ""X7"".","{'nr_machines': 2, 'nr_jobs': 2, 'jobs': [[[1, 1], [0, 42]], [[0, 36], [1, 36]]]}","[{'job': 0, 'tasks': [{'task': 0, 'start': 0, 'machine': 1, 'duration': 1}, {'task': 1, 'start': 36, 'machine': 0, 'duration': 42}]}, {'job': 1, 'tasks': [{'task': 0, 'start': 0, 'machine': 0, 'duration': 36}, {'task': 1, 'start': 36, 'machine': 1, 'duration': 36}]}]",78.0,"{'problem_type': 'JSP', 'nr_jobs': 2, 'nr_machines': 2, 'jobs': ['J1', 'J2'], 'machines': ['A', 'B'], 'records': [{'job_id': 'J1', 'task_id': 0, 'machine_id': 'B', 'duration': 1}, {'job_id': 'J1', 'task_id': 1, 'machine_id': 'A', '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': 0, 'machine': 'B', 'duration': 1}, {'task': 1, 'start': 36, 'machine': 'A', 'duration': 42}]}, {'job': 'J2', 'tasks': [{'task': 0, 'start': 0, 'machine': 'A', 'duration': 36}, {'task': 1, 'start': 36, 'machine': 'B', 'duration': 36}]}]",23,csv,names
JSP,JSP,"Many people think of it like a relay: each garment carries a list of operations, each operation takes a set time on a particular station, and the goal is to pass everything through the stations so the final runner crosses the line as early as possible. That means deciding which operation runs when on each machine so the time when the last garment finishes is as small as possible — compare schedules by that finishing time. Stations can’t handle two pieces at once, and every garment’s chain of steps must be followed exactly, no omissions or repeats. The concrete details are shown below.

They are: there are 4 garments and 2 stations; garment identifiers: J1, J2, J3, J4; station identifiers: A, B.

| garment_id | operation_index | station_id | processing_time |
|---|---|---|---|
| J1 | 0 | B | 1 |
| J1 | 1 | A | 55 |
| J2 | 0 | A | 12 |
| J2 | 1 | B | 81 |
| J3 | 0 | B | 63 |
| J3 | 1 | A | 24 |
| J4 | 0 | B | 6 |
| J4 | 1 | A | 13 |

Compare schedules by the finishing time of the last garment.

Oh, and when you give the actual schedule, please follow this simple JSON layout so everything's easy to parse and compare:

{
  ""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: each top-level item is one job (think of it as one garment), and inside each job there's a list of tasks with the task index, the start time you plan for that task, which machine/station it runs on, and how long it takes. Super casual — fill in the actual numbers and IDs when you send the schedule.

Please use the identifiers exactly as they appear in the instance input — no renaming and no new labels. For example: ""Valid identifiers look like plain numbers such as “1” or “23”, single capital letters like “A” or “B”, or a capital letter followed by digits like “A1” or “X7”.""","{'nr_machines': 2, 'nr_jobs': 4, 'jobs': [[[1, 1], [0, 55]], [[0, 12], [1, 81]], [[1, 63], [0, 24]], [[1, 6], [0, 13]]]}","[{'job': 0, 'tasks': [{'task': 0, 'start': 6, 'machine': 1, 'duration': 1}, {'task': 1, 'start': 12, 'machine': 0, 'duration': 55}]}, {'job': 1, 'tasks': [{'task': 0, 'start': 0, 'machine': 0, 'duration': 12}, {'task': 1, 'start': 70, 'machine': 1, 'duration': 81}]}, {'job': 2, 'tasks': [{'task': 0, 'start': 7, 'machine': 1, 'duration': 63}, {'task': 1, 'start': 80, 'machine': 0, 'duration': 24}]}, {'job': 3, 'tasks': [{'task': 0, 'start': 0, 'machine': 1, 'duration': 6}, {'task': 1, 'start': 67, 'machine': 0, 'duration': 13}]}]",151.0,"{'problem_type': 'JSP', 'nr_jobs': 4, 'nr_machines': 2, 'jobs': ['J1', 'J2', 'J3', 'J4'], 'machines': ['A', 'B'], 'records': [{'job_id': 'J1', 'task_id': 0, 'machine_id': 'B', 'duration': 1}, {'job_id': 'J1', 'task_id': 1, 'machine_id': 'A', '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': 'B', 'duration': 63}, {'job_id': 'J3', 'task_id': 1, 'machine_id': 'A', 'duration': 24}, {'job_id': 'J4', 'task_id': 0, 'machine_id': 'B', 'duration': 6}, {'job_id': 'J4', 'task_id': 1, 'machine_id': 'A', 'duration': 13}]}","[{'job': 'J1', 'tasks': [{'task': 0, 'start': 6, 'machine': 'B', 'duration': 1}, {'task': 1, 'start': 12, 'machine': 'A', 'duration': 55}]}, {'job': 'J2', 'tasks': [{'task': 0, 'start': 0, 'machine': 'A', 'duration': 12}, {'task': 1, 'start': 70, 'machine': 'B', 'duration': 81}]}, {'job': 'J3', 'tasks': [{'task': 0, 'start': 7, 'machine': 'B', 'duration': 63}, {'task': 1, 'start': 80, 'machine': 'A', 'duration': 24}]}, {'job': 'J4', 'tasks': [{'task': 0, 'start': 0, 'machine': 'B', 'duration': 6}, {'task': 1, 'start': 67, 'machine': 'A', 'duration': 13}]}]",24,markdown_table,names
JSP,JSP,"Imagine a tiny workflow where each customer’s basket has a fixed recipe: one cycle after another on particular machines, each taking a fixed span of time. The question is how to slot those cycles onto the washers and dryers to get the whole pile finished in the least calendar time. The winner is the plan that makes the last basket come out sooner — that finishing moment is the measure of success. Every required cycle must be run exactly once and in the prescribed order, and machines can’t do two cycles at once. The concrete details are shown below.

# num_customer_loads=3
# num_machines=2
# load_ids=J1, J2, J3
# appliance_ids=A, B
load_id,cycle_index,appliance_id,cycle_duration
J1,0,B,1
J1,1,A,68
J2,0,B,87
J2,1,A,27
J3,0,A,17
J3,1,B,45

You can hand the schedule back to me in a small JSON form so it's easy to check. Something like this is perfect:

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

Think of it as a simple form: ""solution"" holds a list of jobs; each job entry names the job and then lists its tasks in order. Each task record just says which task number it is, when that task starts, which machine it runs on, and how long it takes. Super informal — just enough structure so I can read your plan.

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

Please be careful 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': 3, 'jobs': [[[1, 1], [0, 68]], [[1, 87], [0, 27]], [[0, 17], [1, 45]]]}","[{'job': 0, 'tasks': [{'task': 0, 'start': 0, 'machine': 1, 'duration': 1}, {'task': 1, 'start': 17, 'machine': 0, 'duration': 68}]}, {'job': 1, 'tasks': [{'task': 0, 'start': 1, 'machine': 1, 'duration': 87}, {'task': 1, 'start': 88, 'machine': 0, 'duration': 27}]}, {'job': 2, 'tasks': [{'task': 0, 'start': 0, 'machine': 0, 'duration': 17}, {'task': 1, 'start': 88, 'machine': 1, 'duration': 45}]}]",133.0,"{'problem_type': 'JSP', 'nr_jobs': 3, 'nr_machines': 2, 'jobs': ['J1', 'J2', 'J3'], 'machines': ['A', 'B'], 'records': [{'job_id': 'J1', 'task_id': 0, 'machine_id': 'B', 'duration': 1}, {'job_id': 'J1', 'task_id': 1, 'machine_id': 'A', 'duration': 68}, {'job_id': 'J2', 'task_id': 0, 'machine_id': 'B', 'duration': 87}, {'job_id': 'J2', 'task_id': 1, 'machine_id': 'A', 'duration': 27}, {'job_id': 'J3', 'task_id': 0, 'machine_id': 'A', 'duration': 17}, {'job_id': 'J3', 'task_id': 1, 'machine_id': 'B', 'duration': 45}]}","[{'job': 'J1', 'tasks': [{'task': 0, 'start': 0, 'machine': 'B', 'duration': 1}, {'task': 1, 'start': 17, 'machine': 'A', 'duration': 68}]}, {'job': 'J2', 'tasks': [{'task': 0, 'start': 1, 'machine': 'B', 'duration': 87}, {'task': 1, 'start': 88, 'machine': 'A', 'duration': 27}]}, {'job': 'J3', 'tasks': [{'task': 0, 'start': 0, 'machine': 'A', 'duration': 17}, {'task': 1, 'start': 88, 'machine': 'B', 'duration': 45}]}]",25,csv,names
JSP,JSP,"Recently the team at a detailing garage noticed their workflow was messy: every car follows a particular sequence of services, each service runs for a fixed duration in a specific bay, and bays can only take one car at a time. The problem to solve was how to schedule those services so the whole set of cars would be completed quickly — the better schedule is the one that makes the time when the last car is finished as small as possible; you find that time by looking at each car’s finish moment and picking the latest. Steps can’t be skipped or reshuffled, and every listed service must be performed once. The detailed list of cars, bays, and times appears below.

{
  ""nr_cars"": 5,
  ""nr_bays"": 3,
  ""car_ids"": [
    ""J1"",
    ""J2"",
    ""J3"",
    ""J4"",
    ""J5""
  ],
  ""bay_ids"": [
    1,
    2,
    3
  ],
  ""tasks"": [
    {
      ""car_id"": ""J1"",
      ""service_index"": 0,
      ""bay_id"": 2,
      ""service_duration"": 1
    },
    {
      ""car_id"": ""J1"",
      ""service_index"": 1,
      ""bay_id"": 3,
      ""service_duration"": 81
    },
    {
      ""car_id"": ""J1"",
      ""service_index"": 2,
      ""bay_id"": 1,
      ""service_duration"": 62
    },
    {
      ""car_id"": ""J2"",
      ""service_index"": 0,
      ""bay_id"": 2,
      ""service_duration"": 73
    },
    {
      ""car_id"": ""J2"",
      ""service_index"": 1,
      ""bay_id"": 1,
      ""service_duration"": 69
    },
    {
      ""car_id"": ""J2"",
      ""service_index"": 2,
      ""bay_id"": 3,
      ""service_duration"": 67
    },
    {
      ""car_id"": ""J3"",
      ""service_index"": 0,
      ""bay_id"": 3,
      ""service_duration"": 16
    },
    {
      ""car_id"": ""J3"",
      ""service_index"": 1,
      ""bay_id"": 1,
      ""service_duration"": 48
    },
    {
      ""car_id"": ""J3"",
      ""service_index"": 2,
      ""bay_id"": 2,
      ""service_duration"": 51
    },
    {
      ""car_id"": ""J4"",
      ""service_index"": 0,
      ""bay_id"": 3,
      ""service_duration"": 62
    },
    {
      ""car_id"": ""J4"",
      ""service_index"": 1,
      ""bay_id"": 1,
      ""service_duration"": 69
    },
    {
      ""car_id"": ""J4"",
      ""service_index"": 2,
      ""bay_id"": 2,
      ""service_duration"": 80
    },
    {
      ""car_id"": ""J5"",
      ""service_index"": 0,
      ""bay_id"": 1,
      ""service_duration"": 67
    },
    {
      ""car_id"": ""J5"",
      ""service_index"": 1,
      ""bay_id"": 3,
      ""service_duration"": 32
    },
    {
      ""car_id"": ""J5"",
      ""service_index"": 2,
      ""bay_id"": 2,
      ""service_duration"": 58
    }
  ]
}

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

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

Think of it like a little form: ""solution"" is a list of cars, each car has a job id and a list of services (tasks). For each service you say which step it is, what time it starts, which bay (machine) it uses, and how long it runs. This block is just a sketch of the shape I expect, not the actual schedule — I'll need the real values for each item from the instance.

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': 3, 'nr_jobs': 5, 'jobs': [[[1, 1], [2, 81], [0, 62]], [[1, 73], [0, 69], [2, 67]], [[2, 16], [0, 48], [1, 51]], [[2, 62], [0, 69], [1, 80]], [[0, 67], [2, 32], [1, 58]]]}","[{'job': 0, 'tasks': [{'task': 0, 'start': 73, 'machine': 1, 'duration': 1}, {'task': 1, 'start': 110, 'machine': 2, 'duration': 81}, {'task': 2, 'start': 253, 'machine': 0, 'duration': 62}]}, {'job': 1, 'tasks': [{'task': 0, 'start': 0, 'machine': 1, 'duration': 73}, {'task': 1, 'start': 136, 'machine': 0, 'duration': 69}, {'task': 2, 'start': 205, 'machine': 2, 'duration': 67}]}, {'job': 2, 'tasks': [{'task': 0, 'start': 62, 'machine': 2, 'duration': 16}, {'task': 1, 'start': 205, 'machine': 0, 'duration': 48}, {'task': 2, 'start': 253, 'machine': 1, 'duration': 51}]}, {'job': 3, 'tasks': [{'task': 0, 'start': 0, 'machine': 2, 'duration': 62}, {'task': 1, 'start': 67, 'machine': 0, 'duration': 69}, {'task': 2, 'start': 168, 'machine': 1, 'duration': 80}]}, {'job': 4, 'tasks': [{'task': 0, 'start': 0, 'machine': 0, 'duration': 67}, {'task': 1, 'start': 78, 'machine': 2, 'duration': 32}, {'task': 2, 'start': 110, 'machine': 1, 'duration': 58}]}]",315.0,"{'problem_type': 'JSP', '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': 2, 'duration': 1}, {'job_id': 'J1', 'task_id': 1, 'machine_id': 3, 'duration': 81}, {'job_id': 'J1', 'task_id': 2, 'machine_id': 1, 'duration': 62}, {'job_id': 'J2', 'task_id': 0, 'machine_id': 2, 'duration': 73}, {'job_id': 'J2', 'task_id': 1, 'machine_id': 1, 'duration': 69}, {'job_id': 'J2', 'task_id': 2, 'machine_id': 3, 'duration': 67}, {'job_id': 'J3', 'task_id': 0, 'machine_id': 3, 'duration': 16}, {'job_id': 'J3', 'task_id': 1, 'machine_id': 1, 'duration': 48}, {'job_id': 'J3', 'task_id': 2, 'machine_id': 2, 'duration': 51}, {'job_id': 'J4', 'task_id': 0, 'machine_id': 3, 'duration': 62}, {'job_id': 'J4', 'task_id': 1, 'machine_id': 1, 'duration': 69}, {'job_id': 'J4', 'task_id': 2, 'machine_id': 2, 'duration': 80}, {'job_id': 'J5', 'task_id': 0, 'machine_id': 1, 'duration': 67}, {'job_id': 'J5', 'task_id': 1, 'machine_id': 3, 'duration': 32}, {'job_id': 'J5', 'task_id': 2, 'machine_id': 2, 'duration': 58}]}","[{'job': 'J1', 'tasks': [{'task': 0, 'start': 73, 'machine': 2, 'duration': 1}, {'task': 1, 'start': 110, 'machine': 3, 'duration': 81}, {'task': 2, 'start': 253, 'machine': 1, 'duration': 62}]}, {'job': 'J2', 'tasks': [{'task': 0, 'start': 0, 'machine': 2, 'duration': 73}, {'task': 1, 'start': 136, 'machine': 1, 'duration': 69}, {'task': 2, 'start': 205, 'machine': 3, 'duration': 67}]}, {'job': 'J3', 'tasks': [{'task': 0, 'start': 62, 'machine': 3, 'duration': 16}, {'task': 1, 'start': 205, 'machine': 1, 'duration': 48}, {'task': 2, 'start': 253, 'machine': 2, 'duration': 51}]}, {'job': 'J4', 'tasks': [{'task': 0, 'start': 0, 'machine': 3, 'duration': 62}, {'task': 1, 'start': 67, 'machine': 1, 'duration': 69}, {'task': 2, 'start': 168, 'machine': 2, 'duration': 80}]}, {'job': 'J5', 'tasks': [{'task': 0, 'start': 0, 'machine': 1, 'duration': 67}, {'task': 1, 'start': 78, 'machine': 3, 'duration': 32}, {'task': 2, 'start': 110, 'machine': 2, 'duration': 58}]}]",26,json,1
JSP,JSP,"I was watching a small metal shop the other day where each part needs a handful of machining and finishing steps in a certain order. The day’s problem is deciding which part goes to which machine and when, so every required step happens once and in the right sequence on the correct machine. The better plan is the one that gets the entire batch finished sooner — you can tell by the clock time when the last part leaves the bench. Concrete details about the parts, machines, and how long each step takes are listed below.

# total_parts=5
# total_machines=3
# parts_list=J1, J2, J3, J4, J5
# machine_ids=1, 2, 3
part_id,operation_index,required_machine_id,processing_time
J1,0,2,1
J1,1,3,94
J1,2,1,38
J2,0,1,19
J2,1,3,23
J2,2,2,89
J3,0,2,20
J3,1,1,17
J3,2,3,20
J4,0,1,56
J4,1,3,8
J4,2,2,32
J5,0,2,51
J5,1,3,35
J5,2,1,63

If you want to hand me a candidate plan (or if you're expecting the output back from me), it's easiest if it's shaped like a little JSON snippet — nothing fancy, just a tidy list of jobs with their tasks and times. Here’s the sketch of the shape I expect:

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

Think of ""solution"" as the whole batch. Each entry under it is a job (one of the parts on the shop floor). Inside a job, ""tasks"" is the sequence of steps for that part; each step records which task number it is, when it starts, which machine it uses, and how long it runs. That's just the form — a sketch of the expected shape, not the filled-in schedule.

Please make sure to use the exact identifiers from the instance input — don't rename anything 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': [[[1, 1], [2, 94], [0, 38]], [[0, 19], [2, 23], [1, 89]], [[1, 20], [0, 17], [2, 20]], [[0, 56], [2, 8], [1, 32]], [[1, 51], [2, 35], [0, 63]]]}","[{'job': 0, 'tasks': [{'task': 0, 'start': 51, 'machine': 1, 'duration': 1}, {'task': 1, 'start': 86, 'machine': 2, 'duration': 94}, {'task': 2, 'start': 180, 'machine': 0, 'duration': 38}]}, {'job': 1, 'tasks': [{'task': 0, 'start': 0, 'machine': 0, 'duration': 19}, {'task': 1, 'start': 19, 'machine': 2, 'duration': 23}, {'task': 2, 'start': 52, 'machine': 1, 'duration': 89}]}, {'job': 2, 'tasks': [{'task': 0, 'start': 141, 'machine': 1, 'duration': 20}, {'task': 1, 'start': 161, 'machine': 0, 'duration': 17}, {'task': 2, 'start': 188, 'machine': 2, 'duration': 20}]}, {'job': 3, 'tasks': [{'task': 0, 'start': 19, 'machine': 0, 'duration': 56}, {'task': 1, 'start': 180, 'machine': 2, 'duration': 8}, {'task': 2, 'start': 188, 'machine': 1, 'duration': 32}]}, {'job': 4, 'tasks': [{'task': 0, 'start': 0, 'machine': 1, 'duration': 51}, {'task': 1, 'start': 51, 'machine': 2, 'duration': 35}, {'task': 2, 'start': 86, 'machine': 0, 'duration': 63}]}]",220.0,"{'problem_type': 'JSP', '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': 2, 'duration': 1}, {'job_id': 'J1', 'task_id': 1, 'machine_id': 3, 'duration': 94}, {'job_id': 'J1', 'task_id': 2, 'machine_id': 1, 'duration': 38}, {'job_id': 'J2', 'task_id': 0, 'machine_id': 1, 'duration': 19}, {'job_id': 'J2', 'task_id': 1, 'machine_id': 3, 'duration': 23}, {'job_id': 'J2', 'task_id': 2, 'machine_id': 2, 'duration': 89}, {'job_id': 'J3', 'task_id': 0, 'machine_id': 2, 'duration': 20}, {'job_id': 'J3', 'task_id': 1, 'machine_id': 1, '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': 3, 'duration': 8}, {'job_id': 'J4', 'task_id': 2, 'machine_id': 2, 'duration': 32}, {'job_id': 'J5', 'task_id': 0, 'machine_id': 2, 'duration': 51}, {'job_id': 'J5', 'task_id': 1, 'machine_id': 3, 'duration': 35}, {'job_id': 'J5', 'task_id': 2, 'machine_id': 1, 'duration': 63}]}","[{'job': 'J1', 'tasks': [{'task': 0, 'start': 51, 'machine': 2, 'duration': 1}, {'task': 1, 'start': 86, 'machine': 3, 'duration': 94}, {'task': 2, 'start': 180, 'machine': 1, 'duration': 38}]}, {'job': 'J2', 'tasks': [{'task': 0, 'start': 0, 'machine': 1, 'duration': 19}, {'task': 1, 'start': 19, 'machine': 3, 'duration': 23}, {'task': 2, 'start': 52, 'machine': 2, 'duration': 89}]}, {'job': 'J3', 'tasks': [{'task': 0, 'start': 141, 'machine': 2, 'duration': 20}, {'task': 1, 'start': 161, 'machine': 1, 'duration': 17}, {'task': 2, 'start': 188, 'machine': 3, 'duration': 20}]}, {'job': 'J4', 'tasks': [{'task': 0, 'start': 19, 'machine': 1, 'duration': 56}, {'task': 1, 'start': 180, 'machine': 3, 'duration': 8}, {'task': 2, 'start': 188, 'machine': 2, 'duration': 32}]}, {'job': 'J5', 'tasks': [{'task': 0, 'start': 0, 'machine': 2, 'duration': 51}, {'task': 1, 'start': 51, 'machine': 3, 'duration': 35}, {'task': 2, 'start': 86, 'machine': 1, 'duration': 63}]}]",27,csv,1
JSP,JSP,"Someone in charge of the assembly line needs to decide the order bouquets visit the stations — each bouquet has a fixed chain of steps and each step has a fixed duration at a particular table or wrapping bench. Since each workstation can serve only one bouquet at a time and steps can’t be rearranged within a bouquet, the goal is to get all bouquets finished quickly; measure success by the time when the final bouquet is ready, and try to make that time as early as possible. The full list of tasks, stations and times appears below.

They are listed here: 3 bouquets, 3 stations, bouquet ids J1, J2, J3, and station ids A, B, C.
Bouquet J1, step 0 requires station B for 1 time units.
Bouquet J1, step 1 requires station C for 8 time units.
Bouquet J1, step 2 requires station A for 14 time units.
Bouquet J2, step 0 requires station B for 65 time units.
Bouquet J2, step 1 requires station C for 76 time units.
Bouquet J2, step 2 requires station A for 11 time units.
Bouquet J3, step 0 requires station A for 25 time units.
Bouquet J3, step 1 requires station C for 84 time units.
Bouquet J3, step 2 requires station B for 87 time units.
They should sequence these ordered steps to minimize the time when the final bouquet is ready.

Oh, and if you want to give me a schedule or get one back, it's easiest if we stick to a tiny JSON layout like this:

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

Think of that as a simple form: ""solution"" holds a list of bouquets (jobs). Each bouquet entry names the job id and a list of its steps; each step lists which task in the sequence it is, when that step should start, which station (machine) it uses, and how long it takes. That block is just the shape I expect — a sketch, not the finished schedule.

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': [[[1, 1], [2, 8], [0, 14]], [[1, 65], [2, 76], [0, 11]], [[0, 25], [2, 84], [1, 87]]]}","[{'job': 0, 'tasks': [{'task': 0, 'start': 0, 'machine': 1, 'duration': 1}, {'task': 1, 'start': 1, 'machine': 2, 'duration': 8}, {'task': 2, 'start': 25, 'machine': 0, 'duration': 14}]}, {'job': 1, 'tasks': [{'task': 0, 'start': 1, 'machine': 1, 'duration': 65}, {'task': 1, 'start': 109, 'machine': 2, 'duration': 76}, {'task': 2, 'start': 185, 'machine': 0, 'duration': 11}]}, {'job': 2, 'tasks': [{'task': 0, 'start': 0, 'machine': 0, 'duration': 25}, {'task': 1, 'start': 25, 'machine': 2, 'duration': 84}, {'task': 2, 'start': 109, 'machine': 1, 'duration': 87}]}]",196.0,"{'problem_type': 'JSP', 'nr_jobs': 3, 'nr_machines': 3, 'jobs': ['J1', 'J2', 'J3'], 'machines': ['A', 'B', 'C'], 'records': [{'job_id': 'J1', 'task_id': 0, 'machine_id': 'B', 'duration': 1}, {'job_id': 'J1', 'task_id': 1, 'machine_id': 'C', 'duration': 8}, {'job_id': 'J1', 'task_id': 2, 'machine_id': 'A', 'duration': 14}, {'job_id': 'J2', 'task_id': 0, 'machine_id': 'B', 'duration': 65}, {'job_id': 'J2', 'task_id': 1, 'machine_id': 'C', 'duration': 76}, {'job_id': 'J2', 'task_id': 2, 'machine_id': 'A', 'duration': 11}, {'job_id': 'J3', 'task_id': 0, 'machine_id': 'A', 'duration': 25}, {'job_id': 'J3', 'task_id': 1, 'machine_id': 'C', 'duration': 84}, {'job_id': 'J3', 'task_id': 2, 'machine_id': 'B', 'duration': 87}]}","[{'job': 'J1', 'tasks': [{'task': 0, 'start': 0, 'machine': 'B', 'duration': 1}, {'task': 1, 'start': 1, 'machine': 'C', 'duration': 8}, {'task': 2, 'start': 25, 'machine': 'A', 'duration': 14}]}, {'job': 'J2', 'tasks': [{'task': 0, 'start': 1, 'machine': 'B', 'duration': 65}, {'task': 1, 'start': 109, 'machine': 'C', 'duration': 76}, {'task': 2, 'start': 185, 'machine': 'A', 'duration': 11}]}, {'job': 'J3', 'tasks': [{'task': 0, 'start': 0, 'machine': 'A', 'duration': 25}, {'task': 1, 'start': 25, 'machine': 'C', 'duration': 84}, {'task': 2, 'start': 109, 'machine': 'B', 'duration': 87}]}]",28,nl,names
JSP,JSP,"There's this familiar scramble before air: a stack of segments, each with its own line of work to pass through, known durations for those jobs, and a handful of rooms that can only do one thing at a time. The decision is how to funnel the segments through those rooms so the final show can be handed off as early as possible. The measure that matters is the time on the clock when the final segment is done — the earlier that finish time, the better the plan. Every segment must complete every step in the given sequence; nothing gets left out or duplicated. The specific rundown and timings are listed below.

There are 4 segments to route through 2 rooms; the segment identifiers are J1, J2, J3, J4 and the room identifiers are A, B.

| segment_id | step_index | room_id | processing_time |
|---|---|---|---|
| J1 | 0 | B | 1 |
| J1 | 1 | A | 21 |
| J2 | 0 | A | 89 |
| J2 | 1 | B | 11 |
| J3 | 0 | A | 30 |
| J3 | 1 | B | 33 |
| J4 | 0 | A | 30 |
| J4 | 1 | B | 52 |

Keep the plan aimed at getting the final segment handed off as early as possible.

Oh, and a handy way to send the plan back is as a little JSON sketch — nothing fancy, just the shape I expect to see:

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

Think of that as a simple form: ""solution"" holds a list of jobs, each job entry names the job and then lists its tasks; for each task you provide the task index (which step it is), the start time, the machine it runs on, and how long it takes. It's just the expected shape — not the actual filled-in answer.

Please use the identifiers exactly as they appear 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': 2, 'nr_jobs': 4, 'jobs': [[[1, 1], [0, 21]], [[0, 89], [1, 11]], [[0, 30], [1, 33]], [[0, 30], [1, 52]]]}","[{'job': 0, 'tasks': [{'task': 0, 'start': 0, 'machine': 1, 'duration': 1}, {'task': 1, 'start': 149, 'machine': 0, 'duration': 21}]}, {'job': 1, 'tasks': [{'task': 0, 'start': 60, 'machine': 0, 'duration': 89}, {'task': 1, 'start': 149, 'machine': 1, 'duration': 11}]}, {'job': 2, 'tasks': [{'task': 0, 'start': 0, 'machine': 0, 'duration': 30}, {'task': 1, 'start': 30, 'machine': 1, 'duration': 33}]}, {'job': 3, 'tasks': [{'task': 0, 'start': 30, 'machine': 0, 'duration': 30}, {'task': 1, 'start': 63, 'machine': 1, 'duration': 52}]}]",170.0,"{'problem_type': 'JSP', 'nr_jobs': 4, 'nr_machines': 2, 'jobs': ['J1', 'J2', 'J3', 'J4'], 'machines': ['A', 'B'], 'records': [{'job_id': 'J1', 'task_id': 0, 'machine_id': 'B', 'duration': 1}, {'job_id': 'J1', 'task_id': 1, 'machine_id': 'A', 'duration': 21}, {'job_id': 'J2', 'task_id': 0, 'machine_id': 'A', 'duration': 89}, {'job_id': 'J2', 'task_id': 1, 'machine_id': 'B', 'duration': 11}, {'job_id': 'J3', 'task_id': 0, 'machine_id': 'A', 'duration': 30}, {'job_id': 'J3', 'task_id': 1, 'machine_id': 'B', 'duration': 33}, {'job_id': 'J4', 'task_id': 0, 'machine_id': 'A', 'duration': 30}, {'job_id': 'J4', 'task_id': 1, 'machine_id': 'B', 'duration': 52}]}","[{'job': 'J1', 'tasks': [{'task': 0, 'start': 0, 'machine': 'B', 'duration': 1}, {'task': 1, 'start': 149, 'machine': 'A', 'duration': 21}]}, {'job': 'J2', 'tasks': [{'task': 0, 'start': 60, 'machine': 'A', 'duration': 89}, {'task': 1, 'start': 149, 'machine': 'B', 'duration': 11}]}, {'job': 'J3', 'tasks': [{'task': 0, 'start': 0, 'machine': 'A', 'duration': 30}, {'task': 1, 'start': 30, 'machine': 'B', 'duration': 33}]}, {'job': 'J4', 'tasks': [{'task': 0, 'start': 30, 'machine': 'A', 'duration': 30}, {'task': 1, 'start': 63, 'machine': 'B', 'duration': 52}]}]",29,markdown_table,names
JSP,JSP,"I run the little packaging line and need to figure out the best way to send every batch out fast. Each batch has a fixed string of steps — fill, cap, label, pack — and each step always takes the same amount of time. The choices are about who goes where and when on the different machines, but the trick is that each machine can only handle one thing at once and every batch must go through its steps in order, never skipping or repeating a step. A better plan is simply the one that gets the very last batch out sooner — measure that by looking at when each batch finishes and taking the latest finish time; that latest time is what to make as small as possible. The exact line layout, machine list and times are shown below.

# nr_batches=4
# nr_stations=2
# batch_ids=J1, J2, J3, J4
# station_ids=A, B
batch_id,step_index,station_id,step_duration
J1,0,B,1
J1,1,A,34
J2,0,A,65
J2,1,B,56
J3,0,A,82
J3,1,B,55
J4,0,B,34
J4,1,A,20

Also, when you send the actual plan back, please use this simple JSON layout so I can read the schedule easily:

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

Think of it like a little form: the top-level ""solution"" is a list of batches (jobs). Each batch lists its tasks in order, and for each task you give the task index (which step it is), the time it starts, what machine it runs on, and how long it takes. Super casual — just fill in the fields for each job.

This JSON is only a sketch of the shape I expect, not the actual 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': 4, 'jobs': [[[1, 1], [0, 34]], [[0, 65], [1, 56]], [[0, 82], [1, 55]], [[1, 34], [0, 20]]]}","[{'job': 0, 'tasks': [{'task': 0, 'start': 34, 'machine': 1, 'duration': 1}, {'task': 1, 'start': 147, 'machine': 0, 'duration': 34}]}, {'job': 1, 'tasks': [{'task': 0, 'start': 0, 'machine': 0, 'duration': 65}, {'task': 1, 'start': 65, 'machine': 1, 'duration': 56}]}, {'job': 2, 'tasks': [{'task': 0, 'start': 65, 'machine': 0, 'duration': 82}, {'task': 1, 'start': 147, 'machine': 1, 'duration': 55}]}, {'job': 3, 'tasks': [{'task': 0, 'start': 0, 'machine': 1, 'duration': 34}, {'task': 1, 'start': 181, 'machine': 0, 'duration': 20}]}]",202.0,"{'problem_type': 'JSP', 'nr_jobs': 4, 'nr_machines': 2, 'jobs': ['J1', 'J2', 'J3', 'J4'], 'machines': ['A', 'B'], 'records': [{'job_id': 'J1', 'task_id': 0, 'machine_id': 'B', 'duration': 1}, {'job_id': 'J1', 'task_id': 1, 'machine_id': 'A', 'duration': 34}, {'job_id': 'J2', 'task_id': 0, 'machine_id': 'A', 'duration': 65}, {'job_id': 'J2', 'task_id': 1, 'machine_id': 'B', 'duration': 56}, {'job_id': 'J3', 'task_id': 0, 'machine_id': 'A', 'duration': 82}, {'job_id': 'J3', 'task_id': 1, 'machine_id': 'B', 'duration': 55}, {'job_id': 'J4', 'task_id': 0, 'machine_id': 'B', 'duration': 34}, {'job_id': 'J4', 'task_id': 1, 'machine_id': 'A', 'duration': 20}]}","[{'job': 'J1', 'tasks': [{'task': 0, 'start': 34, 'machine': 'B', 'duration': 1}, {'task': 1, 'start': 147, 'machine': 'A', 'duration': 34}]}, {'job': 'J2', 'tasks': [{'task': 0, 'start': 0, 'machine': 'A', 'duration': 65}, {'task': 1, 'start': 65, 'machine': 'B', 'duration': 56}]}, {'job': 'J3', 'tasks': [{'task': 0, 'start': 65, 'machine': 'A', 'duration': 82}, {'task': 1, 'start': 147, 'machine': 'B', 'duration': 55}]}, {'job': 'J4', 'tasks': [{'task': 0, 'start': 0, 'machine': 'B', 'duration': 34}, {'task': 1, 'start': 181, 'machine': 'A', 'duration': 20}]}]",30,csv,names
JSP,JSP,"Recently the coordinator was tasked with arranging all class sessions so each class follows its list of sessions in order, every session runs for a fixed period, and no room gets two things at the same time. The aim is practical and simple: make the time when the final session across the school ends as early as possible — for each plan, check when each class ends and take the latest of those times. No session can be left out or duplicated; specific session lengths and room assignments are listed below.

Listed below are 3 classes and 2 rooms, identified as J1, J2, J3 and A, B.
Class J1 session 0 is assigned to room B and lasts 1 time units.
Class J1 session 1 is assigned to room A and lasts 47 time units.
Class J2 session 0 is assigned to room A and lasts 40 time units.
Class J2 session 1 is assigned to room B and lasts 3 time units.
Class J3 session 0 is assigned to room B and lasts 36 time units.
Class J3 session 1 is assigned to room A and lasts 76 time units.
Schedule all sessions so each class's sessions occur in order and no room hosts overlapping sessions; minimize the latest class end time.

Also, when you send back a plan, please use this JSON layout so it's easy to read and check:

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

This is just a simple sketch of the shape I expect. Think of it like a form: ""solution"" holds a list of classes; each entry's job is the class identifier, and its tasks list describes each session in order. For each session you give the task index (which session number it is), the start time, which room (machine) it's in, and how long it lasts. The JSON above is an example structure only — not the actual schedule.

Please make sure to use the identifiers exactly as they appear 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': 2, 'nr_jobs': 3, 'jobs': [[[1, 1], [0, 47]], [[0, 40], [1, 3]], [[1, 36], [0, 76]]]}","[{'job': 0, 'tasks': [{'task': 0, 'start': 36, 'machine': 1, 'duration': 1}, {'task': 1, 'start': 116, 'machine': 0, 'duration': 47}]}, {'job': 1, 'tasks': [{'task': 0, 'start': 0, 'machine': 0, 'duration': 40}, {'task': 1, 'start': 40, 'machine': 1, 'duration': 3}]}, {'job': 2, 'tasks': [{'task': 0, 'start': 0, 'machine': 1, 'duration': 36}, {'task': 1, 'start': 40, 'machine': 0, 'duration': 76}]}]",163.0,"{'problem_type': 'JSP', 'nr_jobs': 3, 'nr_machines': 2, 'jobs': ['J1', 'J2', 'J3'], 'machines': ['A', 'B'], 'records': [{'job_id': 'J1', 'task_id': 0, 'machine_id': 'B', 'duration': 1}, {'job_id': 'J1', 'task_id': 1, 'machine_id': 'A', 'duration': 47}, {'job_id': 'J2', 'task_id': 0, 'machine_id': 'A', 'duration': 40}, {'job_id': 'J2', 'task_id': 1, 'machine_id': 'B', 'duration': 3}, {'job_id': 'J3', 'task_id': 0, 'machine_id': 'B', 'duration': 36}, {'job_id': 'J3', 'task_id': 1, 'machine_id': 'A', 'duration': 76}]}","[{'job': 'J1', 'tasks': [{'task': 0, 'start': 36, 'machine': 'B', 'duration': 1}, {'task': 1, 'start': 116, 'machine': 'A', 'duration': 47}]}, {'job': 'J2', 'tasks': [{'task': 0, 'start': 0, 'machine': 'A', 'duration': 40}, {'task': 1, 'start': 40, 'machine': 'B', 'duration': 3}]}, {'job': 'J3', 'tasks': [{'task': 0, 'start': 0, 'machine': 'B', 'duration': 36}, {'task': 1, 'start': 40, 'machine': 'A', 'duration': 76}]}]",31,nl,names
JSP,JSP,"On a busy morning the radiology scheduler picks start times so every patient’s imaging sequence flows: each scan sits on the scanner it’s supposed to, takes the exact time it needs, follows the previous scan for that patient, and never clashes with another scan on the same machine — success is simply how early the entire set of patients is done, measured by when the last scheduled scan ends. The specific case details are listed below.

There are 3 patients and 3 scanners; patient IDs: J1, J2, J3; scanner IDs: 1, 2, 3.
For patient J1, scan 0 must run on scanner 3 for 1.
For patient J1, scan 1 must run on scanner 2 for 60.
For patient J1, scan 2 must run on scanner 1 for 16.
For patient J2, scan 0 must run on scanner 3 for 48.
For patient J2, scan 1 must run on scanner 2 for 89.
For patient J2, scan 2 must run on scanner 1 for 98.
For patient J3, scan 0 must run on scanner 1 for 43.
For patient J3, scan 1 must run on scanner 3 for 56.
For patient J3, scan 2 must run on scanner 2 for 59.
These entries list every required scan so the scheduler can minimize when the last scan finishes.

If you'd like to return the schedule in a nice, machine-friendly way (and still keep things readable for a human), just follow this simple JSON shape when you reply:

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

Think of that as a lightweight form: ""solution"" is the list of all jobs (each patient or imaging sequence), each job entry names the job id and then a list of its tasks; each task line says which step it is, when that scan starts, which scanner/machine it uses, and how long it runs. It’s just a sketch of the shape I need, not the actual scheduled times.

Please make sure to use the exact identifiers from the instance input — no renaming and no new labels. For example:
- ""Valid identifiers look like plain numbers such as “1” or “23”, single capital letters like “A” or “B”, or a capital letter followed by digits like “A1” or “X7”.""","{'nr_machines': 3, 'nr_jobs': 3, 'jobs': [[[2, 1], [1, 60], [0, 16]], [[2, 48], [1, 89], [0, 98]], [[0, 43], [2, 56], [1, 59]]]}","[{'job': 0, 'tasks': [{'task': 0, 'start': 0, 'machine': 2, 'duration': 1}, {'task': 1, 'start': 1, 'machine': 1, 'duration': 60}, {'task': 2, 'start': 61, 'machine': 0, 'duration': 16}]}, {'job': 1, 'tasks': [{'task': 0, 'start': 1, 'machine': 2, 'duration': 48}, {'task': 1, 'start': 61, 'machine': 1, 'duration': 89}, {'task': 2, 'start': 150, 'machine': 0, 'duration': 98}]}, {'job': 2, 'tasks': [{'task': 0, 'start': 0, 'machine': 0, 'duration': 43}, {'task': 1, 'start': 49, 'machine': 2, 'duration': 56}, {'task': 2, 'start': 150, 'machine': 1, 'duration': 59}]}]",248.0,"{'problem_type': 'JSP', 'nr_jobs': 3, 'nr_machines': 3, 'jobs': ['J1', 'J2', 'J3'], 'machines': [1, 2, 3], 'records': [{'job_id': 'J1', 'task_id': 0, 'machine_id': 3, 'duration': 1}, {'job_id': 'J1', 'task_id': 1, 'machine_id': 2, 'duration': 60}, {'job_id': 'J1', 'task_id': 2, 'machine_id': 1, 'duration': 16}, {'job_id': 'J2', 'task_id': 0, 'machine_id': 3, 'duration': 48}, {'job_id': 'J2', 'task_id': 1, 'machine_id': 2, 'duration': 89}, {'job_id': 'J2', 'task_id': 2, 'machine_id': 1, 'duration': 98}, {'job_id': 'J3', 'task_id': 0, 'machine_id': 1, 'duration': 43}, {'job_id': 'J3', 'task_id': 1, 'machine_id': 3, 'duration': 56}, {'job_id': 'J3', 'task_id': 2, 'machine_id': 2, 'duration': 59}]}","[{'job': 'J1', 'tasks': [{'task': 0, 'start': 0, 'machine': 3, 'duration': 1}, {'task': 1, 'start': 1, 'machine': 2, 'duration': 60}, {'task': 2, 'start': 61, 'machine': 1, 'duration': 16}]}, {'job': 'J2', 'tasks': [{'task': 0, 'start': 1, 'machine': 3, 'duration': 48}, {'task': 1, 'start': 61, 'machine': 2, 'duration': 89}, {'task': 2, 'start': 150, 'machine': 1, 'duration': 98}]}, {'job': 'J3', 'tasks': [{'task': 0, 'start': 0, 'machine': 1, 'duration': 43}, {'task': 1, 'start': 49, 'machine': 3, 'duration': 56}, {'task': 2, 'start': 150, 'machine': 2, 'duration': 59}]}]",32,nl,1
JSP,JSP,"There’s a small studio where projects must pass through editing, then color grading, then sound mixing, and those three steps are fixed for every project. The task at hand is to assign start times on the proper workstations so each step takes its allotted time, no workstation is double-booked, and every step happens exactly once in order. The goal is to bring the time when the very last project finishes as low as possible — compute each project’s finish time and the schedule’s result is the latest finish among them. The exact list of projects and durations appears below.

Instance: 5 projects, 3 workstations; project IDs J1, J2, J3, J4, J5; workstation IDs 0, 1, 2.

| project_id | step_index | workstation_id | processing_duration |
|---|---|---|---|
| J1 | 0 | 1 | 1 |
| J1 | 1 | 2 | 73 |
| J1 | 2 | 0 | 91 |
| J2 | 0 | 1 | 94 |
| J2 | 1 | 0 | 43 |
| J2 | 2 | 2 | 21 |
| J3 | 0 | 2 | 48 |
| J3 | 1 | 1 | 24 |
| J3 | 2 | 0 | 27 |
| J4 | 0 | 0 | 17 |
| J4 | 1 | 1 | 38 |
| J4 | 2 | 2 | 44 |
| J5 | 0 | 1 | 49 |
| J5 | 1 | 2 | 56 |
| J5 | 2 | 0 | 95 |

Place each step so every task occurs once in order and the latest project finish is minimized.

Also, I'll return the schedule in a simple JSON shape so it's easy to check or load into other tools. Something like this:

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

Think of it as a little form: each top-level entry is a project (""job""), and inside you list its ordered steps (""tasks""). For each step you say which step number it is (""task""), when it starts (""start""), which workstation it uses (""machine""), and how long it runs (""duration""). This block is just a sketch of the expected shape — I’ll fill in the actual numbers and IDs for the instance itself.

Please keep all job and machine identifiers exactly as they appear in the instance input — no renaming and no new labels. 
- for example: ""Valid identifiers look like plain numbers such as “1” or “23”, single capital letters like “A” or “B”, or a capital letter followed by digits like “A1” or “X7”.""","{'nr_machines': 3, 'nr_jobs': 5, 'jobs': [[[1, 1], [2, 73], [0, 91]], [[1, 94], [0, 43], [2, 21]], [[2, 48], [1, 24], [0, 27]], [[0, 17], [1, 38], [2, 44]], [[1, 49], [2, 56], [0, 95]]]}","[{'job': 0, 'tasks': [{'task': 0, 'start': 0, 'machine': 1, 'duration': 1}, {'task': 1, 'start': 1, 'machine': 2, 'duration': 73}, {'task': 2, 'start': 74, 'machine': 0, 'duration': 91}]}, {'job': 1, 'tasks': [{'task': 0, 'start': 50, 'machine': 1, 'duration': 94}, {'task': 1, 'start': 165, 'machine': 0, 'duration': 43}, {'task': 2, 'start': 226, 'machine': 2, 'duration': 21}]}, {'job': 2, 'tasks': [{'task': 0, 'start': 130, 'machine': 2, 'duration': 48}, {'task': 1, 'start': 182, 'machine': 1, 'duration': 24}, {'task': 2, 'start': 303, 'machine': 0, 'duration': 27}]}, {'job': 3, 'tasks': [{'task': 0, 'start': 0, 'machine': 0, 'duration': 17}, {'task': 1, 'start': 144, 'machine': 1, 'duration': 38}, {'task': 2, 'start': 182, 'machine': 2, 'duration': 44}]}, {'job': 4, 'tasks': [{'task': 0, 'start': 1, 'machine': 1, 'duration': 49}, {'task': 1, 'start': 74, 'machine': 2, 'duration': 56}, {'task': 2, 'start': 208, 'machine': 0, 'duration': 95}]}]",330.0,"{'problem_type': 'JSP', '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': 1, 'duration': 1}, {'job_id': 'J1', 'task_id': 1, 'machine_id': 2, 'duration': 73}, {'job_id': 'J1', 'task_id': 2, 'machine_id': 0, 'duration': 91}, {'job_id': 'J2', 'task_id': 0, 'machine_id': 1, 'duration': 94}, {'job_id': 'J2', 'task_id': 1, 'machine_id': 0, 'duration': 43}, {'job_id': 'J2', 'task_id': 2, 'machine_id': 2, 'duration': 21}, {'job_id': 'J3', 'task_id': 0, 'machine_id': 2, 'duration': 48}, {'job_id': 'J3', 'task_id': 1, 'machine_id': 1, 'duration': 24}, {'job_id': 'J3', 'task_id': 2, 'machine_id': 0, 'duration': 27}, {'job_id': 'J4', 'task_id': 0, 'machine_id': 0, 'duration': 17}, {'job_id': 'J4', 'task_id': 1, 'machine_id': 1, 'duration': 38}, {'job_id': 'J4', 'task_id': 2, 'machine_id': 2, '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': 0, 'duration': 95}]}","[{'job': 'J1', 'tasks': [{'task': 0, 'start': 0, 'machine': 1, 'duration': 1}, {'task': 1, 'start': 1, 'machine': 2, 'duration': 73}, {'task': 2, 'start': 74, 'machine': 0, 'duration': 91}]}, {'job': 'J2', 'tasks': [{'task': 0, 'start': 50, 'machine': 1, 'duration': 94}, {'task': 1, 'start': 165, 'machine': 0, 'duration': 43}, {'task': 2, 'start': 226, 'machine': 2, 'duration': 21}]}, {'job': 'J3', 'tasks': [{'task': 0, 'start': 130, 'machine': 2, 'duration': 48}, {'task': 1, 'start': 182, 'machine': 1, 'duration': 24}, {'task': 2, 'start': 303, 'machine': 0, 'duration': 27}]}, {'job': 'J4', 'tasks': [{'task': 0, 'start': 0, 'machine': 0, 'duration': 17}, {'task': 1, 'start': 144, 'machine': 1, 'duration': 38}, {'task': 2, 'start': 182, 'machine': 2, 'duration': 44}]}, {'job': 'J5', 'tasks': [{'task': 0, 'start': 1, 'machine': 1, 'duration': 49}, {'task': 1, 'start': 74, 'machine': 2, 'duration': 56}, {'task': 2, 'start': 208, 'machine': 0, 'duration': 95}]}]",33,markdown_table,0
JSP,JSP,"There’s a pile of bookings with each client asking for a string of photos and then retouches, and it’s up to the studio to slot those tasks into the available sets and editing stations. Each item in a session needs a dedicated space for a fixed stretch, the steps must be done in order, and no set or station can handle two things at the same time — everything must be scheduled once, no repeats. The way to tell which schedule is better is to look at when the final session finishes; the earlier that finishing time, the better the plan. Concrete session details are listed below.

{
  ""num_sessions"": 3,
  ""num_sets_and_stations"": 3,
  ""session_ids"": [
    ""J1"",
    ""J2"",
    ""J3""
  ],
  ""resource_ids"": [
    ""A"",
    ""B"",
    ""C""
  ],
  ""tasks"": [
    {
      ""session_id"": ""J1"",
      ""step_index"": 0,
      ""resource_id"": ""B"",
      ""duration_minutes"": 1
    },
    {
      ""session_id"": ""J1"",
      ""step_index"": 1,
      ""resource_id"": ""C"",
      ""duration_minutes"": 86
    },
    {
      ""session_id"": ""J1"",
      ""step_index"": 2,
      ""resource_id"": ""A"",
      ""duration_minutes"": 67
    },
    {
      ""session_id"": ""J2"",
      ""step_index"": 0,
      ""resource_id"": ""A"",
      ""duration_minutes"": 40
    },
    {
      ""session_id"": ""J2"",
      ""step_index"": 1,
      ""resource_id"": ""B"",
      ""duration_minutes"": 95
    },
    {
      ""session_id"": ""J2"",
      ""step_index"": 2,
      ""resource_id"": ""C"",
      ""duration_minutes"": 42
    },
    {
      ""session_id"": ""J3"",
      ""step_index"": 0,
      ""resource_id"": ""C"",
      ""duration_minutes"": 53
    },
    {
      ""session_id"": ""J3"",
      ""step_index"": 1,
      ""resource_id"": ""A"",
      ""duration_minutes"": 91
    },
    {
      ""session_id"": ""J3"",
      ""step_index"": 2,
      ""resource_id"": ""B"",
      ""duration_minutes"": 94
    }
  ]
}

If you'd like the schedule in a tidy, copy-pasteable form, I usually return it as JSON like this:

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

This is just the shape I expect: ""solution"" is a list of sessions, each item has a ""job"" (the session id), and a ""tasks"" list where every task shows which step it is, when it starts, which set or editing station it uses, and how long it runs. Treat it like a simple form—fill in the IDs and numbers in those slots.

Note that this JSON is only a sketch of the expected shape, not the actual schedule.

Please use the exact identifiers from the instance input — do not rename them or invent new labels. Valid identifiers look like plain numbers such as “1” or “23”, single capital letters like “A” or “B”, or a capital letter followed by digits like “A1” or “X7”.","{'nr_machines': 3, 'nr_jobs': 3, 'jobs': [[[1, 1], [2, 86], [0, 67]], [[0, 40], [1, 95], [2, 42]], [[2, 53], [0, 91], [1, 94]]]}","[{'job': 0, 'tasks': [{'task': 0, 'start': 0, 'machine': 1, 'duration': 1}, {'task': 1, 'start': 53, 'machine': 2, 'duration': 86}, {'task': 2, 'start': 144, 'machine': 0, 'duration': 67}]}, {'job': 1, 'tasks': [{'task': 0, 'start': 0, 'machine': 0, 'duration': 40}, {'task': 1, 'start': 40, 'machine': 1, 'duration': 95}, {'task': 2, 'start': 139, 'machine': 2, 'duration': 42}]}, {'job': 2, 'tasks': [{'task': 0, 'start': 0, 'machine': 2, 'duration': 53}, {'task': 1, 'start': 53, 'machine': 0, 'duration': 91}, {'task': 2, 'start': 144, 'machine': 1, 'duration': 94}]}]",238.0,"{'problem_type': 'JSP', 'nr_jobs': 3, 'nr_machines': 3, 'jobs': ['J1', 'J2', 'J3'], 'machines': ['A', 'B', 'C'], 'records': [{'job_id': 'J1', 'task_id': 0, 'machine_id': 'B', 'duration': 1}, {'job_id': 'J1', 'task_id': 1, 'machine_id': 'C', 'duration': 86}, {'job_id': 'J1', 'task_id': 2, 'machine_id': 'A', 'duration': 67}, {'job_id': 'J2', 'task_id': 0, 'machine_id': 'A', 'duration': 40}, {'job_id': 'J2', 'task_id': 1, 'machine_id': 'B', 'duration': 95}, {'job_id': 'J2', 'task_id': 2, 'machine_id': 'C', 'duration': 42}, {'job_id': 'J3', 'task_id': 0, 'machine_id': 'C', 'duration': 53}, {'job_id': 'J3', 'task_id': 1, 'machine_id': 'A', 'duration': 91}, {'job_id': 'J3', 'task_id': 2, 'machine_id': 'B', 'duration': 94}]}","[{'job': 'J1', 'tasks': [{'task': 0, 'start': 0, 'machine': 'B', 'duration': 1}, {'task': 1, 'start': 53, 'machine': 'C', 'duration': 86}, {'task': 2, 'start': 144, 'machine': 'A', 'duration': 67}]}, {'job': 'J2', 'tasks': [{'task': 0, 'start': 0, 'machine': 'A', 'duration': 40}, {'task': 1, 'start': 40, 'machine': 'B', 'duration': 95}, {'task': 2, 'start': 139, 'machine': 'C', 'duration': 42}]}, {'job': 'J3', 'tasks': [{'task': 0, 'start': 0, 'machine': 'C', 'duration': 53}, {'task': 1, 'start': 53, 'machine': 'A', 'duration': 91}, {'task': 2, 'start': 144, 'machine': 'B', 'duration': 94}]}]",34,json,names
JSP,JSP,"We run a fleet of delivery drones and every morning they need a fixed lineup of checks and charging sessions, each tied to a specific pad or bench and lasting a known amount of time. The decision is how to schedule those checks so no pad is double-booked, nothing is skipped or repeated, and each drone’s steps happen in their required order. A schedule that finishes the whole fleet sooner is preferable — measure that by the time the last drone wraps up its final required activity. The concrete list of drones, required steps, pad assignments, and durations follows below.

We have 2 drones and 2 pads; their identifiers are J1, J2 and 0, 1.

| drone_id | step_index | pad_id | duration_minutes |
|---|---|---|---|
| J1 | 0 | 1 | 1 |
| J1 | 1 | 0 | 99 |
| J2 | 0 | 1 | 43 |
| J2 | 1 | 0 | 85 |

We seek a schedule that minimizes when the last of the 2 drones finishes.

Also, when you hand me the schedule, please follow a simple JSON layout — nothing fancy, just the shape I'll parse. Here's the sketch I expect:

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

Quick, informal guide to the fields so it’s clear what goes where:
- ""solution"" is a list with one entry per drone (job).
- ""job"" is the drone identifier.
- ""tasks"" is the ordered list of that drone’s required steps.
- each task has ""task"" (which step it is in the sequence), ""start"" (when it begins), ""machine"" (which pad or bench it uses), and ""duration"" (how long it runs).

This JSON is just a template of the shape I want — not the actual schedule itself.

Please make sure you 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': 2, 'jobs': [[[1, 1], [0, 99]], [[1, 43], [0, 85]]]}","[{'job': 0, 'tasks': [{'task': 0, 'start': 0, 'machine': 1, 'duration': 1}, {'task': 1, 'start': 1, 'machine': 0, 'duration': 99}]}, {'job': 1, 'tasks': [{'task': 0, 'start': 1, 'machine': 1, 'duration': 43}, {'task': 1, 'start': 100, 'machine': 0, 'duration': 85}]}]",185.0,"{'problem_type': 'JSP', 'nr_jobs': 2, 'nr_machines': 2, 'jobs': ['J1', 'J2'], 'machines': [0, 1], 'records': [{'job_id': 'J1', 'task_id': 0, 'machine_id': 1, 'duration': 1}, {'job_id': 'J1', 'task_id': 1, 'machine_id': 0, 'duration': 99}, {'job_id': 'J2', 'task_id': 0, 'machine_id': 1, 'duration': 43}, {'job_id': 'J2', 'task_id': 1, 'machine_id': 0, 'duration': 85}]}","[{'job': 'J1', 'tasks': [{'task': 0, 'start': 0, 'machine': 1, 'duration': 1}, {'task': 1, 'start': 1, 'machine': 0, 'duration': 99}]}, {'job': 'J2', 'tasks': [{'task': 0, 'start': 1, 'machine': 1, 'duration': 43}, {'task': 1, 'start': 100, 'machine': 0, 'duration': 85}]}]",35,markdown_table,0
JSP,JSP,"At the port the challenge is to sequence loading and inspection for all outbound containers so every container follows its prescribed sequence on specific docks and inspection lanes for set time slots. Each operation needs its assigned dock or lane and takes a fixed amount of time, and docks are single-tasked — they can’t run simultaneous operations. The whole plan is judged by how early the last container departs; the sooner that departure time, the better the schedule. No step can be skipped or repeated, order matters, and the exact container operations and timings are provided below.

Below are the 2 containers to schedule across the 3 stations: containers J1, J2; stations A, B, C.
Container J1, operation 0, requires station C for 1 time units.
Container J1, operation 1, requires station B for 13 time units.
Container J1, operation 2, requires station A for 18 time units.
Container J2, operation 0, requires station C for 32 time units.
Container J2, operation 1, requires station B for 3 time units.
Container J2, operation 2, requires station A for 86 time units.
The objective remains to minimize the departure time of the last container across all 3 stations for these 2 containers.

You can just hand me the schedule in this simple JSON shape when you're ready — makes it easy to read and check:

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

Think of it like a little form: ""solution"" is a list of containers (jobs). Each job entry names the job and then lists its ordered tasks. For each task, give the task's index within that job, the planned start time, which dock or lane (machine) it uses, and how long it runs. Super casual — just fill in those fields with the actual IDs and times.

This JSON is only a sketch of the expected shape, not the actual schedule — please fill in the real values from the instance.

Please use the identifiers exactly as they appear in the instance input — do not rename them or invent new labels. For example: ""Valid identifiers look like plain numbers such as “1” or “23”, single capital letters like “A” or “B”, or a capital letter followed by digits like “A1” or “X7”.""","{'nr_machines': 3, 'nr_jobs': 2, 'jobs': [[[2, 1], [1, 13], [0, 18]], [[2, 32], [1, 3], [0, 86]]]}","[{'job': 0, 'tasks': [{'task': 0, 'start': 0, 'machine': 2, 'duration': 1}, {'task': 1, 'start': 1, 'machine': 1, 'duration': 13}, {'task': 2, 'start': 14, 'machine': 0, 'duration': 18}]}, {'job': 1, 'tasks': [{'task': 0, 'start': 1, 'machine': 2, 'duration': 32}, {'task': 1, 'start': 33, 'machine': 1, 'duration': 3}, {'task': 2, 'start': 36, 'machine': 0, 'duration': 86}]}]",122.0,"{'problem_type': 'JSP', 'nr_jobs': 2, 'nr_machines': 3, 'jobs': ['J1', 'J2'], 'machines': ['A', 'B', 'C'], 'records': [{'job_id': 'J1', 'task_id': 0, 'machine_id': 'C', 'duration': 1}, {'job_id': 'J1', 'task_id': 1, 'machine_id': 'B', 'duration': 13}, {'job_id': 'J1', 'task_id': 2, 'machine_id': 'A', 'duration': 18}, {'job_id': 'J2', 'task_id': 0, 'machine_id': 'C', 'duration': 32}, {'job_id': 'J2', 'task_id': 1, 'machine_id': 'B', 'duration': 3}, {'job_id': 'J2', 'task_id': 2, 'machine_id': 'A', 'duration': 86}]}","[{'job': 'J1', 'tasks': [{'task': 0, 'start': 0, 'machine': 'C', 'duration': 1}, {'task': 1, 'start': 1, 'machine': 'B', 'duration': 13}, {'task': 2, 'start': 14, 'machine': 'A', 'duration': 18}]}, {'job': 'J2', 'tasks': [{'task': 0, 'start': 1, 'machine': 'C', 'duration': 32}, {'task': 1, 'start': 33, 'machine': 'B', 'duration': 3}, {'task': 2, 'start': 36, 'machine': 'A', 'duration': 86}]}]",36,nl,names
JSP,JSP,"I’m running the grading room this term and the job is to get a bunch of exam batches through their required review steps — each batch has its own little to-do list that must happen in order, and each step needs a particular workstation for a fixed amount of time. The tricky part is deciding who goes to which table when, since a workstation can only handle one review at a time and no step can be skipped or done twice. The better plans are the ones where the last batch gets finished earlier — success is measured by the clock time when the final batch is signed off. The exact batches, steps, stations and times are shown below.

Here are the 5 batches (J1, J2, J3, J4, J5) and the 3 workstations (A, B, C) that I need to coordinate.

| batch_id | step_index | required_workstation_id | processing_time |
|---|---|---|---|
| J1 | 0 | C | 1 |
| J1 | 1 | B | 26 |
| J1 | 2 | A | 93 |
| J2 | 0 | B | 77 |
| J2 | 1 | A | 56 |
| J2 | 2 | C | 8 |
| J3 | 0 | C | 67 |
| J3 | 1 | B | 95 |
| J3 | 2 | A | 98 |
| J4 | 0 | C | 90 |
| J4 | 1 | B | 91 |
| J4 | 2 | A | 51 |
| J5 | 0 | A | 81 |
| J5 | 1 | B | 69 |
| J5 | 2 | C | 17 |

I'm aiming for a plan that finishes the final batch as early as possible.

Also, when you send the schedule back, please follow this JSON layout:

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

Think of this as a simple form: ""solution"" is a list of batches (jobs), each entry has the job identifier and a list of its ordered tasks. For each task you give the task index (which step it is in that job), the planned start time, the machine/workstation to use, and how long that step takes. This block is just a sketch of the shape I expect — fill it in with the actual ids and times when you submit the schedule.

Please use the identifiers exactly as they appear in the instance input — do not rename them and do not invent new labels.

Valid identifiers look like plain numbers such as ""1"" or ""23"", single capital letters like ""A"" or ""B"", or a capital letter followed by digits like ""A1"" or ""X7"".","{'nr_machines': 3, 'nr_jobs': 5, 'jobs': [[[2, 1], [1, 26], [0, 93]], [[1, 77], [0, 56], [2, 8]], [[2, 67], [1, 95], [0, 98]], [[2, 90], [1, 91], [0, 51]], [[0, 81], [1, 69], [2, 17]]]}","[{'job': 0, 'tasks': [{'task': 0, 'start': 67, 'machine': 2, 'duration': 1}, {'task': 1, 'start': 77, 'machine': 1, 'duration': 26}, {'task': 2, 'start': 137, 'machine': 0, 'duration': 93}]}, {'job': 1, 'tasks': [{'task': 0, 'start': 0, 'machine': 1, 'duration': 77}, {'task': 1, 'start': 81, 'machine': 0, 'duration': 56}, {'task': 2, 'start': 158, 'machine': 2, 'duration': 8}]}, {'job': 2, 'tasks': [{'task': 0, 'start': 0, 'machine': 2, 'duration': 67}, {'task': 1, 'start': 103, 'machine': 1, 'duration': 95}, {'task': 2, 'start': 230, 'machine': 0, 'duration': 98}]}, {'job': 3, 'tasks': [{'task': 0, 'start': 68, 'machine': 2, 'duration': 90}, {'task': 1, 'start': 198, 'machine': 1, 'duration': 91}, {'task': 2, 'start': 328, 'machine': 0, 'duration': 51}]}, {'job': 4, 'tasks': [{'task': 0, 'start': 0, 'machine': 0, 'duration': 81}, {'task': 1, 'start': 289, 'machine': 1, 'duration': 69}, {'task': 2, 'start': 358, 'machine': 2, 'duration': 17}]}]",379.0,"{'problem_type': 'JSP', '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': 'C', 'duration': 1}, {'job_id': 'J1', 'task_id': 1, 'machine_id': 'B', 'duration': 26}, {'job_id': 'J1', 'task_id': 2, 'machine_id': 'A', 'duration': 93}, {'job_id': 'J2', 'task_id': 0, 'machine_id': 'B', 'duration': 77}, {'job_id': 'J2', 'task_id': 1, 'machine_id': 'A', 'duration': 56}, {'job_id': 'J2', 'task_id': 2, 'machine_id': 'C', 'duration': 8}, {'job_id': 'J3', 'task_id': 0, 'machine_id': 'C', 'duration': 67}, {'job_id': 'J3', 'task_id': 1, 'machine_id': 'B', 'duration': 95}, {'job_id': 'J3', 'task_id': 2, 'machine_id': 'A', 'duration': 98}, {'job_id': 'J4', 'task_id': 0, 'machine_id': 'C', 'duration': 90}, {'job_id': 'J4', 'task_id': 1, 'machine_id': 'B', 'duration': 91}, {'job_id': 'J4', 'task_id': 2, 'machine_id': 'A', 'duration': 51}, {'job_id': 'J5', 'task_id': 0, 'machine_id': 'A', 'duration': 81}, {'job_id': 'J5', 'task_id': 1, 'machine_id': 'B', 'duration': 69}, {'job_id': 'J5', 'task_id': 2, 'machine_id': 'C', 'duration': 17}]}","[{'job': 'J1', 'tasks': [{'task': 0, 'start': 67, 'machine': 'C', 'duration': 1}, {'task': 1, 'start': 77, 'machine': 'B', 'duration': 26}, {'task': 2, 'start': 137, 'machine': 'A', 'duration': 93}]}, {'job': 'J2', 'tasks': [{'task': 0, 'start': 0, 'machine': 'B', 'duration': 77}, {'task': 1, 'start': 81, 'machine': 'A', 'duration': 56}, {'task': 2, 'start': 158, 'machine': 'C', 'duration': 8}]}, {'job': 'J3', 'tasks': [{'task': 0, 'start': 0, 'machine': 'C', 'duration': 67}, {'task': 1, 'start': 103, 'machine': 'B', 'duration': 95}, {'task': 2, 'start': 230, 'machine': 'A', 'duration': 98}]}, {'job': 'J4', 'tasks': [{'task': 0, 'start': 68, 'machine': 'C', 'duration': 90}, {'task': 1, 'start': 198, 'machine': 'B', 'duration': 91}, {'task': 2, 'start': 328, 'machine': 'A', 'duration': 51}]}, {'job': 'J5', 'tasks': [{'task': 0, 'start': 0, 'machine': 'A', 'duration': 81}, {'task': 1, 'start': 289, 'machine': 'B', 'duration': 69}, {'task': 2, 'start': 358, 'machine': 'C', 'duration': 17}]}]",37,markdown_table,names
JSP,JSP,"Someone on the team needs to line up the boxing, labeling, and sealing work so all product sets flow through their three steps without collisions on the machines. The choice is about timing and order: which set starts where and when, given each operation’s fixed duration and the rule that a machine can only do one task at once. Plans are judged by how quickly the entire batch is wrapped up — basically, the time on the clock when the last job is done — and the full list of sets, machines, and times appears below.

The list below shows 2 product sets, 2 packing machines, product set ids J1, J2, and machine ids A, B.

| product_set_id | operation_index | assigned_machine_id | processing_duration |
|---|---|---|---|
| J1 | 0 | B | 1 |
| J1 | 1 | A | 39 |
| J2 | 0 | A | 69 |
| J2 | 1 | B | 24 |

Use these entries to plan start times and ordering so machines never overlap and the entire batch finishes as quickly as possible.

Also, when you send back the proposed schedule, please use this simple JSON layout so it's easy to check and plug into the rest of the workflow.

{
  ""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 need: each object in ""solution"" is one product set (job), ""job"" is its identifier, and ""tasks"" is the ordered list of steps for that set. For each task, ""task"" is the task's index in the job, ""start"" is the clock time it begins, ""machine"" is which machine does it, and ""duration"" is how long it runs. Think of it like filling out a little form for each set and each step.

Reminder: this JSON is only the expected shape — not the actual 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': 2, 'nr_jobs': 2, 'jobs': [[[1, 1], [0, 39]], [[0, 69], [1, 24]]]}","[{'job': 0, 'tasks': [{'task': 0, 'start': 0, 'machine': 1, 'duration': 1}, {'task': 1, 'start': 69, 'machine': 0, 'duration': 39}]}, {'job': 1, 'tasks': [{'task': 0, 'start': 0, 'machine': 0, 'duration': 69}, {'task': 1, 'start': 69, 'machine': 1, 'duration': 24}]}]",108.0,"{'problem_type': 'JSP', 'nr_jobs': 2, 'nr_machines': 2, 'jobs': ['J1', 'J2'], 'machines': ['A', 'B'], 'records': [{'job_id': 'J1', 'task_id': 0, 'machine_id': 'B', 'duration': 1}, {'job_id': 'J1', 'task_id': 1, 'machine_id': 'A', 'duration': 39}, {'job_id': 'J2', 'task_id': 0, 'machine_id': 'A', 'duration': 69}, {'job_id': 'J2', 'task_id': 1, 'machine_id': 'B', 'duration': 24}]}","[{'job': 'J1', 'tasks': [{'task': 0, 'start': 0, 'machine': 'B', 'duration': 1}, {'task': 1, 'start': 69, 'machine': 'A', 'duration': 39}]}, {'job': 'J2', 'tasks': [{'task': 0, 'start': 0, 'machine': 'A', 'duration': 69}, {'task': 1, 'start': 69, 'machine': 'B', 'duration': 24}]}]",38,markdown_table,names
JSP,JSP,"Back when planning a large banquet, the coordinator treated every entree like a mini assembly line: a fixed sequence of actions on named stations, each action taking a known amount of time and not to be skipped or repeated. The decision was how to schedule those actions across stations so none overlap on a single station and every recipe keeps its order. Success is measured by how soon the whole job is done — check the finish time of each dish and the latest of those finish times is the overall completion time to make as small as possible. The detailed list of dishes, stations, and durations is provided below.

The list specified 4 menu items and 2 stations; menu IDs were J1, J2, J3, J4 and station IDs were 0, 1.
Menu J1 stage 0 required station 1 and took 1 minutes.
Menu J1 stage 1 required station 0 and took 52 minutes.
Menu J2 stage 0 required station 0 and took 45 minutes.
Menu J2 stage 1 required station 1 and took 69 minutes.
Menu J3 stage 0 required station 0 and took 62 minutes.
Menu J3 stage 1 required station 1 and took 52 minutes.
Menu J4 stage 0 required station 1 and took 76 minutes.
Menu J4 stage 1 required station 0 and took 31 minutes.
With every stage recorded this way, the coordinator could seek the schedule that minimized the banquet's overall completion time.

Also, to keep things simple for me to read and for you to check, please give the schedule using this JSON shape.

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

Think of it like a little form: ""solution"" is a list of the dishes (jobs). Each job object has the job id and a list of its tasks. Each task entry says which step number it is, when that step starts, which station (machine) it uses, and how long it runs. Pretty straightforward — this block is just the expected shape, not the actual schedule.

Please make sure all identifiers are 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': 4, 'jobs': [[[1, 1], [0, 52]], [[0, 45], [1, 69]], [[0, 62], [1, 52]], [[1, 76], [0, 31]]]}","[{'job': 0, 'tasks': [{'task': 0, 'start': 145, 'machine': 1, 'duration': 1}, {'task': 1, 'start': 146, 'machine': 0, 'duration': 52}]}, {'job': 1, 'tasks': [{'task': 0, 'start': 0, 'machine': 0, 'duration': 45}, {'task': 1, 'start': 76, 'machine': 1, 'duration': 69}]}, {'job': 2, 'tasks': [{'task': 0, 'start': 45, 'machine': 0, 'duration': 62}, {'task': 1, 'start': 146, 'machine': 1, 'duration': 52}]}, {'job': 3, 'tasks': [{'task': 0, 'start': 0, 'machine': 1, 'duration': 76}, {'task': 1, 'start': 107, 'machine': 0, 'duration': 31}]}]",198.0,"{'problem_type': 'JSP', 'nr_jobs': 4, 'nr_machines': 2, 'jobs': ['J1', 'J2', 'J3', 'J4'], 'machines': [0, 1], 'records': [{'job_id': 'J1', 'task_id': 0, 'machine_id': 1, 'duration': 1}, {'job_id': 'J1', 'task_id': 1, 'machine_id': 0, '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': 1, 'duration': 76}, {'job_id': 'J4', 'task_id': 1, 'machine_id': 0, 'duration': 31}]}","[{'job': 'J1', 'tasks': [{'task': 0, 'start': 145, 'machine': 1, 'duration': 1}, {'task': 1, 'start': 146, 'machine': 0, 'duration': 52}]}, {'job': 'J2', 'tasks': [{'task': 0, 'start': 0, 'machine': 0, 'duration': 45}, {'task': 1, 'start': 76, 'machine': 1, 'duration': 69}]}, {'job': 'J3', 'tasks': [{'task': 0, 'start': 45, 'machine': 0, 'duration': 62}, {'task': 1, 'start': 146, 'machine': 1, 'duration': 52}]}, {'job': 'J4', 'tasks': [{'task': 0, 'start': 0, 'machine': 1, 'duration': 76}, {'task': 1, 'start': 107, 'machine': 0, 'duration': 31}]}]",39,nl,0
JSP,JSP,"Someone at the shop needs to map out the day: multiple cars, each with a fixed sequence of repairs, and every repair needs a particular lift or diagnostic bay for a set period. The planner must slot each step into its assigned bay without breaking the per-car order, avoid doing any step twice or skipping one, and never double-book a bay. The whole point is to minimize how long the shop takes to get all cars ready — the clock that matters is when the final vehicle finishes, and sooner is clearly preferred. Full details about which car needs what and how long each thing takes are listed below.

{
  ""number_of_vehicles"": 5,
  ""number_of_service_bays"": 3,
  ""vehicle_ids"": [
    ""J1"",
    ""J2"",
    ""J3"",
    ""J4"",
    ""J5""
  ],
  ""service_bay_ids"": [
    1,
    2,
    3
  ],
  ""tasks"": [
    {
      ""vehicle_id"": ""J1"",
      ""step_index"": 0,
      ""service_bay_id"": 2,
      ""service_duration"": 1
    },
    {
      ""vehicle_id"": ""J1"",
      ""step_index"": 1,
      ""service_bay_id"": 3,
      ""service_duration"": 65
    },
    {
      ""vehicle_id"": ""J1"",
      ""step_index"": 2,
      ""service_bay_id"": 1,
      ""service_duration"": 21
    },
    {
      ""vehicle_id"": ""J2"",
      ""step_index"": 0,
      ""service_bay_id"": 3,
      ""service_duration"": 15
    },
    {
      ""vehicle_id"": ""J2"",
      ""step_index"": 1,
      ""service_bay_id"": 2,
      ""service_duration"": 16
    },
    {
      ""vehicle_id"": ""J2"",
      ""step_index"": 2,
      ""service_bay_id"": 1,
      ""service_duration"": 73
    },
    {
      ""vehicle_id"": ""J3"",
      ""step_index"": 0,
      ""service_bay_id"": 2,
      ""service_duration"": 81
    },
    {
      ""vehicle_id"": ""J3"",
      ""step_index"": 1,
      ""service_bay_id"": 1,
      ""service_duration"": 98
    },
    {
      ""vehicle_id"": ""J3"",
      ""step_index"": 2,
      ""service_bay_id"": 3,
      ""service_duration"": 3
    },
    {
      ""vehicle_id"": ""J4"",
      ""step_index"": 0,
      ""service_bay_id"": 3,
      ""service_duration"": 71
    },
    {
      ""vehicle_id"": ""J4"",
      ""step_index"": 1,
      ""service_bay_id"": 2,
      ""service_duration"": 7
    },
    {
      ""vehicle_id"": ""J4"",
      ""step_index"": 2,
      ""service_bay_id"": 1,
      ""service_duration"": 8
    },
    {
      ""vehicle_id"": ""J5"",
      ""step_index"": 0,
      ""service_bay_id"": 1,
      ""service_duration"": 31
    },
    {
      ""vehicle_id"": ""J5"",
      ""step_index"": 1,
      ""service_bay_id"": 2,
      ""service_duration"": 80
    },
    {
      ""vehicle_id"": ""J5"",
      ""step_index"": 2,
      ""service_bay_id"": 3,
      ""service_duration"": 33
    }
  ]
}

Also, when you send the schedule back, just use a simple JSON shape like this so I can read it easily:

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

Think of it as a little form: ""solution"" is the list of cars, each ""job"" is the car identifier, and the ""tasks"" list shows each repair step with when it starts, which bay it uses, and how long it takes. It's just a sketch of the shape I expect, not the final schedule.

Please use the exact identifiers from the instance input — don't rename anything 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': [[[1, 1], [2, 65], [0, 21]], [[2, 15], [1, 16], [0, 73]], [[1, 81], [0, 98], [2, 3]], [[2, 71], [1, 7], [0, 8]], [[0, 31], [1, 80], [2, 33]]]}","[{'job': 0, 'tasks': [{'task': 0, 'start': 0, 'machine': 1, 'duration': 1}, {'task': 1, 'start': 15, 'machine': 2, 'duration': 65}, {'task': 2, 'start': 104, 'machine': 0, 'duration': 21}]}, {'job': 1, 'tasks': [{'task': 0, 'start': 0, 'machine': 2, 'duration': 15}, {'task': 1, 'start': 15, 'machine': 1, 'duration': 16}, {'task': 2, 'start': 31, 'machine': 0, 'duration': 73}]}, {'job': 2, 'tasks': [{'task': 0, 'start': 31, 'machine': 1, 'duration': 81}, {'task': 1, 'start': 125, 'machine': 0, 'duration': 98}, {'task': 2, 'start': 225, 'machine': 2, 'duration': 3}]}, {'job': 3, 'tasks': [{'task': 0, 'start': 80, 'machine': 2, 'duration': 71}, {'task': 1, 'start': 192, 'machine': 1, 'duration': 7}, {'task': 2, 'start': 223, 'machine': 0, 'duration': 8}]}, {'job': 4, 'tasks': [{'task': 0, 'start': 0, 'machine': 0, 'duration': 31}, {'task': 1, 'start': 112, 'machine': 1, 'duration': 80}, {'task': 2, 'start': 192, 'machine': 2, 'duration': 33}]}]",231.0,"{'problem_type': 'JSP', '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': 2, 'duration': 1}, {'job_id': 'J1', 'task_id': 1, 'machine_id': 3, 'duration': 65}, {'job_id': 'J1', 'task_id': 2, 'machine_id': 1, 'duration': 21}, {'job_id': 'J2', 'task_id': 0, 'machine_id': 3, 'duration': 15}, {'job_id': 'J2', 'task_id': 1, 'machine_id': 2, 'duration': 16}, {'job_id': 'J2', 'task_id': 2, 'machine_id': 1, 'duration': 73}, {'job_id': 'J3', 'task_id': 0, 'machine_id': 2, 'duration': 81}, {'job_id': 'J3', 'task_id': 1, 'machine_id': 1, 'duration': 98}, {'job_id': 'J3', 'task_id': 2, 'machine_id': 3, 'duration': 3}, {'job_id': 'J4', 'task_id': 0, 'machine_id': 3, 'duration': 71}, {'job_id': 'J4', 'task_id': 1, 'machine_id': 2, 'duration': 7}, {'job_id': 'J4', 'task_id': 2, 'machine_id': 1, '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': 0, 'machine': 2, 'duration': 1}, {'task': 1, 'start': 15, 'machine': 3, 'duration': 65}, {'task': 2, 'start': 104, 'machine': 1, 'duration': 21}]}, {'job': 'J2', 'tasks': [{'task': 0, 'start': 0, 'machine': 3, 'duration': 15}, {'task': 1, 'start': 15, 'machine': 2, 'duration': 16}, {'task': 2, 'start': 31, 'machine': 1, 'duration': 73}]}, {'job': 'J3', 'tasks': [{'task': 0, 'start': 31, 'machine': 2, 'duration': 81}, {'task': 1, 'start': 125, 'machine': 1, 'duration': 98}, {'task': 2, 'start': 225, 'machine': 3, 'duration': 3}]}, {'job': 'J4', 'tasks': [{'task': 0, 'start': 80, 'machine': 3, 'duration': 71}, {'task': 1, 'start': 192, 'machine': 2, 'duration': 7}, {'task': 2, 'start': 223, 'machine': 1, 'duration': 8}]}, {'job': 'J5', 'tasks': [{'task': 0, 'start': 0, 'machine': 1, 'duration': 31}, {'task': 1, 'start': 112, 'machine': 2, 'duration': 80}, {'task': 2, 'start': 192, 'machine': 3, 'duration': 33}]}]",40,json,1
JSP,JSP,"I was picturing the sewing room as a little juggling act: several outfits need stitching, then pressing, then finishing, and each outfit has its own order of steps that can’t be skipped or shuffled. The job is to assign those stitching, pressing and finishing tasks to the available sewing machines and presses so each task runs on its assigned machine for its given time, and no machine tries to do two things at once. The trick is to lay out the work so the whole batch is done as quickly as possible — in plain terms, look at when the last outfit is finished and make that moment as early as you can. The exact list of outfits, machines and how long each step takes is shown below.

# total_outfits=5
# total_machines=2
# outfit_ids=J1, J2, J3, J4, J5
# machine_ids=A, B
outfit_id,operation_index,required_machine_id,processing_time
J1,0,B,1
J1,1,A,78
J2,0,B,96
J2,1,A,61
J3,0,B,69
J3,1,A,95
J4,0,B,85
J4,1,A,67
J5,0,B,70
J5,1,A,64

Oh, and one more thing — when you send the schedule back, a small JSON sketch like the one below makes it super easy to read and plug into whatever tool you're using. Here’s the shape I expect:

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

Think of it like a simple form: each entry in ""solution"" is one outfit (job), ""job"" is that outfit's id, and ""tasks"" is the ordered list of steps for that outfit. For each step you give the step number (""task""), when it starts (""start"" — absolute time), which machine it runs on (""machine""), and how long it runs (""duration""). This is just the layout — a sketch of the shape I want, not the actual schedule.

Please use the exact identifiers from the instance input — don't rename jobs or machines 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': 5, 'jobs': [[[1, 1], [0, 78]], [[1, 96], [0, 61]], [[1, 69], [0, 95]], [[1, 85], [0, 67]], [[1, 70], [0, 64]]]}","[{'job': 0, 'tasks': [{'task': 0, 'start': 0, 'machine': 1, 'duration': 1}, {'task': 1, 'start': 1, 'machine': 0, 'duration': 78}]}, {'job': 1, 'tasks': [{'task': 0, 'start': 225, 'machine': 1, 'duration': 96}, {'task': 1, 'start': 321, 'machine': 0, 'duration': 61}]}, {'job': 2, 'tasks': [{'task': 0, 'start': 156, 'machine': 1, 'duration': 69}, {'task': 1, 'start': 225, 'machine': 0, 'duration': 95}]}, {'job': 3, 'tasks': [{'task': 0, 'start': 1, 'machine': 1, 'duration': 85}, {'task': 1, 'start': 86, 'machine': 0, 'duration': 67}]}, {'job': 4, 'tasks': [{'task': 0, 'start': 86, 'machine': 1, 'duration': 70}, {'task': 1, 'start': 156, 'machine': 0, 'duration': 64}]}]",382.0,"{'problem_type': 'JSP', 'nr_jobs': 5, 'nr_machines': 2, 'jobs': ['J1', 'J2', 'J3', 'J4', 'J5'], 'machines': ['A', 'B'], 'records': [{'job_id': 'J1', 'task_id': 0, 'machine_id': 'B', 'duration': 1}, {'job_id': 'J1', 'task_id': 1, 'machine_id': 'A', 'duration': 78}, {'job_id': 'J2', 'task_id': 0, 'machine_id': 'B', 'duration': 96}, {'job_id': 'J2', 'task_id': 1, 'machine_id': 'A', 'duration': 61}, {'job_id': 'J3', 'task_id': 0, 'machine_id': 'B', 'duration': 69}, {'job_id': 'J3', 'task_id': 1, 'machine_id': 'A', 'duration': 95}, {'job_id': 'J4', 'task_id': 0, 'machine_id': 'B', 'duration': 85}, {'job_id': 'J4', 'task_id': 1, 'machine_id': 'A', 'duration': 67}, {'job_id': 'J5', 'task_id': 0, 'machine_id': 'B', 'duration': 70}, {'job_id': 'J5', 'task_id': 1, 'machine_id': 'A', 'duration': 64}]}","[{'job': 'J1', 'tasks': [{'task': 0, 'start': 0, 'machine': 'B', 'duration': 1}, {'task': 1, 'start': 1, 'machine': 'A', 'duration': 78}]}, {'job': 'J2', 'tasks': [{'task': 0, 'start': 225, 'machine': 'B', 'duration': 96}, {'task': 1, 'start': 321, 'machine': 'A', 'duration': 61}]}, {'job': 'J3', 'tasks': [{'task': 0, 'start': 156, 'machine': 'B', 'duration': 69}, {'task': 1, 'start': 225, 'machine': 'A', 'duration': 95}]}, {'job': 'J4', 'tasks': [{'task': 0, 'start': 1, 'machine': 'B', 'duration': 85}, {'task': 1, 'start': 86, 'machine': 'A', 'duration': 67}]}, {'job': 'J5', 'tasks': [{'task': 0, 'start': 86, 'machine': 'B', 'duration': 70}, {'task': 1, 'start': 156, 'machine': 'A', 'duration': 64}]}]",41,csv,names
JSP,JSP,"At the venue the planner must slot setup, practice, and teardown for multiple events into the available rooms and equipment, honoring the order of steps for each event and the exact durations each activity needs. No room or piece of gear can host two activities at the same time, and every activity must be scheduled in its required place. The clearest way to pick the best arrangement is to look at when the final activity ends; the earlier that finish time, the better the schedule. The detailed events, spaces, and durations are shown below.

There are 4 events to place across 2 resources: event identifiers J1, J2, J3, J4 and resource identifiers 1, 2.
Event J1 activity 0 must occupy resource 2 for 1.
Event J1 activity 1 must occupy resource 1 for 91.
Event J2 activity 0 must occupy resource 2 for 71.
Event J2 activity 1 must occupy resource 1 for 7.
Event J3 activity 0 must occupy resource 1 for 22.
Event J3 activity 1 must occupy resource 2 for 18.
Event J4 activity 0 must occupy resource 1 for 90.
Event J4 activity 1 must occupy resource 2 for 35.
The schedule is judged by the completion time of the final activity across all 4 events; earlier completion is better.

One more thing — to keep things consistent, please structure your reply using this simple JSON layout:

{
  ""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 is a job (an event), its tasks are listed in order, and each task says which step number it is, when it starts, which room or piece of gear it uses, and how long it runs. This JSON is just a sketch of the shape I need, not the actual schedule — fill it with the real values when you answer.

Please use the exact identifiers from the instance input — don’t rename them or invent new labels.  
- for example: ""Valid identifiers look like plain numbers such as “1” or “23”, single capital letters like “A” or “B”, or a capital letter followed by digits like “A1” or “X7”.""","{'nr_machines': 2, 'nr_jobs': 4, 'jobs': [[[1, 1], [0, 91]], [[1, 71], [0, 7]], [[0, 22], [1, 18]], [[0, 90], [1, 35]]]}","[{'job': 0, 'tasks': [{'task': 0, 'start': 0, 'machine': 1, 'duration': 1}, {'task': 1, 'start': 112, 'machine': 0, 'duration': 91}]}, {'job': 1, 'tasks': [{'task': 0, 'start': 1, 'machine': 1, 'duration': 71}, {'task': 1, 'start': 203, 'machine': 0, 'duration': 7}]}, {'job': 2, 'tasks': [{'task': 0, 'start': 90, 'machine': 0, 'duration': 22}, {'task': 1, 'start': 125, 'machine': 1, 'duration': 18}]}, {'job': 3, 'tasks': [{'task': 0, 'start': 0, 'machine': 0, 'duration': 90}, {'task': 1, 'start': 90, 'machine': 1, 'duration': 35}]}]",210.0,"{'problem_type': 'JSP', 'nr_jobs': 4, 'nr_machines': 2, 'jobs': ['J1', 'J2', 'J3', 'J4'], 'machines': [1, 2], 'records': [{'job_id': 'J1', 'task_id': 0, 'machine_id': 2, 'duration': 1}, {'job_id': 'J1', 'task_id': 1, 'machine_id': 1, 'duration': 91}, {'job_id': 'J2', 'task_id': 0, 'machine_id': 2, 'duration': 71}, {'job_id': 'J2', 'task_id': 1, 'machine_id': 1, 'duration': 7}, {'job_id': 'J3', 'task_id': 0, 'machine_id': 1, 'duration': 22}, {'job_id': 'J3', 'task_id': 1, 'machine_id': 2, 'duration': 18}, {'job_id': 'J4', 'task_id': 0, 'machine_id': 1, 'duration': 90}, {'job_id': 'J4', 'task_id': 1, 'machine_id': 2, 'duration': 35}]}","[{'job': 'J1', 'tasks': [{'task': 0, 'start': 0, 'machine': 2, 'duration': 1}, {'task': 1, 'start': 112, 'machine': 1, 'duration': 91}]}, {'job': 'J2', 'tasks': [{'task': 0, 'start': 1, 'machine': 2, 'duration': 71}, {'task': 1, 'start': 203, 'machine': 1, 'duration': 7}]}, {'job': 'J3', 'tasks': [{'task': 0, 'start': 90, 'machine': 1, 'duration': 22}, {'task': 1, 'start': 125, 'machine': 2, 'duration': 18}]}, {'job': 'J4', 'tasks': [{'task': 0, 'start': 0, 'machine': 1, 'duration': 90}, {'task': 1, 'start': 90, 'machine': 2, 'duration': 35}]}]",42,nl,1
JSP,JSP,"Back at the darkroom, the challenge was to shepherd a stack of film through exposure, development, and drying without any chaos. That means deciding who goes first on which station and when, while keeping every roll’s steps in their fixed order, running each step on its designated station for the required length, and never overlapping tasks on the same station. A clearer plan is the one that gets the final roll out sooner — compute each roll’s completion time and take the last of those times as the result. The specific rolls, stations, and timing details follow below.

They are presented as 3 rolls and 3 stations: roll ids J1, J2, J3; station ids A, B, C.

| roll_id | step_index | station_id | processing_time |
|---|---|---|---|
| J1 | 0 | B | 1 |
| J1 | 1 | C | 5 |
| J1 | 2 | A | 47 |
| J2 | 0 | C | 53 |
| J2 | 1 | A | 75 |
| J2 | 2 | B | 39 |
| J3 | 0 | A | 95 |
| J3 | 1 | C | 3 |
| J3 | 2 | B | 7 |

Keep each roll's steps in order and avoid overlapping any station; the plan is judged by the time the last roll finishes.

And just so we’re on the same page about how to hand back the schedule, here’s the shape I’m expecting — nothing fancy, just a simple JSON sketch you can follow when you fill in the actual plan:

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

Think of that like a little form: ""solution"" is a list of jobs (in our darkroom story, each roll), each job has a list of tasks/steps, and each task says when it starts, which machine/station it needs, and how long it runs. This JSON is just the expected shape — a sketch, not the 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': 3, 'jobs': [[[1, 1], [2, 5], [0, 47]], [[2, 53], [0, 75], [1, 39]], [[0, 95], [2, 3], [1, 7]]]}","[{'job': 0, 'tasks': [{'task': 0, 'start': 0, 'machine': 1, 'duration': 1}, {'task': 1, 'start': 53, 'machine': 2, 'duration': 5}, {'task': 2, 'start': 170, 'machine': 0, 'duration': 47}]}, {'job': 1, 'tasks': [{'task': 0, 'start': 0, 'machine': 2, 'duration': 53}, {'task': 1, 'start': 95, 'machine': 0, 'duration': 75}, {'task': 2, 'start': 170, 'machine': 1, 'duration': 39}]}, {'job': 2, 'tasks': [{'task': 0, 'start': 0, 'machine': 0, 'duration': 95}, {'task': 1, 'start': 95, 'machine': 2, 'duration': 3}, {'task': 2, 'start': 98, 'machine': 1, 'duration': 7}]}]",217.0,"{'problem_type': 'JSP', 'nr_jobs': 3, 'nr_machines': 3, 'jobs': ['J1', 'J2', 'J3'], 'machines': ['A', 'B', 'C'], 'records': [{'job_id': 'J1', 'task_id': 0, 'machine_id': 'B', 'duration': 1}, {'job_id': 'J1', 'task_id': 1, 'machine_id': 'C', 'duration': 5}, {'job_id': 'J1', 'task_id': 2, 'machine_id': 'A', 'duration': 47}, {'job_id': 'J2', 'task_id': 0, 'machine_id': 'C', 'duration': 53}, {'job_id': 'J2', 'task_id': 1, 'machine_id': 'A', 'duration': 75}, {'job_id': 'J2', 'task_id': 2, 'machine_id': 'B', 'duration': 39}, {'job_id': 'J3', 'task_id': 0, 'machine_id': 'A', 'duration': 95}, {'job_id': 'J3', 'task_id': 1, 'machine_id': 'C', 'duration': 3}, {'job_id': 'J3', 'task_id': 2, 'machine_id': 'B', 'duration': 7}]}","[{'job': 'J1', 'tasks': [{'task': 0, 'start': 0, 'machine': 'B', 'duration': 1}, {'task': 1, 'start': 53, 'machine': 'C', 'duration': 5}, {'task': 2, 'start': 170, 'machine': 'A', 'duration': 47}]}, {'job': 'J2', 'tasks': [{'task': 0, 'start': 0, 'machine': 'C', 'duration': 53}, {'task': 1, 'start': 95, 'machine': 'A', 'duration': 75}, {'task': 2, 'start': 170, 'machine': 'B', 'duration': 39}]}, {'job': 'J3', 'tasks': [{'task': 0, 'start': 0, 'machine': 'A', 'duration': 95}, {'task': 1, 'start': 95, 'machine': 'C', 'duration': 3}, {'task': 2, 'start': 98, 'machine': 'B', 'duration': 7}]}]",43,markdown_table,names
JSP,JSP,"There’s a busy makerspace where several projects are queued for cutting, sanding, and painting, and the coordinator needs to line up who uses which machine when. Each project follows the same ordered steps; each step belongs to a particular machine and takes a fixed amount of time, and a machine can only handle one step at any given moment. The aim is to get the whole lot wrapped up quickly — measure success by the time when the last project’s final step finishes, and try to make that time as early as possible. All steps have to happen in order and exactly once, with no overlapping use of machines. The concrete project and timing details are shown below.

# total_projects=5
# total_workshop_machines=3
# project_ids=J1, J2, J3, J4, J5
# machine_ids=0, 1, 2
project_id,step_index,assigned_machine_id,step_duration
J1,0,2,1
J1,1,1,18
J1,2,0,23
J2,0,1,98
J2,1,2,29
J2,2,0,61
J3,0,1,99
J3,1,0,70
J3,2,2,74
J4,0,2,45
J4,1,0,60
J4,2,1,15
J5,0,1,63
J5,1,0,93
J5,2,2,54

Also, when you send the schedule back, a plain JSON layout like the one below works best — just a relaxed, consistent shape so it's easy to read and check:

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

This little sketch is just the shape I’m expecting: ""solution"" holds a list of jobs (projects), each job has its id under ""job"" and an ordered ""tasks"" list. Each task entry says which task index it is, when it starts, which machine it uses, and how long it runs. Think of it like filling out a simple schedule form rather than anything formal — it doesn’t contain the actual scheduled times yet, just the fields I’ll need filled in.

Please use the identifiers exactly as they appear in the instance input — don’t rename them or invent new labels. 
- for example: ""Valid identifiers look like plain numbers such as “1” or “23”, single capital letters like “A” or “B”, or a capital letter followed by digits like “A1” or “X7”.""","{'nr_machines': 3, 'nr_jobs': 5, 'jobs': [[[2, 1], [1, 18], [0, 23]], [[1, 98], [2, 29], [0, 61]], [[1, 99], [0, 70], [2, 74]], [[2, 45], [0, 60], [1, 15]], [[1, 63], [0, 93], [2, 54]]]}","[{'job': 0, 'tasks': [{'task': 0, 'start': 45, 'machine': 2, 'duration': 1}, {'task': 1, 'start': 260, 'machine': 1, 'duration': 18}, {'task': 2, 'start': 278, 'machine': 0, 'duration': 23}]}, {'job': 1, 'tasks': [{'task': 0, 'start': 162, 'machine': 1, 'duration': 98}, {'task': 1, 'start': 260, 'machine': 2, 'duration': 29}, {'task': 2, 'start': 301, 'machine': 0, 'duration': 61}]}, {'job': 2, 'tasks': [{'task': 0, 'start': 0, 'machine': 1, 'duration': 99}, {'task': 1, 'start': 105, 'machine': 0, 'duration': 70}, {'task': 2, 'start': 175, 'machine': 2, 'duration': 74}]}, {'job': 3, 'tasks': [{'task': 0, 'start': 0, 'machine': 2, 'duration': 45}, {'task': 1, 'start': 45, 'machine': 0, 'duration': 60}, {'task': 2, 'start': 278, 'machine': 1, 'duration': 15}]}, {'job': 4, 'tasks': [{'task': 0, 'start': 99, 'machine': 1, 'duration': 63}, {'task': 1, 'start': 175, 'machine': 0, 'duration': 93}, {'task': 2, 'start': 289, 'machine': 2, 'duration': 54}]}]",362.0,"{'problem_type': 'JSP', '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': 2, 'duration': 1}, {'job_id': 'J1', 'task_id': 1, 'machine_id': 1, 'duration': 18}, {'job_id': 'J1', 'task_id': 2, 'machine_id': 0, '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': 0, 'duration': 61}, {'job_id': 'J3', 'task_id': 0, 'machine_id': 1, 'duration': 99}, {'job_id': 'J3', 'task_id': 1, 'machine_id': 0, 'duration': 70}, {'job_id': 'J3', 'task_id': 2, 'machine_id': 2, 'duration': 74}, {'job_id': 'J4', 'task_id': 0, 'machine_id': 2, 'duration': 45}, {'job_id': 'J4', 'task_id': 1, 'machine_id': 0, 'duration': 60}, {'job_id': 'J4', 'task_id': 2, 'machine_id': 1, 'duration': 15}, {'job_id': 'J5', 'task_id': 0, 'machine_id': 1, 'duration': 63}, {'job_id': 'J5', 'task_id': 1, 'machine_id': 0, 'duration': 93}, {'job_id': 'J5', 'task_id': 2, 'machine_id': 2, 'duration': 54}]}","[{'job': 'J1', 'tasks': [{'task': 0, 'start': 45, 'machine': 2, 'duration': 1}, {'task': 1, 'start': 260, 'machine': 1, 'duration': 18}, {'task': 2, 'start': 278, 'machine': 0, 'duration': 23}]}, {'job': 'J2', 'tasks': [{'task': 0, 'start': 162, 'machine': 1, 'duration': 98}, {'task': 1, 'start': 260, 'machine': 2, 'duration': 29}, {'task': 2, 'start': 301, 'machine': 0, 'duration': 61}]}, {'job': 'J3', 'tasks': [{'task': 0, 'start': 0, 'machine': 1, 'duration': 99}, {'task': 1, 'start': 105, 'machine': 0, 'duration': 70}, {'task': 2, 'start': 175, 'machine': 2, 'duration': 74}]}, {'job': 'J4', 'tasks': [{'task': 0, 'start': 0, 'machine': 2, 'duration': 45}, {'task': 1, 'start': 45, 'machine': 0, 'duration': 60}, {'task': 2, 'start': 278, 'machine': 1, 'duration': 15}]}, {'job': 'J5', 'tasks': [{'task': 0, 'start': 99, 'machine': 1, 'duration': 63}, {'task': 1, 'start': 175, 'machine': 0, 'duration': 93}, {'task': 2, 'start': 289, 'machine': 2, 'duration': 54}]}]",44,csv,0
JSP,JSP,"Recently the foreperson asked for a simple plan: spread digging, planting and mulching across the teams and tools so each garden moves from one step to the next in order without crews clashing. Each task must run on its designated crew or machine for the whole time it needs, and every plot must get each step once — nothing missing, nothing doubled. The success of the plan is judged by how soon everything is done, i.e., the clock time when the last plot’s work finishes, and the aim is to make that time as early as possible. The exact plot-by-plot details are given below.

There are 4 plots to complete using 2 crews and tools; plot ids: J1, J2, J3, J4; crew/tool ids: 0, 1.

| plot_id | step_index | crew_or_tool_id | task_duration |
|---|---|---|---|
| J1 | 0 | 1 | 1 |
| J1 | 1 | 0 | 31 |
| J2 | 0 | 0 | 98 |
| J2 | 1 | 1 | 44 |
| J3 | 0 | 1 | 81 |
| J3 | 1 | 0 | 83 |
| J4 | 0 | 0 | 5 |
| J4 | 1 | 1 | 38 |

Cover all 4 plots on the 2 crews/tools and aim to finish as early as possible.

Oh, and one quick thing — when you send the plan back, please follow a little JSON shape like this:

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

This just shows the shape I expect: a top-level ""solution"" list, one entry per job/plot with its id, and for each job a list of tasks giving the task index, the planned start time, which crew/tool (machine) it uses, and how long it runs. Think of it like filling out a simple form for each plot: who does what, when, and for how long. It's only a sketch of the expected shape, not the actual schedule.

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': 2, 'nr_jobs': 4, 'jobs': [[[1, 1], [0, 31]], [[0, 98], [1, 44]], [[1, 81], [0, 83]], [[0, 5], [1, 38]]]}","[{'job': 0, 'tasks': [{'task': 0, 'start': 81, 'machine': 1, 'duration': 1}, {'task': 1, 'start': 186, 'machine': 0, 'duration': 31}]}, {'job': 1, 'tasks': [{'task': 0, 'start': 0, 'machine': 0, 'duration': 98}, {'task': 1, 'start': 98, 'machine': 1, 'duration': 44}]}, {'job': 2, 'tasks': [{'task': 0, 'start': 0, 'machine': 1, 'duration': 81}, {'task': 1, 'start': 103, 'machine': 0, 'duration': 83}]}, {'job': 3, 'tasks': [{'task': 0, 'start': 98, 'machine': 0, 'duration': 5}, {'task': 1, 'start': 142, 'machine': 1, 'duration': 38}]}]",217.0,"{'problem_type': 'JSP', 'nr_jobs': 4, 'nr_machines': 2, 'jobs': ['J1', 'J2', 'J3', 'J4'], 'machines': [0, 1], 'records': [{'job_id': 'J1', 'task_id': 0, 'machine_id': 1, 'duration': 1}, {'job_id': 'J1', 'task_id': 1, 'machine_id': 0, 'duration': 31}, {'job_id': 'J2', 'task_id': 0, 'machine_id': 0, 'duration': 98}, {'job_id': 'J2', 'task_id': 1, 'machine_id': 1, 'duration': 44}, {'job_id': 'J3', 'task_id': 0, 'machine_id': 1, 'duration': 81}, {'job_id': 'J3', 'task_id': 1, 'machine_id': 0, 'duration': 83}, {'job_id': 'J4', 'task_id': 0, 'machine_id': 0, 'duration': 5}, {'job_id': 'J4', 'task_id': 1, 'machine_id': 1, 'duration': 38}]}","[{'job': 'J1', 'tasks': [{'task': 0, 'start': 81, 'machine': 1, 'duration': 1}, {'task': 1, 'start': 186, 'machine': 0, 'duration': 31}]}, {'job': 'J2', 'tasks': [{'task': 0, 'start': 0, 'machine': 0, 'duration': 98}, {'task': 1, 'start': 98, 'machine': 1, 'duration': 44}]}, {'job': 'J3', 'tasks': [{'task': 0, 'start': 0, 'machine': 1, 'duration': 81}, {'task': 1, 'start': 103, 'machine': 0, 'duration': 83}]}, {'job': 'J4', 'tasks': [{'task': 0, 'start': 98, 'machine': 0, 'duration': 5}, {'task': 1, 'start': 142, 'machine': 1, 'duration': 38}]}]",45,markdown_table,0
JSP,JSP,"On a busy exam week the print room looks like a tiny factory: batch A needs printing, then stapling, then packing; batch B the same; and so on. Each batch must follow that order, each operation uses its designated equipment for a set duration, and no equipment can handle two batches at once. The win is the plan that gets the final batch completed earliest — check the clock time when the last batch finishes and try to reduce that time. The precise job-by-job times and machine assignments come next below.

There are 3 batches and 3 equipment units; their identifiers are J1, J2, J3 and 0, 1, 2.
Batch J1, operation 0 runs on equipment 2 for 1 time units.
Batch J1, operation 1 runs on equipment 1 for 44 time units.
Batch J1, operation 2 runs on equipment 0 for 74 time units.
Batch J2, operation 0 runs on equipment 1 for 90 time units.
Batch J2, operation 1 runs on equipment 0 for 35 time units.
Batch J2, operation 2 runs on equipment 2 for 5 time units.
Batch J3, operation 0 runs on equipment 2 for 10 time units.
Batch J3, operation 1 runs on equipment 1 for 7 time units.
Batch J3, operation 2 runs on equipment 0 for 10 time units.
Aim to finish the last of the 3 batches as early as possible.

And when you send the actual schedule back, a neat little JSON sketch is all I need — nothing fancy. Just follow this shape so I can read it easily:

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

This just shows the overall shape: ""solution"" is a list of batches (jobs), each batch has a ""job"" id and a ""tasks"" list. Each task entry says which step number it is (""task""), when that step starts (""start""), which piece of equipment it uses (""machine""), and how long it takes (""duration""). Think of it like filling out a little form for each batch and each step — this example is only a sketch of the expected shape, not the actual schedule.

Please be 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': 3, 'jobs': [[[2, 1], [1, 44], [0, 74]], [[1, 90], [0, 35], [2, 5]], [[2, 10], [1, 7], [0, 10]]]}","[{'job': 0, 'tasks': [{'task': 0, 'start': 0, 'machine': 2, 'duration': 1}, {'task': 1, 'start': 1, 'machine': 1, 'duration': 44}, {'task': 2, 'start': 45, 'machine': 0, 'duration': 74}]}, {'job': 1, 'tasks': [{'task': 0, 'start': 45, 'machine': 1, 'duration': 90}, {'task': 1, 'start': 135, 'machine': 0, 'duration': 35}, {'task': 2, 'start': 170, 'machine': 2, 'duration': 5}]}, {'job': 2, 'tasks': [{'task': 0, 'start': 1, 'machine': 2, 'duration': 10}, {'task': 1, 'start': 135, 'machine': 1, 'duration': 7}, {'task': 2, 'start': 170, 'machine': 0, 'duration': 10}]}]",180.0,"{'problem_type': 'JSP', 'nr_jobs': 3, 'nr_machines': 3, 'jobs': ['J1', 'J2', 'J3'], 'machines': [0, 1, 2], 'records': [{'job_id': 'J1', 'task_id': 0, 'machine_id': 2, 'duration': 1}, {'job_id': 'J1', 'task_id': 1, 'machine_id': 1, 'duration': 44}, {'job_id': 'J1', 'task_id': 2, 'machine_id': 0, 'duration': 74}, {'job_id': 'J2', 'task_id': 0, 'machine_id': 1, 'duration': 90}, {'job_id': 'J2', 'task_id': 1, 'machine_id': 0, 'duration': 35}, {'job_id': 'J2', 'task_id': 2, 'machine_id': 2, 'duration': 5}, {'job_id': 'J3', 'task_id': 0, 'machine_id': 2, 'duration': 10}, {'job_id': 'J3', 'task_id': 1, 'machine_id': 1, 'duration': 7}, {'job_id': 'J3', 'task_id': 2, 'machine_id': 0, 'duration': 10}]}","[{'job': 'J1', 'tasks': [{'task': 0, 'start': 0, 'machine': 2, 'duration': 1}, {'task': 1, 'start': 1, 'machine': 1, 'duration': 44}, {'task': 2, 'start': 45, 'machine': 0, 'duration': 74}]}, {'job': 'J2', 'tasks': [{'task': 0, 'start': 45, 'machine': 1, 'duration': 90}, {'task': 1, 'start': 135, 'machine': 0, 'duration': 35}, {'task': 2, 'start': 170, 'machine': 2, 'duration': 5}]}, {'job': 'J3', 'tasks': [{'task': 0, 'start': 1, 'machine': 2, 'duration': 10}, {'task': 1, 'start': 135, 'machine': 1, 'duration': 7}, {'task': 2, 'start': 170, 'machine': 0, 'duration': 10}]}]",46,nl,0
JSP,JSP,"There’s a busy little workshop where the supervisor needs to line up cutting, assembly, and finishing tasks across a handful of saws, benches, and booths. Every piece has a fixed sequence of steps that must happen in order, each step belongs on a particular station for a given stretch of time, and stations can’t overlap jobs. The aim is to get the whole lot finished in the shortest possible time — basically, make the moment when the last piece is done as early as it can be. Every operation must be scheduled exactly once; nothing gets skipped or doubled. The specific orders, machines, and times are shown below.

{
  ""nr_pieces"": 2,
  ""nr_stations"": 2,
  ""pieces"": [
    ""J1"",
    ""J2""
  ],
  ""stations"": [
    0,
    1
  ],
  ""tasks"": [
    {
      ""piece_id"": ""J1"",
      ""operation_index"": 0,
      ""station_id"": 1,
      ""processing_time"": 1
    },
    {
      ""piece_id"": ""J1"",
      ""operation_index"": 1,
      ""station_id"": 0,
      ""processing_time"": 57
    },
    {
      ""piece_id"": ""J2"",
      ""operation_index"": 0,
      ""station_id"": 0,
      ""processing_time"": 49
    },
    {
      ""piece_id"": ""J2"",
      ""operation_index"": 1,
      ""station_id"": 1,
      ""processing_time"": 36
    }
  ]
}

Also, when you give the schedule back, just use this simple JSON layout so everything is clear and consistent:

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

This is just the shape I need — one object with a ""solution"" list, one entry per job, and each job listing its tasks. In plain terms:
- ""job"" is the job identifier.
- ""tasks"" is the list of operations for that job in whatever order you schedule them.
- ""task"" is the task's index (which step it is within the job).
- ""start"" is the scheduled start time for that task.
- ""machine"" is the machine/station the task runs on.
- ""duration"" is how long the task runs.

Keep in mind this JSON is only a sketch of the expected shape, not the actual schedule — you'll fill in the real values for each field.

Please use the identifiers exactly as they appear in the instance input — do not rename them and do not 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': [[[1, 1], [0, 57]], [[0, 49], [1, 36]]]}","[{'job': 0, 'tasks': [{'task': 0, 'start': 0, 'machine': 1, 'duration': 1}, {'task': 1, 'start': 49, 'machine': 0, 'duration': 57}]}, {'job': 1, 'tasks': [{'task': 0, 'start': 0, 'machine': 0, 'duration': 49}, {'task': 1, 'start': 49, 'machine': 1, 'duration': 36}]}]",106.0,"{'problem_type': 'JSP', 'nr_jobs': 2, 'nr_machines': 2, 'jobs': ['J1', 'J2'], 'machines': [0, 1], 'records': [{'job_id': 'J1', 'task_id': 0, 'machine_id': 1, 'duration': 1}, {'job_id': 'J1', 'task_id': 1, 'machine_id': 0, 'duration': 57}, {'job_id': 'J2', 'task_id': 0, 'machine_id': 0, 'duration': 49}, {'job_id': 'J2', 'task_id': 1, 'machine_id': 1, 'duration': 36}]}","[{'job': 'J1', 'tasks': [{'task': 0, 'start': 0, 'machine': 1, 'duration': 1}, {'task': 1, 'start': 49, 'machine': 0, 'duration': 57}]}, {'job': 'J2', 'tasks': [{'task': 0, 'start': 0, 'machine': 0, 'duration': 49}, {'task': 1, 'start': 49, 'machine': 1, 'duration': 36}]}]",47,json,0
JSP,JSP,"There's a studio manager juggling several portrait shoots where every shoot needs a round of makeup, a photo session, then a retouch pass; each part must happen on its assigned chair or studio and lasts a set amount of time. The manager needs to schedule those steps so they happen in the right sequence for each client, nothing is left out or doubled up, and no chair or room is booked by two sessions at once. The aim is to make the whole day wrap up as soon as possible — you find that by checking all session finish times and using the latest one as the day’s end; the smaller that value, the better the schedule. The concrete details are shown below.

They must schedule 2 portrait sessions across 2 assets — sessions J1, J2 on assets A, B.

| session_id | step_index | asset_id | step_duration |
|---|---|---|---|
| J1 | 0 | B | 1 |
| J1 | 1 | A | 70 |
| J2 | 0 | B | 25 |
| J2 | 1 | A | 82 |

The manager judges the day by the latest session finish time; minimizing that value yields the best schedule.

Oh, and when you send the schedule back, please follow this JSON layout — just a simple sketch of the shape I need:

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

This is just a friendly form: ""solution"" holds a list of sessions (jobs). Each session has a job id and a list of tasks; each task entry says which step it is (task index), when it starts, which chair or studio it uses (machine), and how long it runs (duration). Think of job as the client/session, task as the ordered step (makeup, photo, retouch), start as the time the step begins, machine as the specific chair/room, and duration as how long that step takes.

This JSON is only the expected shape — not the actual schedule answer. Please make sure to use the exact identifiers from the instance input, without renaming or inventing 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': [[[1, 1], [0, 70]], [[1, 25], [0, 82]]]}","[{'job': 0, 'tasks': [{'task': 0, 'start': 0, 'machine': 1, 'duration': 1}, {'task': 1, 'start': 1, 'machine': 0, 'duration': 70}]}, {'job': 1, 'tasks': [{'task': 0, 'start': 1, 'machine': 1, 'duration': 25}, {'task': 1, 'start': 71, 'machine': 0, 'duration': 82}]}]",153.0,"{'problem_type': 'JSP', 'nr_jobs': 2, 'nr_machines': 2, 'jobs': ['J1', 'J2'], 'machines': ['A', 'B'], 'records': [{'job_id': 'J1', 'task_id': 0, 'machine_id': 'B', 'duration': 1}, {'job_id': 'J1', 'task_id': 1, 'machine_id': 'A', 'duration': 70}, {'job_id': 'J2', 'task_id': 0, 'machine_id': 'B', 'duration': 25}, {'job_id': 'J2', 'task_id': 1, 'machine_id': 'A', 'duration': 82}]}","[{'job': 'J1', 'tasks': [{'task': 0, 'start': 0, 'machine': 'B', 'duration': 1}, {'task': 1, 'start': 1, 'machine': 'A', 'duration': 70}]}, {'job': 'J2', 'tasks': [{'task': 0, 'start': 1, 'machine': 'B', 'duration': 25}, {'task': 1, 'start': 71, 'machine': 'A', 'duration': 82}]}]",48,markdown_table,names
JSP,JSP,"Many people think of repair benches as interchangeable, but here every device requires diagnostics, a parts change, then testing — and each step is fixed to a particular bench and length of time. The challenge for the depot coordinator is to arrange the start times so every device follows its step order, every step stays on its correct bench for the full duration, nothing is skipped or duplicated, and benches never have overlapping tasks. The best arrangement is the one that minimizes how long you wait for the whole batch to be finished — i.e., the moment the very last device completes. The detailed list of units, benches, and durations is shown below.

{
  ""nr_devices"": 3,
  ""nr_benches"": 3,
  ""device_ids"": [
    ""J1"",
    ""J2"",
    ""J3""
  ],
  ""bench_ids"": [
    ""A"",
    ""B"",
    ""C""
  ],
  ""tasks"": [
    {
      ""device_id"": ""J1"",
      ""step_index"": 0,
      ""bench_id"": ""B"",
      ""step_duration"": 1
    },
    {
      ""device_id"": ""J1"",
      ""step_index"": 1,
      ""bench_id"": ""C"",
      ""step_duration"": 84
    },
    {
      ""device_id"": ""J1"",
      ""step_index"": 2,
      ""bench_id"": ""A"",
      ""step_duration"": 1
    },
    {
      ""device_id"": ""J2"",
      ""step_index"": 0,
      ""bench_id"": ""C"",
      ""step_duration"": 28
    },
    {
      ""device_id"": ""J2"",
      ""step_index"": 1,
      ""bench_id"": ""B"",
      ""step_duration"": 94
    },
    {
      ""device_id"": ""J2"",
      ""step_index"": 2,
      ""bench_id"": ""A"",
      ""step_duration"": 70
    },
    {
      ""device_id"": ""J3"",
      ""step_index"": 0,
      ""bench_id"": ""C"",
      ""step_duration"": 24
    },
    {
      ""device_id"": ""J3"",
      ""step_index"": 1,
      ""bench_id"": ""A"",
      ""step_duration"": 10
    },
    {
      ""device_id"": ""J3"",
      ""step_index"": 2,
      ""bench_id"": ""B"",
      ""step_duration"": 14
    }
  ]
}

If you want to give me a candidate schedule, just drop it in this simple JSON shape so I can parse it easily — nothing fancy, just the fields I need.

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

Think of it like a little form: each job (one device) gets a list of its tasks in order; every task entry says which step number it is, when that step starts, which bench (machine) it uses, and how long it runs. Super simple — just fill in the real IDs and numbers.

This JSON is just a sketch of the shape I expect, not the actual schedule — please return the real values for the instance instead of these placeholders.

Please 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': [[[1, 1], [2, 84], [0, 1]], [[2, 28], [1, 94], [0, 70]], [[2, 24], [0, 10], [1, 14]]]}","[{'job': 0, 'tasks': [{'task': 0, 'start': 0, 'machine': 1, 'duration': 1}, {'task': 1, 'start': 52, 'machine': 2, 'duration': 84}, {'task': 2, 'start': 192, 'machine': 0, 'duration': 1}]}, {'job': 1, 'tasks': [{'task': 0, 'start': 0, 'machine': 2, 'duration': 28}, {'task': 1, 'start': 28, 'machine': 1, 'duration': 94}, {'task': 2, 'start': 122, 'machine': 0, 'duration': 70}]}, {'job': 2, 'tasks': [{'task': 0, 'start': 28, 'machine': 2, 'duration': 24}, {'task': 1, 'start': 52, 'machine': 0, 'duration': 10}, {'task': 2, 'start': 122, 'machine': 1, 'duration': 14}]}]",193.0,"{'problem_type': 'JSP', 'nr_jobs': 3, 'nr_machines': 3, 'jobs': ['J1', 'J2', 'J3'], 'machines': ['A', 'B', 'C'], 'records': [{'job_id': 'J1', 'task_id': 0, 'machine_id': 'B', 'duration': 1}, {'job_id': 'J1', 'task_id': 1, 'machine_id': 'C', 'duration': 84}, {'job_id': 'J1', 'task_id': 2, 'machine_id': 'A', 'duration': 1}, {'job_id': 'J2', 'task_id': 0, 'machine_id': 'C', 'duration': 28}, {'job_id': 'J2', 'task_id': 1, 'machine_id': 'B', 'duration': 94}, {'job_id': 'J2', 'task_id': 2, 'machine_id': 'A', 'duration': 70}, {'job_id': 'J3', 'task_id': 0, 'machine_id': 'C', 'duration': 24}, {'job_id': 'J3', 'task_id': 1, 'machine_id': 'A', 'duration': 10}, {'job_id': 'J3', 'task_id': 2, 'machine_id': 'B', 'duration': 14}]}","[{'job': 'J1', 'tasks': [{'task': 0, 'start': 0, 'machine': 'B', 'duration': 1}, {'task': 1, 'start': 52, 'machine': 'C', 'duration': 84}, {'task': 2, 'start': 192, 'machine': 'A', 'duration': 1}]}, {'job': 'J2', 'tasks': [{'task': 0, 'start': 0, 'machine': 'C', 'duration': 28}, {'task': 1, 'start': 28, 'machine': 'B', 'duration': 94}, {'task': 2, 'start': 122, 'machine': 'A', 'duration': 70}]}, {'job': 'J3', 'tasks': [{'task': 0, 'start': 28, 'machine': 'C', 'duration': 24}, {'task': 1, 'start': 52, 'machine': 'A', 'duration': 10}, {'task': 2, 'start': 122, 'machine': 'B', 'duration': 14}]}]",49,json,names
JSP,JSP,"On a typical day an engineer is laying out when to run the compile/test steps for a batch of builds. Every build is a short script of steps that have to happen in order, each step takes a fixed amount of time and must land on a specific build server, and servers are one-at-a-time only. The sensible target is to have the whole batch wrapped up quickly — measure a plan by the time the last build finishes, and smaller is better. Every step must take place exactly once and in the given sequence. The concrete items (which build does what, how long, and which server) are listed below.

# nr_builds=2
# nr_servers=3
# build_ids=J1, J2
# server_ids=0, 1, 2
build_id,step_index,server_id,step_duration
J1,0,1,1
J1,1,2,97
J1,2,0,76
J2,0,1,73
J2,1,0,48
J2,2,2,92

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

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

Think of that as a simple form: ""solution"" is a list of job entries; each job has the job identifier and a list of its tasks. For each task, ""task"" is the position in the job's sequence, ""start"" is when that step begins (time), ""machine"" is which build server it runs on, and ""duration"" is how long it takes. Easy and informal — like filling out a schedule sheet.

This JSON is just the expected shape (a sketch) — not the final plan itself. Make sure all identifiers are 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': 3, 'nr_jobs': 2, 'jobs': [[[1, 1], [2, 97], [0, 76]], [[1, 73], [0, 48], [2, 92]]]}","[{'job': 0, 'tasks': [{'task': 0, 'start': 0, 'machine': 1, 'duration': 1}, {'task': 1, 'start': 1, 'machine': 2, 'duration': 97}, {'task': 2, 'start': 122, 'machine': 0, 'duration': 76}]}, {'job': 1, 'tasks': [{'task': 0, 'start': 1, 'machine': 1, 'duration': 73}, {'task': 1, 'start': 74, 'machine': 0, 'duration': 48}, {'task': 2, 'start': 122, 'machine': 2, 'duration': 92}]}]",214.0,"{'problem_type': 'JSP', 'nr_jobs': 2, 'nr_machines': 3, 'jobs': ['J1', 'J2'], 'machines': [0, 1, 2], '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': 0, 'duration': 76}, {'job_id': 'J2', 'task_id': 0, 'machine_id': 1, 'duration': 73}, {'job_id': 'J2', 'task_id': 1, 'machine_id': 0, 'duration': 48}, {'job_id': 'J2', 'task_id': 2, 'machine_id': 2, 'duration': 92}]}","[{'job': 'J1', 'tasks': [{'task': 0, 'start': 0, 'machine': 1, 'duration': 1}, {'task': 1, 'start': 1, 'machine': 2, 'duration': 97}, {'task': 2, 'start': 122, 'machine': 0, 'duration': 76}]}, {'job': 'J2', 'tasks': [{'task': 0, 'start': 1, 'machine': 1, 'duration': 73}, {'task': 1, 'start': 74, 'machine': 0, 'duration': 48}, {'task': 2, 'start': 122, 'machine': 2, 'duration': 92}]}]",50,csv,0