FSP/FSP_S_context.csv

task_name,problem_type,instruction,instance,solution,obj,instance_variant,solution_variant,context_index,input_format,input_index_base
FSP,FSP,"Back at the bakery, the crew has a row of fixed stations and a few batches that all need the same ordered steps, each step having a predictable duration. The decision is picking start times so stations never collide over two batches and every batch completes each station in turn with no missing or repeated steps. The simplest way to compare plans is the finish time of the last batch: the sooner that final time, the better the schedule. The precise batches and their step times are listed below.

# number_of_batches=2
# number_of_stations=2
# batch_ids=J1, J2
# station_ids=0, 1
batch_id,step_index,station_id,processing_duration
J1,0,0,1
J1,1,1,52
J2,0,0,73
J2,1,1,27

You can hand me the plan in a tiny JSON form like this — just a plain list of batches (jobs) with their tasks, start times, machines and durations. Here’s the format I expect:

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

Pretty simple: ""solution"" is the outer list, each entry is a job (a batch), ""tasks"" lists the ordered steps for that job, and each step has which task number it is, when it starts, which machine (station) it uses, and how long it runs. Think of it as a little form to fill in rather than a strict data spec.

This is only a sketch of the shape I want, not the actual schedule — fill the placeholders with the real IDs and numbers when you give the final answer.

Please use the exact identifiers from the problem 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': 2, 'nr_jobs': 2, 'jobs': [[[0, 1], [1, 52]], [[0, 73], [1, 27]]]}","[{'job': 0, 'tasks': [{'task': 0, 'start': 0, 'machine': 0, 'duration': 1}, {'task': 1, 'start': 1, 'machine': 1, 'duration': 52}]}, {'job': 1, 'tasks': [{'task': 0, 'start': 1, 'machine': 0, 'duration': 73}, {'task': 1, 'start': 74, 'machine': 1, 'duration': 27}]}]",101.0,"{'problem_type': 'FSP', 'nr_jobs': 2, 'nr_machines': 2, 'jobs': ['J1', 'J2'], 'machines': [0, 1], 'records': [{'job_id': 'J1', 'task_id': 0, 'machine_id': 0, 'duration': 1}, {'job_id': 'J1', 'task_id': 1, 'machine_id': 1, 'duration': 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': 0, 'duration': 1}, {'task': 1, 'start': 1, 'machine': 1, 'duration': 52}]}, {'job': 'J2', 'tasks': [{'task': 0, 'start': 1, 'machine': 0, 'duration': 73}, {'task': 1, 'start': 74, 'machine': 1, 'duration': 27}]}]",1,csv,0
FSP,FSP,"Many mornings we face the same puzzle: several print jobs each with a list of steps, same machine order for all, and decisions to make about when each step should begin so machines never do two things at once. Each operation must be performed in order and only once, and the yardstick of a good plan is the clock time when the final job is completed — simply the maximum finish time across the batch — which we want as small as we can. The precise job durations and machine order appear below.

{
  ""num_print_jobs"": 4,
  ""num_machines"": 2,
  ""print_job_ids"": [
    ""J1"",
    ""J2"",
    ""J3"",
    ""J4""
  ],
  ""machine_ids"": [
    0,
    1
  ],
  ""tasks"": [
    {
      ""print_job_id"": ""J1"",
      ""task_index"": 0,
      ""required_machine_id"": 0,
      ""processing_duration"": 1
    },
    {
      ""print_job_id"": ""J1"",
      ""task_index"": 1,
      ""required_machine_id"": 1,
      ""processing_duration"": 65
    },
    {
      ""print_job_id"": ""J2"",
      ""task_index"": 0,
      ""required_machine_id"": 0,
      ""processing_duration"": 49
    },
    {
      ""print_job_id"": ""J2"",
      ""task_index"": 1,
      ""required_machine_id"": 1,
      ""processing_duration"": 72
    },
    {
      ""print_job_id"": ""J3"",
      ""task_index"": 0,
      ""required_machine_id"": 0,
      ""processing_duration"": 90
    },
    {
      ""print_job_id"": ""J3"",
      ""task_index"": 1,
      ""required_machine_id"": 1,
      ""processing_duration"": 42
    },
    {
      ""print_job_id"": ""J4"",
      ""task_index"": 0,
      ""required_machine_id"": 0,
      ""processing_duration"": 3
    },
    {
      ""print_job_id"": ""J4"",
      ""task_index"": 1,
      ""required_machine_id"": 1,
      ""processing_duration"": 19
    }
  ]
}

Also, to keep things clean on my end, please give the schedule using this simple JSON layout — nothing fancy, just the shape I can read easily:

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

Pretty straightforward: ""solution"" is a list of jobs; each entry has a ""job"" identifier and a list of ""tasks"". Each task tells me which step it is (""task""), when that step starts (""start""), which machine it runs on (""machine""), and how long it takes (""duration""). This is just a sketch of the shape I need, not the actual schedule.

Please make sure you use the exact identifiers from the instance input — no renaming and no new labels. Valid identifiers look like plain numbers such as “1” or “23”, single capital letters like “A” or “B”, or a capital letter followed by digits like “A1” or “X7”.","{'nr_machines': 2, 'nr_jobs': 4, 'jobs': [[[0, 1], [1, 65]], [[0, 49], [1, 72]], [[0, 90], [1, 42]], [[0, 3], [1, 19]]]}","[{'job': 0, 'tasks': [{'task': 0, 'start': 0, 'machine': 0, 'duration': 1}, {'task': 1, 'start': 1, 'machine': 1, 'duration': 65}]}, {'job': 1, 'tasks': [{'task': 0, 'start': 4, 'machine': 0, 'duration': 49}, {'task': 1, 'start': 85, 'machine': 1, 'duration': 72}]}, {'job': 2, 'tasks': [{'task': 0, 'start': 53, 'machine': 0, 'duration': 90}, {'task': 1, 'start': 157, 'machine': 1, 'duration': 42}]}, {'job': 3, 'tasks': [{'task': 0, 'start': 1, 'machine': 0, 'duration': 3}, {'task': 1, 'start': 66, 'machine': 1, 'duration': 19}]}]",199.0,"{'problem_type': 'FSP', 'nr_jobs': 4, 'nr_machines': 2, 'jobs': ['J1', 'J2', 'J3', 'J4'], 'machines': [0, 1], 'records': [{'job_id': 'J1', 'task_id': 0, 'machine_id': 0, 'duration': 1}, {'job_id': 'J1', 'task_id': 1, 'machine_id': 1, 'duration': 65}, {'job_id': 'J2', 'task_id': 0, 'machine_id': 0, 'duration': 49}, {'job_id': 'J2', 'task_id': 1, 'machine_id': 1, 'duration': 72}, {'job_id': 'J3', 'task_id': 0, 'machine_id': 0, 'duration': 90}, {'job_id': 'J3', 'task_id': 1, 'machine_id': 1, 'duration': 42}, {'job_id': 'J4', 'task_id': 0, 'machine_id': 0, 'duration': 3}, {'job_id': 'J4', 'task_id': 1, 'machine_id': 1, 'duration': 19}]}","[{'job': 'J1', 'tasks': [{'task': 0, 'start': 0, 'machine': 0, 'duration': 1}, {'task': 1, 'start': 1, 'machine': 1, 'duration': 65}]}, {'job': 'J2', 'tasks': [{'task': 0, 'start': 4, 'machine': 0, 'duration': 49}, {'task': 1, 'start': 85, 'machine': 1, 'duration': 72}]}, {'job': 'J3', 'tasks': [{'task': 0, 'start': 53, 'machine': 0, 'duration': 90}, {'task': 1, 'start': 157, 'machine': 1, 'duration': 42}]}, {'job': 'J4', 'tasks': [{'task': 0, 'start': 1, 'machine': 0, 'duration': 3}, {'task': 1, 'start': 66, 'machine': 1, 'duration': 19}]}]",2,json,0
FSP,FSP,"Recently the shop got busier, so the lead detailer is laying out who goes when through the standard line of bays — every car follows the identical list of treatments and each treatment length is known in advance. The choice is about ordering and timing the cars so that bays never try to handle two cars at once and every vehicle completes each required stop exactly once. The best arrangement is the one that brings the finish time of the final car down as much as possible — just read the clock when that last car is done. The concrete details for this run are below.

# num_vehicles=3
# num_service_bays=2
# vehicle_ids=J1, J2, J3
# service_bay_ids=0, 1
vehicle_id,step_index,required_bay_id,process_time
J1,0,0,1
J1,1,1,78
J2,0,0,25
J2,1,1,18
J3,0,0,44
J3,1,1,63

If you want the schedule returned in a tidy, machine-friendly form, send it back following this little layout:

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

This is just a quick sketch of the shape I expect: ""solution"" is a list of jobs (here, cars), each job has a ""tasks"" list, and each task entry records which task number it is, when it starts, which bay (machine) it uses, and how long that stop lasts. Think of it like filling out a simple progress card for every car.

The JSON above is only the format, not the actual schedule — please return your real answers in that same shape. Also, 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': 3, 'jobs': [[[0, 1], [1, 78]], [[0, 25], [1, 18]], [[0, 44], [1, 63]]]}","[{'job': 0, 'tasks': [{'task': 0, 'start': 0, 'machine': 0, 'duration': 1}, {'task': 1, 'start': 1, 'machine': 1, 'duration': 78}]}, {'job': 1, 'tasks': [{'task': 0, 'start': 1, 'machine': 0, 'duration': 25}, {'task': 1, 'start': 142, 'machine': 1, 'duration': 18}]}, {'job': 2, 'tasks': [{'task': 0, 'start': 26, 'machine': 0, 'duration': 44}, {'task': 1, 'start': 79, 'machine': 1, 'duration': 63}]}]",160.0,"{'problem_type': 'FSP', 'nr_jobs': 3, 'nr_machines': 2, 'jobs': ['J1', 'J2', 'J3'], 'machines': [0, 1], 'records': [{'job_id': 'J1', 'task_id': 0, 'machine_id': 0, 'duration': 1}, {'job_id': 'J1', 'task_id': 1, 'machine_id': 1, 'duration': 78}, {'job_id': 'J2', 'task_id': 0, 'machine_id': 0, 'duration': 25}, {'job_id': 'J2', 'task_id': 1, 'machine_id': 1, 'duration': 18}, {'job_id': 'J3', 'task_id': 0, 'machine_id': 0, 'duration': 44}, {'job_id': 'J3', 'task_id': 1, 'machine_id': 1, 'duration': 63}]}","[{'job': 'J1', 'tasks': [{'task': 0, 'start': 0, 'machine': 0, 'duration': 1}, {'task': 1, 'start': 1, 'machine': 1, 'duration': 78}]}, {'job': 'J2', 'tasks': [{'task': 0, 'start': 1, 'machine': 0, 'duration': 25}, {'task': 1, 'start': 142, 'machine': 1, 'duration': 18}]}, {'job': 'J3', 'tasks': [{'task': 0, 'start': 26, 'machine': 0, 'duration': 44}, {'task': 1, 'start': 79, 'machine': 1, 'duration': 63}]}]",3,csv,0
FSP,FSP,"I run the laundry line and have to lay out a simple timetable so every shirt, dress, and towel moves through the same sequence of care stations — each step takes a fixed amount of time. The job is to decide when each garment goes to each station so no station is juggling two items at once and every garment visits every step exactly once. The calendar moment when the very last item leaves the final station is the one to watch — faster that moment, better the plan — so plans are judged by that finishing time. The exact garments, stations, and step lengths are shown below.

# nr_garments=2
# nr_stations=2
# garment_ids=J1, J2
# station_ids=1, 2
garment_id,step_index,station_id,operation_duration
J1,0,1,1
J1,1,2,92
J2,0,1,1
J2,1,2,64

If you want the plan back from me, it's easiest if we stick to a little JSON shape so it's predictable. Something like this will do:

{
  ""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 the list of garments (jobs), each garment entry gives its job id and a list of tasks. Each task line says which step it is (task), when that step starts (start), which station it uses (machine), and how long that step takes (duration). Super casual — it's just so we both know what to expect.

This is only a sketch of the expected shape, not the actual timetable. Please use the exact identifiers from the instance input — don't rename them or invent new labels. Valid identifiers look like plain numbers such as “1” or “23”, single capital letters like “A” or “B”, or a capital letter followed by digits like “A1” or “X7”.","{'nr_machines': 2, 'nr_jobs': 2, 'jobs': [[[0, 1], [1, 92]], [[0, 1], [1, 64]]]}","[{'job': 0, 'tasks': [{'task': 0, 'start': 0, 'machine': 0, 'duration': 1}, {'task': 1, 'start': 1, 'machine': 1, 'duration': 92}]}, {'job': 1, 'tasks': [{'task': 0, 'start': 1, 'machine': 0, 'duration': 1}, {'task': 1, 'start': 93, 'machine': 1, 'duration': 64}]}]",157.0,"{'problem_type': 'FSP', 'nr_jobs': 2, 'nr_machines': 2, 'jobs': ['J1', 'J2'], 'machines': [1, 2], 'records': [{'job_id': 'J1', 'task_id': 0, 'machine_id': 1, 'duration': 1}, {'job_id': 'J1', 'task_id': 1, 'machine_id': 2, 'duration': 92}, {'job_id': 'J2', 'task_id': 0, 'machine_id': 1, 'duration': 1}, {'job_id': 'J2', 'task_id': 1, 'machine_id': 2, 'duration': 64}]}","[{'job': 'J1', 'tasks': [{'task': 0, 'start': 0, 'machine': 1, 'duration': 1}, {'task': 1, 'start': 1, 'machine': 2, 'duration': 92}]}, {'job': 'J2', 'tasks': [{'task': 0, 'start': 1, 'machine': 1, 'duration': 1}, {'task': 1, 'start': 93, 'machine': 2, 'duration': 64}]}]",4,csv,1
FSP,FSP,"Many people treat the line like a relay: every circuit board hands off from station to station in the same order, and the supervisor decides the handoff times. The rules are straightforward — keep the sequence intact for each board, never put two boards on a single machine at once, and don’t skip or repeat tasks. The quality of a schedule is simply how early the last board is finished, i.e., the time when the whole batch is done. The specific boards and step durations follow below.

{
  ""num_boards"": 5,
  ""num_workstations"": 2,
  ""board_ids"": [
    ""J1"",
    ""J2"",
    ""J3"",
    ""J4"",
    ""J5""
  ],
  ""workstation_ids"": [
    0,
    1
  ],
  ""tasks"": [
    {
      ""board_id"": ""J1"",
      ""step_index"": 0,
      ""workstation_id"": 0,
      ""processing_time"": 1
    },
    {
      ""board_id"": ""J1"",
      ""step_index"": 1,
      ""workstation_id"": 1,
      ""processing_time"": 6
    },
    {
      ""board_id"": ""J2"",
      ""step_index"": 0,
      ""workstation_id"": 0,
      ""processing_time"": 76
    },
    {
      ""board_id"": ""J2"",
      ""step_index"": 1,
      ""workstation_id"": 1,
      ""processing_time"": 10
    },
    {
      ""board_id"": ""J3"",
      ""step_index"": 0,
      ""workstation_id"": 0,
      ""processing_time"": 51
    },
    {
      ""board_id"": ""J3"",
      ""step_index"": 1,
      ""workstation_id"": 1,
      ""processing_time"": 8
    },
    {
      ""board_id"": ""J4"",
      ""step_index"": 0,
      ""workstation_id"": 0,
      ""processing_time"": 17
    },
    {
      ""board_id"": ""J4"",
      ""step_index"": 1,
      ""workstation_id"": 1,
      ""processing_time"": 23
    },
    {
      ""board_id"": ""J5"",
      ""step_index"": 0,
      ""workstation_id"": 0,
      ""processing_time"": 25
    },
    {
      ""board_id"": ""J5"",
      ""step_index"": 1,
      ""workstation_id"": 1,
      ""processing_time"": 99
    }
  ]
}

If you prefer to hand the plan over in a tidy format, a small JSON shape like this is perfect — nothing fancy, just the fields I need to read the schedule.

{
  ""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 boards (jobs), each board gets a job identifier in ""job"", and a ""tasks"" list with each step's index, its planned start time, which machine it runs on, and how long it takes. It's just a sketch of the shape I expect — not the real schedule yet.

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': 2, 'nr_jobs': 5, 'jobs': [[[0, 1], [1, 6]], [[0, 76], [1, 10]], [[0, 51], [1, 8]], [[0, 17], [1, 23]], [[0, 25], [1, 99]]]}","[{'job': 0, 'tasks': [{'task': 0, 'start': 42, 'machine': 0, 'duration': 1}, {'task': 1, 'start': 147, 'machine': 1, 'duration': 6}]}, {'job': 1, 'tasks': [{'task': 0, 'start': 43, 'machine': 0, 'duration': 76}, {'task': 1, 'start': 153, 'machine': 1, 'duration': 10}]}, {'job': 2, 'tasks': [{'task': 0, 'start': 119, 'machine': 0, 'duration': 51}, {'task': 1, 'start': 170, 'machine': 1, 'duration': 8}]}, {'job': 3, 'tasks': [{'task': 0, 'start': 25, 'machine': 0, 'duration': 17}, {'task': 1, 'start': 124, 'machine': 1, 'duration': 23}]}, {'job': 4, 'tasks': [{'task': 0, 'start': 0, 'machine': 0, 'duration': 25}, {'task': 1, 'start': 25, 'machine': 1, 'duration': 99}]}]",178.0,"{'problem_type': 'FSP', 'nr_jobs': 5, 'nr_machines': 2, 'jobs': ['J1', 'J2', 'J3', 'J4', 'J5'], 'machines': [0, 1], 'records': [{'job_id': 'J1', 'task_id': 0, 'machine_id': 0, 'duration': 1}, {'job_id': 'J1', 'task_id': 1, 'machine_id': 1, 'duration': 6}, {'job_id': 'J2', 'task_id': 0, 'machine_id': 0, 'duration': 76}, {'job_id': 'J2', 'task_id': 1, 'machine_id': 1, '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': 0, 'duration': 25}, {'job_id': 'J5', 'task_id': 1, 'machine_id': 1, 'duration': 99}]}","[{'job': 'J1', 'tasks': [{'task': 0, 'start': 42, 'machine': 0, 'duration': 1}, {'task': 1, 'start': 147, 'machine': 1, 'duration': 6}]}, {'job': 'J2', 'tasks': [{'task': 0, 'start': 43, 'machine': 0, 'duration': 76}, {'task': 1, 'start': 153, 'machine': 1, 'duration': 10}]}, {'job': 'J3', 'tasks': [{'task': 0, 'start': 119, 'machine': 0, 'duration': 51}, {'task': 1, 'start': 170, 'machine': 1, 'duration': 8}]}, {'job': 'J4', 'tasks': [{'task': 0, 'start': 25, 'machine': 0, 'duration': 17}, {'task': 1, 'start': 124, 'machine': 1, 'duration': 23}]}, {'job': 'J5', 'tasks': [{'task': 0, 'start': 0, 'machine': 0, 'duration': 25}, {'task': 1, 'start': 25, 'machine': 1, 'duration': 99}]}]",5,json,0
FSP,FSP,"Many small bakeries face a simple challenge: each tray must pass through the identical sequence of ovens and coolers, each step lasting a fixed time. The task is to decide the sequence and start times so ovens and cooling areas aren’t juggling multiple trays at once. The best way to tell which plan is better is by when the last tray is finished — whoever gets that final finish time earlier wins. All trays must follow the same ordered steps without skipping or repeating any, and each machine can only handle one tray at a time. The exact counts and durations are given below.

The exact counts and durations are given below: 2 trays, 2 stations; tray IDs: J1, J2; station sequence: 1, 2.

| tray_id | step_index | station_id | processing_time |
|---|---|---|---|
| J1 | 0 | 1 | 1 |
| J1 | 1 | 2 | 19 |
| J2 | 0 | 1 | 51 |
| J2 | 1 | 2 | 56 |

All trays must follow the listed sequence without skipping or repeating steps; the objective is to finish all 2 trays as early as possible.

One more thing — when you send the schedule back, please follow this simple JSON layout so I can read it easily.

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

This is just a quick sketch of the shape I’m expecting: ""solution"" is a list of jobs, each job entry gives the job identifier and a list of its tasks, and each task lists which step it is, when that step starts, which machine it uses, and how long it takes. Think of it like a simple form to fill out for each tray as it moves through the ovens and coolers.

Please be 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': 2, 'jobs': [[[0, 1], [1, 19]], [[0, 51], [1, 56]]]}","[{'job': 0, 'tasks': [{'task': 0, 'start': 0, 'machine': 0, 'duration': 1}, {'task': 1, 'start': 1, 'machine': 1, 'duration': 19}]}, {'job': 1, 'tasks': [{'task': 0, 'start': 1, 'machine': 0, 'duration': 51}, {'task': 1, 'start': 52, 'machine': 1, 'duration': 56}]}]",108.0,"{'problem_type': 'FSP', 'nr_jobs': 2, 'nr_machines': 2, 'jobs': ['J1', 'J2'], 'machines': [1, 2], 'records': [{'job_id': 'J1', 'task_id': 0, 'machine_id': 1, 'duration': 1}, {'job_id': 'J1', 'task_id': 1, 'machine_id': 2, 'duration': 19}, {'job_id': 'J2', 'task_id': 0, 'machine_id': 1, 'duration': 51}, {'job_id': 'J2', 'task_id': 1, 'machine_id': 2, 'duration': 56}]}","[{'job': 'J1', 'tasks': [{'task': 0, 'start': 0, 'machine': 1, 'duration': 1}, {'task': 1, 'start': 1, 'machine': 2, 'duration': 19}]}, {'job': 'J2', 'tasks': [{'task': 0, 'start': 1, 'machine': 1, 'duration': 51}, {'task': 1, 'start': 52, 'machine': 2, 'duration': 56}]}]",6,markdown_table,1
FSP,FSP,"Recently the post team ran into a puzzle: a batch of clips needs to pass through a fixed sequence of editing bays, and someone has to decide the start times so each bay only works on one clip at a time. The processing lengths for each step are known, no clip can skip or repeat a step, and the aim is to have all clips finished as soon as possible — check every clip’s finish moment and the latest one is the one to minimize. The detailed timings and clips are shown right below.

They are: 3 clips, 2 bays, clip IDs J1, J2, J3, bay order 0, 1.
Clip J1, step 0, requires bay 0 for 1.
Clip J1, step 1, requires bay 1 for 32.
Clip J2, step 0, requires bay 0 for 27.
Clip J2, step 1, requires bay 1 for 2.
Clip J3, step 0, requires bay 0 for 57.
Clip J3, step 1, requires bay 1 for 51.
The goal remains to minimize the latest completion time across these 3 clips on the 2 bays.

You can send the final schedule back in a simple JSON shape like this — nothing fancy, just a small list of jobs where each job lists its tasks and start times.

{
  ""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 every clip (job), each job entry names the job and then lists its tasks; each task line says which step it is, when that step starts, which bay (machine) it uses, and how long it runs. This is just the expected shape — not the actual schedule yet.

Please use the exact identifiers from the instance input as-is — do not rename them or introduce new labels. 
- for example: ""Valid identifiers look like plain numbers such as “1” or “23”, single capital letters like “A” or “B”, or a capital letter followed by digits like “A1” or “X7”.""","{'nr_machines': 2, 'nr_jobs': 3, 'jobs': [[[0, 1], [1, 32]], [[0, 27], [1, 2]], [[0, 57], [1, 51]]]}","[{'job': 0, 'tasks': [{'task': 0, 'start': 0, 'machine': 0, 'duration': 1}, {'task': 1, 'start': 1, 'machine': 1, 'duration': 32}]}, {'job': 1, 'tasks': [{'task': 0, 'start': 58, 'machine': 0, 'duration': 27}, {'task': 1, 'start': 109, 'machine': 1, 'duration': 2}]}, {'job': 2, 'tasks': [{'task': 0, 'start': 1, 'machine': 0, 'duration': 57}, {'task': 1, 'start': 58, 'machine': 1, 'duration': 51}]}]",111.0,"{'problem_type': 'FSP', 'nr_jobs': 3, 'nr_machines': 2, 'jobs': ['J1', 'J2', 'J3'], 'machines': [0, 1], 'records': [{'job_id': 'J1', 'task_id': 0, 'machine_id': 0, 'duration': 1}, {'job_id': 'J1', 'task_id': 1, 'machine_id': 1, 'duration': 32}, {'job_id': 'J2', 'task_id': 0, 'machine_id': 0, 'duration': 27}, {'job_id': 'J2', 'task_id': 1, 'machine_id': 1, 'duration': 2}, {'job_id': 'J3', 'task_id': 0, 'machine_id': 0, 'duration': 57}, {'job_id': 'J3', 'task_id': 1, 'machine_id': 1, 'duration': 51}]}","[{'job': 'J1', 'tasks': [{'task': 0, 'start': 0, 'machine': 0, 'duration': 1}, {'task': 1, 'start': 1, 'machine': 1, 'duration': 32}]}, {'job': 'J2', 'tasks': [{'task': 0, 'start': 58, 'machine': 0, 'duration': 27}, {'task': 1, 'start': 109, 'machine': 1, 'duration': 2}]}, {'job': 'J3', 'tasks': [{'task': 0, 'start': 1, 'machine': 0, 'duration': 57}, {'task': 1, 'start': 58, 'machine': 1, 'duration': 51}]}]",7,nl,0
FSP,FSP,"We manage a busy service where every dish needs to pass through the same sequence of prep and finishing stations, each step taking a fixed amount of time. The decision is about scheduling those steps so stations never try to do two things at once and no dish skips or repeats a step. A better plan is one that brings the whole meal service to a close sooner — the finish time of the final dish is the metric to watch. The concrete dish timings and station order are listed below.

{
  ""number_of_dishes"": 2,
  ""number_of_stations"": 2,
  ""dish_identifiers"": [
    ""J1"",
    ""J2""
  ],
  ""station_identifiers"": [
    ""A"",
    ""B""
  ],
  ""tasks"": [
    {
      ""dish_id"": ""J1"",
      ""step_index"": 0,
      ""station_id"": ""A"",
      ""step_duration_minutes"": 1
    },
    {
      ""dish_id"": ""J1"",
      ""step_index"": 1,
      ""station_id"": ""B"",
      ""step_duration_minutes"": 45
    },
    {
      ""dish_id"": ""J2"",
      ""step_index"": 0,
      ""station_id"": ""A"",
      ""step_duration_minutes"": 3
    },
    {
      ""dish_id"": ""J2"",
      ""step_index"": 1,
      ""station_id"": ""B"",
      ""step_duration_minutes"": 47
    }
  ]
}

Also, when you hand me the schedule back, a simple JSON like this is perfect — nothing fancy, just that shape so I can read each dish and its steps easily.

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

Think of that as a little form: ""solution"" is a list of dishes; each dish has a ""job"" identifier and a list of ""tasks"". Each task entry just says which step number it is (""task""), when that step starts (""start""), which station handles it (""machine""), and how long it runs (""duration""). Super lightweight — just enough to capture the order and timing.

This JSON is only a sketch of the expected shape, not your actual answer. Please use the exact identifiers from the instance input — do not rename them or invent new labels. Valid identifiers look like plain numbers such as ""1"" or ""23"", single capital letters like ""A"" or ""B"", or a capital letter followed by digits like ""A1"" or ""X7"".","{'nr_machines': 2, 'nr_jobs': 2, 'jobs': [[[0, 1], [1, 45]], [[0, 3], [1, 47]]]}","[{'job': 0, 'tasks': [{'task': 0, 'start': 0, 'machine': 0, 'duration': 1}, {'task': 1, 'start': 1, 'machine': 1, 'duration': 45}]}, {'job': 1, 'tasks': [{'task': 0, 'start': 1, 'machine': 0, 'duration': 3}, {'task': 1, 'start': 46, 'machine': 1, 'duration': 47}]}]",93.0,"{'problem_type': 'FSP', 'nr_jobs': 2, 'nr_machines': 2, 'jobs': ['J1', 'J2'], 'machines': ['A', 'B'], 'records': [{'job_id': 'J1', 'task_id': 0, 'machine_id': 'A', 'duration': 1}, {'job_id': 'J1', 'task_id': 1, 'machine_id': 'B', 'duration': 45}, {'job_id': 'J2', 'task_id': 0, 'machine_id': 'A', 'duration': 3}, {'job_id': 'J2', 'task_id': 1, 'machine_id': 'B', 'duration': 47}]}","[{'job': 'J1', 'tasks': [{'task': 0, 'start': 0, 'machine': 'A', 'duration': 1}, {'task': 1, 'start': 1, 'machine': 'B', 'duration': 45}]}, {'job': 'J2', 'tasks': [{'task': 0, 'start': 1, 'machine': 'A', 'duration': 3}, {'task': 1, 'start': 46, 'machine': 'B', 'duration': 47}]}]",8,json,names
FSP,FSP,"I’m juggling a bench full of samples that all need to move through the same lineup of instruments, each step taking a known amount of time. The job is to pick when each sample starts on each instrument so nothing gets missed or repeated, every step happens in the fixed order, and no instrument is asked to run two analyses at once. A good plan is one where the whole batch is done as early as possible — measured by the clock time when the last sample finishes — so the later that final finish time is, the worse the plan. The concrete details are shown below.

Below I list the 5 samples and the 2 instruments: sample ids J1, J2, J3, J4, J5 and instrument order 0, 1.
I must schedule sample J1 step 0 on instrument 0 for 1.
I must schedule sample J1 step 1 on instrument 1 for 58.
I must schedule sample J2 step 0 on instrument 0 for 78.
I must schedule sample J2 step 1 on instrument 1 for 93.
I must schedule sample J3 step 0 on instrument 0 for 64.
I must schedule sample J3 step 1 on instrument 1 for 94.
I must schedule sample J4 step 0 on instrument 0 for 35.
I must schedule sample J4 step 1 on instrument 1 for 94.
I must schedule sample J5 step 0 on instrument 0 for 96.
I must schedule sample J5 step 1 on instrument 1 for 73.
I'll use these details to assign start times so the batch finishes as early as possible.

Also, when you send the schedule back, just use this simple JSON layout so everything lines up nicely:

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

Think of that like a little form: ""solution"" is the list of jobs, each job entry names the job and then lists its tasks; for each task you give the task index, the start time, which machine it runs on, and how long it takes. That block is just a sketch of the shape I expect, not the actual schedule.

Please make sure to use the exact identifiers from the instance input — don’t rename 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': [[[0, 1], [1, 58]], [[0, 78], [1, 93]], [[0, 64], [1, 94]], [[0, 35], [1, 94]], [[0, 96], [1, 73]]]}","[{'job': 0, 'tasks': [{'task': 0, 'start': 0, 'machine': 0, 'duration': 1}, {'task': 1, 'start': 1, 'machine': 1, 'duration': 58}]}, {'job': 1, 'tasks': [{'task': 0, 'start': 196, 'machine': 0, 'duration': 78}, {'task': 1, 'start': 320, 'machine': 1, 'duration': 93}]}, {'job': 2, 'tasks': [{'task': 0, 'start': 36, 'machine': 0, 'duration': 64}, {'task': 1, 'start': 153, 'machine': 1, 'duration': 94}]}, {'job': 3, 'tasks': [{'task': 0, 'start': 1, 'machine': 0, 'duration': 35}, {'task': 1, 'start': 59, 'machine': 1, 'duration': 94}]}, {'job': 4, 'tasks': [{'task': 0, 'start': 100, 'machine': 0, 'duration': 96}, {'task': 1, 'start': 247, 'machine': 1, 'duration': 73}]}]",413.0,"{'problem_type': 'FSP', 'nr_jobs': 5, 'nr_machines': 2, 'jobs': ['J1', 'J2', 'J3', 'J4', 'J5'], 'machines': [0, 1], 'records': [{'job_id': 'J1', 'task_id': 0, 'machine_id': 0, 'duration': 1}, {'job_id': 'J1', 'task_id': 1, 'machine_id': 1, 'duration': 58}, {'job_id': 'J2', 'task_id': 0, 'machine_id': 0, 'duration': 78}, {'job_id': 'J2', 'task_id': 1, 'machine_id': 1, 'duration': 93}, {'job_id': 'J3', 'task_id': 0, 'machine_id': 0, 'duration': 64}, {'job_id': 'J3', 'task_id': 1, 'machine_id': 1, 'duration': 94}, {'job_id': 'J4', 'task_id': 0, 'machine_id': 0, 'duration': 35}, {'job_id': 'J4', 'task_id': 1, 'machine_id': 1, 'duration': 94}, {'job_id': 'J5', 'task_id': 0, 'machine_id': 0, 'duration': 96}, {'job_id': 'J5', 'task_id': 1, 'machine_id': 1, 'duration': 73}]}","[{'job': 'J1', 'tasks': [{'task': 0, 'start': 0, 'machine': 0, 'duration': 1}, {'task': 1, 'start': 1, 'machine': 1, 'duration': 58}]}, {'job': 'J2', 'tasks': [{'task': 0, 'start': 196, 'machine': 0, 'duration': 78}, {'task': 1, 'start': 320, 'machine': 1, 'duration': 93}]}, {'job': 'J3', 'tasks': [{'task': 0, 'start': 36, 'machine': 0, 'duration': 64}, {'task': 1, 'start': 153, 'machine': 1, 'duration': 94}]}, {'job': 'J4', 'tasks': [{'task': 0, 'start': 1, 'machine': 0, 'duration': 35}, {'task': 1, 'start': 59, 'machine': 1, 'duration': 94}]}, {'job': 'J5', 'tasks': [{'task': 0, 'start': 100, 'machine': 0, 'duration': 96}, {'task': 1, 'start': 247, 'machine': 1, 'duration': 73}]}]",9,nl,0
FSP,FSP,"I’m the foreperson on the shop floor, lining up a batch of tabletops that all need the same run of stations — sanding, staining, assembly — each step taking a known amount of time. The job is to pick the order the tables go through and set their start times so no station ever works on two tables at once and every table goes through each step exactly once in the same order. A good plan is the one that gets the last table off the final station as early as possible, so success is measured by that finishing time. The exact stations and operation times are shown below.

I'm lining up 5 tabletops to run through 3 stations; the table IDs are J1, J2, J3, J4, J5 and the stations in the fixed route are 0, 1, 2.
For table J1, step 0 at 0 takes 1.
For table J1, step 1 at 1 takes 71.
For table J1, step 2 at 2 takes 54.
For table J2, step 0 at 0 takes 39.
For table J2, step 1 at 1 takes 17.
For table J2, step 2 at 2 takes 17.
For table J3, step 0 at 0 takes 40.
For table J3, step 1 at 1 takes 62.
For table J3, step 2 at 2 takes 64.
For table J4, step 0 at 0 takes 67.
For table J4, step 1 at 1 takes 56.
For table J4, step 2 at 2 takes 49.
For table J5, step 0 at 0 takes 38.
For table J5, step 1 at 1 takes 76.
For table J5, step 2 at 2 takes 72.
I'll use these entries to pick the order and start times so the last table clears the final station as early as possible.

Also, when you send me the actual schedule, it helps if you follow this little JSON layout so everything’s easy to read and parse:

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

This is just a template to show the shape I’m expecting. Think of it like a simple form: ""solution"" is the list of all tables (jobs), each entry has the job identifier, and ""tasks"" is the sequence of steps for that table. Inside each task object, ""task"" is which step in the sequence it is, ""start"" is the time that step begins, ""machine"" is which station is doing the work, and ""duration"" is how long that step takes. Keep it light—this block is a sketch of the expected shape, not the actual schedule.

Please be careful 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': 5, 'jobs': [[[0, 1], [1, 71], [2, 54]], [[0, 39], [1, 17], [2, 17]], [[0, 40], [1, 62], [2, 64]], [[0, 67], [1, 56], [2, 49]], [[0, 38], [1, 76], [2, 72]]]}","[{'job': 0, 'tasks': [{'task': 0, 'start': 0, 'machine': 0, 'duration': 1}, {'task': 1, 'start': 1, 'machine': 1, 'duration': 71}, {'task': 2, 'start': 72, 'machine': 2, 'duration': 54}]}, {'job': 1, 'tasks': [{'task': 0, 'start': 79, 'machine': 0, 'duration': 39}, {'task': 1, 'start': 303, 'machine': 1, 'duration': 17}, {'task': 2, 'start': 331, 'machine': 2, 'duration': 17}]}, {'job': 2, 'tasks': [{'task': 0, 'start': 1, 'machine': 0, 'duration': 40}, {'task': 1, 'start': 72, 'machine': 1, 'duration': 62}, {'task': 2, 'start': 134, 'machine': 2, 'duration': 64}]}, {'job': 3, 'tasks': [{'task': 0, 'start': 118, 'machine': 0, 'duration': 67}, {'task': 1, 'start': 210, 'machine': 1, 'duration': 56}, {'task': 2, 'start': 282, 'machine': 2, 'duration': 49}]}, {'job': 4, 'tasks': [{'task': 0, 'start': 41, 'machine': 0, 'duration': 38}, {'task': 1, 'start': 134, 'machine': 1, 'duration': 76}, {'task': 2, 'start': 210, 'machine': 2, 'duration': 72}]}]",348.0,"{'problem_type': 'FSP', 'nr_jobs': 5, 'nr_machines': 3, 'jobs': ['J1', 'J2', 'J3', 'J4', 'J5'], 'machines': [0, 1, 2], 'records': [{'job_id': 'J1', 'task_id': 0, 'machine_id': 0, 'duration': 1}, {'job_id': 'J1', 'task_id': 1, 'machine_id': 1, 'duration': 71}, {'job_id': 'J1', 'task_id': 2, 'machine_id': 2, 'duration': 54}, {'job_id': 'J2', 'task_id': 0, 'machine_id': 0, 'duration': 39}, {'job_id': 'J2', 'task_id': 1, 'machine_id': 1, 'duration': 17}, {'job_id': 'J2', 'task_id': 2, 'machine_id': 2, 'duration': 17}, {'job_id': 'J3', 'task_id': 0, 'machine_id': 0, 'duration': 40}, {'job_id': 'J3', 'task_id': 1, 'machine_id': 1, 'duration': 62}, {'job_id': 'J3', 'task_id': 2, 'machine_id': 2, 'duration': 64}, {'job_id': 'J4', 'task_id': 0, 'machine_id': 0, 'duration': 67}, {'job_id': 'J4', 'task_id': 1, 'machine_id': 1, 'duration': 56}, {'job_id': 'J4', 'task_id': 2, 'machine_id': 2, 'duration': 49}, {'job_id': 'J5', 'task_id': 0, 'machine_id': 0, 'duration': 38}, {'job_id': 'J5', 'task_id': 1, 'machine_id': 1, 'duration': 76}, {'job_id': 'J5', 'task_id': 2, 'machine_id': 2, 'duration': 72}]}","[{'job': 'J1', 'tasks': [{'task': 0, 'start': 0, 'machine': 0, 'duration': 1}, {'task': 1, 'start': 1, 'machine': 1, 'duration': 71}, {'task': 2, 'start': 72, 'machine': 2, 'duration': 54}]}, {'job': 'J2', 'tasks': [{'task': 0, 'start': 79, 'machine': 0, 'duration': 39}, {'task': 1, 'start': 303, 'machine': 1, 'duration': 17}, {'task': 2, 'start': 331, 'machine': 2, 'duration': 17}]}, {'job': 'J3', 'tasks': [{'task': 0, 'start': 1, 'machine': 0, 'duration': 40}, {'task': 1, 'start': 72, 'machine': 1, 'duration': 62}, {'task': 2, 'start': 134, 'machine': 2, 'duration': 64}]}, {'job': 'J4', 'tasks': [{'task': 0, 'start': 118, 'machine': 0, 'duration': 67}, {'task': 1, 'start': 210, 'machine': 1, 'duration': 56}, {'task': 2, 'start': 282, 'machine': 2, 'duration': 49}]}, {'job': 'J5', 'tasks': [{'task': 0, 'start': 41, 'machine': 0, 'duration': 38}, {'task': 1, 'start': 134, 'machine': 1, 'duration': 76}, {'task': 2, 'start': 210, 'machine': 2, 'duration': 72}]}]",10,nl,0
FSP,FSP,"On a busy morning at the brewery, multiple lots must pass through the same lineup of tanks and finishing stages, each step with its own processing time. The operator must time every move so tanks aren’t used by more than one batch at once, and every batch follows the same ordered steps exactly once. The success metric is easy to understand: the moment the final batch is completed — earlier is better. The instance specifics are written out below.

# nr_batches=2
# nr_stages=2
# batch_ids=J1, J2
# stage_ids=1, 2
batch_id,stage_index,stage_id,processing_time
J1,0,1,1
J1,1,2,84
J2,0,1,29
J2,1,2,85

Also, when you send the schedule back, I’d prefer it in a little JSON layout so it’s easy to read and plug in. Something like this:

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

Think of it as a simple form: the top-level ""solution"" is a list of batches, each ""job"" is a batch identifier, and ""tasks"" is the ordered list of steps that batch goes through. For each task, ""task"" says which step it is, ""start"" says when that step begins (same time units as the instance), ""machine"" names the tank or station used, and ""duration"" is how long that step takes. Super light — just enough to know who goes where and when.

This JSON is only a sketch of the expected shape, not the actual schedule — please fill in the real ids and numbers when you reply.

Also, please use the exact identifiers from the instance input with no renaming or extra labels. Valid identifiers look like plain numbers such as “1” or “23”, single capital letters like “A” or “B”, or a capital letter followed by digits like “A1” or “X7”.","{'nr_machines': 2, 'nr_jobs': 2, 'jobs': [[[0, 1], [1, 84]], [[0, 29], [1, 85]]]}","[{'job': 0, 'tasks': [{'task': 0, 'start': 0, 'machine': 0, 'duration': 1}, {'task': 1, 'start': 1, 'machine': 1, 'duration': 84}]}, {'job': 1, 'tasks': [{'task': 0, 'start': 1, 'machine': 0, 'duration': 29}, {'task': 1, 'start': 85, 'machine': 1, 'duration': 85}]}]",170.0,"{'problem_type': 'FSP', 'nr_jobs': 2, 'nr_machines': 2, 'jobs': ['J1', 'J2'], 'machines': [1, 2], 'records': [{'job_id': 'J1', 'task_id': 0, 'machine_id': 1, 'duration': 1}, {'job_id': 'J1', 'task_id': 1, 'machine_id': 2, 'duration': 84}, {'job_id': 'J2', 'task_id': 0, 'machine_id': 1, 'duration': 29}, {'job_id': 'J2', 'task_id': 1, 'machine_id': 2, 'duration': 85}]}","[{'job': 'J1', 'tasks': [{'task': 0, 'start': 0, 'machine': 1, 'duration': 1}, {'task': 1, 'start': 1, 'machine': 2, 'duration': 84}]}, {'job': 'J2', 'tasks': [{'task': 0, 'start': 1, 'machine': 1, 'duration': 29}, {'task': 1, 'start': 85, 'machine': 2, 'duration': 85}]}]",11,csv,1
FSP,FSP,"Someone’s lined up a batch of vehicles for fixes, and the plan is to move each one through the same sequence of repair stations with known task lengths. The decision is how to sequence and time those moves so each station handles only one car at a time and no service step is omitted or repeated. The success metric is the clock reading when the final car is done — lower is better — which is simply the maximum of all the individual completion times. The full breakdown of cars, bay order, and task durations appears below.

# nr_vehicles=5
# nr_bays=3
# vehicle_ids=J1, J2, J3, J4, J5
# bay_ids=A, B, C
vehicle_id,step_index,bay_id,service_duration
J1,0,A,1
J1,1,B,97
J1,2,C,5
J2,0,A,31
J2,1,B,24
J2,2,C,60
J3,0,A,49
J3,1,B,98
J3,2,C,1
J4,0,A,54
J4,1,B,33
J4,2,C,53
J5,0,A,5
J5,1,B,83
J5,2,C,83

If you want the answer in a tidy, machine-friendly form, just follow this JSON shape for the schedule — nothing fancy, just the fields you need:

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

Think of this as a simple form: ""solution"" holds a list (one entry per car), each entry's ""job"" is the car identifier, and ""tasks"" lists that car's service steps in order. For each task you give the step index, the time it starts, which repair bay/station it uses, and how long that step takes. Super casual — just fill in the placeholders with the real values when you return a schedule.

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': 5, 'jobs': [[[0, 1], [1, 97], [2, 5]], [[0, 31], [1, 24], [2, 60]], [[0, 49], [1, 98], [2, 1]], [[0, 54], [1, 33], [2, 53]], [[0, 5], [1, 83], [2, 83]]]}","[{'job': 0, 'tasks': [{'task': 0, 'start': 0, 'machine': 0, 'duration': 1}, {'task': 1, 'start': 1, 'machine': 1, 'duration': 97}, {'task': 2, 'start': 98, 'machine': 2, 'duration': 5}]}, {'job': 1, 'tasks': [{'task': 0, 'start': 55, 'machine': 0, 'duration': 31}, {'task': 1, 'start': 131, 'machine': 1, 'duration': 24}, {'task': 2, 'start': 184, 'machine': 2, 'duration': 60}]}, {'job': 2, 'tasks': [{'task': 0, 'start': 86, 'machine': 0, 'duration': 49}, {'task': 1, 'start': 238, 'machine': 1, 'duration': 98}, {'task': 2, 'start': 336, 'machine': 2, 'duration': 1}]}, {'job': 3, 'tasks': [{'task': 0, 'start': 1, 'machine': 0, 'duration': 54}, {'task': 1, 'start': 98, 'machine': 1, 'duration': 33}, {'task': 2, 'start': 131, 'machine': 2, 'duration': 53}]}, {'job': 4, 'tasks': [{'task': 0, 'start': 135, 'machine': 0, 'duration': 5}, {'task': 1, 'start': 155, 'machine': 1, 'duration': 83}, {'task': 2, 'start': 244, 'machine': 2, 'duration': 83}]}]",337.0,"{'problem_type': 'FSP', 'nr_jobs': 5, 'nr_machines': 3, 'jobs': ['J1', 'J2', 'J3', 'J4', 'J5'], 'machines': ['A', 'B', 'C'], 'records': [{'job_id': 'J1', 'task_id': 0, 'machine_id': 'A', 'duration': 1}, {'job_id': 'J1', 'task_id': 1, 'machine_id': 'B', 'duration': 97}, {'job_id': 'J1', 'task_id': 2, 'machine_id': 'C', 'duration': 5}, {'job_id': 'J2', 'task_id': 0, 'machine_id': 'A', 'duration': 31}, {'job_id': 'J2', 'task_id': 1, 'machine_id': 'B', 'duration': 24}, {'job_id': 'J2', 'task_id': 2, 'machine_id': 'C', 'duration': 60}, {'job_id': 'J3', 'task_id': 0, 'machine_id': 'A', 'duration': 49}, {'job_id': 'J3', 'task_id': 1, 'machine_id': 'B', 'duration': 98}, {'job_id': 'J3', 'task_id': 2, 'machine_id': 'C', 'duration': 1}, {'job_id': 'J4', 'task_id': 0, 'machine_id': 'A', 'duration': 54}, {'job_id': 'J4', 'task_id': 1, 'machine_id': 'B', 'duration': 33}, {'job_id': 'J4', 'task_id': 2, 'machine_id': 'C', 'duration': 53}, {'job_id': 'J5', 'task_id': 0, 'machine_id': 'A', 'duration': 5}, {'job_id': 'J5', 'task_id': 1, 'machine_id': 'B', 'duration': 83}, {'job_id': 'J5', 'task_id': 2, 'machine_id': 'C', 'duration': 83}]}","[{'job': 'J1', 'tasks': [{'task': 0, 'start': 0, 'machine': 'A', 'duration': 1}, {'task': 1, 'start': 1, 'machine': 'B', 'duration': 97}, {'task': 2, 'start': 98, 'machine': 'C', 'duration': 5}]}, {'job': 'J2', 'tasks': [{'task': 0, 'start': 55, 'machine': 'A', 'duration': 31}, {'task': 1, 'start': 131, 'machine': 'B', 'duration': 24}, {'task': 2, 'start': 184, 'machine': 'C', 'duration': 60}]}, {'job': 'J3', 'tasks': [{'task': 0, 'start': 86, 'machine': 'A', 'duration': 49}, {'task': 1, 'start': 238, 'machine': 'B', 'duration': 98}, {'task': 2, 'start': 336, 'machine': 'C', 'duration': 1}]}, {'job': 'J4', 'tasks': [{'task': 0, 'start': 1, 'machine': 'A', 'duration': 54}, {'task': 1, 'start': 98, 'machine': 'B', 'duration': 33}, {'task': 2, 'start': 131, 'machine': 'C', 'duration': 53}]}, {'job': 'J5', 'tasks': [{'task': 0, 'start': 135, 'machine': 'A', 'duration': 5}, {'task': 1, 'start': 155, 'machine': 'B', 'duration': 83}, {'task': 2, 'start': 244, 'machine': 'C', 'duration': 83}]}]",12,csv,names
FSP,FSP,"Someone’s in charge of timing a line of dough pieces through a fixed chain of machines, with each operation taking a preset amount of time. Their decision is about the exact timing and order of pieces, making sure no machine handles multiple pieces simultaneously and that every piece completes each step exactly once. The runner-up plan is the one where the clock shows a later finish; the best plan is the one with the earliest time when the very last piece is done. The detailed machine steps and durations follow below.

# nr_dough_pieces=4
# nr_stations=2
# dough_piece_ids=J1, J2, J3, J4
# station_ids=0, 1
dough_piece_id,operation_index,required_station_id,processing_time
J1,0,0,1
J1,1,1,11
J2,0,0,80
J2,1,1,76
J3,0,0,77
J3,1,1,82
J4,0,0,54
J4,1,1,66

Also, when you send back the plan, just stick to a little JSON layout like this so it's easy to read and parse:

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

This sketch means: each top-level entry is one job (one dough piece), the tasks array lists the step-by-step operations for that job, ""task"" is the step index in the sequence, ""start"" is the time that step begins, ""machine"" names which machine does it, and ""duration"" is how long it runs. It's just the expected shape — not the actual schedule.

Please be sure to use the exact identifiers from the instance input — do not rename or invent new labels. Valid identifiers look like plain numbers such as ""1"" or ""23"", single capital letters like ""A"" or ""B"", or a capital letter followed by digits like ""A1"" or ""X7"".","{'nr_machines': 2, 'nr_jobs': 4, 'jobs': [[[0, 1], [1, 11]], [[0, 80], [1, 76]], [[0, 77], [1, 82]], [[0, 54], [1, 66]]]}","[{'job': 0, 'tasks': [{'task': 0, 'start': 0, 'machine': 0, 'duration': 1}, {'task': 1, 'start': 1, 'machine': 1, 'duration': 11}]}, {'job': 1, 'tasks': [{'task': 0, 'start': 132, 'machine': 0, 'duration': 80}, {'task': 1, 'start': 214, 'machine': 1, 'duration': 76}]}, {'job': 2, 'tasks': [{'task': 0, 'start': 55, 'machine': 0, 'duration': 77}, {'task': 1, 'start': 132, 'machine': 1, 'duration': 82}]}, {'job': 3, 'tasks': [{'task': 0, 'start': 1, 'machine': 0, 'duration': 54}, {'task': 1, 'start': 55, 'machine': 1, 'duration': 66}]}]",290.0,"{'problem_type': 'FSP', 'nr_jobs': 4, 'nr_machines': 2, 'jobs': ['J1', 'J2', 'J3', 'J4'], 'machines': [0, 1], 'records': [{'job_id': 'J1', 'task_id': 0, 'machine_id': 0, 'duration': 1}, {'job_id': 'J1', 'task_id': 1, 'machine_id': 1, 'duration': 11}, {'job_id': 'J2', 'task_id': 0, 'machine_id': 0, 'duration': 80}, {'job_id': 'J2', 'task_id': 1, 'machine_id': 1, 'duration': 76}, {'job_id': 'J3', 'task_id': 0, 'machine_id': 0, 'duration': 77}, {'job_id': 'J3', 'task_id': 1, 'machine_id': 1, 'duration': 82}, {'job_id': 'J4', 'task_id': 0, 'machine_id': 0, 'duration': 54}, {'job_id': 'J4', 'task_id': 1, 'machine_id': 1, 'duration': 66}]}","[{'job': 'J1', 'tasks': [{'task': 0, 'start': 0, 'machine': 0, 'duration': 1}, {'task': 1, 'start': 1, 'machine': 1, 'duration': 11}]}, {'job': 'J2', 'tasks': [{'task': 0, 'start': 132, 'machine': 0, 'duration': 80}, {'task': 1, 'start': 214, 'machine': 1, 'duration': 76}]}, {'job': 'J3', 'tasks': [{'task': 0, 'start': 55, 'machine': 0, 'duration': 77}, {'task': 1, 'start': 132, 'machine': 1, 'duration': 82}]}, {'job': 'J4', 'tasks': [{'task': 0, 'start': 1, 'machine': 0, 'duration': 54}, {'task': 1, 'start': 55, 'machine': 1, 'duration': 66}]}]",13,csv,0
FSP,FSP,"There’s a small warehouse story: parcels arrive and must pass through a fixed lineup of packing stations, each station taking a known amount of time per parcel. The challenge is picking when to start each parcel at each station so no station overlaps work on two parcels, and every parcel still visits every station in order. Which plan is better is judged by the clock — whoever finishes the last parcel earlier wins, and that finishing time is the number we care about. The specific parcel list and station times are shown below.

# total_parcels=3
# nr_stations=3
# parcel_ids=J1, J2, J3
# station_ids=1, 2, 3
parcel_id,station_step_index,station_id,processing_time
J1,0,1,1
J1,1,2,24
J1,2,3,56
J2,0,1,23
J2,1,2,30
J2,2,3,5
J3,0,1,59
J3,1,2,34
J3,2,3,36

Also, when you share a packing plan, a simple JSON layout like this works best — just fill in the actual ids and numbers for each parcel and step:

{
  ""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 list of parcels, each parcel has a ""job"" id and a list of ""tasks"". Each task is one station visit — ""task"" is which step it is in the sequence, ""start"" is when that parcel begins at that station, ""machine"" is which station it uses, and ""duration"" is how long that station takes for that parcel. Easy, informal, and just a sketch of the shape I need — not the actual filled-in 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': 3, 'nr_jobs': 3, 'jobs': [[[0, 1], [1, 24], [2, 56]], [[0, 23], [1, 30], [2, 5]], [[0, 59], [1, 34], [2, 36]]]}","[{'job': 0, 'tasks': [{'task': 0, 'start': 0, 'machine': 0, 'duration': 1}, {'task': 1, 'start': 1, 'machine': 1, 'duration': 24}, {'task': 2, 'start': 25, 'machine': 2, 'duration': 56}]}, {'job': 1, 'tasks': [{'task': 0, 'start': 60, 'machine': 0, 'duration': 23}, {'task': 1, 'start': 94, 'machine': 1, 'duration': 30}, {'task': 2, 'start': 130, 'machine': 2, 'duration': 5}]}, {'job': 2, 'tasks': [{'task': 0, 'start': 1, 'machine': 0, 'duration': 59}, {'task': 1, 'start': 60, 'machine': 1, 'duration': 34}, {'task': 2, 'start': 94, 'machine': 2, 'duration': 36}]}]",135.0,"{'problem_type': 'FSP', 'nr_jobs': 3, 'nr_machines': 3, 'jobs': ['J1', 'J2', 'J3'], 'machines': [1, 2, 3], 'records': [{'job_id': 'J1', 'task_id': 0, 'machine_id': 1, 'duration': 1}, {'job_id': 'J1', 'task_id': 1, 'machine_id': 2, 'duration': 24}, {'job_id': 'J1', 'task_id': 2, 'machine_id': 3, 'duration': 56}, {'job_id': 'J2', 'task_id': 0, 'machine_id': 1, 'duration': 23}, {'job_id': 'J2', 'task_id': 1, 'machine_id': 2, 'duration': 30}, {'job_id': 'J2', 'task_id': 2, 'machine_id': 3, 'duration': 5}, {'job_id': 'J3', 'task_id': 0, 'machine_id': 1, 'duration': 59}, {'job_id': 'J3', 'task_id': 1, 'machine_id': 2, 'duration': 34}, {'job_id': 'J3', 'task_id': 2, 'machine_id': 3, 'duration': 36}]}","[{'job': 'J1', 'tasks': [{'task': 0, 'start': 0, 'machine': 1, 'duration': 1}, {'task': 1, 'start': 1, 'machine': 2, 'duration': 24}, {'task': 2, 'start': 25, 'machine': 3, 'duration': 56}]}, {'job': 'J2', 'tasks': [{'task': 0, 'start': 60, 'machine': 1, 'duration': 23}, {'task': 1, 'start': 94, 'machine': 2, 'duration': 30}, {'task': 2, 'start': 130, 'machine': 3, 'duration': 5}]}, {'job': 'J3', 'tasks': [{'task': 0, 'start': 1, 'machine': 1, 'duration': 59}, {'task': 1, 'start': 60, 'machine': 2, 'duration': 34}, {'task': 2, 'start': 94, 'machine': 3, 'duration': 36}]}]",14,csv,1
FSP,FSP,"On a busy morning the kiln scheduler must slot pots through three stations — prep, dry, then fire — with fixed durations for each step and the same order for every pot. The call is to choose start times for every pot at every stage so nothing is skipped or repeated and no station is processing more than one pot at any time. The plan that finishes the entire batch the earliest wins, which is measured by the time the final pot finishes firing. The specific instance data appears below.

There are 2 pots (J1, J2) to route through the 2 stations (0, 1).
Pot J1, stage 0 on station 0 requires 1 time units.
Pot J1, stage 1 on station 1 requires 37 time units.
Pot J2, stage 0 on station 0 requires 32 time units.
Pot J2, stage 1 on station 1 requires 68 time units.
Start times must be chosen so the batch finishes as early as possible.

And to keep things tidy, please return the schedule in a simple JSON shape like this — nothing fancy, just the fields shown so I can read each job and its tasks easily.

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

This sketch means: ""solution"" is a list of jobs; each job has its identifier under ""job"" and a ""tasks"" list. Each task entry records which task it is, when it starts, which machine it runs on, and how long it takes. Think of it like filling out a simple form for every pot and each of its steps.

This is just the expected shape — not the actual schedule yet. Please make sure to 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': [[[0, 1], [1, 37]], [[0, 32], [1, 68]]]}","[{'job': 0, 'tasks': [{'task': 0, 'start': 0, 'machine': 0, 'duration': 1}, {'task': 1, 'start': 1, 'machine': 1, 'duration': 37}]}, {'job': 1, 'tasks': [{'task': 0, 'start': 1, 'machine': 0, 'duration': 32}, {'task': 1, 'start': 38, 'machine': 1, 'duration': 68}]}]",106.0,"{'problem_type': 'FSP', 'nr_jobs': 2, 'nr_machines': 2, 'jobs': ['J1', 'J2'], 'machines': [0, 1], 'records': [{'job_id': 'J1', 'task_id': 0, 'machine_id': 0, 'duration': 1}, {'job_id': 'J1', 'task_id': 1, 'machine_id': 1, 'duration': 37}, {'job_id': 'J2', 'task_id': 0, 'machine_id': 0, 'duration': 32}, {'job_id': 'J2', 'task_id': 1, 'machine_id': 1, 'duration': 68}]}","[{'job': 'J1', 'tasks': [{'task': 0, 'start': 0, 'machine': 0, 'duration': 1}, {'task': 1, 'start': 1, 'machine': 1, 'duration': 37}]}, {'job': 'J2', 'tasks': [{'task': 0, 'start': 1, 'machine': 0, 'duration': 32}, {'task': 1, 'start': 38, 'machine': 1, 'duration': 68}]}]",15,nl,0
FSP,FSP,"I’m the person in charge of the test lab, lining up a bunch of gadgets so each one goes through the same string of tests, each test taking a set amount of time. The job is to pick who goes on which test bench and when, making sure every device follows the exact test order and no bench ever runs two tests at once. A schedule is better if the very last device finishes sooner — you measure that by looking at when each device completes its final test and taking the latest of those times. The full list of devices, tests and durations is shown below.

I have 5 devices that must each visit 2 test benches; their IDs are J1, J2, J3, J4, J5 and the benches are A, B.

| device_id | test_step_index | test_bench_id | test_duration |
|---|---|---|---|
| J1 | 0 | A | 1 |
| J1 | 1 | B | 50 |
| J2 | 0 | A | 7 |
| J2 | 1 | B | 15 |
| J3 | 0 | A | 37 |
| J3 | 1 | B | 48 |
| J4 | 0 | A | 68 |
| J4 | 1 | B | 69 |
| J5 | 0 | A | 72 |
| J5 | 1 | B | 28 |

I'll use these entries to assign benches and start times so the last device finishes as soon as possible.

If you want the schedule in a simple, shareable form I usually send it as a little JSON sketch like this — just so we all agree on the shape of the answer:

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

Think of that as a short form: ""solution"" is the list of devices (jobs), each job has a ""tasks"" list showing the individual tests in order. For each test you give which step it is (""task""), when it starts (""start""), which bench it uses (""machine""), and how long it takes (""duration""). Easy, like filling out a little schedule form rather than drawing a diagram.

This JSON is just a sketch of the shape I need — I still need the actual numbers and IDs filled in for your instance.

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': 5, 'jobs': [[[0, 1], [1, 50]], [[0, 7], [1, 15]], [[0, 37], [1, 48]], [[0, 68], [1, 69]], [[0, 72], [1, 28]]]}","[{'job': 0, 'tasks': [{'task': 0, 'start': 0, 'machine': 0, 'duration': 1}, {'task': 1, 'start': 1, 'machine': 1, 'duration': 50}]}, {'job': 1, 'tasks': [{'task': 0, 'start': 1, 'machine': 0, 'duration': 7}, {'task': 1, 'start': 99, 'machine': 1, 'duration': 15}]}, {'job': 2, 'tasks': [{'task': 0, 'start': 8, 'machine': 0, 'duration': 37}, {'task': 1, 'start': 51, 'machine': 1, 'duration': 48}]}, {'job': 3, 'tasks': [{'task': 0, 'start': 45, 'machine': 0, 'duration': 68}, {'task': 1, 'start': 114, 'machine': 1, 'duration': 69}]}, {'job': 4, 'tasks': [{'task': 0, 'start': 113, 'machine': 0, 'duration': 72}, {'task': 1, 'start': 185, 'machine': 1, 'duration': 28}]}]",213.0,"{'problem_type': 'FSP', 'nr_jobs': 5, 'nr_machines': 2, 'jobs': ['J1', 'J2', 'J3', 'J4', 'J5'], 'machines': ['A', 'B'], 'records': [{'job_id': 'J1', 'task_id': 0, 'machine_id': 'A', 'duration': 1}, {'job_id': 'J1', 'task_id': 1, 'machine_id': 'B', 'duration': 50}, {'job_id': 'J2', 'task_id': 0, 'machine_id': 'A', 'duration': 7}, {'job_id': 'J2', 'task_id': 1, 'machine_id': 'B', 'duration': 15}, {'job_id': 'J3', 'task_id': 0, 'machine_id': 'A', 'duration': 37}, {'job_id': 'J3', 'task_id': 1, 'machine_id': 'B', 'duration': 48}, {'job_id': 'J4', 'task_id': 0, 'machine_id': 'A', 'duration': 68}, {'job_id': 'J4', 'task_id': 1, 'machine_id': 'B', 'duration': 69}, {'job_id': 'J5', 'task_id': 0, 'machine_id': 'A', 'duration': 72}, {'job_id': 'J5', 'task_id': 1, 'machine_id': 'B', 'duration': 28}]}","[{'job': 'J1', 'tasks': [{'task': 0, 'start': 0, 'machine': 'A', 'duration': 1}, {'task': 1, 'start': 1, 'machine': 'B', 'duration': 50}]}, {'job': 'J2', 'tasks': [{'task': 0, 'start': 1, 'machine': 'A', 'duration': 7}, {'task': 1, 'start': 99, 'machine': 'B', 'duration': 15}]}, {'job': 'J3', 'tasks': [{'task': 0, 'start': 8, 'machine': 'A', 'duration': 37}, {'task': 1, 'start': 51, 'machine': 'B', 'duration': 48}]}, {'job': 'J4', 'tasks': [{'task': 0, 'start': 45, 'machine': 'A', 'duration': 68}, {'task': 1, 'start': 114, 'machine': 'B', 'duration': 69}]}, {'job': 'J5', 'tasks': [{'task': 0, 'start': 113, 'machine': 'A', 'duration': 72}, {'task': 1, 'start': 185, 'machine': 'B', 'duration': 28}]}]",16,markdown_table,names
FSP,FSP,"I manage a small car wash where every vehicle must go through prewash, soap, rinse, then drying in that exact order, and my job is to line them up so no wash bay is trying to handle two cars at once. The aim is simple: get the whole group finished as fast as possible — you measure success by the clock time when the last car rolls out of the dryer. Nothing can be skipped or done twice, and each station can only work on one car at a time. The concrete list of cars and their timings is shown below.

Here are the 4 vehicles to run through the 3 stations: vehicle IDs J1, J2, J3, J4 and station sequence 1, 2, 3.

| vehicle_id | step_index | station_id | step_duration |
|---|---|---|---|
| J1 | 0 | 1 | 1 |
| J1 | 1 | 2 | 63 |
| J1 | 2 | 3 | 82 |
| J2 | 0 | 1 | 60 |
| J2 | 1 | 2 | 90 |
| J2 | 2 | 3 | 70 |
| J3 | 0 | 1 | 73 |
| J3 | 1 | 2 | 38 |
| J3 | 2 | 3 | 40 |
| J4 | 0 | 1 | 22 |
| J4 | 1 | 2 | 25 |
| J4 | 2 | 3 | 13 |

I'll use these entries to order the vehicles so the last one exits the dryer as early as possible.

I'll lay out the answer in a simple JSON sketch so it's easy to read and plug into whatever you use next — it'll look like this:

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

Pretty straightforward: each top-level object in ""solution"" is one car (job). ""job"" is the car's identifier, and ""tasks"" is the list of steps it goes through. Inside each task, ""task"" is which step in the sequence it is, ""start"" is the time that step begins, ""machine"" tells you which station handles it, and ""duration"" is how long that station works on the car. Think of it like filling out a little schedule form for every car.

This JSON is only a sketch of the expected shape — it's not the actual schedule itself.

Please be sure to 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': 3, 'nr_jobs': 4, 'jobs': [[[0, 1], [1, 63], [2, 82]], [[0, 60], [1, 90], [2, 70]], [[0, 73], [1, 38], [2, 40]], [[0, 22], [1, 25], [2, 13]]]}","[{'job': 0, 'tasks': [{'task': 0, 'start': 0, 'machine': 0, 'duration': 1}, {'task': 1, 'start': 1, 'machine': 1, 'duration': 63}, {'task': 2, 'start': 64, 'machine': 2, 'duration': 82}]}, {'job': 1, 'tasks': [{'task': 0, 'start': 1, 'machine': 0, 'duration': 60}, {'task': 1, 'start': 64, 'machine': 1, 'duration': 90}, {'task': 2, 'start': 154, 'machine': 2, 'duration': 70}]}, {'job': 2, 'tasks': [{'task': 0, 'start': 61, 'machine': 0, 'duration': 73}, {'task': 1, 'start': 154, 'machine': 1, 'duration': 38}, {'task': 2, 'start': 224, 'machine': 2, 'duration': 40}]}, {'job': 3, 'tasks': [{'task': 0, 'start': 134, 'machine': 0, 'duration': 22}, {'task': 1, 'start': 192, 'machine': 1, 'duration': 25}, {'task': 2, 'start': 264, 'machine': 2, 'duration': 13}]}]",277.0,"{'problem_type': 'FSP', 'nr_jobs': 4, 'nr_machines': 3, 'jobs': ['J1', 'J2', 'J3', 'J4'], 'machines': [1, 2, 3], 'records': [{'job_id': 'J1', 'task_id': 0, 'machine_id': 1, 'duration': 1}, {'job_id': 'J1', 'task_id': 1, 'machine_id': 2, 'duration': 63}, {'job_id': 'J1', 'task_id': 2, 'machine_id': 3, 'duration': 82}, {'job_id': 'J2', 'task_id': 0, 'machine_id': 1, 'duration': 60}, {'job_id': 'J2', 'task_id': 1, 'machine_id': 2, 'duration': 90}, {'job_id': 'J2', 'task_id': 2, 'machine_id': 3, 'duration': 70}, {'job_id': 'J3', 'task_id': 0, 'machine_id': 1, 'duration': 73}, {'job_id': 'J3', 'task_id': 1, 'machine_id': 2, 'duration': 38}, {'job_id': 'J3', 'task_id': 2, 'machine_id': 3, 'duration': 40}, {'job_id': 'J4', 'task_id': 0, 'machine_id': 1, 'duration': 22}, {'job_id': 'J4', 'task_id': 1, 'machine_id': 2, 'duration': 25}, {'job_id': 'J4', 'task_id': 2, 'machine_id': 3, 'duration': 13}]}","[{'job': 'J1', 'tasks': [{'task': 0, 'start': 0, 'machine': 1, 'duration': 1}, {'task': 1, 'start': 1, 'machine': 2, 'duration': 63}, {'task': 2, 'start': 64, 'machine': 3, 'duration': 82}]}, {'job': 'J2', 'tasks': [{'task': 0, 'start': 1, 'machine': 1, 'duration': 60}, {'task': 1, 'start': 64, 'machine': 2, 'duration': 90}, {'task': 2, 'start': 154, 'machine': 3, 'duration': 70}]}, {'job': 'J3', 'tasks': [{'task': 0, 'start': 61, 'machine': 1, 'duration': 73}, {'task': 1, 'start': 154, 'machine': 2, 'duration': 38}, {'task': 2, 'start': 224, 'machine': 3, 'duration': 40}]}, {'job': 'J4', 'tasks': [{'task': 0, 'start': 134, 'machine': 1, 'duration': 22}, {'task': 1, 'start': 192, 'machine': 2, 'duration': 25}, {'task': 2, 'start': 264, 'machine': 3, 'duration': 13}]}]",17,markdown_table,1
FSP,FSP,"We have a steady stream of clients who all need the same three stops—shampoo, then a cut, then styling—and they must move through in that sequence. The manager needs to decide who goes when so that each chair and station isn’t expected to handle two clients at the same minute, and every client gets each service once in the right order. The measure of success is how early the whole batch is done: look at the clock when the last client’s styling is finished — the sooner that time, the better. The concrete times and details follow below.

There are 4 clients and 2 stations; client IDs: J1, J2, J3, J4; station IDs: A, B.
Client J1 needs service 0 at A for 1 minutes.
Client J1 needs service 1 at B for 76 minutes.
Client J2 needs service 0 at A for 58 minutes.
Client J2 needs service 1 at B for 6 minutes.
Client J3 needs service 0 at A for 43 minutes.
Client J3 needs service 1 at B for 91 minutes.
Client J4 needs service 0 at A for 77 minutes.
Client J4 needs service 1 at B for 6 minutes.
We must schedule so no station is double-booked and the batch finishes as early as possible.

Oh, and when you send the schedule back, please follow this 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>
        }
      ]
    }
  ]
}

This is just a simple form: each top-level entry is a client (job), and under each client there's a list of their services (tasks). For each task we note which chair/station it uses (machine), when that service starts (start), how long it takes (duration), and the task index to keep the order clear. Think of it like filling out one little card per client with a timeline of their three stops. This block is only a sketch of the shape I need — not the final schedule itself.

Please make sure you use the exact identifiers from the instance input — do not rename them or invent new labels. Valid identifiers look like plain numbers such as “1” or “23”, single capital letters like “A” or “B”, or a capital letter followed by digits like “A1” or “X7”.","{'nr_machines': 2, 'nr_jobs': 4, 'jobs': [[[0, 1], [1, 76]], [[0, 58], [1, 6]], [[0, 43], [1, 91]], [[0, 77], [1, 6]]]}","[{'job': 0, 'tasks': [{'task': 0, 'start': 0, 'machine': 0, 'duration': 1}, {'task': 1, 'start': 1, 'machine': 1, 'duration': 76}]}, {'job': 1, 'tasks': [{'task': 0, 'start': 44, 'machine': 0, 'duration': 58}, {'task': 1, 'start': 168, 'machine': 1, 'duration': 6}]}, {'job': 2, 'tasks': [{'task': 0, 'start': 1, 'machine': 0, 'duration': 43}, {'task': 1, 'start': 77, 'machine': 1, 'duration': 91}]}, {'job': 3, 'tasks': [{'task': 0, 'start': 102, 'machine': 0, 'duration': 77}, {'task': 1, 'start': 179, 'machine': 1, 'duration': 6}]}]",185.0,"{'problem_type': 'FSP', 'nr_jobs': 4, 'nr_machines': 2, 'jobs': ['J1', 'J2', 'J3', 'J4'], 'machines': ['A', 'B'], 'records': [{'job_id': 'J1', 'task_id': 0, 'machine_id': 'A', 'duration': 1}, {'job_id': 'J1', 'task_id': 1, 'machine_id': 'B', 'duration': 76}, {'job_id': 'J2', 'task_id': 0, 'machine_id': 'A', 'duration': 58}, {'job_id': 'J2', 'task_id': 1, 'machine_id': 'B', 'duration': 6}, {'job_id': 'J3', 'task_id': 0, 'machine_id': 'A', 'duration': 43}, {'job_id': 'J3', 'task_id': 1, 'machine_id': 'B', 'duration': 91}, {'job_id': 'J4', 'task_id': 0, 'machine_id': 'A', 'duration': 77}, {'job_id': 'J4', 'task_id': 1, 'machine_id': 'B', 'duration': 6}]}","[{'job': 'J1', 'tasks': [{'task': 0, 'start': 0, 'machine': 'A', 'duration': 1}, {'task': 1, 'start': 1, 'machine': 'B', 'duration': 76}]}, {'job': 'J2', 'tasks': [{'task': 0, 'start': 44, 'machine': 'A', 'duration': 58}, {'task': 1, 'start': 168, 'machine': 'B', 'duration': 6}]}, {'job': 'J3', 'tasks': [{'task': 0, 'start': 1, 'machine': 'A', 'duration': 43}, {'task': 1, 'start': 77, 'machine': 'B', 'duration': 91}]}, {'job': 'J4', 'tasks': [{'task': 0, 'start': 102, 'machine': 'A', 'duration': 77}, {'task': 1, 'start': 179, 'machine': 'B', 'duration': 6}]}]",18,nl,names
FSP,FSP,"There’s a small photo lab humming away: every print needs exposure, then developing, then drying, always in that order. The task is to pick the order the prints go into the line so no machine is asked to do two prints at once and every print goes through each step exactly once. The one schedule that’s better is the one where the clock reads the smallest number when the last print finally finishes drying. Concrete job durations and details follow below.

Here are the 5 prints and the 2 stations: the prints J1, J2, J3, J4, J5 must each pass through the stations A, B in that order.
Print J1, step 0, runs on station A for 1 time units.
Print J1, step 1, runs on station B for 89 time units.
Print J2, step 0, runs on station A for 34 time units.
Print J2, step 1, runs on station B for 52 time units.
Print J3, step 0, runs on station A for 96 time units.
Print J3, step 1, runs on station B for 14 time units.
Print J4, step 0, runs on station A for 82 time units.
Print J4, step 1, runs on station B for 73 time units.
Print J5, step 0, runs on station A for 76 time units.
Print J5, step 1, runs on station B for 9 time units.
List every task as below so the schedule can make the final drying finish as early as possible.

Oh, and when you send the schedule back, a little JSON shape like this makes it easy for me to pick apart who goes where and when:

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

Think of that as a simple form: ""solution"" is the whole set of prints; each entry is one print (""job"" — the print's id); ""tasks"" is the list of steps that print goes through; each step has which step number it is (""task""), when it starts (""start""), which station is doing it (""machine""), and how long it takes (""duration""). Super casual — just a sketch of the shape I expect, not the final plan.

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': 5, 'jobs': [[[0, 1], [1, 89]], [[0, 34], [1, 52]], [[0, 96], [1, 14]], [[0, 82], [1, 73]], [[0, 76], [1, 9]]]}","[{'job': 0, 'tasks': [{'task': 0, 'start': 0, 'machine': 0, 'duration': 1}, {'task': 1, 'start': 1, 'machine': 1, 'duration': 89}]}, {'job': 1, 'tasks': [{'task': 0, 'start': 1, 'machine': 0, 'duration': 34}, {'task': 1, 'start': 90, 'machine': 1, 'duration': 52}]}, {'job': 2, 'tasks': [{'task': 0, 'start': 117, 'machine': 0, 'duration': 96}, {'task': 1, 'start': 215, 'machine': 1, 'duration': 14}]}, {'job': 3, 'tasks': [{'task': 0, 'start': 35, 'machine': 0, 'duration': 82}, {'task': 1, 'start': 142, 'machine': 1, 'duration': 73}]}, {'job': 4, 'tasks': [{'task': 0, 'start': 213, 'machine': 0, 'duration': 76}, {'task': 1, 'start': 289, 'machine': 1, 'duration': 9}]}]",298.0,"{'problem_type': 'FSP', 'nr_jobs': 5, 'nr_machines': 2, 'jobs': ['J1', 'J2', 'J3', 'J4', 'J5'], 'machines': ['A', 'B'], 'records': [{'job_id': 'J1', 'task_id': 0, 'machine_id': 'A', 'duration': 1}, {'job_id': 'J1', 'task_id': 1, 'machine_id': 'B', 'duration': 89}, {'job_id': 'J2', 'task_id': 0, 'machine_id': 'A', 'duration': 34}, {'job_id': 'J2', 'task_id': 1, 'machine_id': 'B', 'duration': 52}, {'job_id': 'J3', 'task_id': 0, 'machine_id': 'A', 'duration': 96}, {'job_id': 'J3', 'task_id': 1, 'machine_id': 'B', 'duration': 14}, {'job_id': 'J4', 'task_id': 0, 'machine_id': 'A', 'duration': 82}, {'job_id': 'J4', 'task_id': 1, 'machine_id': 'B', 'duration': 73}, {'job_id': 'J5', 'task_id': 0, 'machine_id': 'A', 'duration': 76}, {'job_id': 'J5', 'task_id': 1, 'machine_id': 'B', 'duration': 9}]}","[{'job': 'J1', 'tasks': [{'task': 0, 'start': 0, 'machine': 'A', 'duration': 1}, {'task': 1, 'start': 1, 'machine': 'B', 'duration': 89}]}, {'job': 'J2', 'tasks': [{'task': 0, 'start': 1, 'machine': 'A', 'duration': 34}, {'task': 1, 'start': 90, 'machine': 'B', 'duration': 52}]}, {'job': 'J3', 'tasks': [{'task': 0, 'start': 117, 'machine': 'A', 'duration': 96}, {'task': 1, 'start': 215, 'machine': 'B', 'duration': 14}]}, {'job': 'J4', 'tasks': [{'task': 0, 'start': 35, 'machine': 'A', 'duration': 82}, {'task': 1, 'start': 142, 'machine': 'B', 'duration': 73}]}, {'job': 'J5', 'tasks': [{'task': 0, 'start': 213, 'machine': 'A', 'duration': 76}, {'task': 1, 'start': 289, 'machine': 'B', 'duration': 9}]}]",19,nl,names
FSP,FSP,"Someone on the line has to choreograph the flow: each circuit board must go through soldering, then testing, then packing, always in that order. The task is to pick the order the boards pass through the three stations so no station tries to do two boards at once and every board gets each step exactly once. The goal is to minimize how long it takes until the last board is finished — the completion time of the final board from the packer. The exact boards and their step lengths are detailed below.

There are 5 boards to schedule across 2 stations; the board IDs are J1, J2, J3, J4, J5 and the station sequence is 1, 2.

| board_id | step_index | station_id | processing_duration |
|---|---|---|---|
| J1 | 0 | 1 | 1 |
| J1 | 1 | 2 | 3 |
| J2 | 0 | 1 | 10 |
| J2 | 1 | 2 | 97 |
| J3 | 0 | 1 | 50 |
| J3 | 1 | 2 | 36 |
| J4 | 0 | 1 | 87 |
| J4 | 1 | 2 | 41 |
| J5 | 0 | 1 | 44 |
| J5 | 1 | 2 | 2 |

Keep the line moving to minimize the completion time of the final board.

Oh, and before you hand me the schedule, it'd be handy if you put it into this simple JSON shape so I can read it automatically:

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

That's just a sketch of the shape I expect — ""solution"" is a list where each entry is one board (a job), and each board has a ""tasks"" list with each step's index, when it starts, which station/machine it uses, and how long that step takes. Treat it like a simple form to fill out, not the final timetable itself.

Please make sure all identifiers in your actual schedule match the instance input exactly — 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': 5, 'jobs': [[[0, 1], [1, 3]], [[0, 10], [1, 97]], [[0, 50], [1, 36]], [[0, 87], [1, 41]], [[0, 44], [1, 2]]]}","[{'job': 0, 'tasks': [{'task': 0, 'start': 10, 'machine': 0, 'duration': 1}, {'task': 1, 'start': 184, 'machine': 1, 'duration': 3}]}, {'job': 1, 'tasks': [{'task': 0, 'start': 0, 'machine': 0, 'duration': 10}, {'task': 1, 'start': 10, 'machine': 1, 'duration': 97}]}, {'job': 2, 'tasks': [{'task': 0, 'start': 98, 'machine': 0, 'duration': 50}, {'task': 1, 'start': 148, 'machine': 1, 'duration': 36}]}, {'job': 3, 'tasks': [{'task': 0, 'start': 11, 'machine': 0, 'duration': 87}, {'task': 1, 'start': 107, 'machine': 1, 'duration': 41}]}, {'job': 4, 'tasks': [{'task': 0, 'start': 148, 'machine': 0, 'duration': 44}, {'task': 1, 'start': 192, 'machine': 1, 'duration': 2}]}]",194.0,"{'problem_type': 'FSP', 'nr_jobs': 5, 'nr_machines': 2, 'jobs': ['J1', 'J2', 'J3', 'J4', 'J5'], 'machines': [1, 2], 'records': [{'job_id': 'J1', 'task_id': 0, 'machine_id': 1, 'duration': 1}, {'job_id': 'J1', 'task_id': 1, 'machine_id': 2, 'duration': 3}, {'job_id': 'J2', 'task_id': 0, 'machine_id': 1, 'duration': 10}, {'job_id': 'J2', 'task_id': 1, 'machine_id': 2, 'duration': 97}, {'job_id': 'J3', 'task_id': 0, 'machine_id': 1, 'duration': 50}, {'job_id': 'J3', 'task_id': 1, 'machine_id': 2, 'duration': 36}, {'job_id': 'J4', 'task_id': 0, 'machine_id': 1, 'duration': 87}, {'job_id': 'J4', 'task_id': 1, 'machine_id': 2, 'duration': 41}, {'job_id': 'J5', 'task_id': 0, 'machine_id': 1, 'duration': 44}, {'job_id': 'J5', 'task_id': 1, 'machine_id': 2, 'duration': 2}]}","[{'job': 'J1', 'tasks': [{'task': 0, 'start': 10, 'machine': 1, 'duration': 1}, {'task': 1, 'start': 184, 'machine': 2, 'duration': 3}]}, {'job': 'J2', 'tasks': [{'task': 0, 'start': 0, 'machine': 1, 'duration': 10}, {'task': 1, 'start': 10, 'machine': 2, 'duration': 97}]}, {'job': 'J3', 'tasks': [{'task': 0, 'start': 98, 'machine': 1, 'duration': 50}, {'task': 1, 'start': 148, 'machine': 2, 'duration': 36}]}, {'job': 'J4', 'tasks': [{'task': 0, 'start': 11, 'machine': 1, 'duration': 87}, {'task': 1, 'start': 107, 'machine': 2, 'duration': 41}]}, {'job': 'J5', 'tasks': [{'task': 0, 'start': 148, 'machine': 1, 'duration': 44}, {'task': 1, 'start': 192, 'machine': 2, 'duration': 2}]}]",20,markdown_table,1
FSP,FSP,"Many people come through the clinic needing the same three stops in the same order — check-in, sample, then diagnostics — and the receptionist spaces their slots so those stops don’t overlap on the same equipment. Every step has a set duration, and a device can’t handle two patients at once. What makes one spacing better than another is how early the entire group is done: the best plan is the one that makes the finish time of the last patient as early as possible. No steps can be skipped or repeated, and the detailed timings are shown below.

{
  ""nr_patients"": 4,
  ""nr_stations"": 3,
  ""patients"": [
    ""J1"",
    ""J2"",
    ""J3"",
    ""J4""
  ],
  ""stations"": [
    1,
    2,
    3
  ],
  ""tasks"": [
    {
      ""patient_id"": ""J1"",
      ""step_index"": 0,
      ""station_id"": 1,
      ""step_duration"": 1
    },
    {
      ""patient_id"": ""J1"",
      ""step_index"": 1,
      ""station_id"": 2,
      ""step_duration"": 16
    },
    {
      ""patient_id"": ""J1"",
      ""step_index"": 2,
      ""station_id"": 3,
      ""step_duration"": 84
    },
    {
      ""patient_id"": ""J2"",
      ""step_index"": 0,
      ""station_id"": 1,
      ""step_duration"": 44
    },
    {
      ""patient_id"": ""J2"",
      ""step_index"": 1,
      ""station_id"": 2,
      ""step_duration"": 4
    },
    {
      ""patient_id"": ""J2"",
      ""step_index"": 2,
      ""station_id"": 3,
      ""step_duration"": 57
    },
    {
      ""patient_id"": ""J3"",
      ""step_index"": 0,
      ""station_id"": 1,
      ""step_duration"": 91
    },
    {
      ""patient_id"": ""J3"",
      ""step_index"": 1,
      ""station_id"": 2,
      ""step_duration"": 9
    },
    {
      ""patient_id"": ""J3"",
      ""step_index"": 2,
      ""station_id"": 3,
      ""step_duration"": 12
    },
    {
      ""patient_id"": ""J4"",
      ""step_index"": 0,
      ""station_id"": 1,
      ""step_duration"": 95
    },
    {
      ""patient_id"": ""J4"",
      ""step_index"": 1,
      ""station_id"": 2,
      ""step_duration"": 77
    },
    {
      ""patient_id"": ""J4"",
      ""step_index"": 2,
      ""station_id"": 3,
      ""step_duration"": 21
    }
  ]
}

If you'd like the schedule in a machine-friendly form, I usually return it in this little JSON shape:

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

Think of that like a simple form: ""solution"" is the whole plan; inside it there's one entry per patient (job). Each patient entry names the job and then lists their tasks in order. Each task line just says which step number it is, when it starts, which device it uses, and how long it takes. This is just the shape I need — a sketch, not the actual filled-in schedule.

Please make sure to use the exact identifiers from the instance input — don't rename or invent labels. Valid identifiers look like plain numbers such as “1” or “23”, single capital letters like “A” or “B”, or a capital letter followed by digits like “A1” or “X7”.","{'nr_machines': 3, 'nr_jobs': 4, 'jobs': [[[0, 1], [1, 16], [2, 84]], [[0, 44], [1, 4], [2, 57]], [[0, 91], [1, 9], [2, 12]], [[0, 95], [1, 77], [2, 21]]]}","[{'job': 0, 'tasks': [{'task': 0, 'start': 0, 'machine': 0, 'duration': 1}, {'task': 1, 'start': 1, 'machine': 1, 'duration': 16}, {'task': 2, 'start': 17, 'machine': 2, 'duration': 84}]}, {'job': 1, 'tasks': [{'task': 0, 'start': 1, 'machine': 0, 'duration': 44}, {'task': 1, 'start': 45, 'machine': 1, 'duration': 4}, {'task': 2, 'start': 101, 'machine': 2, 'duration': 57}]}, {'job': 2, 'tasks': [{'task': 0, 'start': 140, 'machine': 0, 'duration': 91}, {'task': 1, 'start': 231, 'machine': 1, 'duration': 9}, {'task': 2, 'start': 240, 'machine': 2, 'duration': 12}]}, {'job': 3, 'tasks': [{'task': 0, 'start': 45, 'machine': 0, 'duration': 95}, {'task': 1, 'start': 140, 'machine': 1, 'duration': 77}, {'task': 2, 'start': 217, 'machine': 2, 'duration': 21}]}]",252.0,"{'problem_type': 'FSP', 'nr_jobs': 4, 'nr_machines': 3, 'jobs': ['J1', 'J2', 'J3', 'J4'], 'machines': [1, 2, 3], 'records': [{'job_id': 'J1', 'task_id': 0, 'machine_id': 1, 'duration': 1}, {'job_id': 'J1', 'task_id': 1, 'machine_id': 2, 'duration': 16}, {'job_id': 'J1', 'task_id': 2, 'machine_id': 3, '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': 1, 'duration': 91}, {'job_id': 'J3', 'task_id': 1, 'machine_id': 2, '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': 2, 'duration': 77}, {'job_id': 'J4', 'task_id': 2, 'machine_id': 3, 'duration': 21}]}","[{'job': 'J1', 'tasks': [{'task': 0, 'start': 0, 'machine': 1, 'duration': 1}, {'task': 1, 'start': 1, 'machine': 2, 'duration': 16}, {'task': 2, 'start': 17, 'machine': 3, 'duration': 84}]}, {'job': 'J2', 'tasks': [{'task': 0, 'start': 1, 'machine': 1, 'duration': 44}, {'task': 1, 'start': 45, 'machine': 2, 'duration': 4}, {'task': 2, 'start': 101, 'machine': 3, 'duration': 57}]}, {'job': 'J3', 'tasks': [{'task': 0, 'start': 140, 'machine': 1, 'duration': 91}, {'task': 1, 'start': 231, 'machine': 2, 'duration': 9}, {'task': 2, 'start': 240, 'machine': 3, 'duration': 12}]}, {'job': 'J4', 'tasks': [{'task': 0, 'start': 45, 'machine': 1, 'duration': 95}, {'task': 1, 'start': 140, 'machine': 2, 'duration': 77}, {'task': 2, 'start': 217, 'machine': 3, 'duration': 21}]}]",21,json,1
FSP,FSP,"That afternoon the café had back-to-back orders and the only workflow is espresso first, then milk, then finishing — always in that order for each order. The job is to decide the order of operations so the espresso machine, steamer, and assembly table aren’t booked by overlapping drinks, and every order gets each step exactly once. The better the plan, the earlier the last drink is finished — the completion time of the final cup is how success is measured. The concrete order details and prep durations follow below.

{
  ""orders_count"": 3,
  ""stations_count"": 2,
  ""orders_list"": [
    ""J1"",
    ""J2"",
    ""J3""
  ],
  ""stations_list"": [
    1,
    2
  ],
  ""tasks"": [
    {
      ""order_id"": ""J1"",
      ""step_index"": 0,
      ""station_id"": 1,
      ""step_duration"": 1
    },
    {
      ""order_id"": ""J1"",
      ""step_index"": 1,
      ""station_id"": 2,
      ""step_duration"": 29
    },
    {
      ""order_id"": ""J2"",
      ""step_index"": 0,
      ""station_id"": 1,
      ""step_duration"": 60
    },
    {
      ""order_id"": ""J2"",
      ""step_index"": 1,
      ""station_id"": 2,
      ""step_duration"": 89
    },
    {
      ""order_id"": ""J3"",
      ""step_index"": 0,
      ""station_id"": 1,
      ""step_duration"": 56
    },
    {
      ""order_id"": ""J3"",
      ""step_index"": 1,
      ""station_id"": 2,
      ""step_duration"": 79
    }
  ]
}

Oh, and one more thing — when you send the plan back, please keep it in a simple JSON shape so it's easy to read by humans and machines alike. Something like this is what I expect:

{
  ""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 want, not the actual schedule. In plain terms: each top-level ""job"" is one drink/order, ""tasks"" is the list of steps that drink needs (espresso, milk, assembly), ""task"" is which step in the sequence, ""start"" is when that step begins, ""machine"" names the station doing the step, and ""duration"" is how long that step takes.

Please use the exact identifiers that 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': 2, 'nr_jobs': 3, 'jobs': [[[0, 1], [1, 29]], [[0, 60], [1, 89]], [[0, 56], [1, 79]]]}","[{'job': 0, 'tasks': [{'task': 0, 'start': 0, 'machine': 0, 'duration': 1}, {'task': 1, 'start': 1, 'machine': 1, 'duration': 29}]}, {'job': 1, 'tasks': [{'task': 0, 'start': 57, 'machine': 0, 'duration': 60}, {'task': 1, 'start': 136, 'machine': 1, 'duration': 89}]}, {'job': 2, 'tasks': [{'task': 0, 'start': 1, 'machine': 0, 'duration': 56}, {'task': 1, 'start': 57, 'machine': 1, 'duration': 79}]}]",225.0,"{'problem_type': 'FSP', 'nr_jobs': 3, 'nr_machines': 2, 'jobs': ['J1', 'J2', 'J3'], 'machines': [1, 2], 'records': [{'job_id': 'J1', 'task_id': 0, 'machine_id': 1, 'duration': 1}, {'job_id': 'J1', 'task_id': 1, 'machine_id': 2, 'duration': 29}, {'job_id': 'J2', 'task_id': 0, 'machine_id': 1, 'duration': 60}, {'job_id': 'J2', 'task_id': 1, 'machine_id': 2, 'duration': 89}, {'job_id': 'J3', 'task_id': 0, 'machine_id': 1, 'duration': 56}, {'job_id': 'J3', 'task_id': 1, 'machine_id': 2, 'duration': 79}]}","[{'job': 'J1', 'tasks': [{'task': 0, 'start': 0, 'machine': 1, 'duration': 1}, {'task': 1, 'start': 1, 'machine': 2, 'duration': 29}]}, {'job': 'J2', 'tasks': [{'task': 0, 'start': 57, 'machine': 1, 'duration': 60}, {'task': 1, 'start': 136, 'machine': 2, 'duration': 89}]}, {'job': 'J3', 'tasks': [{'task': 0, 'start': 1, 'machine': 1, 'duration': 56}, {'task': 1, 'start': 57, 'machine': 2, 'duration': 79}]}]",22,json,1
FSP,FSP,"We try to keep the shop humming by sending each job through layout, printing, and binding in sequence, never changing the order of those stages. The job is to pick an order for the runs so no press or binder is asked to do two things at the same time and nothing is skipped or repeated. A good order is simply the one that makes the last job finish as early as possible — the finishing time of that last piece tells us how well we did. The concrete job details and timings are listed below.

There are 2 runs and 2 machines; the runs are J1, J2 and the machines are 0, 1.
Job J1, stage 0: requires 1 on 0.
Job J1, stage 1: requires 42 on 1.
Job J2, stage 0: requires 36 on 0.
Job J2, stage 1: requires 36 on 1.
We judge schedules by the finishing time of the last job.

And when you're ready to hand back the actual schedule, a little heads-up: I like to see it in this simple JSON shape so it's easy to check by eye or by a quick script.

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

Think of that as a short form: ""solution"" is the list of jobs, each job gets its id and a list of its tasks. For each task we want the task index (which step it is), the start time when that step begins, the machine it's done on, and how long it takes. Easy to read, like filling out a little schedule card.

This is just a sketch of the shape I expect — please return the actual schedule following this layout.

Please also make sure to use the exact identifiers shown in the instance input — don't rename them or invent new labels. Valid identifiers look like plain numbers such as “1” or “23”, single capital letters like “A” or “B”, or a capital letter followed by digits like “A1” or “X7”.","{'nr_machines': 2, 'nr_jobs': 2, 'jobs': [[[0, 1], [1, 42]], [[0, 36], [1, 36]]]}","[{'job': 0, 'tasks': [{'task': 0, 'start': 0, 'machine': 0, 'duration': 1}, {'task': 1, 'start': 1, 'machine': 1, 'duration': 42}]}, {'job': 1, 'tasks': [{'task': 0, 'start': 1, 'machine': 0, 'duration': 36}, {'task': 1, 'start': 43, 'machine': 1, 'duration': 36}]}]",79.0,"{'problem_type': 'FSP', 'nr_jobs': 2, 'nr_machines': 2, 'jobs': ['J1', 'J2'], 'machines': [0, 1], 'records': [{'job_id': 'J1', 'task_id': 0, 'machine_id': 0, 'duration': 1}, {'job_id': 'J1', 'task_id': 1, 'machine_id': 1, 'duration': 42}, {'job_id': 'J2', 'task_id': 0, 'machine_id': 0, 'duration': 36}, {'job_id': 'J2', 'task_id': 1, 'machine_id': 1, 'duration': 36}]}","[{'job': 'J1', 'tasks': [{'task': 0, 'start': 0, 'machine': 0, 'duration': 1}, {'task': 1, 'start': 1, 'machine': 1, 'duration': 42}]}, {'job': 'J2', 'tasks': [{'task': 0, 'start': 1, 'machine': 0, 'duration': 36}, {'task': 1, 'start': 43, 'machine': 1, 'duration': 36}]}]",23,nl,0
FSP,FSP,"We manage a studio schedule where every vessel must be shaped, left to dry, and then fired, always following the same three-stage sequence. The decision is how to order the pieces on the bench and in the kiln so no bench or kiln session overlaps for different pots, and every step happens exactly once per piece. What counts as a better choice is the one that gets the final piece done sooner — measured by the time the last pot is finished. The specific batch sizes and timings are given below.

We have 4 vessels and 2 stations: J1, J2, J3, J4; stations in order: A, B.
We schedule vessel J1 stage 0 on A for 1.
We schedule vessel J1 stage 1 on B for 55.
We schedule vessel J2 stage 0 on A for 12.
We schedule vessel J2 stage 1 on B for 81.
We schedule vessel J3 stage 0 on A for 63.
We schedule vessel J3 stage 1 on B for 24.
We schedule vessel J4 stage 0 on A for 6.
We schedule vessel J4 stage 1 on B for 13.
We seek the schedule that finishes the last pot as early as possible.

Also, when you return the schedule, please use this JSON layout so everything lines up nicely:

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

Quick note on what the fields mean in plain terms: ""solution"" is the list of all pieces; each entry is one piece (""job"") and its sequence of steps (""tasks""). Each task shows which step it is (""task""), when that step starts (""start""), which workspace or oven it uses (""machine""), and how long that step takes (""duration""). This JSON is just the shape I need — not the actual schedule yet.

Please make sure to use the exact identifiers from the instance input, with no renaming or extra labels. 
- for example: ""Valid identifiers look like plain numbers such as “1” or “23”, single capital letters like “A” or “B”, or a capital letter followed by digits like “A1” or “X7”. ""","{'nr_machines': 2, 'nr_jobs': 4, 'jobs': [[[0, 1], [1, 55]], [[0, 12], [1, 81]], [[0, 63], [1, 24]], [[0, 6], [1, 13]]]}","[{'job': 0, 'tasks': [{'task': 0, 'start': 0, 'machine': 0, 'duration': 1}, {'task': 1, 'start': 1, 'machine': 1, 'duration': 55}]}, {'job': 1, 'tasks': [{'task': 0, 'start': 1, 'machine': 0, 'duration': 12}, {'task': 1, 'start': 56, 'machine': 1, 'duration': 81}]}, {'job': 2, 'tasks': [{'task': 0, 'start': 13, 'machine': 0, 'duration': 63}, {'task': 1, 'start': 137, 'machine': 1, 'duration': 24}]}, {'job': 3, 'tasks': [{'task': 0, 'start': 76, 'machine': 0, 'duration': 6}, {'task': 1, 'start': 161, 'machine': 1, 'duration': 13}]}]",174.0,"{'problem_type': 'FSP', 'nr_jobs': 4, 'nr_machines': 2, 'jobs': ['J1', 'J2', 'J3', 'J4'], 'machines': ['A', 'B'], 'records': [{'job_id': 'J1', 'task_id': 0, 'machine_id': 'A', 'duration': 1}, {'job_id': 'J1', 'task_id': 1, 'machine_id': 'B', 'duration': 55}, {'job_id': 'J2', 'task_id': 0, 'machine_id': 'A', 'duration': 12}, {'job_id': 'J2', 'task_id': 1, 'machine_id': 'B', 'duration': 81}, {'job_id': 'J3', 'task_id': 0, 'machine_id': 'A', 'duration': 63}, {'job_id': 'J3', 'task_id': 1, 'machine_id': 'B', 'duration': 24}, {'job_id': 'J4', 'task_id': 0, 'machine_id': 'A', 'duration': 6}, {'job_id': 'J4', 'task_id': 1, 'machine_id': 'B', 'duration': 13}]}","[{'job': 'J1', 'tasks': [{'task': 0, 'start': 0, 'machine': 'A', 'duration': 1}, {'task': 1, 'start': 1, 'machine': 'B', 'duration': 55}]}, {'job': 'J2', 'tasks': [{'task': 0, 'start': 1, 'machine': 'A', 'duration': 12}, {'task': 1, 'start': 56, 'machine': 'B', 'duration': 81}]}, {'job': 'J3', 'tasks': [{'task': 0, 'start': 13, 'machine': 'A', 'duration': 63}, {'task': 1, 'start': 137, 'machine': 'B', 'duration': 24}]}, {'job': 'J4', 'tasks': [{'task': 0, 'start': 76, 'machine': 'A', 'duration': 6}, {'task': 1, 'start': 161, 'machine': 'B', 'duration': 13}]}]",24,nl,names
FSP,FSP,"Recently the shop was swamped and the lead had to figure out how to queue phones through inspection, repair, and testing without letting any station work on more than one phone at a time. The problem is choosing the order every phone goes through those three stops, making sure each phone is checked, fixed, and tested once and not repeated, so the whole batch finishes sooner rather than later. Performance is measured by the time the last phone finishes testing — you can compute that by noting every phone’s finish time and taking the largest one — and the goal is to make that as small as possible. The specific job list and step times follow below.

There are 3 devices to route through 2 sequential workstations; device ids: J1, J2, J3; workstation ids: 0, 1.
Device J1, step 0 requires workstation 0 for 1 time units.
Device J1, step 1 requires workstation 1 for 68 time units.
Device J2, step 0 requires workstation 0 for 87 time units.
Device J2, step 1 requires workstation 1 for 27 time units.
Device J3, step 0 requires workstation 0 for 17 time units.
Device J3, step 1 requires workstation 1 for 45 time units.
The lead will use the listed step times to compute each device’s finish time and minimize the final makespan.

Also, when you send the actual schedule back, please stick to a simple JSON layout like this 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 just says: ""solution"" is a list of jobs; each job has an id and a list of its tasks; each task entry gives which step (task), when it starts, which machine it runs on, and how long it takes. Think of it like filling out a simple form for each phone: job = which phone, tasks = the checkpoints with start times, machines, and durations.

Note that the JSON above is only the expected shape — it's a template, not the actual schedule. Also, please use the exact identifiers from the instance input with no renaming and no extra labels. Valid identifiers look like plain numbers such as ""1"" or ""23"", single capital letters like ""A"" or ""B"", or a capital letter followed by digits like ""A1"" or ""X7"".","{'nr_machines': 2, 'nr_jobs': 3, 'jobs': [[[0, 1], [1, 68]], [[0, 87], [1, 27]], [[0, 17], [1, 45]]]}","[{'job': 0, 'tasks': [{'task': 0, 'start': 0, 'machine': 0, 'duration': 1}, {'task': 1, 'start': 1, 'machine': 1, 'duration': 68}]}, {'job': 1, 'tasks': [{'task': 0, 'start': 18, 'machine': 0, 'duration': 87}, {'task': 1, 'start': 114, 'machine': 1, 'duration': 27}]}, {'job': 2, 'tasks': [{'task': 0, 'start': 1, 'machine': 0, 'duration': 17}, {'task': 1, 'start': 69, 'machine': 1, 'duration': 45}]}]",141.0,"{'problem_type': 'FSP', 'nr_jobs': 3, 'nr_machines': 2, 'jobs': ['J1', 'J2', 'J3'], 'machines': [0, 1], 'records': [{'job_id': 'J1', 'task_id': 0, 'machine_id': 0, 'duration': 1}, {'job_id': 'J1', 'task_id': 1, 'machine_id': 1, 'duration': 68}, {'job_id': 'J2', 'task_id': 0, 'machine_id': 0, 'duration': 87}, {'job_id': 'J2', 'task_id': 1, 'machine_id': 1, 'duration': 27}, {'job_id': 'J3', 'task_id': 0, 'machine_id': 0, 'duration': 17}, {'job_id': 'J3', 'task_id': 1, 'machine_id': 1, 'duration': 45}]}","[{'job': 'J1', 'tasks': [{'task': 0, 'start': 0, 'machine': 0, 'duration': 1}, {'task': 1, 'start': 1, 'machine': 1, 'duration': 68}]}, {'job': 'J2', 'tasks': [{'task': 0, 'start': 18, 'machine': 0, 'duration': 87}, {'task': 1, 'start': 114, 'machine': 1, 'duration': 27}]}, {'job': 'J3', 'tasks': [{'task': 0, 'start': 1, 'machine': 0, 'duration': 17}, {'task': 1, 'start': 69, 'machine': 1, 'duration': 45}]}]",25,nl,0
FSP,FSP,"Back at the shop, there’s a rhythm: every bike goes inspection → adjustment → road check, always in that sequence, and bays can’t work on overlapping bikes. The decision is how to sequence and time each bike through those stations so nothing is missed or duplicated and no bay is double-booked. The best arrangement is the one where the final bike finishes earliest — that final completion time is how we’ll compare options. The exact job details appear below.

We have 5 bikes to run through 3 bays: the bike identifiers are J1, J2, J3, J4, J5 and the bay identifiers are 0, 1, 2.
For bike J1, service step 0 runs on bay 0 and requires 1.
For bike J1, service step 1 runs on bay 1 and requires 81.
For bike J1, service step 2 runs on bay 2 and requires 62.
For bike J2, service step 0 runs on bay 0 and requires 73.
For bike J2, service step 1 runs on bay 1 and requires 69.
For bike J2, service step 2 runs on bay 2 and requires 67.
For bike J3, service step 0 runs on bay 0 and requires 16.
For bike J3, service step 1 runs on bay 1 and requires 48.
For bike J3, service step 2 runs on bay 2 and requires 51.
For bike J4, service step 0 runs on bay 0 and requires 62.
For bike J4, service step 1 runs on bay 1 and requires 69.
For bike J4, service step 2 runs on bay 2 and requires 80.
For bike J5, service step 0 runs on bay 0 and requires 67.
For bike J5, service step 1 runs on bay 1 and requires 32.
For bike J5, service step 2 runs on bay 2 and requires 58.
Keep the inspection → adjustment → road check order for all 5 bikes across the 3 bays; we’ll judge schedules by when the last bike finishes.

Also, to keep things tidy, please reply using this JSON shape so I can read the schedule easily:

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

Quick, laid-back guide to the fields:
- ""solution"" is a list of jobs (each bike).
- Each job entry has ""job"" for the job identifier and a ""tasks"" list.
- Each task lists the task index (which step in the bike's sequence), the planned start time, which machine (bay/station) it runs on, and how long that step takes.
This JSON is just a sketch of the shape I want back — not the real schedule itself.

Please make sure to use the exact identifiers from the instance input, with 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': 5, 'jobs': [[[0, 1], [1, 81], [2, 62]], [[0, 73], [1, 69], [2, 67]], [[0, 16], [1, 48], [2, 51]], [[0, 62], [1, 69], [2, 80]], [[0, 67], [1, 32], [2, 58]]]}","[{'job': 0, 'tasks': [{'task': 0, 'start': 0, 'machine': 0, 'duration': 1}, {'task': 1, 'start': 1, 'machine': 1, 'duration': 81}, {'task': 2, 'start': 82, 'machine': 2, 'duration': 62}]}, {'job': 1, 'tasks': [{'task': 0, 'start': 130, 'machine': 0, 'duration': 73}, {'task': 1, 'start': 203, 'machine': 1, 'duration': 69}, {'task': 2, 'start': 282, 'machine': 2, 'duration': 67}]}, {'job': 2, 'tasks': [{'task': 0, 'start': 203, 'machine': 0, 'duration': 16}, {'task': 1, 'start': 272, 'machine': 1, 'duration': 48}, {'task': 2, 'start': 349, 'machine': 2, 'duration': 51}]}, {'job': 3, 'tasks': [{'task': 0, 'start': 68, 'machine': 0, 'duration': 62}, {'task': 1, 'start': 130, 'machine': 1, 'duration': 69}, {'task': 2, 'start': 202, 'machine': 2, 'duration': 80}]}, {'job': 4, 'tasks': [{'task': 0, 'start': 1, 'machine': 0, 'duration': 67}, {'task': 1, 'start': 82, 'machine': 1, 'duration': 32}, {'task': 2, 'start': 144, 'machine': 2, 'duration': 58}]}]",400.0,"{'problem_type': 'FSP', 'nr_jobs': 5, 'nr_machines': 3, 'jobs': ['J1', 'J2', 'J3', 'J4', 'J5'], 'machines': [0, 1, 2], 'records': [{'job_id': 'J1', 'task_id': 0, 'machine_id': 0, 'duration': 1}, {'job_id': 'J1', 'task_id': 1, 'machine_id': 1, 'duration': 81}, {'job_id': 'J1', 'task_id': 2, 'machine_id': 2, 'duration': 62}, {'job_id': 'J2', 'task_id': 0, 'machine_id': 0, 'duration': 73}, {'job_id': 'J2', 'task_id': 1, 'machine_id': 1, 'duration': 69}, {'job_id': 'J2', 'task_id': 2, 'machine_id': 2, 'duration': 67}, {'job_id': 'J3', 'task_id': 0, 'machine_id': 0, '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': 0, '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': 0, 'duration': 67}, {'job_id': 'J5', 'task_id': 1, 'machine_id': 1, 'duration': 32}, {'job_id': 'J5', 'task_id': 2, 'machine_id': 2, 'duration': 58}]}","[{'job': 'J1', 'tasks': [{'task': 0, 'start': 0, 'machine': 0, 'duration': 1}, {'task': 1, 'start': 1, 'machine': 1, 'duration': 81}, {'task': 2, 'start': 82, 'machine': 2, 'duration': 62}]}, {'job': 'J2', 'tasks': [{'task': 0, 'start': 130, 'machine': 0, 'duration': 73}, {'task': 1, 'start': 203, 'machine': 1, 'duration': 69}, {'task': 2, 'start': 282, 'machine': 2, 'duration': 67}]}, {'job': 'J3', 'tasks': [{'task': 0, 'start': 203, 'machine': 0, 'duration': 16}, {'task': 1, 'start': 272, 'machine': 1, 'duration': 48}, {'task': 2, 'start': 349, 'machine': 2, 'duration': 51}]}, {'job': 'J4', 'tasks': [{'task': 0, 'start': 68, 'machine': 0, 'duration': 62}, {'task': 1, 'start': 130, 'machine': 1, 'duration': 69}, {'task': 2, 'start': 202, 'machine': 2, 'duration': 80}]}, {'job': 'J5', 'tasks': [{'task': 0, 'start': 1, 'machine': 0, 'duration': 67}, {'task': 1, 'start': 82, 'machine': 1, 'duration': 32}, {'task': 2, 'start': 144, 'machine': 2, 'duration': 58}]}]",26,nl,0
FSP,FSP,"There’s a stack of shirts, dresses, and coats that all need the same three stops in order — spot treatment, a wash, then a press — and each stop takes a set amount of time per item. Since each machine handles one garment at a time, the trick is deciding the sequence to feed them through so the last garment is done as early as possible; the finish time of that last piece is how to tell if the plan is better. Everything must go through each step exactly once, and no two garments can use the same machine simultaneously. The concrete details for this batch appear below.

# num_garments=5
# num_stations=3
# garment_ids=J1, J2, J3, J4, J5
# station_ids=1, 2, 3
garment_id,stage_index,station_id,processing_time
J1,0,1,1
J1,1,2,94
J1,2,3,38
J2,0,1,19
J2,1,2,23
J2,2,3,89
J3,0,1,20
J3,1,2,17
J3,2,3,20
J4,0,1,56
J4,1,2,8
J4,2,3,32
J5,0,1,51
J5,1,2,35
J5,2,3,63

You can just follow this simple JSON layout when you send the actual schedule — nothing fancy, just a tidy form that lists each garment (job) and the tasks it goes through with timings 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 little checklist: ""solution"" holds all the garments, each garment has a ""job"" identifier and a ""tasks"" list, and each task entry tells you which step it is (""task""), when that step begins (""start""), which station handles it (""machine""), and how long it takes (""duration""). Super casual — it's just a way to keep everything consistent.

This JSON is just a sketch of the shape I need, not the actual scheduled times. 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': 5, 'jobs': [[[0, 1], [1, 94], [2, 38]], [[0, 19], [1, 23], [2, 89]], [[0, 20], [1, 17], [2, 20]], [[0, 56], [1, 8], [2, 32]], [[0, 51], [1, 35], [2, 63]]]}","[{'job': 0, 'tasks': [{'task': 0, 'start': 39, 'machine': 0, 'duration': 1}, {'task': 1, 'start': 59, 'machine': 1, 'duration': 94}, {'task': 2, 'start': 153, 'machine': 2, 'duration': 38}]}, {'job': 1, 'tasks': [{'task': 0, 'start': 0, 'machine': 0, 'duration': 19}, {'task': 1, 'start': 19, 'machine': 1, 'duration': 23}, {'task': 2, 'start': 42, 'machine': 2, 'duration': 89}]}, {'job': 2, 'tasks': [{'task': 0, 'start': 19, 'machine': 0, 'duration': 20}, {'task': 1, 'start': 42, 'machine': 1, 'duration': 17}, {'task': 2, 'start': 131, 'machine': 2, 'duration': 20}]}, {'job': 3, 'tasks': [{'task': 0, 'start': 40, 'machine': 0, 'duration': 56}, {'task': 1, 'start': 153, 'machine': 1, 'duration': 8}, {'task': 2, 'start': 191, 'machine': 2, 'duration': 32}]}, {'job': 4, 'tasks': [{'task': 0, 'start': 96, 'machine': 0, 'duration': 51}, {'task': 1, 'start': 161, 'machine': 1, 'duration': 35}, {'task': 2, 'start': 223, 'machine': 2, 'duration': 63}]}]",286.0,"{'problem_type': 'FSP', 'nr_jobs': 5, 'nr_machines': 3, 'jobs': ['J1', 'J2', 'J3', 'J4', 'J5'], 'machines': [1, 2, 3], 'records': [{'job_id': 'J1', 'task_id': 0, 'machine_id': 1, 'duration': 1}, {'job_id': 'J1', 'task_id': 1, 'machine_id': 2, 'duration': 94}, {'job_id': 'J1', 'task_id': 2, 'machine_id': 3, 'duration': 38}, {'job_id': 'J2', 'task_id': 0, 'machine_id': 1, 'duration': 19}, {'job_id': 'J2', 'task_id': 1, 'machine_id': 2, 'duration': 23}, {'job_id': 'J2', 'task_id': 2, 'machine_id': 3, 'duration': 89}, {'job_id': 'J3', 'task_id': 0, 'machine_id': 1, 'duration': 20}, {'job_id': 'J3', 'task_id': 1, 'machine_id': 2, 'duration': 17}, {'job_id': 'J3', 'task_id': 2, 'machine_id': 3, 'duration': 20}, {'job_id': 'J4', 'task_id': 0, 'machine_id': 1, 'duration': 56}, {'job_id': 'J4', 'task_id': 1, 'machine_id': 2, 'duration': 8}, {'job_id': 'J4', 'task_id': 2, 'machine_id': 3, 'duration': 32}, {'job_id': 'J5', 'task_id': 0, 'machine_id': 1, 'duration': 51}, {'job_id': 'J5', 'task_id': 1, 'machine_id': 2, 'duration': 35}, {'job_id': 'J5', 'task_id': 2, 'machine_id': 3, 'duration': 63}]}","[{'job': 'J1', 'tasks': [{'task': 0, 'start': 39, 'machine': 1, 'duration': 1}, {'task': 1, 'start': 59, 'machine': 2, 'duration': 94}, {'task': 2, 'start': 153, 'machine': 3, 'duration': 38}]}, {'job': 'J2', 'tasks': [{'task': 0, 'start': 0, 'machine': 1, 'duration': 19}, {'task': 1, 'start': 19, 'machine': 2, 'duration': 23}, {'task': 2, 'start': 42, 'machine': 3, 'duration': 89}]}, {'job': 'J3', 'tasks': [{'task': 0, 'start': 19, 'machine': 1, 'duration': 20}, {'task': 1, 'start': 42, 'machine': 2, 'duration': 17}, {'task': 2, 'start': 131, 'machine': 3, 'duration': 20}]}, {'job': 'J4', 'tasks': [{'task': 0, 'start': 40, 'machine': 1, 'duration': 56}, {'task': 1, 'start': 153, 'machine': 2, 'duration': 8}, {'task': 2, 'start': 191, 'machine': 3, 'duration': 32}]}, {'job': 'J5', 'tasks': [{'task': 0, 'start': 96, 'machine': 1, 'duration': 51}, {'task': 1, 'start': 161, 'machine': 2, 'duration': 35}, {'task': 2, 'start': 223, 'machine': 3, 'duration': 63}]}]",27,csv,1
FSP,FSP,"There’s this constant puzzle at the studio: scenes move from shooting to a rough cut and finally to color, and they must all follow that same route. The task is picking the sequence so that no single editing or grading room gets two scenes at the same time. What matters is finishing the whole package as quickly as possible — checked by the time the last scene exits color grading. Every scene has to go through each of the three stages exactly once; details about durations and rooms follow below.

Below are the details for the 3 scenes and the 3 rooms: scene ids J1, J2, J3; room ids 0, 1, 2.
Scene J1, stage 0, requires room 0 for 1.
Scene J1, stage 1, requires room 1 for 8.
Scene J1, stage 2, requires room 2 for 14.
Scene J2, stage 0, requires room 0 for 65.
Scene J2, stage 1, requires room 1 for 76.
Scene J2, stage 2, requires room 2 for 11.
Scene J3, stage 0, requires room 0 for 25.
Scene J3, stage 1, requires room 1 for 84.
Scene J3, stage 2, requires room 2 for 87.
The aim is to sequence these entries so no room is double-booked and the last scene exits color grading as soon as possible.

Oh, and one more thing — when you send the schedule back, it'd be great if you follow a simple JSON layout so it's easy to read and parse. Something like this:

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

This just shows the shape I expect: each top-level entry is a job (a scene), inside each job there's a list of tasks (the three stages), and each task has when it starts, which room it uses, and how long it takes. It's just a template — not the actual schedule.

Please 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': 3, 'nr_jobs': 3, 'jobs': [[[0, 1], [1, 8], [2, 14]], [[0, 65], [1, 76], [2, 11]], [[0, 25], [1, 84], [2, 87]]]}","[{'job': 0, 'tasks': [{'task': 0, 'start': 0, 'machine': 0, 'duration': 1}, {'task': 1, 'start': 1, 'machine': 1, 'duration': 8}, {'task': 2, 'start': 9, 'machine': 2, 'duration': 14}]}, {'job': 1, 'tasks': [{'task': 0, 'start': 26, 'machine': 0, 'duration': 65}, {'task': 1, 'start': 110, 'machine': 1, 'duration': 76}, {'task': 2, 'start': 197, 'machine': 2, 'duration': 11}]}, {'job': 2, 'tasks': [{'task': 0, 'start': 1, 'machine': 0, 'duration': 25}, {'task': 1, 'start': 26, 'machine': 1, 'duration': 84}, {'task': 2, 'start': 110, 'machine': 2, 'duration': 87}]}]",208.0,"{'problem_type': 'FSP', 'nr_jobs': 3, 'nr_machines': 3, 'jobs': ['J1', 'J2', 'J3'], 'machines': [0, 1, 2], 'records': [{'job_id': 'J1', 'task_id': 0, 'machine_id': 0, 'duration': 1}, {'job_id': 'J1', 'task_id': 1, 'machine_id': 1, 'duration': 8}, {'job_id': 'J1', 'task_id': 2, 'machine_id': 2, 'duration': 14}, {'job_id': 'J2', 'task_id': 0, 'machine_id': 0, 'duration': 65}, {'job_id': 'J2', 'task_id': 1, 'machine_id': 1, 'duration': 76}, {'job_id': 'J2', 'task_id': 2, 'machine_id': 2, 'duration': 11}, {'job_id': 'J3', 'task_id': 0, 'machine_id': 0, 'duration': 25}, {'job_id': 'J3', 'task_id': 1, 'machine_id': 1, 'duration': 84}, {'job_id': 'J3', 'task_id': 2, 'machine_id': 2, 'duration': 87}]}","[{'job': 'J1', 'tasks': [{'task': 0, 'start': 0, 'machine': 0, 'duration': 1}, {'task': 1, 'start': 1, 'machine': 1, 'duration': 8}, {'task': 2, 'start': 9, 'machine': 2, 'duration': 14}]}, {'job': 'J2', 'tasks': [{'task': 0, 'start': 26, 'machine': 0, 'duration': 65}, {'task': 1, 'start': 110, 'machine': 1, 'duration': 76}, {'task': 2, 'start': 197, 'machine': 2, 'duration': 11}]}, {'job': 'J3', 'tasks': [{'task': 0, 'start': 1, 'machine': 0, 'duration': 25}, {'task': 1, 'start': 26, 'machine': 1, 'duration': 84}, {'task': 2, 'start': 110, 'machine': 2, 'duration': 87}]}]",28,nl,0
FSP,FSP,"As the teacher juggling multiple lab groups, the routine is the same for everyone — setup, run the experiment, then clean up — and no bench can take two groups at once. What needs deciding is the order and timing of those starts so the whole rotation wraps up fast. The thing to look at is the clock time when the final group is done cleaning: whoever finishes sooner wins in practice. Each group has set durations for the three parts, nothing is omitted or repeated, and the exact numbers are given below.

There are 4 student groups and 2 lab benches; the group ids are J1, J2, J3, J4 and the bench ids are 0, 1.
Group J1, step 0 uses bench 0 for 1 minutes.
Group J1, step 1 uses bench 1 for 21 minutes.
Group J2, step 0 uses bench 0 for 89 minutes.
Group J2, step 1 uses bench 1 for 11 minutes.
Group J3, step 0 uses bench 0 for 30 minutes.
Group J3, step 1 uses bench 1 for 33 minutes.
Group J4, step 0 uses bench 0 for 30 minutes.
Group J4, step 1 uses bench 1 for 52 minutes.
Keep the goal in mind: minimize the clock time when the final group finishes cleaning.

Also, when you send the actual plan, please put it in 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>
        }
      ]
    }
  ]
}

Think of that JSON as a little form: ""solution"" holds a list of groups (jobs), each group gets a job id and a list of its steps. Each step (task) just records which numbered step it is, when it starts, which bench (machine) it uses, and how long it takes. It's just a sketch of the shape I need — not the real filled-in answer.

Please be 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': [[[0, 1], [1, 21]], [[0, 89], [1, 11]], [[0, 30], [1, 33]], [[0, 30], [1, 52]]]}","[{'job': 0, 'tasks': [{'task': 0, 'start': 0, 'machine': 0, 'duration': 1}, {'task': 1, 'start': 1, 'machine': 1, 'duration': 21}]}, {'job': 1, 'tasks': [{'task': 0, 'start': 61, 'machine': 0, 'duration': 89}, {'task': 1, 'start': 150, 'machine': 1, 'duration': 11}]}, {'job': 2, 'tasks': [{'task': 0, 'start': 31, 'machine': 0, 'duration': 30}, {'task': 1, 'start': 83, 'machine': 1, 'duration': 33}]}, {'job': 3, 'tasks': [{'task': 0, 'start': 1, 'machine': 0, 'duration': 30}, {'task': 1, 'start': 31, 'machine': 1, 'duration': 52}]}]",161.0,"{'problem_type': 'FSP', 'nr_jobs': 4, 'nr_machines': 2, 'jobs': ['J1', 'J2', 'J3', 'J4'], 'machines': [0, 1], 'records': [{'job_id': 'J1', 'task_id': 0, 'machine_id': 0, 'duration': 1}, {'job_id': 'J1', 'task_id': 1, 'machine_id': 1, 'duration': 21}, {'job_id': 'J2', 'task_id': 0, 'machine_id': 0, 'duration': 89}, {'job_id': 'J2', 'task_id': 1, 'machine_id': 1, 'duration': 11}, {'job_id': 'J3', 'task_id': 0, 'machine_id': 0, 'duration': 30}, {'job_id': 'J3', 'task_id': 1, 'machine_id': 1, 'duration': 33}, {'job_id': 'J4', 'task_id': 0, 'machine_id': 0, 'duration': 30}, {'job_id': 'J4', 'task_id': 1, 'machine_id': 1, 'duration': 52}]}","[{'job': 'J1', 'tasks': [{'task': 0, 'start': 0, 'machine': 0, 'duration': 1}, {'task': 1, 'start': 1, 'machine': 1, 'duration': 21}]}, {'job': 'J2', 'tasks': [{'task': 0, 'start': 61, 'machine': 0, 'duration': 89}, {'task': 1, 'start': 150, 'machine': 1, 'duration': 11}]}, {'job': 'J3', 'tasks': [{'task': 0, 'start': 31, 'machine': 0, 'duration': 30}, {'task': 1, 'start': 83, 'machine': 1, 'duration': 33}]}, {'job': 'J4', 'tasks': [{'task': 0, 'start': 1, 'machine': 0, 'duration': 30}, {'task': 1, 'start': 31, 'machine': 1, 'duration': 52}]}]",29,nl,0
FSP,FSP,"Recently the nursery has been juggling batches of saplings through potting, fertilizing, and then shading, and it’s clear the stations can’t share work at the same time. The task is to arrange the processing order and start times so each plant goes through those three steps in order, nobody skips a step, and no workstation is asked to handle two plants simultaneously. The way to compare plans is simple: look at the time the final sapling is completed (when it leaves the shading station) — the earlier that finish time, the better the plan. Concrete task durations and the batch list are given below.

Concretely, the batch contains 4 saplings to process through 2 stations; sapling ids: J1, J2, J3, J4; station sequence: 1, 2.
Sapling J1, step 0, needs station 1 for 1 time units.
Sapling J1, step 1, needs station 2 for 34 time units.
Sapling J2, step 0, needs station 1 for 65 time units.
Sapling J2, step 1, needs station 2 for 56 time units.
Sapling J3, step 0, needs station 1 for 82 time units.
Sapling J3, step 1, needs station 2 for 55 time units.
Sapling J4, step 0, needs station 1 for 34 time units.
Sapling J4, step 1, needs station 2 for 20 time units.
Respect these task entries so every sapling follows the three-step sequence without station overlap; the plan that minimizes the completion time of the last sapling is best.

If you want the plan in a machine-friendly form (or just to keep things tidy), I usually lay it out in a little JSON shape 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"" is a list of the plants (jobs), each entry names the job and then lists its tasks in order. Each task entry has the task number, when it starts, which station (machine) it uses, and how long it runs. Super informal: it’s just a way to say “this job does task 1 on machine A at time 5 for 10 minutes,” but in a neat, copy-pasteable format.

This JSON is only a sketch of the shape I’ll use — not the actual schedule yet.

Please use the exact identifiers from the instance input when you give or expect results — no renaming 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': 2, 'nr_jobs': 4, 'jobs': [[[0, 1], [1, 34]], [[0, 65], [1, 56]], [[0, 82], [1, 55]], [[0, 34], [1, 20]]]}","[{'job': 0, 'tasks': [{'task': 0, 'start': 0, 'machine': 0, 'duration': 1}, {'task': 1, 'start': 1, 'machine': 1, 'duration': 34}]}, {'job': 1, 'tasks': [{'task': 0, 'start': 1, 'machine': 0, 'duration': 65}, {'task': 1, 'start': 66, 'machine': 1, 'duration': 56}]}, {'job': 2, 'tasks': [{'task': 0, 'start': 66, 'machine': 0, 'duration': 82}, {'task': 1, 'start': 148, 'machine': 1, 'duration': 55}]}, {'job': 3, 'tasks': [{'task': 0, 'start': 148, 'machine': 0, 'duration': 34}, {'task': 1, 'start': 203, 'machine': 1, 'duration': 20}]}]",223.0,"{'problem_type': 'FSP', 'nr_jobs': 4, 'nr_machines': 2, 'jobs': ['J1', 'J2', 'J3', 'J4'], 'machines': [1, 2], 'records': [{'job_id': 'J1', 'task_id': 0, 'machine_id': 1, 'duration': 1}, {'job_id': 'J1', 'task_id': 1, 'machine_id': 2, 'duration': 34}, {'job_id': 'J2', 'task_id': 0, 'machine_id': 1, 'duration': 65}, {'job_id': 'J2', 'task_id': 1, 'machine_id': 2, 'duration': 56}, {'job_id': 'J3', 'task_id': 0, 'machine_id': 1, 'duration': 82}, {'job_id': 'J3', 'task_id': 1, 'machine_id': 2, 'duration': 55}, {'job_id': 'J4', 'task_id': 0, 'machine_id': 1, 'duration': 34}, {'job_id': 'J4', 'task_id': 1, 'machine_id': 2, 'duration': 20}]}","[{'job': 'J1', 'tasks': [{'task': 0, 'start': 0, 'machine': 1, 'duration': 1}, {'task': 1, 'start': 1, 'machine': 2, 'duration': 34}]}, {'job': 'J2', 'tasks': [{'task': 0, 'start': 1, 'machine': 1, 'duration': 65}, {'task': 1, 'start': 66, 'machine': 2, 'duration': 56}]}, {'job': 'J3', 'tasks': [{'task': 0, 'start': 66, 'machine': 1, 'duration': 82}, {'task': 1, 'start': 148, 'machine': 2, 'duration': 55}]}, {'job': 'J4', 'tasks': [{'task': 0, 'start': 148, 'machine': 1, 'duration': 34}, {'task': 1, 'start': 203, 'machine': 2, 'duration': 20}]}]",30,nl,1
FSP,FSP,"There’s this rhythm to running a pizzeria: every pie needs shaping, then toppings, and then a turn in the oven, and the job is to schedule them so the last pie finishes as early as possible. Picking one schedule over another matters because the clock time when the final pie is done changes — that finishing time is what’s used to judge a plan. Rules are simple: every pizza must go through the three stations in the same order, nothing is duplicated or left out, and a station can’t handle overlapping pies. The exact order of pies and how long each step takes will be shown below.

{
  ""number_of_pizzas"": 3,
  ""number_of_stations"": 2,
  ""pizza_ids"": [
    ""J1"",
    ""J2"",
    ""J3""
  ],
  ""station_ids"": [
    1,
    2
  ],
  ""tasks"": [
    {
      ""pizza_id"": ""J1"",
      ""step_index"": 0,
      ""required_station_id"": 1,
      ""processing_time_minutes"": 1
    },
    {
      ""pizza_id"": ""J1"",
      ""step_index"": 1,
      ""required_station_id"": 2,
      ""processing_time_minutes"": 47
    },
    {
      ""pizza_id"": ""J2"",
      ""step_index"": 0,
      ""required_station_id"": 1,
      ""processing_time_minutes"": 40
    },
    {
      ""pizza_id"": ""J2"",
      ""step_index"": 1,
      ""required_station_id"": 2,
      ""processing_time_minutes"": 3
    },
    {
      ""pizza_id"": ""J3"",
      ""step_index"": 0,
      ""required_station_id"": 1,
      ""processing_time_minutes"": 36
    },
    {
      ""pizza_id"": ""J3"",
      ""step_index"": 1,
      ""required_station_id"": 2,
      ""processing_time_minutes"": 76
    }
  ]
}

Also, when you give me the schedule, please follow this JSON layout so it's clear and machine-friendly — nothing fancy, just the shape below.

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

Think of the pieces like a simple form: ""solution"" is a list of pizzas (jobs), each entry names the job (""job"") and lists its steps (""tasks""). Each step says which step number it is (""task""), when that step starts (""start""), which station handles it (""machine""), and how long it takes (""duration""). This JSON is just a sketch of the shape I expect — not the actual schedule.

Please also be 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': 2, 'nr_jobs': 3, 'jobs': [[[0, 1], [1, 47]], [[0, 40], [1, 3]], [[0, 36], [1, 76]]]}","[{'job': 0, 'tasks': [{'task': 0, 'start': 0, 'machine': 0, 'duration': 1}, {'task': 1, 'start': 1, 'machine': 1, 'duration': 47}]}, {'job': 1, 'tasks': [{'task': 0, 'start': 37, 'machine': 0, 'duration': 40}, {'task': 1, 'start': 124, 'machine': 1, 'duration': 3}]}, {'job': 2, 'tasks': [{'task': 0, 'start': 1, 'machine': 0, 'duration': 36}, {'task': 1, 'start': 48, 'machine': 1, 'duration': 76}]}]",127.0,"{'problem_type': 'FSP', 'nr_jobs': 3, 'nr_machines': 2, 'jobs': ['J1', 'J2', 'J3'], 'machines': [1, 2], 'records': [{'job_id': 'J1', 'task_id': 0, 'machine_id': 1, 'duration': 1}, {'job_id': 'J1', 'task_id': 1, 'machine_id': 2, 'duration': 47}, {'job_id': 'J2', 'task_id': 0, 'machine_id': 1, 'duration': 40}, {'job_id': 'J2', 'task_id': 1, 'machine_id': 2, 'duration': 3}, {'job_id': 'J3', 'task_id': 0, 'machine_id': 1, 'duration': 36}, {'job_id': 'J3', 'task_id': 1, 'machine_id': 2, 'duration': 76}]}","[{'job': 'J1', 'tasks': [{'task': 0, 'start': 0, 'machine': 1, 'duration': 1}, {'task': 1, 'start': 1, 'machine': 2, 'duration': 47}]}, {'job': 'J2', 'tasks': [{'task': 0, 'start': 37, 'machine': 1, 'duration': 40}, {'task': 1, 'start': 124, 'machine': 2, 'duration': 3}]}, {'job': 'J3', 'tasks': [{'task': 0, 'start': 1, 'machine': 1, 'duration': 36}, {'task': 1, 'start': 48, 'machine': 2, 'duration': 76}]}]",31,json,1
FSP,FSP,"Back when the shop was busiest, the challenge was lining up vehicles so each went through inspection, repair, and paint in the same sequence, with known durations for each step. The goal was to choose an order that kept each bay from handling two cars at once, ensured every car received those three steps exactly once in order, and got everyone out fast. To tell which ordering is best, look at the clock when the final vehicle is completed — the earlier that finish time, the better the plan. The exact vehicle times are included below.

# nr_vehicles=3
# nr_service_bays=3
# vehicles=J1, J2, J3
# service_bays=A, B, C
vehicle_id,service_step_index,bay_id,service_duration
J1,0,A,1
J1,1,B,60
J1,2,C,16
J2,0,A,48
J2,1,B,89
J2,2,C,98
J3,0,A,43
J3,1,B,56
J3,2,C,59

If you want the plan from me, I’ll return it in a compact JSON layout so it’s easy to check or load into other tools. Here’s the little sketch of the shape I’ll follow:

{
  ""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 cars (jobs), each entry names the job and then lists its tasks in order. Each task entry just says which step number it is, when it starts, which bay (machine) handles it, and how long that step takes. It’s just a template — I’ll fill in the real numbers and IDs for the actual schedule.

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': 3, 'jobs': [[[0, 1], [1, 60], [2, 16]], [[0, 48], [1, 89], [2, 98]], [[0, 43], [1, 56], [2, 59]]]}","[{'job': 0, 'tasks': [{'task': 0, 'start': 43, 'machine': 0, 'duration': 1}, {'task': 1, 'start': 188, 'machine': 1, 'duration': 60}, {'task': 2, 'start': 286, 'machine': 2, 'duration': 16}]}, {'job': 1, 'tasks': [{'task': 0, 'start': 44, 'machine': 0, 'duration': 48}, {'task': 1, 'start': 99, 'machine': 1, 'duration': 89}, {'task': 2, 'start': 188, 'machine': 2, 'duration': 98}]}, {'job': 2, 'tasks': [{'task': 0, 'start': 0, 'machine': 0, 'duration': 43}, {'task': 1, 'start': 43, 'machine': 1, 'duration': 56}, {'task': 2, 'start': 99, 'machine': 2, 'duration': 59}]}]",302.0,"{'problem_type': 'FSP', 'nr_jobs': 3, 'nr_machines': 3, 'jobs': ['J1', 'J2', 'J3'], 'machines': ['A', 'B', 'C'], 'records': [{'job_id': 'J1', 'task_id': 0, 'machine_id': 'A', 'duration': 1}, {'job_id': 'J1', 'task_id': 1, 'machine_id': 'B', 'duration': 60}, {'job_id': 'J1', 'task_id': 2, 'machine_id': 'C', 'duration': 16}, {'job_id': 'J2', 'task_id': 0, 'machine_id': 'A', 'duration': 48}, {'job_id': 'J2', 'task_id': 1, 'machine_id': 'B', 'duration': 89}, {'job_id': 'J2', 'task_id': 2, 'machine_id': 'C', 'duration': 98}, {'job_id': 'J3', 'task_id': 0, 'machine_id': 'A', 'duration': 43}, {'job_id': 'J3', 'task_id': 1, 'machine_id': 'B', 'duration': 56}, {'job_id': 'J3', 'task_id': 2, 'machine_id': 'C', 'duration': 59}]}","[{'job': 'J1', 'tasks': [{'task': 0, 'start': 43, 'machine': 'A', 'duration': 1}, {'task': 1, 'start': 188, 'machine': 'B', 'duration': 60}, {'task': 2, 'start': 286, 'machine': 'C', 'duration': 16}]}, {'job': 'J2', 'tasks': [{'task': 0, 'start': 44, 'machine': 'A', 'duration': 48}, {'task': 1, 'start': 99, 'machine': 'B', 'duration': 89}, {'task': 2, 'start': 188, 'machine': 'C', 'duration': 98}]}, {'job': 'J3', 'tasks': [{'task': 0, 'start': 0, 'machine': 'A', 'duration': 43}, {'task': 1, 'start': 43, 'machine': 'B', 'duration': 56}, {'task': 2, 'start': 99, 'machine': 'C', 'duration': 59}]}]",32,csv,names
FSP,FSP,"I run the little tailoring corner and my job is to line up a pile of garments so each one goes through cutting, then stitching, then pressing — always in that order. The decision is about which piece goes when and how to time them so the cutting table, sewing machines, and press never have two pieces fighting for the same spot at once. A better plan is simply one where the whole batch is done sooner: measure that by the clock time when the last garment comes off the press, and try to make that as small as possible. Every garment must go through all three steps exactly once, with the known time each step takes, and the exact timings and durations will be shown below.

# nr_garments=5
# nr_workstations=3
# garment_ids=J1, J2, J3, J4, J5
# workstation_ids=0, 1, 2
garment_id,step_index,workstation_id,operation_time
J1,0,0,1
J1,1,1,73
J1,2,2,91
J2,0,0,94
J2,1,1,43
J2,2,2,21
J3,0,0,48
J3,1,1,24
J3,2,2,27
J4,0,0,17
J4,1,1,38
J4,2,2,44
J5,0,0,49
J5,1,1,56
J5,2,2,95

If you want to send me a plan, a neat little JSON sketch makes it easy for me to read — nothing fancy, just this shape:

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

This shows the shape I'm expecting: a top-level ""solution"" list with one entry per garment (job). Each job has its identifier under ""job"" and a ""tasks"" list describing each step for that garment. Inside each task you'll put which step it is (""task""), when it starts (""start""), which machine it uses (""machine""), and how long it takes (""duration""). Think of it like filling out a simple work ticket for each piece.

This is just the sketch of the format — not the actual schedule itself. Please use the exact identifiers from the instance input when you fill it in — don't rename things or invent new labels.

Valid identifiers look like plain numbers such as “1” or “23”, single capital letters like “A” or “B”, or a capital letter followed by digits like “A1” or “X7”.","{'nr_machines': 3, 'nr_jobs': 5, 'jobs': [[[0, 1], [1, 73], [2, 91]], [[0, 94], [1, 43], [2, 21]], [[0, 48], [1, 24], [2, 27]], [[0, 17], [1, 38], [2, 44]], [[0, 49], [1, 56], [2, 95]]]}","[{'job': 0, 'tasks': [{'task': 0, 'start': 0, 'machine': 0, 'duration': 1}, {'task': 1, 'start': 1, 'machine': 1, 'duration': 73}, {'task': 2, 'start': 74, 'machine': 2, 'duration': 91}]}, {'job': 1, 'tasks': [{'task': 0, 'start': 50, 'machine': 0, 'duration': 94}, {'task': 1, 'start': 144, 'machine': 1, 'duration': 43}, {'task': 2, 'start': 331, 'machine': 2, 'duration': 21}]}, {'job': 2, 'tasks': [{'task': 0, 'start': 161, 'machine': 0, 'duration': 48}, {'task': 1, 'start': 225, 'machine': 1, 'duration': 24}, {'task': 2, 'start': 304, 'machine': 2, 'duration': 27}]}, {'job': 3, 'tasks': [{'task': 0, 'start': 144, 'machine': 0, 'duration': 17}, {'task': 1, 'start': 187, 'machine': 1, 'duration': 38}, {'task': 2, 'start': 260, 'machine': 2, 'duration': 44}]}, {'job': 4, 'tasks': [{'task': 0, 'start': 1, 'machine': 0, 'duration': 49}, {'task': 1, 'start': 74, 'machine': 1, 'duration': 56}, {'task': 2, 'start': 165, 'machine': 2, 'duration': 95}]}]",352.0,"{'problem_type': 'FSP', 'nr_jobs': 5, 'nr_machines': 3, 'jobs': ['J1', 'J2', 'J3', 'J4', 'J5'], 'machines': [0, 1, 2], 'records': [{'job_id': 'J1', 'task_id': 0, 'machine_id': 0, 'duration': 1}, {'job_id': 'J1', 'task_id': 1, 'machine_id': 1, 'duration': 73}, {'job_id': 'J1', 'task_id': 2, 'machine_id': 2, 'duration': 91}, {'job_id': 'J2', 'task_id': 0, 'machine_id': 0, 'duration': 94}, {'job_id': 'J2', 'task_id': 1, 'machine_id': 1, 'duration': 43}, {'job_id': 'J2', 'task_id': 2, 'machine_id': 2, 'duration': 21}, {'job_id': 'J3', 'task_id': 0, 'machine_id': 0, 'duration': 48}, {'job_id': 'J3', 'task_id': 1, 'machine_id': 1, 'duration': 24}, {'job_id': 'J3', 'task_id': 2, 'machine_id': 2, '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': 0, 'duration': 49}, {'job_id': 'J5', 'task_id': 1, 'machine_id': 1, 'duration': 56}, {'job_id': 'J5', 'task_id': 2, 'machine_id': 2, 'duration': 95}]}","[{'job': 'J1', 'tasks': [{'task': 0, 'start': 0, 'machine': 0, 'duration': 1}, {'task': 1, 'start': 1, 'machine': 1, 'duration': 73}, {'task': 2, 'start': 74, 'machine': 2, 'duration': 91}]}, {'job': 'J2', 'tasks': [{'task': 0, 'start': 50, 'machine': 0, 'duration': 94}, {'task': 1, 'start': 144, 'machine': 1, 'duration': 43}, {'task': 2, 'start': 331, 'machine': 2, 'duration': 21}]}, {'job': 'J3', 'tasks': [{'task': 0, 'start': 161, 'machine': 0, 'duration': 48}, {'task': 1, 'start': 225, 'machine': 1, 'duration': 24}, {'task': 2, 'start': 304, 'machine': 2, 'duration': 27}]}, {'job': 'J4', 'tasks': [{'task': 0, 'start': 144, 'machine': 0, 'duration': 17}, {'task': 1, 'start': 187, 'machine': 1, 'duration': 38}, {'task': 2, 'start': 260, 'machine': 2, 'duration': 44}]}, {'job': 'J5', 'tasks': [{'task': 0, 'start': 1, 'machine': 0, 'duration': 49}, {'task': 1, 'start': 74, 'machine': 1, 'duration': 56}, {'task': 2, 'start': 165, 'machine': 2, 'duration': 95}]}]",33,csv,0
FSP,FSP,"On a typical day the process is the same for everyone: sign in, get scanned, then meet the reviewer, with each segment taking a predictable amount of time. The goal is to schedule people into registration desks, scanners, and review rooms so no resource is handling more than one person at a time and nobody skips or repeats any step. Which schedule is best is decided by the clock time when the final patient is completely done — earlier finish times win. The detailed instance information is shown below.

There are 3 patients and 3 sequential stages; patient IDs: J1, J2, J3; stage IDs: 0, 1, 2.
Patient J1, stage 0: uses 0 for 1 minutes.
Patient J1, stage 1: uses 1 for 86 minutes.
Patient J1, stage 2: uses 2 for 67 minutes.
Patient J2, stage 0: uses 0 for 40 minutes.
Patient J2, stage 1: uses 1 for 95 minutes.
Patient J2, stage 2: uses 2 for 42 minutes.
Patient J3, stage 0: uses 0 for 53 minutes.
Patient J3, stage 1: uses 1 for 91 minutes.
Patient J3, stage 2: uses 2 for 94 minutes.
Use these details to build schedules and determine the earliest completion time.

Also, just so we're on the same page about how I'd like the reply laid out, a relaxed little JSON sketch is easiest for me to read — just list the jobs and their tasks. Something like this:

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

Think of it like a simple form: each ""job"" is one person going through the process, the ""tasks"" array lists the steps they take in order, and for each step you give which task number it is, when it starts, which machine/desk/room it uses, and how long that step lasts. That JSON is just the shape I want — a template, not the actual filled-in schedule.

Please use the exact identifiers from the instance input — don't rename them or invent new labels. 
- for example: ""Valid identifiers look like plain numbers such as “1” or “23”, single capital letters like “A” or “B”, or a capital letter followed by digits like “A1” or “X7”.""","{'nr_machines': 3, 'nr_jobs': 3, 'jobs': [[[0, 1], [1, 86], [2, 67]], [[0, 40], [1, 95], [2, 42]], [[0, 53], [1, 91], [2, 94]]]}","[{'job': 0, 'tasks': [{'task': 0, 'start': 0, 'machine': 0, 'duration': 1}, {'task': 1, 'start': 1, 'machine': 1, 'duration': 86}, {'task': 2, 'start': 87, 'machine': 2, 'duration': 67}]}, {'job': 1, 'tasks': [{'task': 0, 'start': 54, 'machine': 0, 'duration': 40}, {'task': 1, 'start': 178, 'machine': 1, 'duration': 95}, {'task': 2, 'start': 273, 'machine': 2, 'duration': 42}]}, {'job': 2, 'tasks': [{'task': 0, 'start': 1, 'machine': 0, 'duration': 53}, {'task': 1, 'start': 87, 'machine': 1, 'duration': 91}, {'task': 2, 'start': 178, 'machine': 2, 'duration': 94}]}]",315.0,"{'problem_type': 'FSP', 'nr_jobs': 3, 'nr_machines': 3, 'jobs': ['J1', 'J2', 'J3'], 'machines': [0, 1, 2], 'records': [{'job_id': 'J1', 'task_id': 0, 'machine_id': 0, 'duration': 1}, {'job_id': 'J1', 'task_id': 1, 'machine_id': 1, 'duration': 86}, {'job_id': 'J1', 'task_id': 2, 'machine_id': 2, 'duration': 67}, {'job_id': 'J2', 'task_id': 0, 'machine_id': 0, 'duration': 40}, {'job_id': 'J2', 'task_id': 1, 'machine_id': 1, 'duration': 95}, {'job_id': 'J2', 'task_id': 2, 'machine_id': 2, 'duration': 42}, {'job_id': 'J3', 'task_id': 0, 'machine_id': 0, 'duration': 53}, {'job_id': 'J3', 'task_id': 1, 'machine_id': 1, 'duration': 91}, {'job_id': 'J3', 'task_id': 2, 'machine_id': 2, 'duration': 94}]}","[{'job': 'J1', 'tasks': [{'task': 0, 'start': 0, 'machine': 0, 'duration': 1}, {'task': 1, 'start': 1, 'machine': 1, 'duration': 86}, {'task': 2, 'start': 87, 'machine': 2, 'duration': 67}]}, {'job': 'J2', 'tasks': [{'task': 0, 'start': 54, 'machine': 0, 'duration': 40}, {'task': 1, 'start': 178, 'machine': 1, 'duration': 95}, {'task': 2, 'start': 273, 'machine': 2, 'duration': 42}]}, {'job': 'J3', 'tasks': [{'task': 0, 'start': 1, 'machine': 0, 'duration': 53}, {'task': 1, 'start': 87, 'machine': 1, 'duration': 91}, {'task': 2, 'start': 178, 'machine': 2, 'duration': 94}]}]",34,nl,0
FSP,FSP,"Someone in the shop has to line up the pieces so each one goes through cutting, sanding, and varnishing in that exact sequence, with each operation taking a predetermined amount of time. No station can handle overlapping pieces and nothing can be skipped or repeated; the decision is just the order of the pieces, and the goal is to minimize the total time until the very last piece is finished — basically the elapsed time from the start of work to the last varnished piece. The detailed list of pieces and times is below.

# nr_pieces=2
# nr_stations=2
# pieces=J1, J2
# stations=0, 1
piece_id,operation_index,station_id,processing_time
J1,0,0,1
J1,1,1,99
J2,0,0,43
J2,1,1,85

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

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

This is just the form I expect: each item in ""solution"" is a job (a piece), ""tasks"" lists that job's operations in order, and each task shows which step it is, when it starts, which machine it uses, and how long it takes. Think of it like filling out a simple form — it's the shape I need, not the final numbers.

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': [[[0, 1], [1, 99]], [[0, 43], [1, 85]]]}","[{'job': 0, 'tasks': [{'task': 0, 'start': 0, 'machine': 0, 'duration': 1}, {'task': 1, 'start': 1, 'machine': 1, 'duration': 99}]}, {'job': 1, 'tasks': [{'task': 0, 'start': 1, 'machine': 0, 'duration': 43}, {'task': 1, 'start': 100, 'machine': 1, 'duration': 85}]}]",185.0,"{'problem_type': 'FSP', 'nr_jobs': 2, 'nr_machines': 2, 'jobs': ['J1', 'J2'], 'machines': [0, 1], 'records': [{'job_id': 'J1', 'task_id': 0, 'machine_id': 0, 'duration': 1}, {'job_id': 'J1', 'task_id': 1, 'machine_id': 1, 'duration': 99}, {'job_id': 'J2', 'task_id': 0, 'machine_id': 0, 'duration': 43}, {'job_id': 'J2', 'task_id': 1, 'machine_id': 1, 'duration': 85}]}","[{'job': 'J1', 'tasks': [{'task': 0, 'start': 0, 'machine': 0, 'duration': 1}, {'task': 1, 'start': 1, 'machine': 1, 'duration': 99}]}, {'job': 'J2', 'tasks': [{'task': 0, 'start': 1, 'machine': 0, 'duration': 43}, {'task': 1, 'start': 100, 'machine': 1, 'duration': 85}]}]",35,csv,0
FSP,FSP,"There’s a steady rhythm on the shop floor: every frame needs cutting, then assembly, then stitching, and we know how long each of those tasks takes. The puzzle is arranging which frame goes through which station at what time so a station never handles two frames simultaneously, each frame gets each step in order exactly once, and the total job is wrapped up as early as possible — determined by the time the very last frame comes off the final station. Concrete details will be shown below.

Below are the concrete details for 2 frames processed across 3 stations: frame IDs J1, J2, station IDs A, B, C.
Frame J1 requires step 0 on station A for 1 time units.
Frame J1 requires step 1 on station B for 13 time units.
Frame J1 requires step 2 on station C for 18 time units.
Frame J2 requires step 0 on station A for 32 time units.
Frame J2 requires step 1 on station B for 3 time units.
Frame J2 requires step 2 on station C for 86 time units.
We’ll arrange these task entries so no station handles two frames at once and each frame’s steps occur in order to minimize the overall completion time.

I'll return the schedule in a simple JSON layout so it's easy to read and machine-friendly — something like this:

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

This sketch shows the shape I'll use: each job gets an entry, with a list of its tasks. For each task you'll see which step it is (task), when it starts (start), which machine/station it runs on (machine), and how long it takes (duration). Think of it as a little form for each frame going through cut → assemble → stitch.

Please remember to use the exact identifiers from the instance input with no renaming or added 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': 2, 'jobs': [[[0, 1], [1, 13], [2, 18]], [[0, 32], [1, 3], [2, 86]]]}","[{'job': 0, 'tasks': [{'task': 0, 'start': 0, 'machine': 0, 'duration': 1}, {'task': 1, 'start': 1, 'machine': 1, 'duration': 13}, {'task': 2, 'start': 14, 'machine': 2, 'duration': 18}]}, {'job': 1, 'tasks': [{'task': 0, 'start': 1, 'machine': 0, 'duration': 32}, {'task': 1, 'start': 33, 'machine': 1, 'duration': 3}, {'task': 2, 'start': 36, 'machine': 2, 'duration': 86}]}]",122.0,"{'problem_type': 'FSP', 'nr_jobs': 2, 'nr_machines': 3, 'jobs': ['J1', 'J2'], 'machines': ['A', 'B', 'C'], 'records': [{'job_id': 'J1', 'task_id': 0, 'machine_id': 'A', 'duration': 1}, {'job_id': 'J1', 'task_id': 1, 'machine_id': 'B', 'duration': 13}, {'job_id': 'J1', 'task_id': 2, 'machine_id': 'C', 'duration': 18}, {'job_id': 'J2', 'task_id': 0, 'machine_id': 'A', 'duration': 32}, {'job_id': 'J2', 'task_id': 1, 'machine_id': 'B', 'duration': 3}, {'job_id': 'J2', 'task_id': 2, 'machine_id': 'C', 'duration': 86}]}","[{'job': 'J1', 'tasks': [{'task': 0, 'start': 0, 'machine': 'A', 'duration': 1}, {'task': 1, 'start': 1, 'machine': 'B', 'duration': 13}, {'task': 2, 'start': 14, 'machine': 'C', 'duration': 18}]}, {'job': 'J2', 'tasks': [{'task': 0, 'start': 1, 'machine': 'A', 'duration': 32}, {'task': 1, 'start': 33, 'machine': 'B', 'duration': 3}, {'task': 2, 'start': 36, 'machine': 'C', 'duration': 86}]}]",36,nl,names
FSP,FSP,"There's a cramped shop where every part must be stamped, then assembled, then inspected in that order, and the supervisor needs to arrange the batch flow so machines aren’t stuck doing two things at once. The whole point is to get the entire set of parts done as quickly as possible — you track that by the time the last part clears inspection — and you can’t drop or duplicate any operation. The specific job times and items follow below.

You'll schedule 5 parts (J1, J2, J3, J4, J5) across 3 workstations (1, 2, 3).

| item_id | operation_step | station_id | operation_time |
|---|---|---|---|
| J1 | 0 | 1 | 1 |
| J1 | 1 | 2 | 26 |
| J1 | 2 | 3 | 93 |
| J2 | 0 | 1 | 77 |
| J2 | 1 | 2 | 56 |
| J2 | 2 | 3 | 8 |
| J3 | 0 | 1 | 67 |
| J3 | 1 | 2 | 95 |
| J3 | 2 | 3 | 98 |
| J4 | 0 | 1 | 90 |
| J4 | 1 | 2 | 91 |
| J4 | 2 | 3 | 51 |
| J5 | 0 | 1 | 81 |
| J5 | 1 | 2 | 69 |
| J5 | 2 | 3 | 17 |

Prevent stations from doing two things at once, don't drop or duplicate any operation, and minimize the time when the last part clears inspection.

Also, when you hand me the actual schedule, please stick to this simple JSON layout so everything lines up neatly:

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

Think of that JSON as a little form: ""solution"" holds the whole batch, each entry is one job with its id, and under ""tasks"" you list the operations for that job. For each task you fill in which task number it is, when it starts, which machine does it, and how long it takes. Super straightforward — like filling in a work ticket.

This is just a sketch of the expected shape, not the actual schedule. Also, 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': 3, 'nr_jobs': 5, 'jobs': [[[0, 1], [1, 26], [2, 93]], [[0, 77], [1, 56], [2, 8]], [[0, 67], [1, 95], [2, 98]], [[0, 90], [1, 91], [2, 51]], [[0, 81], [1, 69], [2, 17]]]}","[{'job': 0, 'tasks': [{'task': 0, 'start': 0, 'machine': 0, 'duration': 1}, {'task': 1, 'start': 1, 'machine': 1, 'duration': 26}, {'task': 2, 'start': 27, 'machine': 2, 'duration': 93}]}, {'job': 1, 'tasks': [{'task': 0, 'start': 239, 'machine': 0, 'duration': 77}, {'task': 1, 'start': 323, 'machine': 1, 'duration': 56}, {'task': 2, 'start': 379, 'machine': 2, 'duration': 8}]}, {'job': 2, 'tasks': [{'task': 0, 'start': 1, 'machine': 0, 'duration': 67}, {'task': 1, 'start': 68, 'machine': 1, 'duration': 95}, {'task': 2, 'start': 163, 'machine': 2, 'duration': 98}]}, {'job': 3, 'tasks': [{'task': 0, 'start': 68, 'machine': 0, 'duration': 90}, {'task': 1, 'start': 163, 'machine': 1, 'duration': 91}, {'task': 2, 'start': 261, 'machine': 2, 'duration': 51}]}, {'job': 4, 'tasks': [{'task': 0, 'start': 158, 'machine': 0, 'duration': 81}, {'task': 1, 'start': 254, 'machine': 1, 'duration': 69}, {'task': 2, 'start': 323, 'machine': 2, 'duration': 17}]}]",387.0,"{'problem_type': 'FSP', 'nr_jobs': 5, 'nr_machines': 3, 'jobs': ['J1', 'J2', 'J3', 'J4', 'J5'], 'machines': [1, 2, 3], 'records': [{'job_id': 'J1', 'task_id': 0, 'machine_id': 1, 'duration': 1}, {'job_id': 'J1', 'task_id': 1, 'machine_id': 2, 'duration': 26}, {'job_id': 'J1', 'task_id': 2, 'machine_id': 3, 'duration': 93}, {'job_id': 'J2', 'task_id': 0, 'machine_id': 1, 'duration': 77}, {'job_id': 'J2', 'task_id': 1, 'machine_id': 2, 'duration': 56}, {'job_id': 'J2', 'task_id': 2, 'machine_id': 3, 'duration': 8}, {'job_id': 'J3', 'task_id': 0, 'machine_id': 1, 'duration': 67}, {'job_id': 'J3', 'task_id': 1, 'machine_id': 2, 'duration': 95}, {'job_id': 'J3', 'task_id': 2, 'machine_id': 3, 'duration': 98}, {'job_id': 'J4', 'task_id': 0, 'machine_id': 1, 'duration': 90}, {'job_id': 'J4', 'task_id': 1, 'machine_id': 2, 'duration': 91}, {'job_id': 'J4', 'task_id': 2, 'machine_id': 3, 'duration': 51}, {'job_id': 'J5', 'task_id': 0, 'machine_id': 1, 'duration': 81}, {'job_id': 'J5', 'task_id': 1, 'machine_id': 2, 'duration': 69}, {'job_id': 'J5', 'task_id': 2, 'machine_id': 3, 'duration': 17}]}","[{'job': 'J1', 'tasks': [{'task': 0, 'start': 0, 'machine': 1, 'duration': 1}, {'task': 1, 'start': 1, 'machine': 2, 'duration': 26}, {'task': 2, 'start': 27, 'machine': 3, 'duration': 93}]}, {'job': 'J2', 'tasks': [{'task': 0, 'start': 239, 'machine': 1, 'duration': 77}, {'task': 1, 'start': 323, 'machine': 2, 'duration': 56}, {'task': 2, 'start': 379, 'machine': 3, 'duration': 8}]}, {'job': 'J3', 'tasks': [{'task': 0, 'start': 1, 'machine': 1, 'duration': 67}, {'task': 1, 'start': 68, 'machine': 2, 'duration': 95}, {'task': 2, 'start': 163, 'machine': 3, 'duration': 98}]}, {'job': 'J4', 'tasks': [{'task': 0, 'start': 68, 'machine': 1, 'duration': 90}, {'task': 1, 'start': 163, 'machine': 2, 'duration': 91}, {'task': 2, 'start': 261, 'machine': 3, 'duration': 51}]}, {'job': 'J5', 'tasks': [{'task': 0, 'start': 158, 'machine': 1, 'duration': 81}, {'task': 1, 'start': 254, 'machine': 2, 'duration': 69}, {'task': 2, 'start': 323, 'machine': 3, 'duration': 17}]}]",37,markdown_table,1
FSP,FSP,"Someone at the dispatch desk juggles parcels through scan, label, and sort every shift, and they have to decide which parcel to send first, second, third, and so on. The rule is rigid: every parcel must go through the three steps in that order, no step can be skipped or repeated, and a station can only work on one parcel at a time. A sequence is judged by when the very last parcel is done — the sooner that time happens, the better the sequence. The full list of parcel times and the setup follows below.

There are 2 parcels (J1, J2), each routed through 2 sequential workstations in order: 1, 2.

| parcel_id | step_index | workstation_id | handling_time |
|---|---|---|---|
| J1 | 0 | 1 | 1 |
| J1 | 1 | 2 | 39 |
| J2 | 0 | 1 | 69 |
| J2 | 1 | 2 | 24 |

Use this list to pick the parcel order that minimizes when the very last parcel is done.

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

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

Pretty straightforward — in story terms, each ""job"" is a parcel, and the tasks list shows the steps that parcel goes through (scan, label, sort) in order. ""task"" is the step index in that job's sequence, ""start"" is when that step begins, ""machine"" is which station handles it, and ""duration"" is how long that step takes. Think of it as filling out a little form for each parcel: which parcel, which steps, when each step starts, which station does it, and how long it runs.

This JSON is just a sketch of the shape I expect, not the actual schedule — you'll fill in the real numbers and IDs when you answer.

Please make sure you use the exact identifiers from the instance input — do not rename them or invent new labels. For example: Valid identifiers look like plain numbers such as ""1"" or ""23"", single capital letters like ""A"" or ""B"", or a capital letter followed by digits like ""A1"" or ""X7"".","{'nr_machines': 2, 'nr_jobs': 2, 'jobs': [[[0, 1], [1, 39]], [[0, 69], [1, 24]]]}","[{'job': 0, 'tasks': [{'task': 0, 'start': 0, 'machine': 0, 'duration': 1}, {'task': 1, 'start': 1, 'machine': 1, 'duration': 39}]}, {'job': 1, 'tasks': [{'task': 0, 'start': 1, 'machine': 0, 'duration': 69}, {'task': 1, 'start': 70, 'machine': 1, 'duration': 24}]}]",94.0,"{'problem_type': 'FSP', 'nr_jobs': 2, 'nr_machines': 2, 'jobs': ['J1', 'J2'], 'machines': [1, 2], 'records': [{'job_id': 'J1', 'task_id': 0, 'machine_id': 1, 'duration': 1}, {'job_id': 'J1', 'task_id': 1, 'machine_id': 2, 'duration': 39}, {'job_id': 'J2', 'task_id': 0, 'machine_id': 1, 'duration': 69}, {'job_id': 'J2', 'task_id': 1, 'machine_id': 2, 'duration': 24}]}","[{'job': 'J1', 'tasks': [{'task': 0, 'start': 0, 'machine': 1, 'duration': 1}, {'task': 1, 'start': 1, 'machine': 2, 'duration': 39}]}, {'job': 'J2', 'tasks': [{'task': 0, 'start': 1, 'machine': 1, 'duration': 69}, {'task': 1, 'start': 70, 'machine': 2, 'duration': 24}]}]",38,markdown_table,1
FSP,FSP,"At my job the pipeline is strict — compile, then test, then deploy for every change — and each stage takes a fixed time. I have to slot changes into the build agents without letting any agent do two tasks at once, and every change must go through each stage once. The aim is to have the entire batch finished as soon as possible: the important number is the time when the last deployment completes, found by looking at each change’s deploy finish time and taking the latest. The concrete schedules and durations are provided below.

# nr_changes=4
# nr_pipeline_stages=2
# changes=J1, J2, J3, J4
# pipeline_stages=0, 1
change_id,stage_index,stage_id,stage_duration
J1,0,0,1
J1,1,1,52
J2,0,0,45
J2,1,1,69
J3,0,0,62
J3,1,1,52
J4,0,0,76
J4,1,1,31

If you want the result in a predictable, machine-friendly layout, just use this JSON shape — nothing fancy, just a list of jobs and their tasks:

{
  ""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 single change), ""tasks"" lists its stages in order, ""task"" is the stage index, ""start"" is when that stage begins, ""machine"" is which build agent handles it, and ""duration"" is how long that stage runs. This JSON is just a sketch of the shape I want back — not the actual filled-in schedule.

Please make sure to use the exact identifiers from the instance input — don't rename them and don't invent new labels. For example: ""Valid identifiers look like plain numbers such as “1” or “23”, single capital letters like “A” or “B”, or a capital letter followed by digits like “A1” or “X7”.""","{'nr_machines': 2, 'nr_jobs': 4, 'jobs': [[[0, 1], [1, 52]], [[0, 45], [1, 69]], [[0, 62], [1, 52]], [[0, 76], [1, 31]]]}","[{'job': 0, 'tasks': [{'task': 0, 'start': 0, 'machine': 0, 'duration': 1}, {'task': 1, 'start': 1, 'machine': 1, 'duration': 52}]}, {'job': 1, 'tasks': [{'task': 0, 'start': 1, 'machine': 0, 'duration': 45}, {'task': 1, 'start': 53, 'machine': 1, 'duration': 69}]}, {'job': 2, 'tasks': [{'task': 0, 'start': 46, 'machine': 0, 'duration': 62}, {'task': 1, 'start': 122, 'machine': 1, 'duration': 52}]}, {'job': 3, 'tasks': [{'task': 0, 'start': 108, 'machine': 0, 'duration': 76}, {'task': 1, 'start': 184, 'machine': 1, 'duration': 31}]}]",215.0,"{'problem_type': 'FSP', 'nr_jobs': 4, 'nr_machines': 2, 'jobs': ['J1', 'J2', 'J3', 'J4'], 'machines': [0, 1], 'records': [{'job_id': 'J1', 'task_id': 0, 'machine_id': 0, 'duration': 1}, {'job_id': 'J1', 'task_id': 1, 'machine_id': 1, 'duration': 52}, {'job_id': 'J2', 'task_id': 0, 'machine_id': 0, 'duration': 45}, {'job_id': 'J2', 'task_id': 1, 'machine_id': 1, 'duration': 69}, {'job_id': 'J3', 'task_id': 0, 'machine_id': 0, 'duration': 62}, {'job_id': 'J3', 'task_id': 1, 'machine_id': 1, 'duration': 52}, {'job_id': 'J4', 'task_id': 0, 'machine_id': 0, 'duration': 76}, {'job_id': 'J4', 'task_id': 1, 'machine_id': 1, 'duration': 31}]}","[{'job': 'J1', 'tasks': [{'task': 0, 'start': 0, 'machine': 0, 'duration': 1}, {'task': 1, 'start': 1, 'machine': 1, 'duration': 52}]}, {'job': 'J2', 'tasks': [{'task': 0, 'start': 1, 'machine': 0, 'duration': 45}, {'task': 1, 'start': 53, 'machine': 1, 'duration': 69}]}, {'job': 'J3', 'tasks': [{'task': 0, 'start': 46, 'machine': 0, 'duration': 62}, {'task': 1, 'start': 122, 'machine': 1, 'duration': 52}]}, {'job': 'J4', 'tasks': [{'task': 0, 'start': 108, 'machine': 0, 'duration': 76}, {'task': 1, 'start': 184, 'machine': 1, 'duration': 31}]}]",39,csv,0
FSP,FSP,"I run the little canning line and every day I have to line up a batch of cans so each one goes through sterilization, then filling, then sealing — in that exact order. The choice to make is how to time and order those cans down the line so no station ever tries to work on two cans at once and no can skips or repeats a step. A better plan is simply the one that gets the very last can finished sooner; the clock time when the final sealed can leaves the line is the number to watch, and the aim is to make that time as small as possible. The exact batch sizes and step times are shown below.

# batch_size=5
# station_count=3
# can_ids=J1, J2, J3, J4, J5
# station_ids=1, 2, 3
can_id,step_index,station_id,processing_time
J1,0,1,1
J1,1,2,65
J1,2,3,21
J2,0,1,15
J2,1,2,16
J2,2,3,73
J3,0,1,81
J3,1,2,98
J3,2,3,3
J4,0,1,71
J4,1,2,7
J4,2,3,8
J5,0,1,31
J5,1,2,80
J5,2,3,33

Also, when you send the actual schedule back, it'd be handy if you stick to this little JSON layout so I can read it straightaway:

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

It's just a simple form: ""solution"" holds a list of jobs; each job has a job id and a list of its tasks. For each task, ""task"" is which step in the job's sequence, ""start"" is the clock time that step begins, ""machine"" tells which station does it, and ""duration"" is how long that step takes. Think of it like filling out a little card for every can and every step it goes through.

This JSON is only a sketch of the expected shape, not the real answer. Please make sure to 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': [[[0, 1], [1, 65], [2, 21]], [[0, 15], [1, 16], [2, 73]], [[0, 81], [1, 98], [2, 3]], [[0, 71], [1, 7], [2, 8]], [[0, 31], [1, 80], [2, 33]]]}","[{'job': 0, 'tasks': [{'task': 0, 'start': 0, 'machine': 0, 'duration': 1}, {'task': 1, 'start': 1, 'machine': 1, 'duration': 65}, {'task': 2, 'start': 66, 'machine': 2, 'duration': 21}]}, {'job': 1, 'tasks': [{'task': 0, 'start': 32, 'machine': 0, 'duration': 15}, {'task': 1, 'start': 66, 'machine': 1, 'duration': 16}, {'task': 2, 'start': 87, 'machine': 2, 'duration': 73}]}, {'job': 2, 'tasks': [{'task': 0, 'start': 47, 'machine': 0, 'duration': 81}, {'task': 1, 'start': 162, 'machine': 1, 'duration': 98}, {'task': 2, 'start': 260, 'machine': 2, 'duration': 3}]}, {'job': 3, 'tasks': [{'task': 0, 'start': 128, 'machine': 0, 'duration': 71}, {'task': 1, 'start': 260, 'machine': 1, 'duration': 7}, {'task': 2, 'start': 267, 'machine': 2, 'duration': 8}]}, {'job': 4, 'tasks': [{'task': 0, 'start': 1, 'machine': 0, 'duration': 31}, {'task': 1, 'start': 82, 'machine': 1, 'duration': 80}, {'task': 2, 'start': 162, 'machine': 2, 'duration': 33}]}]",275.0,"{'problem_type': 'FSP', 'nr_jobs': 5, 'nr_machines': 3, 'jobs': ['J1', 'J2', 'J3', 'J4', 'J5'], 'machines': [1, 2, 3], 'records': [{'job_id': 'J1', 'task_id': 0, 'machine_id': 1, 'duration': 1}, {'job_id': 'J1', 'task_id': 1, 'machine_id': 2, 'duration': 65}, {'job_id': 'J1', 'task_id': 2, 'machine_id': 3, 'duration': 21}, {'job_id': 'J2', 'task_id': 0, 'machine_id': 1, 'duration': 15}, {'job_id': 'J2', 'task_id': 1, 'machine_id': 2, 'duration': 16}, {'job_id': 'J2', 'task_id': 2, 'machine_id': 3, 'duration': 73}, {'job_id': 'J3', 'task_id': 0, 'machine_id': 1, 'duration': 81}, {'job_id': 'J3', 'task_id': 1, 'machine_id': 2, 'duration': 98}, {'job_id': 'J3', 'task_id': 2, 'machine_id': 3, 'duration': 3}, {'job_id': 'J4', 'task_id': 0, 'machine_id': 1, 'duration': 71}, {'job_id': 'J4', 'task_id': 1, 'machine_id': 2, 'duration': 7}, {'job_id': 'J4', 'task_id': 2, 'machine_id': 3, 'duration': 8}, {'job_id': 'J5', 'task_id': 0, 'machine_id': 1, 'duration': 31}, {'job_id': 'J5', 'task_id': 1, 'machine_id': 2, 'duration': 80}, {'job_id': 'J5', 'task_id': 2, 'machine_id': 3, 'duration': 33}]}","[{'job': 'J1', 'tasks': [{'task': 0, 'start': 0, 'machine': 1, 'duration': 1}, {'task': 1, 'start': 1, 'machine': 2, 'duration': 65}, {'task': 2, 'start': 66, 'machine': 3, 'duration': 21}]}, {'job': 'J2', 'tasks': [{'task': 0, 'start': 32, 'machine': 1, 'duration': 15}, {'task': 1, 'start': 66, 'machine': 2, 'duration': 16}, {'task': 2, 'start': 87, 'machine': 3, 'duration': 73}]}, {'job': 'J3', 'tasks': [{'task': 0, 'start': 47, 'machine': 1, 'duration': 81}, {'task': 1, 'start': 162, 'machine': 2, 'duration': 98}, {'task': 2, 'start': 260, 'machine': 3, 'duration': 3}]}, {'job': 'J4', 'tasks': [{'task': 0, 'start': 128, 'machine': 1, 'duration': 71}, {'task': 1, 'start': 260, 'machine': 2, 'duration': 7}, {'task': 2, 'start': 267, 'machine': 3, 'duration': 8}]}, {'job': 'J5', 'tasks': [{'task': 0, 'start': 1, 'machine': 1, 'duration': 31}, {'task': 1, 'start': 82, 'machine': 2, 'duration': 80}, {'task': 2, 'start': 162, 'machine': 3, 'duration': 33}]}]",40,csv,1
FSP,FSP,"We manage a small appliances repair shop where every item must go through diagnosis, parts replacement, then final testing in that order. The job is to line things up so no station is double-booked and nothing gets skipped or repeated, and to pick the sequence that gets the very last unit ready for pickup as early as possible — that completion moment is found by looking at the end times of the final tests and taking the largest. Concrete runtimes and the list of units are shown below.

{
  ""total_units"": 5,
  ""total_stations"": 2,
  ""unit_ids"": [
    ""J1"",
    ""J2"",
    ""J3"",
    ""J4"",
    ""J5""
  ],
  ""station_ids"": [
    0,
    1
  ],
  ""tasks"": [
    {
      ""unit_id"": ""J1"",
      ""step_index"": 0,
      ""station_id"": 0,
      ""step_duration_minutes"": 1
    },
    {
      ""unit_id"": ""J1"",
      ""step_index"": 1,
      ""station_id"": 1,
      ""step_duration_minutes"": 78
    },
    {
      ""unit_id"": ""J2"",
      ""step_index"": 0,
      ""station_id"": 0,
      ""step_duration_minutes"": 96
    },
    {
      ""unit_id"": ""J2"",
      ""step_index"": 1,
      ""station_id"": 1,
      ""step_duration_minutes"": 61
    },
    {
      ""unit_id"": ""J3"",
      ""step_index"": 0,
      ""station_id"": 0,
      ""step_duration_minutes"": 69
    },
    {
      ""unit_id"": ""J3"",
      ""step_index"": 1,
      ""station_id"": 1,
      ""step_duration_minutes"": 95
    },
    {
      ""unit_id"": ""J4"",
      ""step_index"": 0,
      ""station_id"": 0,
      ""step_duration_minutes"": 85
    },
    {
      ""unit_id"": ""J4"",
      ""step_index"": 1,
      ""station_id"": 1,
      ""step_duration_minutes"": 67
    },
    {
      ""unit_id"": ""J5"",
      ""step_index"": 0,
      ""station_id"": 0,
      ""step_duration_minutes"": 70
    },
    {
      ""unit_id"": ""J5"",
      ""step_index"": 1,
      ""station_id"": 1,
      ""step_duration_minutes"": 64
    }
  ]
}

Oh, and when you send the planned schedule back, a simple JSON sketch like this is perfect to capture the structure:

{
  ""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 repair jobs; each job entry has the job identifier under ""job"" and a ""tasks"" list showing the steps that job goes through. For each task we note which step number it is (""task""), when that step starts (""start""), which station handles it (""machine""), and how long it takes (""duration""). This is just the expected shape — a sketch of the format, not the actual schedule.

Please make sure to use the exact identifiers given in the instance input — no renaming and no invented labels. 
For example: ""Valid identifiers look like plain numbers such as “1” or “23”, single capital letters like “A” or “B”, or a capital letter followed by digits like “A1” or “X7”.""","{'nr_machines': 2, 'nr_jobs': 5, 'jobs': [[[0, 1], [1, 78]], [[0, 96], [1, 61]], [[0, 69], [1, 95]], [[0, 85], [1, 67]], [[0, 70], [1, 64]]]}","[{'job': 0, 'tasks': [{'task': 0, 'start': 0, 'machine': 0, 'duration': 1}, {'task': 1, 'start': 1, 'machine': 1, 'duration': 78}]}, {'job': 1, 'tasks': [{'task': 0, 'start': 225, 'machine': 0, 'duration': 96}, {'task': 1, 'start': 321, 'machine': 1, 'duration': 61}]}, {'job': 2, 'tasks': [{'task': 0, 'start': 71, 'machine': 0, 'duration': 69}, {'task': 1, 'start': 143, 'machine': 1, 'duration': 95}]}, {'job': 3, 'tasks': [{'task': 0, 'start': 140, 'machine': 0, 'duration': 85}, {'task': 1, 'start': 238, 'machine': 1, 'duration': 67}]}, {'job': 4, 'tasks': [{'task': 0, 'start': 1, 'machine': 0, 'duration': 70}, {'task': 1, 'start': 79, 'machine': 1, 'duration': 64}]}]",382.0,"{'problem_type': 'FSP', 'nr_jobs': 5, 'nr_machines': 2, 'jobs': ['J1', 'J2', 'J3', 'J4', 'J5'], 'machines': [0, 1], 'records': [{'job_id': 'J1', 'task_id': 0, 'machine_id': 0, 'duration': 1}, {'job_id': 'J1', 'task_id': 1, 'machine_id': 1, 'duration': 78}, {'job_id': 'J2', 'task_id': 0, 'machine_id': 0, 'duration': 96}, {'job_id': 'J2', 'task_id': 1, 'machine_id': 1, 'duration': 61}, {'job_id': 'J3', 'task_id': 0, 'machine_id': 0, 'duration': 69}, {'job_id': 'J3', 'task_id': 1, 'machine_id': 1, 'duration': 95}, {'job_id': 'J4', 'task_id': 0, 'machine_id': 0, 'duration': 85}, {'job_id': 'J4', 'task_id': 1, 'machine_id': 1, 'duration': 67}, {'job_id': 'J5', 'task_id': 0, 'machine_id': 0, 'duration': 70}, {'job_id': 'J5', 'task_id': 1, 'machine_id': 1, 'duration': 64}]}","[{'job': 'J1', 'tasks': [{'task': 0, 'start': 0, 'machine': 0, 'duration': 1}, {'task': 1, 'start': 1, 'machine': 1, 'duration': 78}]}, {'job': 'J2', 'tasks': [{'task': 0, 'start': 225, 'machine': 0, 'duration': 96}, {'task': 1, 'start': 321, 'machine': 1, 'duration': 61}]}, {'job': 'J3', 'tasks': [{'task': 0, 'start': 71, 'machine': 0, 'duration': 69}, {'task': 1, 'start': 143, 'machine': 1, 'duration': 95}]}, {'job': 'J4', 'tasks': [{'task': 0, 'start': 140, 'machine': 0, 'duration': 85}, {'task': 1, 'start': 238, 'machine': 1, 'duration': 67}]}, {'job': 'J5', 'tasks': [{'task': 0, 'start': 1, 'machine': 0, 'duration': 70}, {'task': 1, 'start': 79, 'machine': 1, 'duration': 64}]}]",41,json,0
FSP,FSP,"Someone set up a potluck and left a batch of casseroles to be handled — each one needs prep, then baking, then cooling, and the challenge is to schedule when each casserole starts each step so the meal is ready fast. Because the prep station, oven, and cooling area can only work on one casserole at a time and no step can be skipped or repeated, the timing choices matter. The better the timing, the sooner the last casserole is completed; the plan is evaluated by that final finish time on the clock. Specifics about how long each step takes and how many dishes there are appear below.

There are 4 casserole dishes that must pass through 2 shared appliances; the dishes are J1, J2, J3, J4 and the appliances are A, B.

| casserole_id | step_index | appliance_id | duration_minutes |
|---|---|---|---|
| J1 | 0 | A | 1 |
| J1 | 1 | B | 91 |
| J2 | 0 | A | 71 |
| J2 | 1 | B | 7 |
| J3 | 0 | A | 22 |
| J3 | 1 | B | 18 |
| J4 | 0 | A | 90 |
| J4 | 1 | B | 35 |

Aim to sequence the starts so the last casserole finishes as early as possible.

If you want to hand me the schedule, a simple JSON layout works nicely — 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: ""solution"" holds a list of casseroles, each entry's ""job"" is the dish identifier, and ""tasks"" is the sequence of steps for that dish. Each task line says which step it is (""task""), when that step starts on the clock (""start""), which station it's on (""machine""), and how long it runs (""duration""). This is just a sketch of the shape I expect, not the actual plan.

Please make sure to use the exact identifiers from the instance input — don't rename or invent labels. Valid identifiers look like plain numbers such as “1” or “23”, single capital letters like “A” or “B”, or a capital letter followed by digits like “A1” or “X7”.","{'nr_machines': 2, 'nr_jobs': 4, 'jobs': [[[0, 1], [1, 91]], [[0, 71], [1, 7]], [[0, 22], [1, 18]], [[0, 90], [1, 35]]]}","[{'job': 0, 'tasks': [{'task': 0, 'start': 0, 'machine': 0, 'duration': 1}, {'task': 1, 'start': 1, 'machine': 1, 'duration': 91}]}, {'job': 1, 'tasks': [{'task': 0, 'start': 113, 'machine': 0, 'duration': 71}, {'task': 1, 'start': 184, 'machine': 1, 'duration': 7}]}, {'job': 2, 'tasks': [{'task': 0, 'start': 91, 'machine': 0, 'duration': 22}, {'task': 1, 'start': 127, 'machine': 1, 'duration': 18}]}, {'job': 3, 'tasks': [{'task': 0, 'start': 1, 'machine': 0, 'duration': 90}, {'task': 1, 'start': 92, 'machine': 1, 'duration': 35}]}]",191.0,"{'problem_type': 'FSP', 'nr_jobs': 4, 'nr_machines': 2, 'jobs': ['J1', 'J2', 'J3', 'J4'], 'machines': ['A', 'B'], 'records': [{'job_id': 'J1', 'task_id': 0, 'machine_id': 'A', 'duration': 1}, {'job_id': 'J1', 'task_id': 1, 'machine_id': 'B', 'duration': 91}, {'job_id': 'J2', 'task_id': 0, 'machine_id': 'A', 'duration': 71}, {'job_id': 'J2', 'task_id': 1, 'machine_id': 'B', 'duration': 7}, {'job_id': 'J3', 'task_id': 0, 'machine_id': 'A', 'duration': 22}, {'job_id': 'J3', 'task_id': 1, 'machine_id': 'B', 'duration': 18}, {'job_id': 'J4', 'task_id': 0, 'machine_id': 'A', 'duration': 90}, {'job_id': 'J4', 'task_id': 1, 'machine_id': 'B', 'duration': 35}]}","[{'job': 'J1', 'tasks': [{'task': 0, 'start': 0, 'machine': 'A', 'duration': 1}, {'task': 1, 'start': 1, 'machine': 'B', 'duration': 91}]}, {'job': 'J2', 'tasks': [{'task': 0, 'start': 113, 'machine': 'A', 'duration': 71}, {'task': 1, 'start': 184, 'machine': 'B', 'duration': 7}]}, {'job': 'J3', 'tasks': [{'task': 0, 'start': 91, 'machine': 'A', 'duration': 22}, {'task': 1, 'start': 127, 'machine': 'B', 'duration': 18}]}, {'job': 'J4', 'tasks': [{'task': 0, 'start': 1, 'machine': 'A', 'duration': 90}, {'task': 1, 'start': 92, 'machine': 'B', 'duration': 35}]}]",42,markdown_table,names
FSP,FSP,"I was thinking about a busy bakery where every loaf has to go from the mixer to the oven to the glazing bench in that exact order, each step taking a set amount of time. The decision is how to line up the loaves so that the whole batch is finished as quickly as possible — the plan that finishes the very last loaf sooner is the better one. To see which plan wins, look at when each loaf comes off the glazing bench and take the latest finishing time; that number is what needs to be as small as possible. Remember, the mixer, oven, and glazing station can each handle only one loaf at a time, and every loaf must go through all three steps exactly once. The exact loaf times and details are shown below.

# nr_loaves=3
# nr_stations=3
# loaves=J1, J2, J3
# stations=A, B, C
loaf_id,step_index,station_id,processing_time
J1,0,A,1
J1,1,B,5
J1,2,C,47
J2,0,A,53
J2,1,B,75
J2,2,C,39
J3,0,A,95
J3,1,B,3
J3,2,C,7

Oh, and when you send back the actual plan, please follow this simple JSON layout so I can read it easily:

{
  ""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 list of loaves, each loaf object has a ""job"" label and a ""tasks"" list, and each task entry says which step it is (""task""), when that step starts (""start""), which station handles it (""machine""), and how long it takes (""duration""). Pretty informal — just the shape of what I expect, not the real answers.

This JSON is only a sketch of the expected shape, not the actual schedule. Also make sure to use the exact identifiers from the instance input — do not 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': 3, 'jobs': [[[0, 1], [1, 5], [2, 47]], [[0, 53], [1, 75], [2, 39]], [[0, 95], [1, 3], [2, 7]]]}","[{'job': 0, 'tasks': [{'task': 0, 'start': 0, 'machine': 0, 'duration': 1}, {'task': 1, 'start': 1, 'machine': 1, 'duration': 5}, {'task': 2, 'start': 6, 'machine': 2, 'duration': 47}]}, {'job': 1, 'tasks': [{'task': 0, 'start': 1, 'machine': 0, 'duration': 53}, {'task': 1, 'start': 54, 'machine': 1, 'duration': 75}, {'task': 2, 'start': 129, 'machine': 2, 'duration': 39}]}, {'job': 2, 'tasks': [{'task': 0, 'start': 54, 'machine': 0, 'duration': 95}, {'task': 1, 'start': 149, 'machine': 1, 'duration': 3}, {'task': 2, 'start': 168, 'machine': 2, 'duration': 7}]}]",175.0,"{'problem_type': 'FSP', 'nr_jobs': 3, 'nr_machines': 3, 'jobs': ['J1', 'J2', 'J3'], 'machines': ['A', 'B', 'C'], 'records': [{'job_id': 'J1', 'task_id': 0, 'machine_id': 'A', 'duration': 1}, {'job_id': 'J1', 'task_id': 1, 'machine_id': 'B', 'duration': 5}, {'job_id': 'J1', 'task_id': 2, 'machine_id': 'C', 'duration': 47}, {'job_id': 'J2', 'task_id': 0, 'machine_id': 'A', 'duration': 53}, {'job_id': 'J2', 'task_id': 1, 'machine_id': 'B', 'duration': 75}, {'job_id': 'J2', 'task_id': 2, 'machine_id': 'C', 'duration': 39}, {'job_id': 'J3', 'task_id': 0, 'machine_id': 'A', 'duration': 95}, {'job_id': 'J3', 'task_id': 1, 'machine_id': 'B', 'duration': 3}, {'job_id': 'J3', 'task_id': 2, 'machine_id': 'C', 'duration': 7}]}","[{'job': 'J1', 'tasks': [{'task': 0, 'start': 0, 'machine': 'A', 'duration': 1}, {'task': 1, 'start': 1, 'machine': 'B', 'duration': 5}, {'task': 2, 'start': 6, 'machine': 'C', 'duration': 47}]}, {'job': 'J2', 'tasks': [{'task': 0, 'start': 1, 'machine': 'A', 'duration': 53}, {'task': 1, 'start': 54, 'machine': 'B', 'duration': 75}, {'task': 2, 'start': 129, 'machine': 'C', 'duration': 39}]}, {'job': 'J3', 'tasks': [{'task': 0, 'start': 54, 'machine': 'A', 'duration': 95}, {'task': 1, 'start': 149, 'machine': 'B', 'duration': 3}, {'task': 2, 'start': 168, 'machine': 'C', 'duration': 7}]}]",43,csv,names
FSP,FSP,"At the shop the workflow is straightforward: every booklet goes through printing, then trimming, then binding. The decision is how to schedule the batches through those three stations so that the final booklet is finished as early as possible — the finish time of the last job is the way to tell which plan is better. Machines can't handle more than one batch simultaneously, and every job must complete all three steps in order. The exact timings and batches are shown below.

# nr_booklets=5
# nr_stations=3
# booklet_ids=J1, J2, J3, J4, J5
# station_ids=A, B, C
booklet_id,step_index,station_id,processing_time
J1,0,A,1
J1,1,B,18
J1,2,C,23
J2,0,A,98
J2,1,B,29
J2,2,C,61
J3,0,A,99
J3,1,B,70
J3,2,C,74
J4,0,A,45
J4,1,B,60
J4,2,C,15
J5,0,A,63
J5,1,B,93
J5,2,C,54

Also, when you give me the actual schedule, please follow this simple JSON layout so I can read it programmatically — nothing fancy, just the shape shown below.

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

Think of that JSON as a little form: ""solution"" holds a list of jobs, each job has an id and a list of its tasks; each task notes which step it is, when it starts, which machine does it, and how long it takes. It's just a sketch of the expected shape — not the actual schedule yet.

Please make sure to 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': [[[0, 1], [1, 18], [2, 23]], [[0, 98], [1, 29], [2, 61]], [[0, 99], [1, 70], [2, 74]], [[0, 45], [1, 60], [2, 15]], [[0, 63], [1, 93], [2, 54]]]}","[{'job': 0, 'tasks': [{'task': 0, 'start': 0, 'machine': 0, 'duration': 1}, {'task': 1, 'start': 1, 'machine': 1, 'duration': 18}, {'task': 2, 'start': 19, 'machine': 2, 'duration': 23}]}, {'job': 1, 'tasks': [{'task': 0, 'start': 163, 'machine': 0, 'duration': 98}, {'task': 1, 'start': 263, 'machine': 1, 'duration': 29}, {'task': 2, 'start': 307, 'machine': 2, 'duration': 61}]}, {'job': 2, 'tasks': [{'task': 0, 'start': 64, 'machine': 0, 'duration': 99}, {'task': 1, 'start': 163, 'machine': 1, 'duration': 70}, {'task': 2, 'start': 233, 'machine': 2, 'duration': 74}]}, {'job': 3, 'tasks': [{'task': 0, 'start': 261, 'machine': 0, 'duration': 45}, {'task': 1, 'start': 306, 'machine': 1, 'duration': 60}, {'task': 2, 'start': 368, 'machine': 2, 'duration': 15}]}, {'job': 4, 'tasks': [{'task': 0, 'start': 1, 'machine': 0, 'duration': 63}, {'task': 1, 'start': 64, 'machine': 1, 'duration': 93}, {'task': 2, 'start': 157, 'machine': 2, 'duration': 54}]}]",383.0,"{'problem_type': 'FSP', 'nr_jobs': 5, 'nr_machines': 3, 'jobs': ['J1', 'J2', 'J3', 'J4', 'J5'], 'machines': ['A', 'B', 'C'], 'records': [{'job_id': 'J1', 'task_id': 0, 'machine_id': 'A', 'duration': 1}, {'job_id': 'J1', 'task_id': 1, 'machine_id': 'B', 'duration': 18}, {'job_id': 'J1', 'task_id': 2, 'machine_id': 'C', 'duration': 23}, {'job_id': 'J2', 'task_id': 0, 'machine_id': 'A', 'duration': 98}, {'job_id': 'J2', 'task_id': 1, 'machine_id': 'B', 'duration': 29}, {'job_id': 'J2', 'task_id': 2, 'machine_id': 'C', 'duration': 61}, {'job_id': 'J3', 'task_id': 0, 'machine_id': 'A', 'duration': 99}, {'job_id': 'J3', 'task_id': 1, 'machine_id': 'B', 'duration': 70}, {'job_id': 'J3', 'task_id': 2, 'machine_id': 'C', 'duration': 74}, {'job_id': 'J4', 'task_id': 0, 'machine_id': 'A', 'duration': 45}, {'job_id': 'J4', 'task_id': 1, 'machine_id': 'B', 'duration': 60}, {'job_id': 'J4', 'task_id': 2, 'machine_id': 'C', 'duration': 15}, {'job_id': 'J5', 'task_id': 0, 'machine_id': 'A', 'duration': 63}, {'job_id': 'J5', 'task_id': 1, 'machine_id': 'B', 'duration': 93}, {'job_id': 'J5', 'task_id': 2, 'machine_id': 'C', 'duration': 54}]}","[{'job': 'J1', 'tasks': [{'task': 0, 'start': 0, 'machine': 'A', 'duration': 1}, {'task': 1, 'start': 1, 'machine': 'B', 'duration': 18}, {'task': 2, 'start': 19, 'machine': 'C', 'duration': 23}]}, {'job': 'J2', 'tasks': [{'task': 0, 'start': 163, 'machine': 'A', 'duration': 98}, {'task': 1, 'start': 263, 'machine': 'B', 'duration': 29}, {'task': 2, 'start': 307, 'machine': 'C', 'duration': 61}]}, {'job': 'J3', 'tasks': [{'task': 0, 'start': 64, 'machine': 'A', 'duration': 99}, {'task': 1, 'start': 163, 'machine': 'B', 'duration': 70}, {'task': 2, 'start': 233, 'machine': 'C', 'duration': 74}]}, {'job': 'J4', 'tasks': [{'task': 0, 'start': 261, 'machine': 'A', 'duration': 45}, {'task': 1, 'start': 306, 'machine': 'B', 'duration': 60}, {'task': 2, 'start': 368, 'machine': 'C', 'duration': 15}]}, {'job': 'J5', 'tasks': [{'task': 0, 'start': 1, 'machine': 'A', 'duration': 63}, {'task': 1, 'start': 64, 'machine': 'B', 'duration': 93}, {'task': 2, 'start': 157, 'machine': 'C', 'duration': 54}]}]",44,csv,names
FSP,FSP,"Many people on the floor watch three stations — roast, cool, pack — and every load must pass through them in that order, once each. The choice to make is the order of the loads through the line; the better the choice, the sooner the last load will finish, and that finish time is the simple way to compare plans. No station can be doing two loads at the same time. The detailed timings for each load are listed below.

There are 4 loads and 2 stations — the loads are J1, J2, J3, J4 and the stations are A, B.
Load J1, stage 0 needs station A for 1.
Load J1, stage 1 needs station B for 31.
Load J2, stage 0 needs station A for 98.
Load J2, stage 1 needs station B for 44.
Load J3, stage 0 needs station A for 81.
Load J3, stage 1 needs station B for 83.
Load J4, stage 0 needs station A for 5.
Load J4, stage 1 needs station B for 38.
Plans are compared by the finish time of the last of the 4 loads.

Oh, and when you send the actual plan back, please use this simple JSON shape so I can read it easily — something like:

{
  ""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 list of loads, each entry names the job and then lists its tasks in order. Each task line just says which step it is, when it starts, which machine (station) it runs on, and how long it takes. This is just the shape I want — not the actual schedule.

Please use the exact identifiers from the 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': [[[0, 1], [1, 31]], [[0, 98], [1, 44]], [[0, 81], [1, 83]], [[0, 5], [1, 38]]]}","[{'job': 0, 'tasks': [{'task': 0, 'start': 5, 'machine': 0, 'duration': 1}, {'task': 1, 'start': 43, 'machine': 1, 'duration': 31}]}, {'job': 1, 'tasks': [{'task': 0, 'start': 87, 'machine': 0, 'duration': 98}, {'task': 1, 'start': 185, 'machine': 1, 'duration': 44}]}, {'job': 2, 'tasks': [{'task': 0, 'start': 6, 'machine': 0, 'duration': 81}, {'task': 1, 'start': 87, 'machine': 1, 'duration': 83}]}, {'job': 3, 'tasks': [{'task': 0, 'start': 0, 'machine': 0, 'duration': 5}, {'task': 1, 'start': 5, 'machine': 1, 'duration': 38}]}]",229.0,"{'problem_type': 'FSP', 'nr_jobs': 4, 'nr_machines': 2, 'jobs': ['J1', 'J2', 'J3', 'J4'], 'machines': ['A', 'B'], 'records': [{'job_id': 'J1', 'task_id': 0, 'machine_id': 'A', 'duration': 1}, {'job_id': 'J1', 'task_id': 1, 'machine_id': 'B', 'duration': 31}, {'job_id': 'J2', 'task_id': 0, 'machine_id': 'A', 'duration': 98}, {'job_id': 'J2', 'task_id': 1, 'machine_id': 'B', 'duration': 44}, {'job_id': 'J3', 'task_id': 0, 'machine_id': 'A', 'duration': 81}, {'job_id': 'J3', 'task_id': 1, 'machine_id': 'B', 'duration': 83}, {'job_id': 'J4', 'task_id': 0, 'machine_id': 'A', 'duration': 5}, {'job_id': 'J4', 'task_id': 1, 'machine_id': 'B', 'duration': 38}]}","[{'job': 'J1', 'tasks': [{'task': 0, 'start': 5, 'machine': 'A', 'duration': 1}, {'task': 1, 'start': 43, 'machine': 'B', 'duration': 31}]}, {'job': 'J2', 'tasks': [{'task': 0, 'start': 87, 'machine': 'A', 'duration': 98}, {'task': 1, 'start': 185, 'machine': 'B', 'duration': 44}]}, {'job': 'J3', 'tasks': [{'task': 0, 'start': 6, 'machine': 'A', 'duration': 81}, {'task': 1, 'start': 87, 'machine': 'B', 'duration': 83}]}, {'job': 'J4', 'tasks': [{'task': 0, 'start': 0, 'machine': 'A', 'duration': 5}, {'task': 1, 'start': 5, 'machine': 'B', 'duration': 38}]}]",45,nl,names
FSP,FSP,"There’s a small factory scene: parts come in, hit the molding machine, then the trimmer, then the inspector — always in that sequence. The task is to arrange which part goes when so the whole group clears inspection as quickly as possible; the result is judged by the moment the last part is finished. Each part has its own times for each stage, none of the stages can be done in parallel on multiple parts, and every part must go through all three stations exactly once. The concrete details will be shown below.

# nr_parts=3
# nr_stations=3
# parts=J1, J2, J3
# stations=A, B, C
part_id,stage_index,station_id,processing_time
J1,0,A,1
J1,1,B,44
J1,2,C,74
J2,0,A,90
J2,1,B,35
J2,2,C,5
J3,0,A,10
J3,1,B,7
J3,2,C,10

Oh, and when you send the schedule back, please use this little JSON shape so I can read it easily:

{
  ""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 the list of parts, each entry says which part (job) it is and then lists the tasks for that part. Each task entry notes which step it is (task), when that step starts (start), which station/machine handles it (machine), and how long it runs (duration). It's just a sketch of the shape I need, not the actual schedule yet.

Also: 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': [[[0, 1], [1, 44], [2, 74]], [[0, 90], [1, 35], [2, 5]], [[0, 10], [1, 7], [2, 10]]]}","[{'job': 0, 'tasks': [{'task': 0, 'start': 10, 'machine': 0, 'duration': 1}, {'task': 1, 'start': 17, 'machine': 1, 'duration': 44}, {'task': 2, 'start': 61, 'machine': 2, 'duration': 74}]}, {'job': 1, 'tasks': [{'task': 0, 'start': 11, 'machine': 0, 'duration': 90}, {'task': 1, 'start': 101, 'machine': 1, 'duration': 35}, {'task': 2, 'start': 136, 'machine': 2, 'duration': 5}]}, {'job': 2, 'tasks': [{'task': 0, 'start': 0, 'machine': 0, 'duration': 10}, {'task': 1, 'start': 10, 'machine': 1, 'duration': 7}, {'task': 2, 'start': 17, 'machine': 2, 'duration': 10}]}]",141.0,"{'problem_type': 'FSP', 'nr_jobs': 3, 'nr_machines': 3, 'jobs': ['J1', 'J2', 'J3'], 'machines': ['A', 'B', 'C'], 'records': [{'job_id': 'J1', 'task_id': 0, 'machine_id': 'A', 'duration': 1}, {'job_id': 'J1', 'task_id': 1, 'machine_id': 'B', 'duration': 44}, {'job_id': 'J1', 'task_id': 2, 'machine_id': 'C', 'duration': 74}, {'job_id': 'J2', 'task_id': 0, 'machine_id': 'A', 'duration': 90}, {'job_id': 'J2', 'task_id': 1, 'machine_id': 'B', 'duration': 35}, {'job_id': 'J2', 'task_id': 2, 'machine_id': 'C', 'duration': 5}, {'job_id': 'J3', 'task_id': 0, 'machine_id': 'A', 'duration': 10}, {'job_id': 'J3', 'task_id': 1, 'machine_id': 'B', 'duration': 7}, {'job_id': 'J3', 'task_id': 2, 'machine_id': 'C', 'duration': 10}]}","[{'job': 'J1', 'tasks': [{'task': 0, 'start': 10, 'machine': 'A', 'duration': 1}, {'task': 1, 'start': 17, 'machine': 'B', 'duration': 44}, {'task': 2, 'start': 61, 'machine': 'C', 'duration': 74}]}, {'job': 'J2', 'tasks': [{'task': 0, 'start': 11, 'machine': 'A', 'duration': 90}, {'task': 1, 'start': 101, 'machine': 'B', 'duration': 35}, {'task': 2, 'start': 136, 'machine': 'C', 'duration': 5}]}, {'job': 'J3', 'tasks': [{'task': 0, 'start': 0, 'machine': 'A', 'duration': 10}, {'task': 1, 'start': 10, 'machine': 'B', 'duration': 7}, {'task': 2, 'start': 17, 'machine': 'C', 'duration': 10}]}]",46,csv,names
FSP,FSP,"Backstage at the reception, the coordinator had to line platters up so they’d each go through making, cooling, and setting out in that order, and the only real choice was the sequence in which they’d take turns at each station. Each platter’s make, chill, and staging times were known ahead of time, and since every station can handle only one platter at a time and every platter must visit all three stations exactly once, the order can’t break those rules. The whole thing is judged by when the final platter is ready on the serving table — the earlier that finish time, the better the schedule. The detailed platter times are shown below.

There were 2 platters and 2 stations; the platters were J1, J2 and the stations were 0, 1.

| platter_id | step_index | station_id | processing_time |
|---|---|---|---|
| J1 | 0 | 0 | 1 |
| J1 | 1 | 1 | 57 |
| J2 | 0 | 0 | 49 |
| J2 | 1 | 1 | 36 |

The coordinator's objective remained to minimize when the final platter finished across the 2 platters at the 2 stations.

If you want the schedule back in a tidy, machine-friendly way, just follow this little JSON layout when you send it over:

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

Think of it like a simple form: ""solution"" holds a list of platters (jobs). Each platter entry names the platter (""job"") and then lists its steps (""tasks""). For each step you say which step number it is (""task""), when that step should start (""start""), which station it's on (""machine""), and how long that step takes (""duration""). This is just the sketch of the shape I need, not the actual schedule.

Please use the exact identifiers from the instance input — don’t rename them or invent new labels. Valid identifiers look like plain numbers such as “1” or “23”, single capital letters like “A” or “B”, or a capital letter followed by digits like “A1” or “X7”.","{'nr_machines': 2, 'nr_jobs': 2, 'jobs': [[[0, 1], [1, 57]], [[0, 49], [1, 36]]]}","[{'job': 0, 'tasks': [{'task': 0, 'start': 0, 'machine': 0, 'duration': 1}, {'task': 1, 'start': 1, 'machine': 1, 'duration': 57}]}, {'job': 1, 'tasks': [{'task': 0, 'start': 1, 'machine': 0, 'duration': 49}, {'task': 1, 'start': 58, 'machine': 1, 'duration': 36}]}]",94.0,"{'problem_type': 'FSP', 'nr_jobs': 2, 'nr_machines': 2, 'jobs': ['J1', 'J2'], 'machines': [0, 1], 'records': [{'job_id': 'J1', 'task_id': 0, 'machine_id': 0, 'duration': 1}, {'job_id': 'J1', 'task_id': 1, 'machine_id': 1, 'duration': 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': 0, 'duration': 1}, {'task': 1, 'start': 1, 'machine': 1, 'duration': 57}]}, {'job': 'J2', 'tasks': [{'task': 0, 'start': 1, 'machine': 0, 'duration': 49}, {'task': 1, 'start': 58, 'machine': 1, 'duration': 36}]}]",47,markdown_table,0
FSP,FSP,"Picture a simple route through the kitchen — prep, warming, serving — with a bunch of trays that each have to travel those three steps; the job is slotting each tray’s passage so the last tray is done sooner and nobody tries to use the same station at the same time. To judge a plan, look at the finish time of the last tray; that’s the number to bring down. No tray can skip or repeat a step, every tray follows the same sequence, and the concrete timings and tray details follow below.

# number_of_trays=2
# number_of_stations=2
# tray_ids=J1, J2
# station_ids=1, 2
tray_id,step_index,station_id,task_duration
J1,0,1,1
J1,1,2,70
J2,0,1,25
J2,1,2,82

If you want to hand me a plan, the easiest is to use a tiny JSON form — think of it like filling out a little schedule sheet. Here’s the shape I expect:

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

This is just a sketch of the shape, not the actual plan. In plain terms: ""solution"" is a list of trays (jobs). Each job has a job id and a list of tasks. Each task records which step it is (task), when that step starts (start), which station it uses (machine), and how long it takes (duration). Keep it simple and human-readable, like filling in a timetable.

Please use the instance’s identifiers exactly as given — don’t rename them or invent new labels. 
- for example: ""Valid identifiers look like plain numbers such as “1” or “23”, single capital letters like “A” or “B”, or a capital letter followed by digits like “A1” or “X7”.""","{'nr_machines': 2, 'nr_jobs': 2, 'jobs': [[[0, 1], [1, 70]], [[0, 25], [1, 82]]]}","[{'job': 0, 'tasks': [{'task': 0, 'start': 0, 'machine': 0, 'duration': 1}, {'task': 1, 'start': 1, 'machine': 1, 'duration': 70}]}, {'job': 1, 'tasks': [{'task': 0, 'start': 1, 'machine': 0, 'duration': 25}, {'task': 1, 'start': 71, 'machine': 1, 'duration': 82}]}]",153.0,"{'problem_type': 'FSP', 'nr_jobs': 2, 'nr_machines': 2, 'jobs': ['J1', 'J2'], 'machines': [1, 2], 'records': [{'job_id': 'J1', 'task_id': 0, 'machine_id': 1, 'duration': 1}, {'job_id': 'J1', 'task_id': 1, 'machine_id': 2, 'duration': 70}, {'job_id': 'J2', 'task_id': 0, 'machine_id': 1, 'duration': 25}, {'job_id': 'J2', 'task_id': 1, 'machine_id': 2, 'duration': 82}]}","[{'job': 'J1', 'tasks': [{'task': 0, 'start': 0, 'machine': 1, 'duration': 1}, {'task': 1, 'start': 1, 'machine': 2, 'duration': 70}]}, {'job': 'J2', 'tasks': [{'task': 0, 'start': 1, 'machine': 1, 'duration': 25}, {'task': 1, 'start': 71, 'machine': 2, 'duration': 82}]}]",48,csv,1
FSP,FSP,"Someone in the workshop is juggling a stack of tabletops and a calendar: each tabletop must be cut, sanded and finished, and the only choice is the order to feed them through those machines. A good ordering is the one that makes the last tabletop come off the finishing stage sooner rather than later — that final completion time is the score for the plan. All tabletops must go through cutting → sanding → finishing exactly once, and machines can’t handle two pieces at once. The detailed task times are laid out below.

# nr_tabletops=3
# nr_stations=3
# tabletops=J1, J2, J3
# stations=1, 2, 3
tabletop_id,operation_index,station_id,processing_time
J1,0,1,1
J1,1,2,84
J1,2,3,1
J2,0,1,28
J2,1,2,94
J2,2,3,70
J3,0,1,24
J3,1,2,10
J3,2,3,14

Also, when you hand me the plan, please put it in a simple JSON shape so it's easy to read and reuse. Something like this:

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

This is just a sketch of the shape I expect: ""solution"" is an array of jobs, each job entry gives the job identifier and a list of its tasks. Each task entry shows which task number it is, when that task starts, which machine it runs on, and how long it takes. Keep it casual — it's like filling out a little form for each tabletop as it moves through cutting, sanding and finishing.

This JSON block is only 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': [[[0, 1], [1, 84], [2, 1]], [[0, 28], [1, 94], [2, 70]], [[0, 24], [1, 10], [2, 14]]]}","[{'job': 0, 'tasks': [{'task': 0, 'start': 28, 'machine': 0, 'duration': 1}, {'task': 1, 'start': 132, 'machine': 1, 'duration': 84}, {'task': 2, 'start': 216, 'machine': 2, 'duration': 1}]}, {'job': 1, 'tasks': [{'task': 0, 'start': 0, 'machine': 0, 'duration': 28}, {'task': 1, 'start': 28, 'machine': 1, 'duration': 94}, {'task': 2, 'start': 122, 'machine': 2, 'duration': 70}]}, {'job': 2, 'tasks': [{'task': 0, 'start': 29, 'machine': 0, 'duration': 24}, {'task': 1, 'start': 122, 'machine': 1, 'duration': 10}, {'task': 2, 'start': 192, 'machine': 2, 'duration': 14}]}]",217.0,"{'problem_type': 'FSP', 'nr_jobs': 3, 'nr_machines': 3, 'jobs': ['J1', 'J2', 'J3'], 'machines': [1, 2, 3], 'records': [{'job_id': 'J1', 'task_id': 0, 'machine_id': 1, 'duration': 1}, {'job_id': 'J1', 'task_id': 1, 'machine_id': 2, 'duration': 84}, {'job_id': 'J1', 'task_id': 2, 'machine_id': 3, 'duration': 1}, {'job_id': 'J2', 'task_id': 0, 'machine_id': 1, 'duration': 28}, {'job_id': 'J2', 'task_id': 1, 'machine_id': 2, 'duration': 94}, {'job_id': 'J2', 'task_id': 2, 'machine_id': 3, 'duration': 70}, {'job_id': 'J3', 'task_id': 0, 'machine_id': 1, 'duration': 24}, {'job_id': 'J3', 'task_id': 1, 'machine_id': 2, 'duration': 10}, {'job_id': 'J3', 'task_id': 2, 'machine_id': 3, 'duration': 14}]}","[{'job': 'J1', 'tasks': [{'task': 0, 'start': 28, 'machine': 1, 'duration': 1}, {'task': 1, 'start': 132, 'machine': 2, 'duration': 84}, {'task': 2, 'start': 216, 'machine': 3, 'duration': 1}]}, {'job': 'J2', 'tasks': [{'task': 0, 'start': 0, 'machine': 1, 'duration': 28}, {'task': 1, 'start': 28, 'machine': 2, 'duration': 94}, {'task': 2, 'start': 122, 'machine': 3, 'duration': 70}]}, {'job': 'J3', 'tasks': [{'task': 0, 'start': 29, 'machine': 1, 'duration': 24}, {'task': 1, 'start': 122, 'machine': 2, 'duration': 10}, {'task': 2, 'start': 192, 'machine': 3, 'duration': 14}]}]",49,csv,1
FSP,FSP,"Many people don’t realize how much planning goes into a simple run: samples must go through a centrifuge, then an incubator, then an assay, and the order you send them in determines how long the whole batch takes. The better plan is the one where the last sample exits the assay sooner — that finish time is what you compare. All samples have set times for each stage, none can skip or repeat a stage, and equipment can’t work on more than one sample at once. The exact sample timings are listed below.

There are 2 samples to process across 3 pieces of equipment; the sample IDs are J1, J2 and the equipment order is 1, 2, 3.
Sample J1, step 0 on equipment 1 requires 1 time units.
Sample J1, step 1 on equipment 2 requires 97 time units.
Sample J1, step 2 on equipment 3 requires 76 time units.
Sample J2, step 0 on equipment 1 requires 73 time units.
Sample J2, step 1 on equipment 2 requires 48 time units.
Sample J2, step 2 on equipment 3 requires 92 time units.
These task timings set the scheduling constraints so plans can be compared by the final assay finish time.

If you prefer the schedule in a neat, machine-friendly layout, I'll use the JSON shape below 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 simple form: ""solution"" holds a list of jobs; each job entry names the job and then lists its tasks. Each task entry says which step it is (""task""), when that step starts (""start""), which piece of equipment it uses (""machine""), and how long it runs (""duration""). It's just a sketch of the shape I need — not the real schedule yet.

Please use the exact identifiers from the instance input when filling this in — 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': 2, 'jobs': [[[0, 1], [1, 97], [2, 76]], [[0, 73], [1, 48], [2, 92]]]}","[{'job': 0, 'tasks': [{'task': 0, 'start': 0, 'machine': 0, 'duration': 1}, {'task': 1, 'start': 1, 'machine': 1, 'duration': 97}, {'task': 2, 'start': 98, 'machine': 2, 'duration': 76}]}, {'job': 1, 'tasks': [{'task': 0, 'start': 1, 'machine': 0, 'duration': 73}, {'task': 1, 'start': 98, 'machine': 1, 'duration': 48}, {'task': 2, 'start': 174, 'machine': 2, 'duration': 92}]}]",266.0,"{'problem_type': 'FSP', 'nr_jobs': 2, 'nr_machines': 3, 'jobs': ['J1', 'J2'], 'machines': [1, 2, 3], 'records': [{'job_id': 'J1', 'task_id': 0, 'machine_id': 1, 'duration': 1}, {'job_id': 'J1', 'task_id': 1, 'machine_id': 2, 'duration': 97}, {'job_id': 'J1', 'task_id': 2, 'machine_id': 3, 'duration': 76}, {'job_id': 'J2', 'task_id': 0, 'machine_id': 1, 'duration': 73}, {'job_id': 'J2', 'task_id': 1, 'machine_id': 2, 'duration': 48}, {'job_id': 'J2', 'task_id': 2, 'machine_id': 3, 'duration': 92}]}","[{'job': 'J1', 'tasks': [{'task': 0, 'start': 0, 'machine': 1, 'duration': 1}, {'task': 1, 'start': 1, 'machine': 2, 'duration': 97}, {'task': 2, 'start': 98, 'machine': 3, 'duration': 76}]}, {'job': 'J2', 'tasks': [{'task': 0, 'start': 1, 'machine': 1, 'duration': 73}, {'task': 1, 'start': 98, 'machine': 2, 'duration': 48}, {'task': 2, 'start': 174, 'machine': 3, 'duration': 92}]}]",50,nl,1