2SP/2SP_S_context.csv

task_name,problem_type,instruction,instance,solution,obj,instance_variant,solution_variant,context_index,input_format,input_index_base
2SP,2SP,"Many movers know the drill: fit a bunch of flat panels into a van of fixed width, align every piece with the walls so nothing is rotated or sticking out, and make sure exactly one of each panel is onboard with no overlaps. What matters is where each panel sits horizontally and vertically, because the packing is scored by the height of the tallest panel top above the floor — the lower that highest top edge, the better. The concrete van and panel dimensions are shown below.

- **van_interior_width**: 160
- **van_internal_ceiling_height**: 37

| panel_id | panel_width | panel_height |
|---|---|---|
| A | 54 | 14 |
| B | 22 | 20 |
| C | 21 | 26 |
| D | 35 | 28 |
| E | 64 | 21 |

If you want the packing back from me, I'll hand it over in a little JSON sketch like this:

{
  ""solution"": [{""item_type"": <panel_type_id>, ""x"": 0, ""y"": 0, ""width"": 10, ""height"": 5}, ...]
}

Think of it like a simple form: ""solution"" is a list of placed panels. Each entry gives the panel's type (item_type), the x/y coordinates of the bottom-left corner, and the panel's width and height. This block is just a template of the shape I’ll use — not the actual answer.

Please make sure to use the exact identifiers from the instance input — don't rename them or invent new ones. Valid identifiers look like plain numbers such as ""1"" or ""23"", single capital letters like ""A"" or ""B"", or a capital letter followed by digits like ""A1"" or ""X7"".","{'items': [{'width': 54, 'height': 14, 'demand': 1}, {'width': 22, 'height': 20, 'demand': 1}, {'width': 21, 'height': 26, 'demand': 1}, {'width': 35, 'height': 28, 'demand': 1}, {'width': 64, 'height': 21, 'demand': 1}], 'bin_width': 160, 'bin_height': 37, 'is_strip_packing': False, 'solution': [{'item_type': 0, 'x': 0, 'y': 21, 'width': 54, 'height': 14}, {'item_type': 1, 'x': 0, 'y': 0, 'width': 22, 'height': 20}, {'item_type': 2, 'x': 86, 'y': 0, 'width': 21, 'height': 26}, {'item_type': 3, 'x': 125, 'y': 0, 'width': 35, 'height': 28}, {'item_type': 4, 'x': 22, 'y': 0, 'width': 64, 'height': 21}], 'obj': 35.0, 'is_nontrivial': True, 'problem_type': '2SP'}","[{'item_type': 0, 'x': 0, 'y': 21, 'width': 54, 'height': 14}, {'item_type': 1, 'x': 0, 'y': 0, 'width': 22, 'height': 20}, {'item_type': 2, 'x': 86, 'y': 0, 'width': 21, 'height': 26}, {'item_type': 3, 'x': 125, 'y': 0, 'width': 35, 'height': 28}, {'item_type': 4, 'x': 22, 'y': 0, 'width': 64, 'height': 21}]",35.0,"{'problem_type': '2SP', 'bin_width': 160, 'bin_height': 37, 'items': [{'item_id': 'A', 'width': 54, 'height': 14}, {'item_id': 'B', 'width': 22, 'height': 20}, {'item_id': 'C', 'width': 21, 'height': 26}, {'item_id': 'D', 'width': 35, 'height': 28}, {'item_id': 'E', 'width': 64, 'height': 21}], 'num_item_types': 5}","[{'item_type': 'A', 'x': 0, 'y': 21, 'width': 54, 'height': 14}, {'item_type': 'B', 'x': 0, 'y': 0, 'width': 22, 'height': 20}, {'item_type': 'C', 'x': 86, 'y': 0, 'width': 21, 'height': 26}, {'item_type': 'D', 'x': 125, 'y': 0, 'width': 35, 'height': 28}, {'item_type': 'E', 'x': 22, 'y': 0, 'width': 64, 'height': 21}]",1,markdown_table,names
2SP,2SP,"I was trying to stack a bunch of rectangular ad blocks into a narrow sidebar that can’t change width. The task was to pick where each ad sits from left to right and how far up from the bottom it starts, keeping every ad flush with the sidebar edges (no tilting), making sure none of them overlap and that each ad appears exactly once. The aim was to keep the whole column as short as possible — measured by the highest top edge of any ad from the bottom of the sidebar — so whatever layout made that top edge lowest was the best. The exact sidebar width and the sizes of the ads will be shown below.

- **sidebar_width**: 160
- **sidebar_height**: 64

| ad_id | ad_width | ad_height |
|---|---|---|
| 1 | 15 | 21 |
| 2 | 31 | 7 |
| 3 | 11 | 4 |
| 4 | 42 | 11 |
| 5 | 12 | 32 |
| 6 | 19 | 14 |
| 7 | 19 | 49 |
| 8 | 90 | 30 |
| 9 | 69 | 27 |
| 10 | 21 | 41 |

I’ll return the layout in a simple JSON form so it’s easy to read and reuse. Here’s the little sketch I’ll follow:

{
  ""solution"": [{""item_type"": <ad_type_id>, ""x"": 0, ""y"": 0, ""width"": 10, ""height"": 5}, ...]
}

Think of it like a short form: ""solution"" is the whole packing, each entry is one ad block. item_type is the ad’s identifier, x and y are where the bottom-left corner sits (distance from the left and the bottom), and width/height are the ad’s size. Super informal — just a template showing the shape I’ll use, not the real final placement.

Please use the exact identifiers that appear 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”.","{'items': [{'width': 15, 'height': 21, 'demand': 1}, {'width': 31, 'height': 7, 'demand': 1}, {'width': 11, 'height': 4, 'demand': 1}, {'width': 42, 'height': 11, 'demand': 1}, {'width': 12, 'height': 32, 'demand': 1}, {'width': 19, 'height': 14, 'demand': 1}, {'width': 19, 'height': 49, 'demand': 1}, {'width': 90, 'height': 30, 'demand': 1}, {'width': 69, 'height': 27, 'demand': 1}, {'width': 21, 'height': 41, 'demand': 1}], 'bin_width': 160, 'bin_height': 64, 'is_strip_packing': False, 'solution': [{'item_type': 0, 'x': 0, 'y': 0, 'width': 15, 'height': 21}, {'item_type': 1, 'x': 39, 'y': 0, 'width': 31, 'height': 7}, {'item_type': 2, 'x': 0, 'y': 21, 'width': 11, 'height': 4}, {'item_type': 3, 'x': 49, 'y': 48, 'width': 42, 'height': 11}, {'item_type': 4, 'x': 15, 'y': 0, 'width': 12, 'height': 32}, {'item_type': 5, 'x': 11, 'y': 32, 'width': 19, 'height': 14}, {'item_type': 6, 'x': 30, 'y': 7, 'width': 19, 'height': 49}, {'item_type': 7, 'x': 70, 'y': 0, 'width': 90, 'height': 30}, {'item_type': 8, 'x': 91, 'y': 30, 'width': 69, 'height': 27}, {'item_type': 9, 'x': 49, 'y': 7, 'width': 21, 'height': 41}], 'obj': 59.0, 'is_nontrivial': True, 'problem_type': '2SP'}","[{'item_type': 0, 'x': 0, 'y': 0, 'width': 15, 'height': 21}, {'item_type': 1, 'x': 39, 'y': 0, 'width': 31, 'height': 7}, {'item_type': 2, 'x': 0, 'y': 21, 'width': 11, 'height': 4}, {'item_type': 3, 'x': 49, 'y': 48, 'width': 42, 'height': 11}, {'item_type': 4, 'x': 15, 'y': 0, 'width': 12, 'height': 32}, {'item_type': 5, 'x': 11, 'y': 32, 'width': 19, 'height': 14}, {'item_type': 6, 'x': 30, 'y': 7, 'width': 19, 'height': 49}, {'item_type': 7, 'x': 70, 'y': 0, 'width': 90, 'height': 30}, {'item_type': 8, 'x': 91, 'y': 30, 'width': 69, 'height': 27}, {'item_type': 9, 'x': 49, 'y': 7, 'width': 21, 'height': 41}]",59.0,"{'problem_type': '2SP', 'bin_width': 160, 'bin_height': 64, 'items': [{'item_id': 1, 'width': 15, 'height': 21}, {'item_id': 2, 'width': 31, 'height': 7}, {'item_id': 3, 'width': 11, 'height': 4}, {'item_id': 4, 'width': 42, 'height': 11}, {'item_id': 5, 'width': 12, 'height': 32}, {'item_id': 6, 'width': 19, 'height': 14}, {'item_id': 7, 'width': 19, 'height': 49}, {'item_id': 8, 'width': 90, 'height': 30}, {'item_id': 9, 'width': 69, 'height': 27}, {'item_id': 10, 'width': 21, 'height': 41}], 'num_item_types': 10}","[{'item_type': 1, 'x': 0, 'y': 0, 'width': 15, 'height': 21}, {'item_type': 2, 'x': 39, 'y': 0, 'width': 31, 'height': 7}, {'item_type': 3, 'x': 0, 'y': 21, 'width': 11, 'height': 4}, {'item_type': 4, 'x': 49, 'y': 48, 'width': 42, 'height': 11}, {'item_type': 5, 'x': 15, 'y': 0, 'width': 12, 'height': 32}, {'item_type': 6, 'x': 11, 'y': 32, 'width': 19, 'height': 14}, {'item_type': 7, 'x': 30, 'y': 7, 'width': 19, 'height': 49}, {'item_type': 8, 'x': 70, 'y': 0, 'width': 90, 'height': 30}, {'item_type': 9, 'x': 91, 'y': 30, 'width': 69, 'height': 27}, {'item_type': 10, 'x': 49, 'y': 7, 'width': 21, 'height': 41}]",2,markdown_table,1
2SP,2SP,"In a tiny gallery room there’s a long, narrow display wall and one copy of every rectangular painting must go on it. Each piece stays axis-aligned with the wall frame (no tilting), must lie entirely within the wall area, and cannot overlap another piece. The whole arrangement should use as little vertical space as possible — the used height equals the highest top edge of any painting on the wall. Positions are given by horizontal offset from the left and vertical offset from the bottom; exact dimensions are listed below.

{
  ""display_wall_width"": 160,
  ""display_wall_available_height"": 36,
  ""items"": [
    {
      ""painting_id"": 0,
      ""painting_width"": 57,
      ""painting_height"": 17
    },
    {
      ""painting_id"": 1,
      ""painting_width"": 18,
      ""painting_height"": 6
    },
    {
      ""painting_id"": 2,
      ""painting_width"": 31,
      ""painting_height"": 24
    },
    {
      ""painting_id"": 3,
      ""painting_width"": 6,
      ""painting_height"": 11
    },
    {
      ""painting_id"": 4,
      ""painting_width"": 17,
      ""painting_height"": 27
    },
    {
      ""painting_id"": 5,
      ""painting_width"": 8,
      ""painting_height"": 8
    },
    {
      ""painting_id"": 6,
      ""painting_width"": 73,
      ""painting_height"": 18
    }
  ]
}

If it helps, you can return the placement in a little JSON sketch like this:

{
  ""solution"": [{""item_type"": <painting_id>, ""x"": 0, ""y"": 0, ""width"": 10, ""height"": 5}, ...]
}

Here the ""solution"" list contains one entry per painting: ""item_type"" is the painting identifier, ""x"" and ""y"" are the horizontal and vertical offsets from the left and bottom of the wall, and ""width"" and ""height"" are the painting's dimensions. It's just a template to show the shape I expect — not the actual arrangement.

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”.""","{'items': [{'width': 57, 'height': 17, 'demand': 1}, {'width': 18, 'height': 6, 'demand': 1}, {'width': 31, 'height': 24, 'demand': 1}, {'width': 6, 'height': 11, 'demand': 1}, {'width': 17, 'height': 27, 'demand': 1}, {'width': 8, 'height': 8, 'demand': 1}, {'width': 73, 'height': 18, 'demand': 1}], 'bin_width': 160, 'bin_height': 36, 'is_strip_packing': False, 'solution': [{'item_type': 0, 'x': 18, 'y': 19, 'width': 57, 'height': 17}, {'item_type': 1, 'x': 0, 'y': 19, 'width': 18, 'height': 6}, {'item_type': 2, 'x': 75, 'y': 11, 'width': 31, 'height': 24}, {'item_type': 3, 'x': 73, 'y': 0, 'width': 6, 'height': 11}, {'item_type': 4, 'x': 143, 'y': 0, 'width': 17, 'height': 27}, {'item_type': 5, 'x': 106, 'y': 11, 'width': 8, 'height': 8}, {'item_type': 6, 'x': 0, 'y': 0, 'width': 73, 'height': 18}], 'obj': 36.0, 'is_nontrivial': True, 'problem_type': '2SP'}","[{'item_type': 0, 'x': 18, 'y': 19, 'width': 57, 'height': 17}, {'item_type': 1, 'x': 0, 'y': 19, 'width': 18, 'height': 6}, {'item_type': 2, 'x': 75, 'y': 11, 'width': 31, 'height': 24}, {'item_type': 3, 'x': 73, 'y': 0, 'width': 6, 'height': 11}, {'item_type': 4, 'x': 143, 'y': 0, 'width': 17, 'height': 27}, {'item_type': 5, 'x': 106, 'y': 11, 'width': 8, 'height': 8}, {'item_type': 6, 'x': 0, 'y': 0, 'width': 73, 'height': 18}]",36.0,"{'problem_type': '2SP', 'bin_width': 160, 'bin_height': 36, 'items': [{'item_id': 0, 'width': 57, 'height': 17}, {'item_id': 1, 'width': 18, 'height': 6}, {'item_id': 2, 'width': 31, 'height': 24}, {'item_id': 3, 'width': 6, 'height': 11}, {'item_id': 4, 'width': 17, 'height': 27}, {'item_id': 5, 'width': 8, 'height': 8}, {'item_id': 6, 'width': 73, 'height': 18}], 'num_item_types': 7}","[{'item_type': 0, 'x': 18, 'y': 19, 'width': 57, 'height': 17}, {'item_type': 1, 'x': 0, 'y': 19, 'width': 18, 'height': 6}, {'item_type': 2, 'x': 75, 'y': 11, 'width': 31, 'height': 24}, {'item_type': 3, 'x': 73, 'y': 0, 'width': 6, 'height': 11}, {'item_type': 4, 'x': 143, 'y': 0, 'width': 17, 'height': 27}, {'item_type': 5, 'x': 106, 'y': 11, 'width': 8, 'height': 8}, {'item_type': 6, 'x': 0, 'y': 0, 'width': 73, 'height': 18}]",3,json,0
2SP,2SP,"We were organizing a single set of different crates into one racking bay, making sure every type appears exactly once and every box stays aligned with the walls — no rotations, no sticking out. The choices are about horizontal placement from the left side and how crates get stacked vertically, with the rule that nothing can overlap and everything must remain inside the bay boundaries. The best arrangement is the one that results in the lowest overall stack; measure that by looking at the topmost crate and reading off its height from the floor. Concrete dimensions and the bay width appear below.

# rack_bay_width=160
# rack_bay_height=63
crate_type_id,crate_width,crate_height
1,78,35
2,18,13
3,38,48
4,6,6
5,19,6
6,5,9
7,21,6
8,64,19
9,12,33

Also, when you send back the actual arrangement, just use a simple JSON sketch like this so it's easy to parse:

{
  ""solution"": [{""item_type"": <crate_type_id>, ""x"": 0, ""y"": 0, ""width"": 10, ""height"": 5}, ...]
}

This little blob is just a template: ""solution"" is the list of crate placements. Each object says which crate type goes where — item_type is the crate type identifier, x and y are the bottom-left coordinates (distance from the left wall and the floor), and width/height are the crate's dimensions. Think of it as filling out a short form for each box.

Please remember to use the exact identifiers from the instance input — do not rename them or invent new labels.

- for example: ""Valid identifiers look like plain numbers such as “1” or “23”, single capital letters like “A” or “B”, or a capital letter followed by digits like “A1” or “X7”.""","{'items': [{'width': 78, 'height': 35, 'demand': 1}, {'width': 18, 'height': 13, 'demand': 1}, {'width': 38, 'height': 48, 'demand': 1}, {'width': 6, 'height': 6, 'demand': 1}, {'width': 19, 'height': 6, 'demand': 1}, {'width': 5, 'height': 9, 'demand': 1}, {'width': 21, 'height': 6, 'demand': 1}, {'width': 64, 'height': 19, 'demand': 1}, {'width': 12, 'height': 33, 'demand': 1}], 'bin_width': 160, 'bin_height': 63, 'is_strip_packing': False, 'solution': [{'item_type': 0, 'x': 38, 'y': 19, 'width': 78, 'height': 35}, {'item_type': 1, 'x': 43, 'y': 6, 'width': 18, 'height': 13}, {'item_type': 2, 'x': 0, 'y': 6, 'width': 38, 'height': 48}, {'item_type': 3, 'x': 0, 'y': 0, 'width': 6, 'height': 6}, {'item_type': 4, 'x': 125, 'y': 0, 'width': 19, 'height': 6}, {'item_type': 5, 'x': 38, 'y': 10, 'width': 5, 'height': 9}, {'item_type': 6, 'x': 6, 'y': 0, 'width': 21, 'height': 6}, {'item_type': 7, 'x': 61, 'y': 0, 'width': 64, 'height': 19}, {'item_type': 8, 'x': 116, 'y': 21, 'width': 12, 'height': 33}], 'obj': 54.0, 'is_nontrivial': True, 'problem_type': '2SP'}","[{'item_type': 0, 'x': 38, 'y': 19, 'width': 78, 'height': 35}, {'item_type': 1, 'x': 43, 'y': 6, 'width': 18, 'height': 13}, {'item_type': 2, 'x': 0, 'y': 6, 'width': 38, 'height': 48}, {'item_type': 3, 'x': 0, 'y': 0, 'width': 6, 'height': 6}, {'item_type': 4, 'x': 125, 'y': 0, 'width': 19, 'height': 6}, {'item_type': 5, 'x': 38, 'y': 10, 'width': 5, 'height': 9}, {'item_type': 6, 'x': 6, 'y': 0, 'width': 21, 'height': 6}, {'item_type': 7, 'x': 61, 'y': 0, 'width': 64, 'height': 19}, {'item_type': 8, 'x': 116, 'y': 21, 'width': 12, 'height': 33}]",54.0,"{'problem_type': '2SP', 'bin_width': 160, 'bin_height': 63, 'items': [{'item_id': 1, 'width': 78, 'height': 35}, {'item_id': 2, 'width': 18, 'height': 13}, {'item_id': 3, 'width': 38, 'height': 48}, {'item_id': 4, 'width': 6, 'height': 6}, {'item_id': 5, 'width': 19, 'height': 6}, {'item_id': 6, 'width': 5, 'height': 9}, {'item_id': 7, 'width': 21, 'height': 6}, {'item_id': 8, 'width': 64, 'height': 19}, {'item_id': 9, 'width': 12, 'height': 33}], 'num_item_types': 9}","[{'item_type': 1, 'x': 38, 'y': 19, 'width': 78, 'height': 35}, {'item_type': 2, 'x': 43, 'y': 6, 'width': 18, 'height': 13}, {'item_type': 3, 'x': 0, 'y': 6, 'width': 38, 'height': 48}, {'item_type': 4, 'x': 0, 'y': 0, 'width': 6, 'height': 6}, {'item_type': 5, 'x': 125, 'y': 0, 'width': 19, 'height': 6}, {'item_type': 6, 'x': 38, 'y': 10, 'width': 5, 'height': 9}, {'item_type': 7, 'x': 6, 'y': 0, 'width': 21, 'height': 6}, {'item_type': 8, 'x': 61, 'y': 0, 'width': 64, 'height': 19}, {'item_type': 9, 'x': 116, 'y': 21, 'width': 12, 'height': 33}]",4,csv,1
2SP,2SP,"I’m trying to fit one copy of every rectangular book spine onto a shallow, fixed-width shelf so every spine stands upright, stays parallel to the shelf sides, sits completely inside the shelf boundaries, and never overlaps another spine. The layout is judged by the tallest top edge among them — that highest point is the shelf height used, and the aim is to make that as small as possible. The concrete sizes and list will be shown below.

The shelf has usable horizontal width 160 and a vertical limit of 41.
One 1: width 26, height 7.
One 2: width 21, height 31.
One 3: width 5, height 25.
One 4: width 55, height 17.
One 5: width 57, height 22.
One 6: width 117, height 17.
I will arrange these spines to minimize the maximum top edge (the used shelf height).

Oh also — when you send the layout back, please follow a simple JSON shape so it's easy to check automatically. Here's the sketch of the exact structure I'm expecting:

{
  ""solution"": [{""item_type"": <book_id>, ""x"": 0, ""y"": 0, ""width"": 10, ""height"": 5}, ...]
}

This just means: ""solution"" is a list of placements. Each object says which book spine (item_type), where its bottom-left corner sits (x and y), and the spine's own width and height. Super casual: think of each object as one filled line on a form — which spine, where it starts, how big it is.

The JSON above is only a shape example, not the actual packing — please return your real placement in the same format. Also, use the identifiers exactly as they appear in the instance input — do not rename 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”.""","{'items': [{'width': 26, 'height': 7, 'demand': 1}, {'width': 21, 'height': 31, 'demand': 1}, {'width': 5, 'height': 25, 'demand': 1}, {'width': 55, 'height': 17, 'demand': 1}, {'width': 57, 'height': 22, 'demand': 1}, {'width': 117, 'height': 17, 'demand': 1}], 'bin_width': 160, 'bin_height': 41, 'is_strip_packing': False, 'solution': [{'item_type': 0, 'x': 122, 'y': 31, 'width': 26, 'height': 7}, {'item_type': 1, 'x': 122, 'y': 0, 'width': 21, 'height': 31}, {'item_type': 2, 'x': 0, 'y': 0, 'width': 5, 'height': 25}, {'item_type': 3, 'x': 5, 'y': 0, 'width': 55, 'height': 17}, {'item_type': 4, 'x': 60, 'y': 0, 'width': 57, 'height': 22}, {'item_type': 5, 'x': 5, 'y': 22, 'width': 117, 'height': 17}], 'obj': 39.0, 'is_nontrivial': True, 'problem_type': '2SP'}","[{'item_type': 0, 'x': 122, 'y': 31, 'width': 26, 'height': 7}, {'item_type': 1, 'x': 122, 'y': 0, 'width': 21, 'height': 31}, {'item_type': 2, 'x': 0, 'y': 0, 'width': 5, 'height': 25}, {'item_type': 3, 'x': 5, 'y': 0, 'width': 55, 'height': 17}, {'item_type': 4, 'x': 60, 'y': 0, 'width': 57, 'height': 22}, {'item_type': 5, 'x': 5, 'y': 22, 'width': 117, 'height': 17}]",39.0,"{'problem_type': '2SP', 'bin_width': 160, 'bin_height': 41, 'items': [{'item_id': 1, 'width': 26, 'height': 7}, {'item_id': 2, 'width': 21, 'height': 31}, {'item_id': 3, 'width': 5, 'height': 25}, {'item_id': 4, 'width': 55, 'height': 17}, {'item_id': 5, 'width': 57, 'height': 22}, {'item_id': 6, 'width': 117, 'height': 17}], 'num_item_types': 6}","[{'item_type': 1, 'x': 122, 'y': 31, 'width': 26, 'height': 7}, {'item_type': 2, 'x': 122, 'y': 0, 'width': 21, 'height': 31}, {'item_type': 3, 'x': 0, 'y': 0, 'width': 5, 'height': 25}, {'item_type': 4, 'x': 5, 'y': 0, 'width': 55, 'height': 17}, {'item_type': 5, 'x': 60, 'y': 0, 'width': 57, 'height': 22}, {'item_type': 6, 'x': 5, 'y': 22, 'width': 117, 'height': 17}]",5,nl,1
2SP,2SP,"Many people in the shop try to be clever about stacking bolts in our fixed-width chute: the trick is to place every single rectangular bolt (one of each type) so its sides sit parallel to the chute walls, they don’t overlap, and none protrudes outside. The quality of a stacking plan is determined by the tallest top edge among the bolts — measure straight up from the chute floor to that top edge, and a smaller number means a tighter, better stack. The instance details with the exact measurements are listed below.

{
  ""chute_inner_width"": 160,
  ""chute_height_limit"": 24,
  ""items"": [
    {
      ""bolt_type_id"": 0,
      ""bolt_width"": 16,
      ""bolt_height"": 3
    },
    {
      ""bolt_type_id"": 1,
      ""bolt_width"": 7,
      ""bolt_height"": 7
    },
    {
      ""bolt_type_id"": 2,
      ""bolt_width"": 34,
      ""bolt_height"": 7
    },
    {
      ""bolt_type_id"": 3,
      ""bolt_width"": 22,
      ""bolt_height"": 8
    },
    {
      ""bolt_type_id"": 4,
      ""bolt_width"": 57,
      ""bolt_height"": 17
    },
    {
      ""bolt_type_id"": 5,
      ""bolt_width"": 7,
      ""bolt_height"": 10
    },
    {
      ""bolt_type_id"": 6,
      ""bolt_width"": 42,
      ""bolt_height"": 6
    },
    {
      ""bolt_type_id"": 7,
      ""bolt_width"": 9,
      ""bolt_height"": 4
    },
    {
      ""bolt_type_id"": 8,
      ""bolt_width"": 18,
      ""bolt_height"": 6
    },
    {
      ""bolt_type_id"": 9,
      ""bolt_width"": 80,
      ""bolt_height"": 18
    }
  ]
}

If you want to hand me a packing plan, just slip it into this simple JSON shape so I can read it easily — nothing fancy, just a list of placed bolts with their positions and sizes.

{
  ""solution"": [{""item_type"": <bolt_type_id>, ""x"": 0, ""y"": 0, ""width"": 10, ""height"": 5}, ...]
}

Think of that block as a form: ""solution"" is the list of placements. Each object in the list tells me which bolt type it is (item_type), where its bottom-left corner sits (x and y), and how big the bolt is (width and height). Super casual: one object per bolt, coordinates measured from the chute floor and left wall.

This JSON is just a sketch of the expected shape, not the actual answer — fill it with the real identifiers and numbers when you submit a packing.

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”.","{'items': [{'width': 16, 'height': 3, 'demand': 1}, {'width': 7, 'height': 7, 'demand': 1}, {'width': 34, 'height': 7, 'demand': 1}, {'width': 22, 'height': 8, 'demand': 1}, {'width': 57, 'height': 17, 'demand': 1}, {'width': 7, 'height': 10, 'demand': 1}, {'width': 42, 'height': 6, 'demand': 1}, {'width': 9, 'height': 4, 'demand': 1}, {'width': 18, 'height': 6, 'demand': 1}, {'width': 80, 'height': 18, 'demand': 1}], 'bin_width': 160, 'bin_height': 24, 'is_strip_packing': False, 'solution': [{'item_type': 0, 'x': 87, 'y': 0, 'width': 16, 'height': 3}, {'item_type': 1, 'x': 96, 'y': 3, 'width': 7, 'height': 7}, {'item_type': 2, 'x': 126, 'y': 17, 'width': 34, 'height': 7}, {'item_type': 3, 'x': 81, 'y': 10, 'width': 22, 'height': 8}, {'item_type': 4, 'x': 103, 'y': 0, 'width': 57, 'height': 17}, {'item_type': 5, 'x': 80, 'y': 0, 'width': 7, 'height': 10}, {'item_type': 6, 'x': 84, 'y': 18, 'width': 42, 'height': 6}, {'item_type': 7, 'x': 0, 'y': 20, 'width': 9, 'height': 4}, {'item_type': 8, 'x': 9, 'y': 18, 'width': 18, 'height': 6}, {'item_type': 9, 'x': 0, 'y': 0, 'width': 80, 'height': 18}], 'obj': 24.0, 'is_nontrivial': True, 'problem_type': '2SP'}","[{'item_type': 0, 'x': 87, 'y': 0, 'width': 16, 'height': 3}, {'item_type': 1, 'x': 96, 'y': 3, 'width': 7, 'height': 7}, {'item_type': 2, 'x': 126, 'y': 17, 'width': 34, 'height': 7}, {'item_type': 3, 'x': 81, 'y': 10, 'width': 22, 'height': 8}, {'item_type': 4, 'x': 103, 'y': 0, 'width': 57, 'height': 17}, {'item_type': 5, 'x': 80, 'y': 0, 'width': 7, 'height': 10}, {'item_type': 6, 'x': 84, 'y': 18, 'width': 42, 'height': 6}, {'item_type': 7, 'x': 0, 'y': 20, 'width': 9, 'height': 4}, {'item_type': 8, 'x': 9, 'y': 18, 'width': 18, 'height': 6}, {'item_type': 9, 'x': 0, 'y': 0, 'width': 80, 'height': 18}]",24.0,"{'problem_type': '2SP', 'bin_width': 160, 'bin_height': 24, 'items': [{'item_id': 0, 'width': 16, 'height': 3}, {'item_id': 1, 'width': 7, 'height': 7}, {'item_id': 2, 'width': 34, 'height': 7}, {'item_id': 3, 'width': 22, 'height': 8}, {'item_id': 4, 'width': 57, 'height': 17}, {'item_id': 5, 'width': 7, 'height': 10}, {'item_id': 6, 'width': 42, 'height': 6}, {'item_id': 7, 'width': 9, 'height': 4}, {'item_id': 8, 'width': 18, 'height': 6}, {'item_id': 9, 'width': 80, 'height': 18}], 'num_item_types': 10}","[{'item_type': 0, 'x': 87, 'y': 0, 'width': 16, 'height': 3}, {'item_type': 1, 'x': 96, 'y': 3, 'width': 7, 'height': 7}, {'item_type': 2, 'x': 126, 'y': 17, 'width': 34, 'height': 7}, {'item_type': 3, 'x': 81, 'y': 10, 'width': 22, 'height': 8}, {'item_type': 4, 'x': 103, 'y': 0, 'width': 57, 'height': 17}, {'item_type': 5, 'x': 80, 'y': 0, 'width': 7, 'height': 10}, {'item_type': 6, 'x': 84, 'y': 18, 'width': 42, 'height': 6}, {'item_type': 7, 'x': 0, 'y': 20, 'width': 9, 'height': 4}, {'item_type': 8, 'x': 9, 'y': 18, 'width': 18, 'height': 6}, {'item_type': 9, 'x': 0, 'y': 0, 'width': 80, 'height': 18}]",6,json,0
2SP,2SP,"There’s this job where a bunch of rectangular sign pieces need to be mounted on a tall signboard with a fixed width; each piece must be mounted once, kept upright with its edges parallel to the board, and placed so none overlap or stick off the board. For each piece, you decide how far from the left edge it sits and how high its bottom edge is, and then you check the very highest top edge among all panels — the better plan is the one that keeps that highest point as low as possible. The specific panel dimensions and the board width are shown below.

# board_width=160
# used_board_height=49
panel_id,panel_width,panel_height
0,62,17
1,4,27
2,20,37
3,67,16
4,62,18
5,15,22
6,10,13
7,78,15
8,72,12

Also, when you send back the placement plan, just use this little JSON shape so it's easy to read and check:

{
  ""solution"": [{""item_type"": <panel_type_id>, ""x"": 0, ""y"": 0, ""width"": 10, ""height"": 5}, ...]
}

This is just a sketch of the shape I expect, not the actual answer. In plain terms: ""solution"" is a list of the panels you place; each entry says which panel type it is (item_type), how far from the left edge it sits (x), how high its bottom sits (y), and the panel's width and height. Think of it like a short form to tell me ""panel X at (x,y) with these dimensions.""

Please keep in mind that every identifier must match the instance input exactly — 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”.","{'items': [{'width': 62, 'height': 17, 'demand': 1}, {'width': 4, 'height': 27, 'demand': 1}, {'width': 20, 'height': 37, 'demand': 1}, {'width': 67, 'height': 16, 'demand': 1}, {'width': 62, 'height': 18, 'demand': 1}, {'width': 15, 'height': 22, 'demand': 1}, {'width': 10, 'height': 13, 'demand': 1}, {'width': 78, 'height': 15, 'demand': 1}, {'width': 72, 'height': 12, 'demand': 1}], 'bin_width': 160, 'bin_height': 49, 'is_strip_packing': False, 'solution': [{'item_type': 0, 'x': 24, 'y': 32, 'width': 62, 'height': 17}, {'item_type': 1, 'x': 0, 'y': 22, 'width': 4, 'height': 27}, {'item_type': 2, 'x': 4, 'y': 12, 'width': 20, 'height': 37}, {'item_type': 3, 'x': 72, 'y': 0, 'width': 67, 'height': 16}, {'item_type': 4, 'x': 98, 'y': 31, 'width': 62, 'height': 18}, {'item_type': 5, 'x': 145, 'y': 0, 'width': 15, 'height': 22}, {'item_type': 6, 'x': 24, 'y': 12, 'width': 10, 'height': 13}, {'item_type': 7, 'x': 34, 'y': 16, 'width': 78, 'height': 15}, {'item_type': 8, 'x': 0, 'y': 0, 'width': 72, 'height': 12}], 'obj': 49.0, 'is_nontrivial': True, 'problem_type': '2SP'}","[{'item_type': 0, 'x': 24, 'y': 32, 'width': 62, 'height': 17}, {'item_type': 1, 'x': 0, 'y': 22, 'width': 4, 'height': 27}, {'item_type': 2, 'x': 4, 'y': 12, 'width': 20, 'height': 37}, {'item_type': 3, 'x': 72, 'y': 0, 'width': 67, 'height': 16}, {'item_type': 4, 'x': 98, 'y': 31, 'width': 62, 'height': 18}, {'item_type': 5, 'x': 145, 'y': 0, 'width': 15, 'height': 22}, {'item_type': 6, 'x': 24, 'y': 12, 'width': 10, 'height': 13}, {'item_type': 7, 'x': 34, 'y': 16, 'width': 78, 'height': 15}, {'item_type': 8, 'x': 0, 'y': 0, 'width': 72, 'height': 12}]",49.0,"{'problem_type': '2SP', 'bin_width': 160, 'bin_height': 49, 'items': [{'item_id': 0, 'width': 62, 'height': 17}, {'item_id': 1, 'width': 4, 'height': 27}, {'item_id': 2, 'width': 20, 'height': 37}, {'item_id': 3, 'width': 67, 'height': 16}, {'item_id': 4, 'width': 62, 'height': 18}, {'item_id': 5, 'width': 15, 'height': 22}, {'item_id': 6, 'width': 10, 'height': 13}, {'item_id': 7, 'width': 78, 'height': 15}, {'item_id': 8, 'width': 72, 'height': 12}], 'num_item_types': 9}","[{'item_type': 0, 'x': 24, 'y': 32, 'width': 62, 'height': 17}, {'item_type': 1, 'x': 0, 'y': 22, 'width': 4, 'height': 27}, {'item_type': 2, 'x': 4, 'y': 12, 'width': 20, 'height': 37}, {'item_type': 3, 'x': 72, 'y': 0, 'width': 67, 'height': 16}, {'item_type': 4, 'x': 98, 'y': 31, 'width': 62, 'height': 18}, {'item_type': 5, 'x': 145, 'y': 0, 'width': 15, 'height': 22}, {'item_type': 6, 'x': 24, 'y': 12, 'width': 10, 'height': 13}, {'item_type': 7, 'x': 34, 'y': 16, 'width': 78, 'height': 15}, {'item_type': 8, 'x': 0, 'y': 0, 'width': 72, 'height': 12}]",7,csv,0
2SP,2SP,"We’ve got a roll of fixed width and a pile of different poster prints; the plan is to lay one copy of each poster down flat, with their sides parallel to the roll edges so nothing is rotated. The decision is where along the roll (how far in from the left and how far up from the bottom) each poster should sit so none overlap and every poster is completely on the roll. The “best” arrangement is the one where the highest top edge among all posters is as low as possible — that highest top edge is what counts as the used height. The concrete poster dimensions and roll measurements follow below.

# roll_usable_width=160
# roll_height_limit=179
poster_label,poster_width,poster_height
A,44,109
B,25,34
C,35,137
D,146,25
E,31,68
F,115,22
G,36,15

You can just send back the layout in a little JSON snippet like this — nothing fancy, just that shape so I can read it programmatically.

{
  ""solution"": [{""item_type"": <poster_type_id>, ""x"": 0, ""y"": 0, ""width"": 10, ""height"": 5}, ...]
}

This shows the kind of info I need: ""solution"" is a list of placements, each entry names which poster type it is (use the poster type identifier), the x and y coordinates of the poster's bottom-left corner on the roll, and the poster's width and height. It’s just a sketch of the expected shape, not the actual final packing.

Please make sure to use the exact identifiers from the instance input — don’t rename them or invent new labels. Valid identifiers look like plain numbers such as ""1"" or ""23"", single capital letters like ""A"" or ""B"", or a capital letter followed by digits like ""A1"" or ""X7"".","{'items': [{'width': 44, 'height': 109, 'demand': 1}, {'width': 25, 'height': 34, 'demand': 1}, {'width': 35, 'height': 137, 'demand': 1}, {'width': 146, 'height': 25, 'demand': 1}, {'width': 31, 'height': 68, 'demand': 1}, {'width': 115, 'height': 22, 'demand': 1}, {'width': 36, 'height': 15, 'demand': 1}], 'bin_width': 160, 'bin_height': 179, 'is_strip_packing': False, 'solution': [{'item_type': 0, 'x': 0, 'y': 53, 'width': 44, 'height': 109}, {'item_type': 1, 'x': 44, 'y': 62, 'width': 25, 'height': 34}, {'item_type': 2, 'x': 125, 'y': 25, 'width': 35, 'height': 137}, {'item_type': 3, 'x': 0, 'y': 0, 'width': 146, 'height': 25}, {'item_type': 4, 'x': 69, 'y': 62, 'width': 31, 'height': 68}, {'item_type': 5, 'x': 10, 'y': 25, 'width': 115, 'height': 22}, {'item_type': 6, 'x': 44, 'y': 47, 'width': 36, 'height': 15}], 'obj': 162.0, 'is_nontrivial': True, 'problem_type': '2SP'}","[{'item_type': 0, 'x': 0, 'y': 53, 'width': 44, 'height': 109}, {'item_type': 1, 'x': 44, 'y': 62, 'width': 25, 'height': 34}, {'item_type': 2, 'x': 125, 'y': 25, 'width': 35, 'height': 137}, {'item_type': 3, 'x': 0, 'y': 0, 'width': 146, 'height': 25}, {'item_type': 4, 'x': 69, 'y': 62, 'width': 31, 'height': 68}, {'item_type': 5, 'x': 10, 'y': 25, 'width': 115, 'height': 22}, {'item_type': 6, 'x': 44, 'y': 47, 'width': 36, 'height': 15}]",162.0,"{'problem_type': '2SP', 'bin_width': 160, 'bin_height': 179, 'items': [{'item_id': 'A', 'width': 44, 'height': 109}, {'item_id': 'B', 'width': 25, 'height': 34}, {'item_id': 'C', 'width': 35, 'height': 137}, {'item_id': 'D', 'width': 146, 'height': 25}, {'item_id': 'E', 'width': 31, 'height': 68}, {'item_id': 'F', 'width': 115, 'height': 22}, {'item_id': 'G', 'width': 36, 'height': 15}], 'num_item_types': 7}","[{'item_type': 'A', 'x': 0, 'y': 53, 'width': 44, 'height': 109}, {'item_type': 'B', 'x': 44, 'y': 62, 'width': 25, 'height': 34}, {'item_type': 'C', 'x': 125, 'y': 25, 'width': 35, 'height': 137}, {'item_type': 'D', 'x': 0, 'y': 0, 'width': 146, 'height': 25}, {'item_type': 'E', 'x': 69, 'y': 62, 'width': 31, 'height': 68}, {'item_type': 'F', 'x': 10, 'y': 25, 'width': 115, 'height': 22}, {'item_type': 'G', 'x': 44, 'y': 47, 'width': 36, 'height': 15}]",8,csv,names
2SP,2SP,"On a narrow balcony ledge sat a collection of rectangular planters that all needed a spot — exactly one of each, placed squarely so their edges line up with the ledge and none of them hang off or overlap. Positions are given by how far across from the left they sit and how high their bottoms are, and each planter’s top is simply its bottom level plus its height; the arrangement that keeps the tallest of those tops as low as possible is the one to aim for. The concrete sizes for the ledge and planters are listed below.

The ledge measures 160 units across and allows up to 108 units of vertical stacking.
Planter 1: 95 wide and 20 tall.
Planter 2: 26 wide and 11 tall.
Planter 3: 151 wide and 25 tall.
Planter 4: 33 wide and 9 tall.
Planter 5: 21 wide and 44 tall.
Planter 6: 44 wide and 60 tall.
Planter 7: 63 wide and 83 tall.
Planter 8: 11 wide and 37 tall.
Each planter must sit squarely within the 160 by 108 ledge so none hang off or overlap; arrange them to keep the highest top as low as possible.

If you'd like me to return a placement, I usually pack it into a tiny JSON snippet so it's easy to read and reuse. Here's the shape I expect — just a quick sketch of the layout rather than the final answer:

{
  ""solution"": [{""item_type"": <planter_type_id>, ""x"": 0, ""y"": 0, ""width"": 10, ""height"": 5}, ...]
}

""item_type"" is the placeholder for which planter (one of the planter types) you're placing; x and y say how far it sits from the left edge and the bottom edge of the ledge; width and height are the planter's own sizes. Think of each entry as a little label on a form: which planter, where its bottom-left corner is, and how big it is. This block is just the expected shape — not the actual arrangement.

Please be sure to use the exact identifiers from the instance input when you give actual placements — 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”.","{'items': [{'width': 95, 'height': 20, 'demand': 1}, {'width': 26, 'height': 11, 'demand': 1}, {'width': 151, 'height': 25, 'demand': 1}, {'width': 33, 'height': 9, 'demand': 1}, {'width': 21, 'height': 44, 'demand': 1}, {'width': 44, 'height': 60, 'demand': 1}, {'width': 63, 'height': 83, 'demand': 1}, {'width': 11, 'height': 37, 'demand': 1}], 'bin_width': 160, 'bin_height': 108, 'is_strip_packing': False, 'solution': [{'item_type': 0, 'x': 63, 'y': 0, 'width': 95, 'height': 20}, {'item_type': 1, 'x': 63, 'y': 72, 'width': 26, 'height': 11}, {'item_type': 2, 'x': 0, 'y': 83, 'width': 151, 'height': 25}, {'item_type': 3, 'x': 63, 'y': 20, 'width': 33, 'height': 9}, {'item_type': 4, 'x': 89, 'y': 29, 'width': 21, 'height': 44}, {'item_type': 5, 'x': 116, 'y': 20, 'width': 44, 'height': 60}, {'item_type': 6, 'x': 0, 'y': 0, 'width': 63, 'height': 83}, {'item_type': 7, 'x': 63, 'y': 29, 'width': 11, 'height': 37}], 'obj': 108.0, 'is_nontrivial': True, 'problem_type': '2SP'}","[{'item_type': 0, 'x': 63, 'y': 0, 'width': 95, 'height': 20}, {'item_type': 1, 'x': 63, 'y': 72, 'width': 26, 'height': 11}, {'item_type': 2, 'x': 0, 'y': 83, 'width': 151, 'height': 25}, {'item_type': 3, 'x': 63, 'y': 20, 'width': 33, 'height': 9}, {'item_type': 4, 'x': 89, 'y': 29, 'width': 21, 'height': 44}, {'item_type': 5, 'x': 116, 'y': 20, 'width': 44, 'height': 60}, {'item_type': 6, 'x': 0, 'y': 0, 'width': 63, 'height': 83}, {'item_type': 7, 'x': 63, 'y': 29, 'width': 11, 'height': 37}]",108.0,"{'problem_type': '2SP', 'bin_width': 160, 'bin_height': 108, 'items': [{'item_id': 1, 'width': 95, 'height': 20}, {'item_id': 2, 'width': 26, 'height': 11}, {'item_id': 3, 'width': 151, 'height': 25}, {'item_id': 4, 'width': 33, 'height': 9}, {'item_id': 5, 'width': 21, 'height': 44}, {'item_id': 6, 'width': 44, 'height': 60}, {'item_id': 7, 'width': 63, 'height': 83}, {'item_id': 8, 'width': 11, 'height': 37}], 'num_item_types': 8}","[{'item_type': 1, 'x': 63, 'y': 0, 'width': 95, 'height': 20}, {'item_type': 2, 'x': 63, 'y': 72, 'width': 26, 'height': 11}, {'item_type': 3, 'x': 0, 'y': 83, 'width': 151, 'height': 25}, {'item_type': 4, 'x': 63, 'y': 20, 'width': 33, 'height': 9}, {'item_type': 5, 'x': 89, 'y': 29, 'width': 21, 'height': 44}, {'item_type': 6, 'x': 116, 'y': 20, 'width': 44, 'height': 60}, {'item_type': 7, 'x': 0, 'y': 0, 'width': 63, 'height': 83}, {'item_type': 8, 'x': 63, 'y': 29, 'width': 11, 'height': 37}]",9,nl,1
2SP,2SP,"One afternoon the stage manager asked for a neat stacking of flat scenic elements in a narrow wing: each element placed once, kept axis-aligned with the wing edges, and arranged so none overlap or stick outside. Every piece is located by choosing the coordinates of its bottom-left corner — how far from the left wall and how high from the floor — and the layout is judged by the maximum top-edge height among all pieces; the lower that value, the better the packing. No element may be omitted or repeated, and full dimensions follow below.

{
  ""wing_width"": 160,
  ""wing_height_limit"": 34,
  ""items"": [
    {
      ""element_id"": 0,
      ""element_width"": 64,
      ""element_height"": 17
    },
    {
      ""element_id"": 1,
      ""element_width"": 82,
      ""element_height"": 14
    },
    {
      ""element_id"": 2,
      ""element_width"": 4,
      ""element_height"": 21
    },
    {
      ""element_id"": 3,
      ""element_width"": 52,
      ""element_height"": 14
    },
    {
      ""element_id"": 4,
      ""element_width"": 2,
      ""element_height"": 13
    },
    {
      ""element_id"": 5,
      ""element_width"": 12,
      ""element_height"": 26
    }
  ]
}

If you want to send the layout back to me, a small JSON sketch like this is perfect — just list each piece and where its bottom-left corner should go.

{
  ""solution"": [{""item_type"": <scenic_element_id>, ""x"": 0, ""y"": 0, ""width"": 10, ""height"": 5}, ...]
}

Think of that as a little form: ""solution"" is the list of placements, each entry says which scenic element (item_type), how far from the left wall (x) and floor (y) its bottom-left corner is, and the element's width and height. It's just the shape I expect, not the actual answer.

Please use the exact identifiers from the instance input — don't rename them or invent new labels. For example: ""Valid identifiers look like plain numbers such as “1” or “23”, single capital letters like “A” or “B”, or a capital letter followed by digits like “A1” or “X7”.""","{'items': [{'width': 64, 'height': 17, 'demand': 1}, {'width': 82, 'height': 14, 'demand': 1}, {'width': 4, 'height': 21, 'demand': 1}, {'width': 52, 'height': 14, 'demand': 1}, {'width': 2, 'height': 13, 'demand': 1}, {'width': 12, 'height': 26, 'demand': 1}], 'bin_width': 160, 'bin_height': 34, 'is_strip_packing': False, 'solution': [{'item_type': 0, 'x': 96, 'y': 14, 'width': 64, 'height': 17}, {'item_type': 1, 'x': 78, 'y': 0, 'width': 82, 'height': 14}, {'item_type': 2, 'x': 0, 'y': 0, 'width': 4, 'height': 21}, {'item_type': 3, 'x': 26, 'y': 0, 'width': 52, 'height': 14}, {'item_type': 4, 'x': 24, 'y': 0, 'width': 2, 'height': 13}, {'item_type': 5, 'x': 4, 'y': 0, 'width': 12, 'height': 26}], 'obj': 31.0, 'is_nontrivial': True, 'problem_type': '2SP'}","[{'item_type': 0, 'x': 96, 'y': 14, 'width': 64, 'height': 17}, {'item_type': 1, 'x': 78, 'y': 0, 'width': 82, 'height': 14}, {'item_type': 2, 'x': 0, 'y': 0, 'width': 4, 'height': 21}, {'item_type': 3, 'x': 26, 'y': 0, 'width': 52, 'height': 14}, {'item_type': 4, 'x': 24, 'y': 0, 'width': 2, 'height': 13}, {'item_type': 5, 'x': 4, 'y': 0, 'width': 12, 'height': 26}]",31.0,"{'problem_type': '2SP', 'bin_width': 160, 'bin_height': 34, 'items': [{'item_id': 0, 'width': 64, 'height': 17}, {'item_id': 1, 'width': 82, 'height': 14}, {'item_id': 2, 'width': 4, 'height': 21}, {'item_id': 3, 'width': 52, 'height': 14}, {'item_id': 4, 'width': 2, 'height': 13}, {'item_id': 5, 'width': 12, 'height': 26}], 'num_item_types': 6}","[{'item_type': 0, 'x': 96, 'y': 14, 'width': 64, 'height': 17}, {'item_type': 1, 'x': 78, 'y': 0, 'width': 82, 'height': 14}, {'item_type': 2, 'x': 0, 'y': 0, 'width': 4, 'height': 21}, {'item_type': 3, 'x': 26, 'y': 0, 'width': 52, 'height': 14}, {'item_type': 4, 'x': 24, 'y': 0, 'width': 2, 'height': 13}, {'item_type': 5, 'x': 4, 'y': 0, 'width': 12, 'height': 26}]",10,json,0
2SP,2SP,"Recently a store manager tried to stack one of every folded clothing bundle into a narrow fixed-width display column. The rule was to place each stack flat and aligned with the column walls (no turning or angling), choose its spot by how far it is from the left wall and from the floor, and include each bundle exactly once with no overlaps and no part sticking outside. The trick is to arrange them so the tallest top edge is as low as possible — the total used height is simply the vertical distance from the bottom of the column to that highest top. The specific dimensions are given below.

They were: display column width 160 and maximum height 97.
Bundle A measures 48 by 23.
Bundle B measures 34 by 51.
Bundle C measures 50 by 41.
Bundle D measures 20 by 20.
Bundle E measures 28 by 71.
Bundle F measures 93 by 20.
Bundle G measures 26 by 31.
Bundle H measures 18 by 74.
Bundle I measures 23 by 4.
Arrange them so the highest top edge is minimized while keeping every bundle within the 160-wide column and below height 97.

If you want to hand me the layout, just send it back in a little JSON snippet like this — nothing fancy, just the shape shown below.

{
  ""solution"": [{""item_type"": <bundle_type_id>, ""x"": 0, ""y"": 0, ""width"": 10, ""height"": 5}, ...]
}

Think of that JSON as a simple form: ""solution"" is the list of placed bundles, each entry says which bundle type it is, how far it sits from the left (""x"") and the floor (""y""), and the bundle's width and height. It's just a sketch of the expected shape — not the real packing answer.

Please make sure you use the exact identifiers from the instance input — no renaming and no new labels. Valid identifiers look like these examples:
- 1 or 23
- A or B
- A1 or X7","{'items': [{'width': 48, 'height': 23, 'demand': 1}, {'width': 34, 'height': 51, 'demand': 1}, {'width': 50, 'height': 41, 'demand': 1}, {'width': 20, 'height': 20, 'demand': 1}, {'width': 28, 'height': 71, 'demand': 1}, {'width': 93, 'height': 20, 'demand': 1}, {'width': 26, 'height': 31, 'demand': 1}, {'width': 18, 'height': 74, 'demand': 1}, {'width': 23, 'height': 4, 'demand': 1}], 'bin_width': 160, 'bin_height': 97, 'is_strip_packing': False, 'solution': [{'item_type': 0, 'x': 66, 'y': 41, 'width': 48, 'height': 23}, {'item_type': 1, 'x': 26, 'y': 0, 'width': 34, 'height': 51}, {'item_type': 2, 'x': 60, 'y': 0, 'width': 50, 'height': 41}, {'item_type': 3, 'x': 0, 'y': 0, 'width': 20, 'height': 20}, {'item_type': 4, 'x': 132, 'y': 0, 'width': 28, 'height': 71}, {'item_type': 5, 'x': 0, 'y': 64, 'width': 93, 'height': 20}, {'item_type': 6, 'x': 0, 'y': 20, 'width': 26, 'height': 31}, {'item_type': 7, 'x': 114, 'y': 0, 'width': 18, 'height': 74}, {'item_type': 8, 'x': 26, 'y': 51, 'width': 23, 'height': 4}], 'obj': 84.0, 'is_nontrivial': True, 'problem_type': '2SP'}","[{'item_type': 0, 'x': 66, 'y': 41, 'width': 48, 'height': 23}, {'item_type': 1, 'x': 26, 'y': 0, 'width': 34, 'height': 51}, {'item_type': 2, 'x': 60, 'y': 0, 'width': 50, 'height': 41}, {'item_type': 3, 'x': 0, 'y': 0, 'width': 20, 'height': 20}, {'item_type': 4, 'x': 132, 'y': 0, 'width': 28, 'height': 71}, {'item_type': 5, 'x': 0, 'y': 64, 'width': 93, 'height': 20}, {'item_type': 6, 'x': 0, 'y': 20, 'width': 26, 'height': 31}, {'item_type': 7, 'x': 114, 'y': 0, 'width': 18, 'height': 74}, {'item_type': 8, 'x': 26, 'y': 51, 'width': 23, 'height': 4}]",84.0,"{'problem_type': '2SP', 'bin_width': 160, 'bin_height': 97, 'items': [{'item_id': 'A', 'width': 48, 'height': 23}, {'item_id': 'B', 'width': 34, 'height': 51}, {'item_id': 'C', 'width': 50, 'height': 41}, {'item_id': 'D', 'width': 20, 'height': 20}, {'item_id': 'E', 'width': 28, 'height': 71}, {'item_id': 'F', 'width': 93, 'height': 20}, {'item_id': 'G', 'width': 26, 'height': 31}, {'item_id': 'H', 'width': 18, 'height': 74}, {'item_id': 'I', 'width': 23, 'height': 4}], 'num_item_types': 9}","[{'item_type': 'A', 'x': 66, 'y': 41, 'width': 48, 'height': 23}, {'item_type': 'B', 'x': 26, 'y': 0, 'width': 34, 'height': 51}, {'item_type': 'C', 'x': 60, 'y': 0, 'width': 50, 'height': 41}, {'item_type': 'D', 'x': 0, 'y': 0, 'width': 20, 'height': 20}, {'item_type': 'E', 'x': 132, 'y': 0, 'width': 28, 'height': 71}, {'item_type': 'F', 'x': 0, 'y': 64, 'width': 93, 'height': 20}, {'item_type': 'G', 'x': 0, 'y': 20, 'width': 26, 'height': 31}, {'item_type': 'H', 'x': 114, 'y': 0, 'width': 18, 'height': 74}, {'item_type': 'I', 'x': 26, 'y': 51, 'width': 23, 'height': 4}]",11,nl,names
2SP,2SP,"On a typical maintenance day there was a single-width bay and a handful of flat panels to fit in, one of each. The panels had to sit squarely against the rails, remain completely inside the bay without overlapping, and each placement could be described by how far it sits from the left rail and from the bottom. The goal was to keep the highest top edge as low as possible — the used height equals the vertical distance up to that top edge from the bay floor — the concrete dimensions and bay width are shown below.

{
  ""bay_interior_width"": 160,
  ""bay_internal_height_limit"": 65,
  ""items"": [
    {
      ""panel_id"": 1,
      ""panel_width"": 44,
      ""panel_height"": 11
    },
    {
      ""panel_id"": 2,
      ""panel_width"": 40,
      ""panel_height"": 12
    },
    {
      ""panel_id"": 3,
      ""panel_width"": 55,
      ""panel_height"": 50
    },
    {
      ""panel_id"": 4,
      ""panel_width"": 33,
      ""panel_height"": 36
    },
    {
      ""panel_id"": 5,
      ""panel_width"": 16,
      ""panel_height"": 13
    },
    {
      ""panel_id"": 6,
      ""panel_width"": 89,
      ""panel_height"": 17
    },
    {
      ""panel_id"": 7,
      ""panel_width"": 24,
      ""panel_height"": 39
    },
    {
      ""panel_id"": 8,
      ""panel_width"": 1,
      ""panel_height"": 3
    }
  ]
}

If you want to hand me a placement, a handy way to give it is this little JSON sketch.

{
  ""solution"": [{""item_type"": <panel_type_id>, ""x"": 0, ""y"": 0, ""width"": 10, ""height"": 5}, ...]
}

Think of it like a simple form: ""solution"" is the list of panel placements; each object says which panel type it is (item_type), how far it sits from the left (x) and the floor (y), and the panel's own width and height. It's just the expected shape of the reply — not the actual placement yet.

Please make sure all panel identifiers are used exactly as they appear in the instance input — do not rename them or invent new labels.
- for example: ""Valid identifiers look like plain numbers such as “1” or “23”, single capital letters like “A” or “B”, or a capital letter followed by digits like “A1” or “X7”.""","{'items': [{'width': 44, 'height': 11, 'demand': 1}, {'width': 40, 'height': 12, 'demand': 1}, {'width': 55, 'height': 50, 'demand': 1}, {'width': 33, 'height': 36, 'demand': 1}, {'width': 16, 'height': 13, 'demand': 1}, {'width': 89, 'height': 17, 'demand': 1}, {'width': 24, 'height': 39, 'demand': 1}, {'width': 1, 'height': 3, 'demand': 1}], 'bin_width': 160, 'bin_height': 65, 'is_strip_packing': False, 'solution': [{'item_type': 0, 'x': 0, 'y': 17, 'width': 44, 'height': 11}, {'item_type': 1, 'x': 0, 'y': 28, 'width': 40, 'height': 12}, {'item_type': 2, 'x': 105, 'y': 6, 'width': 55, 'height': 50}, {'item_type': 3, 'x': 68, 'y': 20, 'width': 33, 'height': 36}, {'item_type': 4, 'x': 89, 'y': 0, 'width': 16, 'height': 13}, {'item_type': 5, 'x': 0, 'y': 0, 'width': 89, 'height': 17}, {'item_type': 6, 'x': 44, 'y': 17, 'width': 24, 'height': 39}, {'item_type': 7, 'x': 77, 'y': 17, 'width': 1, 'height': 3}], 'obj': 56.0, 'is_nontrivial': True, 'problem_type': '2SP'}","[{'item_type': 0, 'x': 0, 'y': 17, 'width': 44, 'height': 11}, {'item_type': 1, 'x': 0, 'y': 28, 'width': 40, 'height': 12}, {'item_type': 2, 'x': 105, 'y': 6, 'width': 55, 'height': 50}, {'item_type': 3, 'x': 68, 'y': 20, 'width': 33, 'height': 36}, {'item_type': 4, 'x': 89, 'y': 0, 'width': 16, 'height': 13}, {'item_type': 5, 'x': 0, 'y': 0, 'width': 89, 'height': 17}, {'item_type': 6, 'x': 44, 'y': 17, 'width': 24, 'height': 39}, {'item_type': 7, 'x': 77, 'y': 17, 'width': 1, 'height': 3}]",56.0,"{'problem_type': '2SP', 'bin_width': 160, 'bin_height': 65, 'items': [{'item_id': 1, 'width': 44, 'height': 11}, {'item_id': 2, 'width': 40, 'height': 12}, {'item_id': 3, 'width': 55, 'height': 50}, {'item_id': 4, 'width': 33, 'height': 36}, {'item_id': 5, 'width': 16, 'height': 13}, {'item_id': 6, 'width': 89, 'height': 17}, {'item_id': 7, 'width': 24, 'height': 39}, {'item_id': 8, 'width': 1, 'height': 3}], 'num_item_types': 8}","[{'item_type': 1, 'x': 0, 'y': 17, 'width': 44, 'height': 11}, {'item_type': 2, 'x': 0, 'y': 28, 'width': 40, 'height': 12}, {'item_type': 3, 'x': 105, 'y': 6, 'width': 55, 'height': 50}, {'item_type': 4, 'x': 68, 'y': 20, 'width': 33, 'height': 36}, {'item_type': 5, 'x': 89, 'y': 0, 'width': 16, 'height': 13}, {'item_type': 6, 'x': 0, 'y': 0, 'width': 89, 'height': 17}, {'item_type': 7, 'x': 44, 'y': 17, 'width': 24, 'height': 39}, {'item_type': 8, 'x': 77, 'y': 17, 'width': 1, 'height': 3}]",12,json,1
2SP,2SP,"Someone on the installation team has to place one of each rectangular solar panel onto a fixed-width tower face, keeping them square with the sides (no rotating) and fully on the face, and making sure no two panels overlap. Every panel’s location is given by where its bottom-left corner sits — how far in from the left edge and how far up from the bottom — and the aim is to pack them so the stack reaches the least possible height. Practically, that means looking at the top edge of every panel and minimizing the highest of those top edges; nothing can be omitted or duplicated. The exact sizes and the tower’s width are shown below.

# tower_face_width=160
# tower_face_height=93
panel_id,panel_width,panel_height
A,89,21
B,22,71
C,14,66
D,29,12
E,18,12
F,57,23
G,75,44
H,24,5

You can just send the final packing in a simple JSON form so the installers (and whatever script reads this) know exactly where each panel goes. Something like this:

{
  ""solution"": [{""item_type"": <panel_type_id>, ""x"": 0, ""y"": 0, ""width"": 10, ""height"": 5}, ...]
}

A quick note on what the fields mean in plain language: ""solution"" is the list of panels to place; each object is one panel type, ""item_type"" is the panel's identifier, ""x"" and ""y"" are how far in from the left edge and how far up from the bottom the panel's bottom-left corner sits, and ""width"" and ""height"" are that panel's size. This JSON is just a sketch of the shape I expect, not the actual placement — fill it with the real values when you're ready.

Please make sure to use the exact identifiers from the instance input — no renaming and no new labels. Valid identifiers look like plain numbers such as “1” or “23”, single capital letters like “A” or “B”, or a capital letter followed by digits like “A1” or “X7”.","{'items': [{'width': 89, 'height': 21, 'demand': 1}, {'width': 22, 'height': 71, 'demand': 1}, {'width': 14, 'height': 66, 'demand': 1}, {'width': 29, 'height': 12, 'demand': 1}, {'width': 18, 'height': 12, 'demand': 1}, {'width': 57, 'height': 23, 'demand': 1}, {'width': 75, 'height': 44, 'demand': 1}, {'width': 24, 'height': 5, 'demand': 1}], 'bin_width': 160, 'bin_height': 93, 'is_strip_packing': False, 'solution': [{'item_type': 0, 'x': 24, 'y': 0, 'width': 89, 'height': 21}, {'item_type': 1, 'x': 0, 'y': 5, 'width': 22, 'height': 71}, {'item_type': 2, 'x': 146, 'y': 21, 'width': 14, 'height': 66}, {'item_type': 3, 'x': 117, 'y': 76, 'width': 29, 'height': 12}, {'item_type': 4, 'x': 99, 'y': 76, 'width': 18, 'height': 12}, {'item_type': 5, 'x': 22, 'y': 21, 'width': 57, 'height': 23}, {'item_type': 6, 'x': 22, 'y': 44, 'width': 75, 'height': 44}, {'item_type': 7, 'x': 0, 'y': 0, 'width': 24, 'height': 5}], 'obj': 88.0, 'is_nontrivial': True, 'problem_type': '2SP'}","[{'item_type': 0, 'x': 24, 'y': 0, 'width': 89, 'height': 21}, {'item_type': 1, 'x': 0, 'y': 5, 'width': 22, 'height': 71}, {'item_type': 2, 'x': 146, 'y': 21, 'width': 14, 'height': 66}, {'item_type': 3, 'x': 117, 'y': 76, 'width': 29, 'height': 12}, {'item_type': 4, 'x': 99, 'y': 76, 'width': 18, 'height': 12}, {'item_type': 5, 'x': 22, 'y': 21, 'width': 57, 'height': 23}, {'item_type': 6, 'x': 22, 'y': 44, 'width': 75, 'height': 44}, {'item_type': 7, 'x': 0, 'y': 0, 'width': 24, 'height': 5}]",88.0,"{'problem_type': '2SP', 'bin_width': 160, 'bin_height': 93, 'items': [{'item_id': 'A', 'width': 89, 'height': 21}, {'item_id': 'B', 'width': 22, 'height': 71}, {'item_id': 'C', 'width': 14, 'height': 66}, {'item_id': 'D', 'width': 29, 'height': 12}, {'item_id': 'E', 'width': 18, 'height': 12}, {'item_id': 'F', 'width': 57, 'height': 23}, {'item_id': 'G', 'width': 75, 'height': 44}, {'item_id': 'H', 'width': 24, 'height': 5}], 'num_item_types': 8}","[{'item_type': 'A', 'x': 24, 'y': 0, 'width': 89, 'height': 21}, {'item_type': 'B', 'x': 0, 'y': 5, 'width': 22, 'height': 71}, {'item_type': 'C', 'x': 146, 'y': 21, 'width': 14, 'height': 66}, {'item_type': 'D', 'x': 117, 'y': 76, 'width': 29, 'height': 12}, {'item_type': 'E', 'x': 99, 'y': 76, 'width': 18, 'height': 12}, {'item_type': 'F', 'x': 22, 'y': 21, 'width': 57, 'height': 23}, {'item_type': 'G', 'x': 22, 'y': 44, 'width': 75, 'height': 44}, {'item_type': 'H', 'x': 0, 'y': 0, 'width': 24, 'height': 5}]",13,csv,names
2SP,2SP,"Recently the field team had to figure out how to mount a set of advertisement boards on a single fixed-width column. The rule was: one of every board, no duplicates or misses; all boards upright and lined up with the column edges; everything fully within the column and not overlapping. For each board they chose its left-right offset and how high to place its bottom, and then measured the overall height by the highest top edge among them. The aim was to keep that highest top edge as low as possible. The specific measurements come next.

{
  ""column_width"": 160,
  ""column_max_height"": 75,
  ""items"": [
    {
      ""board_id"": ""A"",
      ""board_width"": 55,
      ""board_height"": 52
    },
    {
      ""board_id"": ""B"",
      ""board_width"": 37,
      ""board_height"": 57
    },
    {
      ""board_id"": ""C"",
      ""board_width"": 27,
      ""board_height"": 53
    },
    {
      ""board_id"": ""D"",
      ""board_width"": 21,
      ""board_height"": 18
    },
    {
      ""board_id"": ""E"",
      ""board_width"": 48,
      ""board_height"": 23
    },
    {
      ""board_id"": ""F"",
      ""board_width"": 5,
      ""board_height"": 12
    }
  ]
}

To keep things simple, here's the little JSON shape I'd like you to follow when you send the placement back — nothing fancy, just a straightforward list of boards and where each one sits.

{
  ""solution"": [{""item_type"": <board_type_id>, ""x"": 0, ""y"": 0, ""width"": 10, ""height"": 5}, ...]
}

This is just a template: the ""solution"" array holds one object per board. Each object lists:
- ""item_type"" to indicate which board type it is,
- ""x"" and ""y"" for the left/right offset and the bottom height,
- ""width"" and ""height"" for the board's size.

The JSON above is only a sketch of the expected shape, not the actual answer.

Please make sure all identifiers are used exactly as they appear in the instance input — do not rename them or invent new labels. Valid identifiers look like plain numbers such as ""1"" or ""23"", single capital letters like ""A"" or ""B"", or a capital letter followed by digits like ""A1"" or ""X7"".","{'items': [{'width': 55, 'height': 52, 'demand': 1}, {'width': 37, 'height': 57, 'demand': 1}, {'width': 27, 'height': 53, 'demand': 1}, {'width': 21, 'height': 18, 'demand': 1}, {'width': 48, 'height': 23, 'demand': 1}, {'width': 5, 'height': 12, 'demand': 1}], 'bin_width': 160, 'bin_height': 75, 'is_strip_packing': False, 'solution': [{'item_type': 0, 'x': 37, 'y': 23, 'width': 55, 'height': 52}, {'item_type': 1, 'x': 0, 'y': 18, 'width': 37, 'height': 57}, {'item_type': 2, 'x': 92, 'y': 22, 'width': 27, 'height': 53}, {'item_type': 3, 'x': 85, 'y': 0, 'width': 21, 'height': 18}, {'item_type': 4, 'x': 37, 'y': 0, 'width': 48, 'height': 23}, {'item_type': 5, 'x': 0, 'y': 0, 'width': 5, 'height': 12}], 'obj': 75.0, 'is_nontrivial': True, 'problem_type': '2SP'}","[{'item_type': 0, 'x': 37, 'y': 23, 'width': 55, 'height': 52}, {'item_type': 1, 'x': 0, 'y': 18, 'width': 37, 'height': 57}, {'item_type': 2, 'x': 92, 'y': 22, 'width': 27, 'height': 53}, {'item_type': 3, 'x': 85, 'y': 0, 'width': 21, 'height': 18}, {'item_type': 4, 'x': 37, 'y': 0, 'width': 48, 'height': 23}, {'item_type': 5, 'x': 0, 'y': 0, 'width': 5, 'height': 12}]",75.0,"{'problem_type': '2SP', 'bin_width': 160, 'bin_height': 75, 'items': [{'item_id': 'A', 'width': 55, 'height': 52}, {'item_id': 'B', 'width': 37, 'height': 57}, {'item_id': 'C', 'width': 27, 'height': 53}, {'item_id': 'D', 'width': 21, 'height': 18}, {'item_id': 'E', 'width': 48, 'height': 23}, {'item_id': 'F', 'width': 5, 'height': 12}], 'num_item_types': 6}","[{'item_type': 'A', 'x': 37, 'y': 23, 'width': 55, 'height': 52}, {'item_type': 'B', 'x': 0, 'y': 18, 'width': 37, 'height': 57}, {'item_type': 'C', 'x': 92, 'y': 22, 'width': 27, 'height': 53}, {'item_type': 'D', 'x': 85, 'y': 0, 'width': 21, 'height': 18}, {'item_type': 'E', 'x': 37, 'y': 0, 'width': 48, 'height': 23}, {'item_type': 'F', 'x': 0, 'y': 0, 'width': 5, 'height': 12}]",14,json,names
2SP,2SP,"Someone in the warehouse had to fit every type of product box into a single shipping sleeve that has a fixed width; each box had to sit straight, snug against the sleeve sides, never overlapping another, and exactly one of each had to be included. The placement choice for each box was simply how far across and how far up to set its bottom-left corner, keeping all boxes fully inside the sleeve. The aim was to minimize how tall the finished sleeve needs to be — in other words, measure the topmost edge among all boxes and make that as small as possible. The exact instance details follow below.

For this instance the sleeve's usable inner width was 64 and the sleeve's maximum height was 50.
Product box 0 had width 61 and height 38.
Product box 1 had width 7 and height 7.
Product box 2 had width 4 and height 4.
Product box 3 had width 5 and height 12.
Product box 4 had width 5 and height 4.
Product box 5 had width 4 and height 4.
Each product box had to be placed straight, snug against the sleeve sides, non-overlapping, and fully inside those bounds.

Oh, and when you give me the placement back, just follow this little JSON shape so it's easy to read and plug in:

{
  ""solution"": [{""item_type"": <box_type_id>, ""x"": 0, ""y"": 0, ""width"": 10, ""height"": 5}, ...]
}

It's just a sketch of the shape I expect: each entry names which box type it is, where its bottom-left corner sits (x across, y up), and what its box size is. Think of it like filling out a simple form for each product box — not the final plan, just the form layout.

Please remember that the actual identifiers for item types must match the instance input exactly — do not rename them or invent new labels. Valid identifiers look like plain numbers such as “1” or “23”, single capital letters like “A” or “B”, or a capital letter followed by digits like “A1” or “X7”.","{'items': [{'width': 61, 'height': 38, 'demand': 1}, {'width': 7, 'height': 7, 'demand': 1}, {'width': 4, 'height': 4, 'demand': 1}, {'width': 5, 'height': 12, 'demand': 1}, {'width': 5, 'height': 4, 'demand': 1}, {'width': 4, 'height': 4, 'demand': 1}], 'bin_width': 64, 'bin_height': 50, 'is_strip_packing': False, 'solution': [{'item_type': 0, 'x': 0, 'y': 0, 'width': 61, 'height': 38}, {'item_type': 1, 'x': 4, 'y': 43, 'width': 7, 'height': 7}, {'item_type': 2, 'x': 0, 'y': 46, 'width': 4, 'height': 4}, {'item_type': 3, 'x': 11, 'y': 38, 'width': 5, 'height': 12}, {'item_type': 4, 'x': 16, 'y': 38, 'width': 5, 'height': 4}, {'item_type': 5, 'x': 21, 'y': 38, 'width': 4, 'height': 4}], 'obj': 50.0, 'is_nontrivial': True, 'problem_type': '2SP'}","[{'item_type': 0, 'x': 0, 'y': 0, 'width': 61, 'height': 38}, {'item_type': 1, 'x': 4, 'y': 43, 'width': 7, 'height': 7}, {'item_type': 2, 'x': 0, 'y': 46, 'width': 4, 'height': 4}, {'item_type': 3, 'x': 11, 'y': 38, 'width': 5, 'height': 12}, {'item_type': 4, 'x': 16, 'y': 38, 'width': 5, 'height': 4}, {'item_type': 5, 'x': 21, 'y': 38, 'width': 4, 'height': 4}]",50.0,"{'problem_type': '2SP', 'bin_width': 64, 'bin_height': 50, 'items': [{'item_id': 0, 'width': 61, 'height': 38}, {'item_id': 1, 'width': 7, 'height': 7}, {'item_id': 2, 'width': 4, 'height': 4}, {'item_id': 3, 'width': 5, 'height': 12}, {'item_id': 4, 'width': 5, 'height': 4}, {'item_id': 5, 'width': 4, 'height': 4}], 'num_item_types': 6}","[{'item_type': 0, 'x': 0, 'y': 0, 'width': 61, 'height': 38}, {'item_type': 1, 'x': 4, 'y': 43, 'width': 7, 'height': 7}, {'item_type': 2, 'x': 0, 'y': 46, 'width': 4, 'height': 4}, {'item_type': 3, 'x': 11, 'y': 38, 'width': 5, 'height': 12}, {'item_type': 4, 'x': 16, 'y': 38, 'width': 5, 'height': 4}, {'item_type': 5, 'x': 21, 'y': 38, 'width': 4, 'height': 4}]",15,nl,0
2SP,2SP,"Imagine lining up every vendor’s rectangular graphic along a long wall of fixed width, each image hung straight and never rotated, with no duplicates and none missing. For each piece, a spot across the width and a height from the floor are chosen so that everything fits inside the wall and nothing overlaps. The whole point is to keep the overall display short — you check how tall it is by looking at the top edge of the tallest graphic, and the better the layout, the lower that top edge ends up. The specific measurements are below.

- **wall_width**: 160
- **wall_available_height**: 36

| vendor_id | graphic_width | graphic_height |
|---|---|---|
| 0 | 4 | 23 |
| 1 | 74 | 14 |
| 2 | 27 | 24 |
| 3 | 15 | 18 |
| 4 | 14 | 3 |
| 5 | 14 | 4 |
| 6 | 2 | 8 |
| 7 | 65 | 22 |
| 8 | 36 | 11 |
| 9 | 8 | 27 |

Also, when you send back your layout, please follow this little JSON shape so it's easy to read by whoever's hanging the pieces:

{
  ""solution"": [{""item_type"": <graphic_type_id>, ""x"": 0, ""y"": 0, ""width"": 10, ""height"": 5}, ...]
}

Think of that as a simple form: ""solution"" is the whole plan, each entry names which graphic goes where (item_type), the bottom-left corner (x and y), and the graphic's size (width and height). Super informal — it's just a sketch of the shape I need, not the final packing.

One important note: 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”.","{'items': [{'width': 4, 'height': 23, 'demand': 1}, {'width': 74, 'height': 14, 'demand': 1}, {'width': 27, 'height': 24, 'demand': 1}, {'width': 15, 'height': 18, 'demand': 1}, {'width': 14, 'height': 3, 'demand': 1}, {'width': 14, 'height': 4, 'demand': 1}, {'width': 2, 'height': 8, 'demand': 1}, {'width': 65, 'height': 22, 'demand': 1}, {'width': 36, 'height': 11, 'demand': 1}, {'width': 8, 'height': 27, 'demand': 1}], 'bin_width': 160, 'bin_height': 36, 'is_strip_packing': False, 'solution': [{'item_type': 0, 'x': 2, 'y': 7, 'width': 4, 'height': 23}, {'item_type': 1, 'x': 65, 'y': 0, 'width': 74, 'height': 14}, {'item_type': 2, 'x': 29, 'y': 12, 'width': 27, 'height': 24}, {'item_type': 3, 'x': 6, 'y': 18, 'width': 15, 'height': 18}, {'item_type': 4, 'x': 2, 'y': 0, 'width': 14, 'height': 3}, {'item_type': 5, 'x': 2, 'y': 3, 'width': 14, 'height': 4}, {'item_type': 6, 'x': 0, 'y': 0, 'width': 2, 'height': 8}, {'item_type': 7, 'x': 56, 'y': 14, 'width': 65, 'height': 22}, {'item_type': 8, 'x': 29, 'y': 0, 'width': 36, 'height': 11}, {'item_type': 9, 'x': 21, 'y': 9, 'width': 8, 'height': 27}], 'obj': 36.0, 'is_nontrivial': True, 'problem_type': '2SP'}","[{'item_type': 0, 'x': 2, 'y': 7, 'width': 4, 'height': 23}, {'item_type': 1, 'x': 65, 'y': 0, 'width': 74, 'height': 14}, {'item_type': 2, 'x': 29, 'y': 12, 'width': 27, 'height': 24}, {'item_type': 3, 'x': 6, 'y': 18, 'width': 15, 'height': 18}, {'item_type': 4, 'x': 2, 'y': 0, 'width': 14, 'height': 3}, {'item_type': 5, 'x': 2, 'y': 3, 'width': 14, 'height': 4}, {'item_type': 6, 'x': 0, 'y': 0, 'width': 2, 'height': 8}, {'item_type': 7, 'x': 56, 'y': 14, 'width': 65, 'height': 22}, {'item_type': 8, 'x': 29, 'y': 0, 'width': 36, 'height': 11}, {'item_type': 9, 'x': 21, 'y': 9, 'width': 8, 'height': 27}]",36.0,"{'problem_type': '2SP', 'bin_width': 160, 'bin_height': 36, 'items': [{'item_id': 0, 'width': 4, 'height': 23}, {'item_id': 1, 'width': 74, 'height': 14}, {'item_id': 2, 'width': 27, 'height': 24}, {'item_id': 3, 'width': 15, 'height': 18}, {'item_id': 4, 'width': 14, 'height': 3}, {'item_id': 5, 'width': 14, 'height': 4}, {'item_id': 6, 'width': 2, 'height': 8}, {'item_id': 7, 'width': 65, 'height': 22}, {'item_id': 8, 'width': 36, 'height': 11}, {'item_id': 9, 'width': 8, 'height': 27}], 'num_item_types': 10}","[{'item_type': 0, 'x': 2, 'y': 7, 'width': 4, 'height': 23}, {'item_type': 1, 'x': 65, 'y': 0, 'width': 74, 'height': 14}, {'item_type': 2, 'x': 29, 'y': 12, 'width': 27, 'height': 24}, {'item_type': 3, 'x': 6, 'y': 18, 'width': 15, 'height': 18}, {'item_type': 4, 'x': 2, 'y': 0, 'width': 14, 'height': 3}, {'item_type': 5, 'x': 2, 'y': 3, 'width': 14, 'height': 4}, {'item_type': 6, 'x': 0, 'y': 0, 'width': 2, 'height': 8}, {'item_type': 7, 'x': 56, 'y': 14, 'width': 65, 'height': 22}, {'item_type': 8, 'x': 29, 'y': 0, 'width': 36, 'height': 11}, {'item_type': 9, 'x': 21, 'y': 9, 'width': 8, 'height': 27}]",16,markdown_table,0
2SP,2SP,"Recently we tried a neat packing puzzle: load a fixed-width crate with one copy of every rectangular timber panel, all lined up with the crate sides so they sit straight and flat. Every piece is placed by where its bottom-left corner lands (how far from the left side and how high from the base), making sure everything fits inside and nothing overlaps. The aim was to keep the whole stack short — check the highest top edge among the panels and make that distance from the crate floor as small as possible. The concrete panel dimensions and crate measurements are given below.

# crate_inner_width=160
# crate_height_limit=46
panel_id,panel_width,panel_height
1,20,30
2,38,19
3,55,12
4,10,34
5,30,27
6,13,35
7,16,30
8,28,14
9,16,27
10,20,18

Oh, and when you send the packing back, just put it in a little JSON parcel like this so it's easy to read and reuse:

{
  ""solution"": [{""item_type"": <panel_type_id>, ""x"": 0, ""y"": 0, ""width"": 10, ""height"": 5}, ...]
}

Here ""item_type"" is the ID of the panel (the placeholder is just showing the shape), ""x"" and ""y"" are where the panel's bottom-left corner sits in the crate, and ""width"" and ""height"" are the panel's dimensions. Super simple — think of it like filling out a form for each panel: which one it is, where it starts, and how big it is.

This JSON is only a sketch of the expected shape, not the actual packing — you'll fill in the real IDs and coordinates for your answer. 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”.""","{'items': [{'width': 20, 'height': 30, 'demand': 1}, {'width': 38, 'height': 19, 'demand': 1}, {'width': 55, 'height': 12, 'demand': 1}, {'width': 10, 'height': 34, 'demand': 1}, {'width': 30, 'height': 27, 'demand': 1}, {'width': 13, 'height': 35, 'demand': 1}, {'width': 16, 'height': 30, 'demand': 1}, {'width': 28, 'height': 14, 'demand': 1}, {'width': 16, 'height': 27, 'demand': 1}, {'width': 20, 'height': 18, 'demand': 1}], 'bin_width': 160, 'bin_height': 46, 'is_strip_packing': False, 'solution': [{'item_type': 0, 'x': 16, 'y': 5, 'width': 20, 'height': 30}, {'item_type': 1, 'x': 36, 'y': 0, 'width': 38, 'height': 19}, {'item_type': 2, 'x': 74, 'y': 0, 'width': 55, 'height': 12}, {'item_type': 3, 'x': 148, 'y': 1, 'width': 10, 'height': 34}, {'item_type': 4, 'x': 86, 'y': 12, 'width': 30, 'height': 27}, {'item_type': 5, 'x': 3, 'y': 0, 'width': 13, 'height': 35}, {'item_type': 6, 'x': 132, 'y': 5, 'width': 16, 'height': 30}, {'item_type': 7, 'x': 58, 'y': 19, 'width': 28, 'height': 14}, {'item_type': 8, 'x': 116, 'y': 12, 'width': 16, 'height': 27}, {'item_type': 9, 'x': 38, 'y': 19, 'width': 20, 'height': 18}], 'obj': 39.0, 'is_nontrivial': True, 'problem_type': '2SP'}","[{'item_type': 0, 'x': 16, 'y': 5, 'width': 20, 'height': 30}, {'item_type': 1, 'x': 36, 'y': 0, 'width': 38, 'height': 19}, {'item_type': 2, 'x': 74, 'y': 0, 'width': 55, 'height': 12}, {'item_type': 3, 'x': 148, 'y': 1, 'width': 10, 'height': 34}, {'item_type': 4, 'x': 86, 'y': 12, 'width': 30, 'height': 27}, {'item_type': 5, 'x': 3, 'y': 0, 'width': 13, 'height': 35}, {'item_type': 6, 'x': 132, 'y': 5, 'width': 16, 'height': 30}, {'item_type': 7, 'x': 58, 'y': 19, 'width': 28, 'height': 14}, {'item_type': 8, 'x': 116, 'y': 12, 'width': 16, 'height': 27}, {'item_type': 9, 'x': 38, 'y': 19, 'width': 20, 'height': 18}]",39.0,"{'problem_type': '2SP', 'bin_width': 160, 'bin_height': 46, 'items': [{'item_id': 1, 'width': 20, 'height': 30}, {'item_id': 2, 'width': 38, 'height': 19}, {'item_id': 3, 'width': 55, 'height': 12}, {'item_id': 4, 'width': 10, 'height': 34}, {'item_id': 5, 'width': 30, 'height': 27}, {'item_id': 6, 'width': 13, 'height': 35}, {'item_id': 7, 'width': 16, 'height': 30}, {'item_id': 8, 'width': 28, 'height': 14}, {'item_id': 9, 'width': 16, 'height': 27}, {'item_id': 10, 'width': 20, 'height': 18}], 'num_item_types': 10}","[{'item_type': 1, 'x': 16, 'y': 5, 'width': 20, 'height': 30}, {'item_type': 2, 'x': 36, 'y': 0, 'width': 38, 'height': 19}, {'item_type': 3, 'x': 74, 'y': 0, 'width': 55, 'height': 12}, {'item_type': 4, 'x': 148, 'y': 1, 'width': 10, 'height': 34}, {'item_type': 5, 'x': 86, 'y': 12, 'width': 30, 'height': 27}, {'item_type': 6, 'x': 3, 'y': 0, 'width': 13, 'height': 35}, {'item_type': 7, 'x': 132, 'y': 5, 'width': 16, 'height': 30}, {'item_type': 8, 'x': 58, 'y': 19, 'width': 28, 'height': 14}, {'item_type': 9, 'x': 116, 'y': 12, 'width': 16, 'height': 27}, {'item_type': 10, 'x': 38, 'y': 19, 'width': 20, 'height': 18}]",17,csv,1
2SP,2SP,"There’s this real-world task: arrange one of every rectangular sample tray inside a narrow incubator so that each tray sits flat and flush with the walls, nothing overlaps, and everything stays fully inside the chamber. The aim is to keep the highest tray top as low as you can — you measure that by finding the top edge of each tray and taking the maximum vertical position. The concrete sizes and the chamber width come next.

The incubator interior width is 160 and the usable interior height is 23.
Place tray 1 of width 21 and height 17 flat and flush with the walls, fully inside the chamber and not overlapping others.
Place tray 2 of width 7 and height 15 flat and flush with the walls, fully inside the chamber and not overlapping others.
Place tray 3 of width 15 and height 11 flat and flush with the walls, fully inside the chamber and not overlapping others.
Place tray 4 of width 19 and height 3 flat and flush with the walls, fully inside the chamber and not overlapping others.
Place tray 5 of width 20 and height 14 flat and flush with the walls, fully inside the chamber and not overlapping others.
Place tray 6 of width 62 and height 10 flat and flush with the walls, fully inside the chamber and not overlapping others.
Place tray 7 of width 5 and height 8 flat and flush with the walls, fully inside the chamber and not overlapping others.
Place tray 8 of width 12 and height 9 flat and flush with the walls, fully inside the chamber and not overlapping others.
Place tray 9 of width 11 and height 10 flat and flush with the walls, fully inside the chamber and not overlapping others.
Place tray 10 of width 58 and height 10 flat and flush with the walls, fully inside the chamber and not overlapping others.
Keep every tray within 0 and 160 horizontally and minimize the maximum tray top.

Also, when you send back the actual packing, please stick to this simple JSON layout so it's easy to check.

{
  ""solution"": [{""item_type"": <tray_type_id>, ""x"": 0, ""y"": 0, ""width"": 10, ""height"": 5}, ...]
}

This is just a sketch of the shape I expect — ""solution"" holds a list of placements, each placement tells you which tray type goes where (item_type), the bottom-left x and y coordinates, and the tray's width and height. Think of it like filling out a little form for each tray.

A quick note: that JSON is only the expected shape, not the actual answer. Use the exact identifiers from the instance input when you fill it in — do not rename them or invent new labels. 

For example: Valid identifiers look like plain numbers such as “1” or “23”, single capital letters like “A” or “B”, or a capital letter followed by digits like “A1” or “X7”.","{'items': [{'width': 21, 'height': 17, 'demand': 1}, {'width': 7, 'height': 15, 'demand': 1}, {'width': 15, 'height': 11, 'demand': 1}, {'width': 19, 'height': 3, 'demand': 1}, {'width': 20, 'height': 14, 'demand': 1}, {'width': 62, 'height': 10, 'demand': 1}, {'width': 5, 'height': 8, 'demand': 1}, {'width': 12, 'height': 9, 'demand': 1}, {'width': 11, 'height': 10, 'demand': 1}, {'width': 58, 'height': 10, 'demand': 1}], 'bin_width': 160, 'bin_height': 23, 'is_strip_packing': False, 'solution': [{'item_type': 0, 'x': 0, 'y': 0, 'width': 21, 'height': 17}, {'item_type': 1, 'x': 21, 'y': 0, 'width': 7, 'height': 15}, {'item_type': 2, 'x': 28, 'y': 0, 'width': 15, 'height': 11}, {'item_type': 3, 'x': 141, 'y': 17, 'width': 19, 'height': 3}, {'item_type': 4, 'x': 43, 'y': 0, 'width': 20, 'height': 14}, {'item_type': 5, 'x': 63, 'y': 0, 'width': 62, 'height': 10}, {'item_type': 6, 'x': 28, 'y': 12, 'width': 5, 'height': 8}, {'item_type': 7, 'x': 148, 'y': 0, 'width': 12, 'height': 9}, {'item_type': 8, 'x': 63, 'y': 10, 'width': 11, 'height': 10}, {'item_type': 9, 'x': 74, 'y': 10, 'width': 58, 'height': 10}], 'obj': 20.0, 'is_nontrivial': True, 'problem_type': '2SP'}","[{'item_type': 0, 'x': 0, 'y': 0, 'width': 21, 'height': 17}, {'item_type': 1, 'x': 21, 'y': 0, 'width': 7, 'height': 15}, {'item_type': 2, 'x': 28, 'y': 0, 'width': 15, 'height': 11}, {'item_type': 3, 'x': 141, 'y': 17, 'width': 19, 'height': 3}, {'item_type': 4, 'x': 43, 'y': 0, 'width': 20, 'height': 14}, {'item_type': 5, 'x': 63, 'y': 0, 'width': 62, 'height': 10}, {'item_type': 6, 'x': 28, 'y': 12, 'width': 5, 'height': 8}, {'item_type': 7, 'x': 148, 'y': 0, 'width': 12, 'height': 9}, {'item_type': 8, 'x': 63, 'y': 10, 'width': 11, 'height': 10}, {'item_type': 9, 'x': 74, 'y': 10, 'width': 58, 'height': 10}]",20.0,"{'problem_type': '2SP', 'bin_width': 160, 'bin_height': 23, 'items': [{'item_id': 1, 'width': 21, 'height': 17}, {'item_id': 2, 'width': 7, 'height': 15}, {'item_id': 3, 'width': 15, 'height': 11}, {'item_id': 4, 'width': 19, 'height': 3}, {'item_id': 5, 'width': 20, 'height': 14}, {'item_id': 6, 'width': 62, 'height': 10}, {'item_id': 7, 'width': 5, 'height': 8}, {'item_id': 8, 'width': 12, 'height': 9}, {'item_id': 9, 'width': 11, 'height': 10}, {'item_id': 10, 'width': 58, 'height': 10}], 'num_item_types': 10}","[{'item_type': 1, 'x': 0, 'y': 0, 'width': 21, 'height': 17}, {'item_type': 2, 'x': 21, 'y': 0, 'width': 7, 'height': 15}, {'item_type': 3, 'x': 28, 'y': 0, 'width': 15, 'height': 11}, {'item_type': 4, 'x': 141, 'y': 17, 'width': 19, 'height': 3}, {'item_type': 5, 'x': 43, 'y': 0, 'width': 20, 'height': 14}, {'item_type': 6, 'x': 63, 'y': 0, 'width': 62, 'height': 10}, {'item_type': 7, 'x': 28, 'y': 12, 'width': 5, 'height': 8}, {'item_type': 8, 'x': 148, 'y': 0, 'width': 12, 'height': 9}, {'item_type': 9, 'x': 63, 'y': 10, 'width': 11, 'height': 10}, {'item_type': 10, 'x': 74, 'y': 10, 'width': 58, 'height': 10}]",18,nl,1
2SP,2SP,"On a busy layout day, a designer needed to fit a set of rectangular shelf labels into a fixed-width header: each label goes in once, kept straight, possibly aligned with the strip edges, but never overlapping and always fully contained. The height of the whole arrangement is read from the topmost edge of the labels — the aim is to keep that top as low as it can be. The concrete sizes and other details are listed below.

{
  ""header_strip_width"": 160,
  ""header_strip_height_limit"": 51,
  ""items"": [
    {
      ""label_id"": 0,
      ""label_width"": 40,
      ""label_height"": 18
    },
    {
      ""label_id"": 1,
      ""label_width"": 17,
      ""label_height"": 4
    },
    {
      ""label_id"": 2,
      ""label_width"": 53,
      ""label_height"": 28
    },
    {
      ""label_id"": 3,
      ""label_width"": 45,
      ""label_height"": 39
    },
    {
      ""label_id"": 4,
      ""label_width"": 57,
      ""label_height"": 30
    }
  ]
}

Oh, and when you send the layout back, a tiny JSON snippet like the one below is perfect — it just lists each label and where it sits inside the header.

{
  ""solution"": [{""item_type"": <label_type_id>, ""x"": 0, ""y"": 0, ""width"": 10, ""height"": 5}, ...]
}

""solution"" is the list of placements. Each object shows which label type goes where: item_type is the label type identifier, x and y are the coordinates of the label's bottom-left corner, and width and height are the label's size. This is just a sketch of the expected shape, not the actual answer — fill it in with the real placements.

Please use the identifiers exactly as they appear in the instance input — no renaming and no new labels.
- for example: ""Valid identifiers look like plain numbers such as “1” or “23”, single capital letters like “A” or “B”, or a capital letter followed by digits like “A1” or “X7”.""","{'items': [{'width': 40, 'height': 18, 'demand': 1}, {'width': 17, 'height': 4, 'demand': 1}, {'width': 53, 'height': 28, 'demand': 1}, {'width': 45, 'height': 39, 'demand': 1}, {'width': 57, 'height': 30, 'demand': 1}], 'bin_width': 160, 'bin_height': 51, 'is_strip_packing': False, 'solution': [{'item_type': 0, 'x': 0, 'y': 0, 'width': 40, 'height': 18}, {'item_type': 1, 'x': 143, 'y': 0, 'width': 17, 'height': 4}, {'item_type': 2, 'x': 0, 'y': 18, 'width': 53, 'height': 28}, {'item_type': 3, 'x': 110, 'y': 4, 'width': 45, 'height': 39}, {'item_type': 4, 'x': 53, 'y': 0, 'width': 57, 'height': 30}], 'obj': 46.0, 'is_nontrivial': True, 'problem_type': '2SP'}","[{'item_type': 0, 'x': 0, 'y': 0, 'width': 40, 'height': 18}, {'item_type': 1, 'x': 143, 'y': 0, 'width': 17, 'height': 4}, {'item_type': 2, 'x': 0, 'y': 18, 'width': 53, 'height': 28}, {'item_type': 3, 'x': 110, 'y': 4, 'width': 45, 'height': 39}, {'item_type': 4, 'x': 53, 'y': 0, 'width': 57, 'height': 30}]",46.0,"{'problem_type': '2SP', 'bin_width': 160, 'bin_height': 51, 'items': [{'item_id': 0, 'width': 40, 'height': 18}, {'item_id': 1, 'width': 17, 'height': 4}, {'item_id': 2, 'width': 53, 'height': 28}, {'item_id': 3, 'width': 45, 'height': 39}, {'item_id': 4, 'width': 57, 'height': 30}], 'num_item_types': 5}","[{'item_type': 0, 'x': 0, 'y': 0, 'width': 40, 'height': 18}, {'item_type': 1, 'x': 143, 'y': 0, 'width': 17, 'height': 4}, {'item_type': 2, 'x': 0, 'y': 18, 'width': 53, 'height': 28}, {'item_type': 3, 'x': 110, 'y': 4, 'width': 45, 'height': 39}, {'item_type': 4, 'x': 53, 'y': 0, 'width': 57, 'height': 30}]",19,json,0
2SP,2SP,"We had a simple brief: place one copy of each rectangular content card into a single mobile column so everything lines up with the column sides, stays fully inside the column, and never overlaps with anything else. The trick is deciding the stacking order and vertical positions so the feed’s total height — measured by the highest top edge of any card — is as small as possible. Concrete card sizes and the column width are given below.

We use a fixed column width of 160 and treat the vertical limit as 24.
We place one 0 card of width 11 and height 14, aligned with the column sides and entirely inside without overlapping any other card.
We place one 1 card of width 21 and height 17, aligned with the column sides and entirely inside without overlapping any other card.
We place one 2 card of width 5 and height 11, aligned with the column sides and entirely inside without overlapping any other card.
We place one 3 card of width 14 and height 6, aligned with the column sides and entirely inside without overlapping any other card.
We place one 4 card of width 29 and height 18, aligned with the column sides and entirely inside without overlapping any other card.
We place one 5 card of width 89 and height 17, aligned with the column sides and entirely inside without overlapping any other card.
We then stack and position the cards so the feed’s highest top edge is as low as possible within 24.

Feel free to return the placements using a tiny JSON snippet like the one below — it's just the simple shape I expect, nothing fancy.

{
  ""solution"": [{""item_type"": <card_type_id>, ""x"": 0, ""y"": 0, ""width"": 10, ""height"": 5}, ...]
}

Quick rundown: ""solution"" is the list of cards you're placing; each object is one card. ""item_type"" holds the card type identifier (that's the id you see in the instance), ""x"" and ""y"" are the bottom-left coordinates inside the column, and ""width"" / ""height"" are the card's size. Super casual — think of it like filling out a short form. This JSON is just a sketch showing the expected shape, not the real answer.

Please use the exact identifiers from the instance input — don't rename them or invent new labels. Valid identifiers look like plain numbers such as “1” or “23”, single capital letters like “A” or “B”, or a capital letter followed by digits like “A1” or “X7”.","{'items': [{'width': 11, 'height': 14, 'demand': 1}, {'width': 21, 'height': 17, 'demand': 1}, {'width': 5, 'height': 11, 'demand': 1}, {'width': 14, 'height': 6, 'demand': 1}, {'width': 29, 'height': 18, 'demand': 1}, {'width': 89, 'height': 17, 'demand': 1}], 'bin_width': 160, 'bin_height': 24, 'is_strip_packing': False, 'solution': [{'item_type': 0, 'x': 0, 'y': 0, 'width': 11, 'height': 14}, {'item_type': 1, 'x': 14, 'y': 0, 'width': 21, 'height': 17}, {'item_type': 2, 'x': 35, 'y': 0, 'width': 5, 'height': 11}, {'item_type': 3, 'x': 0, 'y': 14, 'width': 14, 'height': 6}, {'item_type': 4, 'x': 40, 'y': 0, 'width': 29, 'height': 18}, {'item_type': 5, 'x': 69, 'y': 0, 'width': 89, 'height': 17}], 'obj': 20.0, 'is_nontrivial': True, 'problem_type': '2SP'}","[{'item_type': 0, 'x': 0, 'y': 0, 'width': 11, 'height': 14}, {'item_type': 1, 'x': 14, 'y': 0, 'width': 21, 'height': 17}, {'item_type': 2, 'x': 35, 'y': 0, 'width': 5, 'height': 11}, {'item_type': 3, 'x': 0, 'y': 14, 'width': 14, 'height': 6}, {'item_type': 4, 'x': 40, 'y': 0, 'width': 29, 'height': 18}, {'item_type': 5, 'x': 69, 'y': 0, 'width': 89, 'height': 17}]",20.0,"{'problem_type': '2SP', 'bin_width': 160, 'bin_height': 24, 'items': [{'item_id': 0, 'width': 11, 'height': 14}, {'item_id': 1, 'width': 21, 'height': 17}, {'item_id': 2, 'width': 5, 'height': 11}, {'item_id': 3, 'width': 14, 'height': 6}, {'item_id': 4, 'width': 29, 'height': 18}, {'item_id': 5, 'width': 89, 'height': 17}], 'num_item_types': 6}","[{'item_type': 0, 'x': 0, 'y': 0, 'width': 11, 'height': 14}, {'item_type': 1, 'x': 14, 'y': 0, 'width': 21, 'height': 17}, {'item_type': 2, 'x': 35, 'y': 0, 'width': 5, 'height': 11}, {'item_type': 3, 'x': 0, 'y': 14, 'width': 14, 'height': 6}, {'item_type': 4, 'x': 40, 'y': 0, 'width': 29, 'height': 18}, {'item_type': 5, 'x': 69, 'y': 0, 'width': 89, 'height': 17}]",20,nl,0
2SP,2SP,"Someone in the studio is trying to pack a set of one-of-a-kind frames onto a fixed-width display shelf without tilting them. For every frame the placement is described by how far its bottom-left corner is from the left edge and from the bottom. The aim is to make the display as short as possible from the bottom up — that is, the final height is determined by the highest top edge among all the frames, and the goal is to make that number small. All frames must be placed exactly once, wholly inside the board, and no two frames can overlap. The full list of frames and the board width are shown below.

{
  ""board_width"": 160,
  ""board_max_height"": 94,
  ""items"": [
    {
      ""frame_id"": 1,
      ""frame_width"": 112,
      ""frame_height"": 22
    },
    {
      ""frame_id"": 2,
      ""frame_width"": 42,
      ""frame_height"": 60
    },
    {
      ""frame_id"": 3,
      ""frame_width"": 14,
      ""frame_height"": 34
    },
    {
      ""frame_id"": 4,
      ""frame_width"": 23,
      ""frame_height"": 72
    },
    {
      ""frame_id"": 5,
      ""frame_width"": 17,
      ""frame_height"": 11
    },
    {
      ""frame_id"": 6,
      ""frame_width"": 9,
      ""frame_height"": 38
    },
    {
      ""frame_id"": 7,
      ""frame_width"": 38,
      ""frame_height"": 43
    },
    {
      ""frame_id"": 8,
      ""frame_width"": 35,
      ""frame_height"": 33
    }
  ]
}

If you'd like to give me a proposed layout, just drop it in this simple JSON shape — nothing fancy, just that structure so I can read where each frame goes:

{
  ""solution"": [{""item_type"": <frame_type_id>, ""x"": 0, ""y"": 0, ""width"": 10, ""height"": 5}, ...]
}

This sketch shows a list called ""solution"" made of placements. Each placement says which frame type it is (item_type), where its bottom-left corner sits (x and y), and the frame's size (width and height). It's just an example of the shape I expect — not the real answer.

Please remember to use the exact identifiers from the instance input — no renaming and no new labels. 
- for example: ""Valid identifiers look like plain numbers such as “1” or “23”, single capital letters like “A” or “B”, or a capital letter followed by digits like “A1” or “X7”.""","{'items': [{'width': 112, 'height': 22, 'demand': 1}, {'width': 42, 'height': 60, 'demand': 1}, {'width': 14, 'height': 34, 'demand': 1}, {'width': 23, 'height': 72, 'demand': 1}, {'width': 17, 'height': 11, 'demand': 1}, {'width': 9, 'height': 38, 'demand': 1}, {'width': 38, 'height': 43, 'demand': 1}, {'width': 35, 'height': 33, 'demand': 1}], 'bin_width': 160, 'bin_height': 94, 'is_strip_packing': False, 'solution': [{'item_type': 0, 'x': 0, 'y': 0, 'width': 112, 'height': 22}, {'item_type': 1, 'x': 0, 'y': 22, 'width': 42, 'height': 60}, {'item_type': 2, 'x': 146, 'y': 0, 'width': 14, 'height': 34}, {'item_type': 3, 'x': 123, 'y': 0, 'width': 23, 'height': 72}, {'item_type': 4, 'x': 42, 'y': 22, 'width': 17, 'height': 11}, {'item_type': 5, 'x': 151, 'y': 34, 'width': 9, 'height': 38}, {'item_type': 6, 'x': 85, 'y': 39, 'width': 38, 'height': 43}, {'item_type': 7, 'x': 42, 'y': 49, 'width': 35, 'height': 33}], 'obj': 82.0, 'is_nontrivial': True, 'problem_type': '2SP'}","[{'item_type': 0, 'x': 0, 'y': 0, 'width': 112, 'height': 22}, {'item_type': 1, 'x': 0, 'y': 22, 'width': 42, 'height': 60}, {'item_type': 2, 'x': 146, 'y': 0, 'width': 14, 'height': 34}, {'item_type': 3, 'x': 123, 'y': 0, 'width': 23, 'height': 72}, {'item_type': 4, 'x': 42, 'y': 22, 'width': 17, 'height': 11}, {'item_type': 5, 'x': 151, 'y': 34, 'width': 9, 'height': 38}, {'item_type': 6, 'x': 85, 'y': 39, 'width': 38, 'height': 43}, {'item_type': 7, 'x': 42, 'y': 49, 'width': 35, 'height': 33}]",82.0,"{'problem_type': '2SP', 'bin_width': 160, 'bin_height': 94, 'items': [{'item_id': 1, 'width': 112, 'height': 22}, {'item_id': 2, 'width': 42, 'height': 60}, {'item_id': 3, 'width': 14, 'height': 34}, {'item_id': 4, 'width': 23, 'height': 72}, {'item_id': 5, 'width': 17, 'height': 11}, {'item_id': 6, 'width': 9, 'height': 38}, {'item_id': 7, 'width': 38, 'height': 43}, {'item_id': 8, 'width': 35, 'height': 33}], 'num_item_types': 8}","[{'item_type': 1, 'x': 0, 'y': 0, 'width': 112, 'height': 22}, {'item_type': 2, 'x': 0, 'y': 22, 'width': 42, 'height': 60}, {'item_type': 3, 'x': 146, 'y': 0, 'width': 14, 'height': 34}, {'item_type': 4, 'x': 123, 'y': 0, 'width': 23, 'height': 72}, {'item_type': 5, 'x': 42, 'y': 22, 'width': 17, 'height': 11}, {'item_type': 6, 'x': 151, 'y': 34, 'width': 9, 'height': 38}, {'item_type': 7, 'x': 85, 'y': 39, 'width': 38, 'height': 43}, {'item_type': 8, 'x': 42, 'y': 49, 'width': 35, 'height': 33}]",21,json,1
2SP,2SP,"Many people end up trying to squeeze folded clothes into a slim closet niche, and here’s that same sort of task: place a set of garments into a fixed-width slot so each one is used once, none are turned or tilted, nothing overlaps, and everything sits fully inside the slot. For each garment, give the distance from the left side and the distance from the floor to its bottom-left corner. The trick is to keep the tallest top edge as low as possible — the used height is simply the height reached by that highest top edge. The full list of garments and their measurements follow below.

{
  ""slot_width"": 160,
  ""slot_height_limit"": 46,
  ""items"": [
    {
      ""garment_id"": 1,
      ""garment_width"": 25,
      ""garment_height"": 11
    },
    {
      ""garment_id"": 2,
      ""garment_width"": 55,
      ""garment_height"": 28
    },
    {
      ""garment_id"": 3,
      ""garment_width"": 76,
      ""garment_height"": 35
    },
    {
      ""garment_id"": 4,
      ""garment_width"": 30,
      ""garment_height"": 11
    },
    {
      ""garment_id"": 5,
      ""garment_width"": 32,
      ""garment_height"": 13
    },
    {
      ""garment_id"": 6,
      ""garment_width"": 17,
      ""garment_height"": 3
    },
    {
      ""garment_id"": 7,
      ""garment_width"": 5,
      ""garment_height"": 30
    }
  ]
}

Oh, and when you give me the placement, it'd be great if you follow a tiny JSON layout so it's clear and easy to check — something like this:

{
  ""solution"": [{""item_type"": <garment_type_id>, ""x"": 0, ""y"": 0, ""width"": 10, ""height"": 5}, ...]
}

This sketch just shows the shape I expect: ""solution"" is a list of placements, each object names which garment type goes where and how big it is. ""item_type"" is the garment identifier (the one from the instance), ""x"" is the distance from the left wall, ""y"" is the distance from the floor, and ""width"" and ""height"" are the item's dimensions. Nice and simple — it's just a template, not the actual answer.

Please remember: use the exact identifiers as they appear in the instance input — do not rename them or invent new labels. Valid identifiers look like plain numbers such as “1” or “23”, single capital letters like “A” or “B”, or a capital letter followed by digits like “A1” or “X7”.","{'items': [{'width': 25, 'height': 11, 'demand': 1}, {'width': 55, 'height': 28, 'demand': 1}, {'width': 76, 'height': 35, 'demand': 1}, {'width': 30, 'height': 11, 'demand': 1}, {'width': 32, 'height': 13, 'demand': 1}, {'width': 17, 'height': 3, 'demand': 1}, {'width': 5, 'height': 30, 'demand': 1}], 'bin_width': 160, 'bin_height': 46, 'is_strip_packing': False, 'solution': [{'item_type': 0, 'x': 131, 'y': 0, 'width': 25, 'height': 11}, {'item_type': 1, 'x': 76, 'y': 0, 'width': 55, 'height': 28}, {'item_type': 2, 'x': 0, 'y': 0, 'width': 76, 'height': 35}, {'item_type': 3, 'x': 76, 'y': 28, 'width': 30, 'height': 11}, {'item_type': 4, 'x': 106, 'y': 28, 'width': 32, 'height': 13}, {'item_type': 5, 'x': 138, 'y': 11, 'width': 17, 'height': 3}, {'item_type': 6, 'x': 155, 'y': 11, 'width': 5, 'height': 30}], 'obj': 41.0, 'is_nontrivial': True, 'problem_type': '2SP'}","[{'item_type': 0, 'x': 131, 'y': 0, 'width': 25, 'height': 11}, {'item_type': 1, 'x': 76, 'y': 0, 'width': 55, 'height': 28}, {'item_type': 2, 'x': 0, 'y': 0, 'width': 76, 'height': 35}, {'item_type': 3, 'x': 76, 'y': 28, 'width': 30, 'height': 11}, {'item_type': 4, 'x': 106, 'y': 28, 'width': 32, 'height': 13}, {'item_type': 5, 'x': 138, 'y': 11, 'width': 17, 'height': 3}, {'item_type': 6, 'x': 155, 'y': 11, 'width': 5, 'height': 30}]",41.0,"{'problem_type': '2SP', 'bin_width': 160, 'bin_height': 46, 'items': [{'item_id': 1, 'width': 25, 'height': 11}, {'item_id': 2, 'width': 55, 'height': 28}, {'item_id': 3, 'width': 76, 'height': 35}, {'item_id': 4, 'width': 30, 'height': 11}, {'item_id': 5, 'width': 32, 'height': 13}, {'item_id': 6, 'width': 17, 'height': 3}, {'item_id': 7, 'width': 5, 'height': 30}], 'num_item_types': 7}","[{'item_type': 1, 'x': 131, 'y': 0, 'width': 25, 'height': 11}, {'item_type': 2, 'x': 76, 'y': 0, 'width': 55, 'height': 28}, {'item_type': 3, 'x': 0, 'y': 0, 'width': 76, 'height': 35}, {'item_type': 4, 'x': 76, 'y': 28, 'width': 30, 'height': 11}, {'item_type': 5, 'x': 106, 'y': 28, 'width': 32, 'height': 13}, {'item_type': 6, 'x': 138, 'y': 11, 'width': 17, 'height': 3}, {'item_type': 7, 'x': 155, 'y': 11, 'width': 5, 'height': 30}]",22,json,1
2SP,2SP,"I’m fixing up a backsplash and have a pile of rectangular ceramic tiles to place on a strip that has a fixed width. The job is to lay every single tile once, keeping them all straight with the edges (no rotating), making sure none of them overlap or stick out of the backsplash area. The trick is to stack them so the tallest point any tile reaches is as low as possible — the total height used is simply the highest top edge of any tile, and smaller is better. For each tile I’ll record how far its bottom-left corner sits from the left edge and from the bottom edge. The exact tile sizes and the backsplash width are shown below.

# backsplash_width=160
# backsplash_height_limit=37
tile_id,tile_width,tile_height
0,26,7
1,20,28
2,24,21
3,112,22
4,31,5
5,29,8
6,35,13
7,2,11

Also, when you send the layout back, it'd be great if you follow a simple JSON shape so I can read the placements automatically. Something like:

{
  ""solution"": [{""item_type"": <tile_type_id>, ""x"": 0, ""y"": 0, ""width"": 10, ""height"": 5}, ...]
}

This just sketches the idea: ""solution"" is the list of tile placements, each entry has the tile identifier (item_type), the x/y coordinates of the tile's bottom-left corner (distance from the left and bottom edges), and the tile's width and height. Those numbers in the example are placeholders — it's just showing the fields, not the real answer.

Please remember to use the identifiers exactly as they appear in the instance input — no renaming and no new labels. Valid identifiers look like plain numbers such as “1” or “23”, single capital letters like “A” or “B”, or a capital letter followed by digits like “A1” or “X7”.","{'items': [{'width': 26, 'height': 7, 'demand': 1}, {'width': 20, 'height': 28, 'demand': 1}, {'width': 24, 'height': 21, 'demand': 1}, {'width': 112, 'height': 22, 'demand': 1}, {'width': 31, 'height': 5, 'demand': 1}, {'width': 29, 'height': 8, 'demand': 1}, {'width': 35, 'height': 13, 'demand': 1}, {'width': 2, 'height': 11, 'demand': 1}], 'bin_width': 160, 'bin_height': 37, 'is_strip_packing': False, 'solution': [{'item_type': 0, 'x': 31, 'y': 0, 'width': 26, 'height': 7}, {'item_type': 1, 'x': 140, 'y': 0, 'width': 20, 'height': 28}, {'item_type': 2, 'x': 116, 'y': 7, 'width': 24, 'height': 21}, {'item_type': 3, 'x': 2, 'y': 13, 'width': 112, 'height': 22}, {'item_type': 4, 'x': 0, 'y': 0, 'width': 31, 'height': 5}, {'item_type': 5, 'x': 131, 'y': 28, 'width': 29, 'height': 8}, {'item_type': 6, 'x': 57, 'y': 0, 'width': 35, 'height': 13}, {'item_type': 7, 'x': 0, 'y': 25, 'width': 2, 'height': 11}], 'obj': 36.0, 'is_nontrivial': True, 'problem_type': '2SP'}","[{'item_type': 0, 'x': 31, 'y': 0, 'width': 26, 'height': 7}, {'item_type': 1, 'x': 140, 'y': 0, 'width': 20, 'height': 28}, {'item_type': 2, 'x': 116, 'y': 7, 'width': 24, 'height': 21}, {'item_type': 3, 'x': 2, 'y': 13, 'width': 112, 'height': 22}, {'item_type': 4, 'x': 0, 'y': 0, 'width': 31, 'height': 5}, {'item_type': 5, 'x': 131, 'y': 28, 'width': 29, 'height': 8}, {'item_type': 6, 'x': 57, 'y': 0, 'width': 35, 'height': 13}, {'item_type': 7, 'x': 0, 'y': 25, 'width': 2, 'height': 11}]",36.0,"{'problem_type': '2SP', 'bin_width': 160, 'bin_height': 37, 'items': [{'item_id': 0, 'width': 26, 'height': 7}, {'item_id': 1, 'width': 20, 'height': 28}, {'item_id': 2, 'width': 24, 'height': 21}, {'item_id': 3, 'width': 112, 'height': 22}, {'item_id': 4, 'width': 31, 'height': 5}, {'item_id': 5, 'width': 29, 'height': 8}, {'item_id': 6, 'width': 35, 'height': 13}, {'item_id': 7, 'width': 2, 'height': 11}], 'num_item_types': 8}","[{'item_type': 0, 'x': 31, 'y': 0, 'width': 26, 'height': 7}, {'item_type': 1, 'x': 140, 'y': 0, 'width': 20, 'height': 28}, {'item_type': 2, 'x': 116, 'y': 7, 'width': 24, 'height': 21}, {'item_type': 3, 'x': 2, 'y': 13, 'width': 112, 'height': 22}, {'item_type': 4, 'x': 0, 'y': 0, 'width': 31, 'height': 5}, {'item_type': 5, 'x': 131, 'y': 28, 'width': 29, 'height': 8}, {'item_type': 6, 'x': 57, 'y': 0, 'width': 35, 'height': 13}, {'item_type': 7, 'x': 0, 'y': 25, 'width': 2, 'height': 11}]",23,csv,0
2SP,2SP,"Recently the small exhibit got a long, fixed-width hanging strip and a batch of rectangular panels, and the curator needed to squeeze them all in cleanly. Each panel must be hung upright, entirely inside the strip, used exactly once, and never overlap another piece. The aim is to keep the very top of the arrangement as low as possible — compute each panel’s top by adding its bottom offset to its height and then take the largest of those; the lower that maximum is, the better the arrangement. Every panel’s placement will be given by its leftward distance from the strip’s left side and its upward distance from the bottom to the panel’s bottom-left corner. Full dimensions and the fixed strip width follow below.

# strip_width=160
# strip_height_limit=62
panel_id,panel_width,panel_height
1,60,28
2,8,38
3,24,10
4,112,22
5,18,47
6,35,33
7,6,33
8,48,9
9,2,11

Also, when you send the placement back, a quick JSON sketch like the one below is easiest for me to parse:

{
  ""solution"": [{""item_type"": <panel_type_id>, ""x"": 0, ""y"": 0, ""width"": 10, ""height"": 5}, ...]
}

This just shows the shape I expect: ""solution"" is a list of panel placements; each entry names the panel (item_type), its left offset (x), its bottom offset (y), and the panel’s width and height. Think of it like filling out a simple form for each hanging panel — the numbers in the example are placeholders, not the final answer.

Please be sure to use the exact identifiers from the instance input — don’t rename them or invent new labels. Valid identifiers look like plain numbers such as “1” or “23”, single capital letters like “A” or “B”, or a capital letter followed by digits like “A1” or “X7”.","{'items': [{'width': 60, 'height': 28, 'demand': 1}, {'width': 8, 'height': 38, 'demand': 1}, {'width': 24, 'height': 10, 'demand': 1}, {'width': 112, 'height': 22, 'demand': 1}, {'width': 18, 'height': 47, 'demand': 1}, {'width': 35, 'height': 33, 'demand': 1}, {'width': 6, 'height': 33, 'demand': 1}, {'width': 48, 'height': 9, 'demand': 1}, {'width': 2, 'height': 11, 'demand': 1}], 'bin_width': 160, 'bin_height': 62, 'is_strip_packing': False, 'solution': [{'item_type': 0, 'x': 100, 'y': 27, 'width': 60, 'height': 28}, {'item_type': 1, 'x': 24, 'y': 10, 'width': 8, 'height': 38}, {'item_type': 2, 'x': 24, 'y': 0, 'width': 24, 'height': 10}, {'item_type': 3, 'x': 48, 'y': 0, 'width': 112, 'height': 22}, {'item_type': 4, 'x': 6, 'y': 0, 'width': 18, 'height': 47}, {'item_type': 5, 'x': 48, 'y': 22, 'width': 35, 'height': 33}, {'item_type': 6, 'x': 83, 'y': 22, 'width': 6, 'height': 33}, {'item_type': 7, 'x': 0, 'y': 48, 'width': 48, 'height': 9}, {'item_type': 8, 'x': 0, 'y': 22, 'width': 2, 'height': 11}], 'obj': 57.0, 'is_nontrivial': True, 'problem_type': '2SP'}","[{'item_type': 0, 'x': 100, 'y': 27, 'width': 60, 'height': 28}, {'item_type': 1, 'x': 24, 'y': 10, 'width': 8, 'height': 38}, {'item_type': 2, 'x': 24, 'y': 0, 'width': 24, 'height': 10}, {'item_type': 3, 'x': 48, 'y': 0, 'width': 112, 'height': 22}, {'item_type': 4, 'x': 6, 'y': 0, 'width': 18, 'height': 47}, {'item_type': 5, 'x': 48, 'y': 22, 'width': 35, 'height': 33}, {'item_type': 6, 'x': 83, 'y': 22, 'width': 6, 'height': 33}, {'item_type': 7, 'x': 0, 'y': 48, 'width': 48, 'height': 9}, {'item_type': 8, 'x': 0, 'y': 22, 'width': 2, 'height': 11}]",57.0,"{'problem_type': '2SP', 'bin_width': 160, 'bin_height': 62, 'items': [{'item_id': 1, 'width': 60, 'height': 28}, {'item_id': 2, 'width': 8, 'height': 38}, {'item_id': 3, 'width': 24, 'height': 10}, {'item_id': 4, 'width': 112, 'height': 22}, {'item_id': 5, 'width': 18, 'height': 47}, {'item_id': 6, 'width': 35, 'height': 33}, {'item_id': 7, 'width': 6, 'height': 33}, {'item_id': 8, 'width': 48, 'height': 9}, {'item_id': 9, 'width': 2, 'height': 11}], 'num_item_types': 9}","[{'item_type': 1, 'x': 100, 'y': 27, 'width': 60, 'height': 28}, {'item_type': 2, 'x': 24, 'y': 10, 'width': 8, 'height': 38}, {'item_type': 3, 'x': 24, 'y': 0, 'width': 24, 'height': 10}, {'item_type': 4, 'x': 48, 'y': 0, 'width': 112, 'height': 22}, {'item_type': 5, 'x': 6, 'y': 0, 'width': 18, 'height': 47}, {'item_type': 6, 'x': 48, 'y': 22, 'width': 35, 'height': 33}, {'item_type': 7, 'x': 83, 'y': 22, 'width': 6, 'height': 33}, {'item_type': 8, 'x': 0, 'y': 48, 'width': 48, 'height': 9}, {'item_type': 9, 'x': 0, 'y': 22, 'width': 2, 'height': 11}]",24,csv,1
2SP,2SP,"In a small workshop the task was to arrange every rectangular sample board into a fixed-width display tray, one copy of each, with edges aligned to the tray sides and no piece overlapping another or sticking out. The aim is to keep the overall packing short — measured by the highest top edge among the pieces — so that the tallest point is as low as possible. Give for each board the distance from the left boundary and the distance from the bottom to the board’s bottom-left corner. The concrete dimensions and tray width are provided below.

The tray's usable inner width is 160 and its height limit is 69.
Sample 0: width 4, height 8.
Sample 1: width 58, height 29.
Sample 2: width 93, height 20.
Sample 3: width 15, height 8.
Sample 4: width 27, height 53.
Sample 5: width 10, height 30.
Sample 6: width 50, height 41.
Report each board's distance from the left and from the bottom for every sample.

Oh, and when you send back the actual placements, just use this little JSON layout so it's easy to read and parse:

{
  ""solution"": [{""item_type"": <board_type_id>, ""x"": 0, ""y"": 0, ""width"": 10, ""height"": 5}, ...]
}

This shows the shape I expect: ""solution"" is a list of entries, each one saying which board type it is, how far it sits from the left (x) and from the bottom (y), and the board's width and height. Think of it like filling out a simple form — each line is one board's position and size. It's only a sketch of the shape I want back, not the actual packing.

Please make sure all identifiers are used exactly as they appear in 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”.""","{'items': [{'width': 4, 'height': 8, 'demand': 1}, {'width': 58, 'height': 29, 'demand': 1}, {'width': 93, 'height': 20, 'demand': 1}, {'width': 15, 'height': 8, 'demand': 1}, {'width': 27, 'height': 53, 'demand': 1}, {'width': 10, 'height': 30, 'demand': 1}, {'width': 50, 'height': 41, 'demand': 1}], 'bin_width': 160, 'bin_height': 69, 'is_strip_packing': False, 'solution': [{'item_type': 0, 'x': 0, 'y': 0, 'width': 4, 'height': 8}, {'item_type': 1, 'x': 52, 'y': 20, 'width': 58, 'height': 29}, {'item_type': 2, 'x': 52, 'y': 0, 'width': 93, 'height': 20}, {'item_type': 3, 'x': 0, 'y': 8, 'width': 15, 'height': 8}, {'item_type': 4, 'x': 15, 'y': 0, 'width': 27, 'height': 53}, {'item_type': 5, 'x': 42, 'y': 0, 'width': 10, 'height': 30}, {'item_type': 6, 'x': 110, 'y': 20, 'width': 50, 'height': 41}], 'obj': 61.0, 'is_nontrivial': True, 'problem_type': '2SP'}","[{'item_type': 0, 'x': 0, 'y': 0, 'width': 4, 'height': 8}, {'item_type': 1, 'x': 52, 'y': 20, 'width': 58, 'height': 29}, {'item_type': 2, 'x': 52, 'y': 0, 'width': 93, 'height': 20}, {'item_type': 3, 'x': 0, 'y': 8, 'width': 15, 'height': 8}, {'item_type': 4, 'x': 15, 'y': 0, 'width': 27, 'height': 53}, {'item_type': 5, 'x': 42, 'y': 0, 'width': 10, 'height': 30}, {'item_type': 6, 'x': 110, 'y': 20, 'width': 50, 'height': 41}]",61.0,"{'problem_type': '2SP', 'bin_width': 160, 'bin_height': 69, 'items': [{'item_id': 0, 'width': 4, 'height': 8}, {'item_id': 1, 'width': 58, 'height': 29}, {'item_id': 2, 'width': 93, 'height': 20}, {'item_id': 3, 'width': 15, 'height': 8}, {'item_id': 4, 'width': 27, 'height': 53}, {'item_id': 5, 'width': 10, 'height': 30}, {'item_id': 6, 'width': 50, 'height': 41}], 'num_item_types': 7}","[{'item_type': 0, 'x': 0, 'y': 0, 'width': 4, 'height': 8}, {'item_type': 1, 'x': 52, 'y': 20, 'width': 58, 'height': 29}, {'item_type': 2, 'x': 52, 'y': 0, 'width': 93, 'height': 20}, {'item_type': 3, 'x': 0, 'y': 8, 'width': 15, 'height': 8}, {'item_type': 4, 'x': 15, 'y': 0, 'width': 27, 'height': 53}, {'item_type': 5, 'x': 42, 'y': 0, 'width': 10, 'height': 30}, {'item_type': 6, 'x': 110, 'y': 20, 'width': 50, 'height': 41}]",25,nl,0
2SP,2SP,"Someone wants to display a set of unique gift boxes on a vertical display with a fixed width. Each box must be used once and set down squarely with its faces parallel to the display edges, staying fully inside the display and not covering any other box. The success of a layout is judged by how low the highest top edge sits — the lower, the better — so note the single tallest top edge as the packing height. For every box, give the leftward offset from the rack’s left edge and the upward offset from the base to its bottom-left corner. Exact box dimensions and rack info are given below.

{
  ""rack_width"": 160,
  ""rack_height_limit"": 146,
  ""items"": [
    {
      ""box_id"": 1,
      ""box_width"": 17,
      ""box_height"": 112
    },
    {
      ""box_id"": 2,
      ""box_width"": 29,
      ""box_height"": 12
    },
    {
      ""box_id"": 3,
      ""box_width"": 58,
      ""box_height"": 71
    },
    {
      ""box_id"": 4,
      ""box_width"": 38,
      ""box_height"": 59
    },
    {
      ""box_id"": 5,
      ""box_width"": 129,
      ""box_height"": 31
    },
    {
      ""box_id"": 6,
      ""box_width"": 35,
      ""box_height"": 93
    },
    {
      ""box_id"": 7,
      ""box_width"": 20,
      ""box_height"": 45
    }
  ]
}

Also, when you send the layout back, please follow this simple JSON shape so I can read it easily. Something like:

{
  ""solution"": [{""item_type"": <box_type_id>, ""x"": 0, ""y"": 0, ""width"": 10, ""height"": 5}, ...]
}

This is just a sketch of the shape I expect, not your final answer — fill in one object per box.

Quickly, what those bits mean in plain words: the solution list contains one entry per box type. item_type is the box identifier (use the exact id from the instance), x is how far from the left edge the box’s bottom-left corner sits, y is how far up from the base that corner is, and width/height are the box’s dimensions. Keep it simple and human-friendly.

Please remember: all identifiers in item_type must be used exactly as they appear in the instance input — do not rename them or invent new labels. 
- for example: ""Valid identifiers look like plain numbers such as “1” or “23”, single capital letters like “A” or “B”, or a capital letter followed by digits like “A1” or “X7”.""","{'items': [{'width': 17, 'height': 112, 'demand': 1}, {'width': 29, 'height': 12, 'demand': 1}, {'width': 58, 'height': 71, 'demand': 1}, {'width': 38, 'height': 59, 'demand': 1}, {'width': 129, 'height': 31, 'demand': 1}, {'width': 35, 'height': 93, 'demand': 1}, {'width': 20, 'height': 45, 'demand': 1}], 'bin_width': 160, 'bin_height': 146, 'is_strip_packing': False, 'solution': [{'item_type': 0, 'x': 143, 'y': 12, 'width': 17, 'height': 112}, {'item_type': 1, 'x': 131, 'y': 0, 'width': 29, 'height': 12}, {'item_type': 2, 'x': 0, 'y': 31, 'width': 58, 'height': 71}, {'item_type': 3, 'x': 58, 'y': 76, 'width': 38, 'height': 59}, {'item_type': 4, 'x': 0, 'y': 0, 'width': 129, 'height': 31}, {'item_type': 5, 'x': 96, 'y': 31, 'width': 35, 'height': 93}, {'item_type': 6, 'x': 58, 'y': 31, 'width': 20, 'height': 45}], 'obj': 135.0, 'is_nontrivial': True, 'problem_type': '2SP'}","[{'item_type': 0, 'x': 143, 'y': 12, 'width': 17, 'height': 112}, {'item_type': 1, 'x': 131, 'y': 0, 'width': 29, 'height': 12}, {'item_type': 2, 'x': 0, 'y': 31, 'width': 58, 'height': 71}, {'item_type': 3, 'x': 58, 'y': 76, 'width': 38, 'height': 59}, {'item_type': 4, 'x': 0, 'y': 0, 'width': 129, 'height': 31}, {'item_type': 5, 'x': 96, 'y': 31, 'width': 35, 'height': 93}, {'item_type': 6, 'x': 58, 'y': 31, 'width': 20, 'height': 45}]",135.0,"{'problem_type': '2SP', 'bin_width': 160, 'bin_height': 146, 'items': [{'item_id': 1, 'width': 17, 'height': 112}, {'item_id': 2, 'width': 29, 'height': 12}, {'item_id': 3, 'width': 58, 'height': 71}, {'item_id': 4, 'width': 38, 'height': 59}, {'item_id': 5, 'width': 129, 'height': 31}, {'item_id': 6, 'width': 35, 'height': 93}, {'item_id': 7, 'width': 20, 'height': 45}], 'num_item_types': 7}","[{'item_type': 1, 'x': 143, 'y': 12, 'width': 17, 'height': 112}, {'item_type': 2, 'x': 131, 'y': 0, 'width': 29, 'height': 12}, {'item_type': 3, 'x': 0, 'y': 31, 'width': 58, 'height': 71}, {'item_type': 4, 'x': 58, 'y': 76, 'width': 38, 'height': 59}, {'item_type': 5, 'x': 0, 'y': 0, 'width': 129, 'height': 31}, {'item_type': 6, 'x': 96, 'y': 31, 'width': 35, 'height': 93}, {'item_type': 7, 'x': 58, 'y': 31, 'width': 20, 'height': 45}]",26,json,1
2SP,2SP,"We’ve got a fixed-width shelf and a set of planks that all need to find a spot on it. Every plank must be placed exactly once, laid straight so its sides run parallel to the shelf, never overlapping another plank, and fully inside the shelf area. What makes a layout better is simply that the tallest point reached by any plank is lower — check that by measuring from the shelf floor up to the highest top edge. For each plank, note two numbers: distance from the shelf’s left edge and the height of its bottom-left corner above the floor. The concrete sizes and ledge details are listed below.

We have 160 of usable horizontal width and a height limit of 49.
Plank 1: size 19×25; note its distance from the left edge and the height of its bottom-left corner above the floor.
Plank 2: size 29×37; note its distance from the left edge and the height of its bottom-left corner above the floor.
Plank 3: size 64×19; note its distance from the left edge and the height of its bottom-left corner above the floor.
Plank 4: size 13×11; note its distance from the left edge and the height of its bottom-left corner above the floor.
Plank 5: size 26×7; note its distance from the left edge and the height of its bottom-left corner above the floor.
Plank 6: size 34×23; note its distance from the left edge and the height of its bottom-left corner above the floor.
Plank 7: size 8×17; note its distance from the left edge and the height of its bottom-left corner above the floor.
Plank 8: size 7×2; note its distance from the left edge and the height of its bottom-left corner above the floor.
Plank 9: size 22×35; note its distance from the left edge and the height of its bottom-left corner above the floor.
Record one line per plank so we can compute and minimize the highest top edge.

Oh, and when you jot down a candidate layout, just follow this simple JSON shape so everything’s easy to read:

{
  ""solution"": [{""item_type"": <plank_type_id>, ""x"": 0, ""y"": 0, ""width"": 10, ""height"": 5}, ...]
}

It’s straightforward: each object in the solution array describes one plank — item_type points to which plank type it is, x and y say where the plank’s bottom-left corner sits (distance from the left edge and floor), and width/height are the plank’s size. Think of it like filling out a short form for each plank. This block is only a sketch of the shape I expect, not the actual packing answer.

Please make sure to use the exact identifiers from the instance input — don’t rename them or invent new labels. Valid identifiers look like plain numbers such as “1” or “23”, single capital letters like “A” or “B”, or a capital letter followed by digits like “A1” or “X7”.","{'items': [{'width': 19, 'height': 25, 'demand': 1}, {'width': 29, 'height': 37, 'demand': 1}, {'width': 64, 'height': 19, 'demand': 1}, {'width': 13, 'height': 11, 'demand': 1}, {'width': 26, 'height': 7, 'demand': 1}, {'width': 34, 'height': 23, 'demand': 1}, {'width': 8, 'height': 17, 'demand': 1}, {'width': 7, 'height': 2, 'demand': 1}, {'width': 22, 'height': 35, 'demand': 1}], 'bin_width': 160, 'bin_height': 49, 'is_strip_packing': False, 'solution': [{'item_type': 0, 'x': 7, 'y': 12, 'width': 19, 'height': 25}, {'item_type': 1, 'x': 26, 'y': 0, 'width': 29, 'height': 37}, {'item_type': 2, 'x': 77, 'y': 0, 'width': 64, 'height': 19}, {'item_type': 3, 'x': 0, 'y': 0, 'width': 13, 'height': 11}, {'item_type': 4, 'x': 77, 'y': 19, 'width': 26, 'height': 7}, {'item_type': 5, 'x': 118, 'y': 19, 'width': 34, 'height': 23}, {'item_type': 6, 'x': 152, 'y': 0, 'width': 8, 'height': 17}, {'item_type': 7, 'x': 0, 'y': 11, 'width': 7, 'height': 2}, {'item_type': 8, 'x': 55, 'y': 0, 'width': 22, 'height': 35}], 'obj': 42.0, 'is_nontrivial': True, 'problem_type': '2SP'}","[{'item_type': 0, 'x': 7, 'y': 12, 'width': 19, 'height': 25}, {'item_type': 1, 'x': 26, 'y': 0, 'width': 29, 'height': 37}, {'item_type': 2, 'x': 77, 'y': 0, 'width': 64, 'height': 19}, {'item_type': 3, 'x': 0, 'y': 0, 'width': 13, 'height': 11}, {'item_type': 4, 'x': 77, 'y': 19, 'width': 26, 'height': 7}, {'item_type': 5, 'x': 118, 'y': 19, 'width': 34, 'height': 23}, {'item_type': 6, 'x': 152, 'y': 0, 'width': 8, 'height': 17}, {'item_type': 7, 'x': 0, 'y': 11, 'width': 7, 'height': 2}, {'item_type': 8, 'x': 55, 'y': 0, 'width': 22, 'height': 35}]",42.0,"{'problem_type': '2SP', 'bin_width': 160, 'bin_height': 49, 'items': [{'item_id': 1, 'width': 19, 'height': 25}, {'item_id': 2, 'width': 29, 'height': 37}, {'item_id': 3, 'width': 64, 'height': 19}, {'item_id': 4, 'width': 13, 'height': 11}, {'item_id': 5, 'width': 26, 'height': 7}, {'item_id': 6, 'width': 34, 'height': 23}, {'item_id': 7, 'width': 8, 'height': 17}, {'item_id': 8, 'width': 7, 'height': 2}, {'item_id': 9, 'width': 22, 'height': 35}], 'num_item_types': 9}","[{'item_type': 1, 'x': 7, 'y': 12, 'width': 19, 'height': 25}, {'item_type': 2, 'x': 26, 'y': 0, 'width': 29, 'height': 37}, {'item_type': 3, 'x': 77, 'y': 0, 'width': 64, 'height': 19}, {'item_type': 4, 'x': 0, 'y': 0, 'width': 13, 'height': 11}, {'item_type': 5, 'x': 77, 'y': 19, 'width': 26, 'height': 7}, {'item_type': 6, 'x': 118, 'y': 19, 'width': 34, 'height': 23}, {'item_type': 7, 'x': 152, 'y': 0, 'width': 8, 'height': 17}, {'item_type': 8, 'x': 0, 'y': 11, 'width': 7, 'height': 2}, {'item_type': 9, 'x': 55, 'y': 0, 'width': 22, 'height': 35}]",27,nl,1
2SP,2SP,"In a small workshop the crew needs to arrange several rectangular swatches on a board whose width won’t change. Every swatch gets one spot, positioned so its edges line up with the board, never covering another swatch and never extending beyond the board. For each swatch the position is recorded as how far it sits from the left border and how far up from the bottom its lower-left corner is. The final “height” of the arrangement is measured by the top edge of the tallest swatch (its bottom offset plus its height), and better arrangements are those that keep that top edge as low as they can. The concrete instance details are listed below.

- **board_width**: 160
- **board_height**: 94

| swatch_id | swatch_width | swatch_height |
|---|---|---|
| 1 | 26 | 57 |
| 2 | 31 | 5 |
| 3 | 25 | 14 |
| 4 | 23 | 72 |
| 5 | 50 | 12 |
| 6 | 21 | 25 |
| 7 | 64 | 19 |
| 8 | 111 | 58 |

If you want to give me a candidate layout, just send it in a relaxed JSON shape like this:

{
  ""solution"": [{""item_type"": <swatch_type_id>, ""x"": 0, ""y"": 0, ""width"": 10, ""height"": 5}, ...]
}

Here’s what the pieces mean in plain terms: ""solution"" is a list of spots on the board; each object says which swatch type goes where (""item_type""), how far from the left (""x"") and how far up from the bottom (""y"") its bottom-left corner sits, and the swatch's own ""width"" and ""height"". This is just a sketch of the expected shape — not the actual answer.

Please use the exact identifiers from the instance input — don’t rename them 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"".","{'items': [{'width': 26, 'height': 57, 'demand': 1}, {'width': 31, 'height': 5, 'demand': 1}, {'width': 25, 'height': 14, 'demand': 1}, {'width': 23, 'height': 72, 'demand': 1}, {'width': 50, 'height': 12, 'demand': 1}, {'width': 21, 'height': 25, 'demand': 1}, {'width': 64, 'height': 19, 'demand': 1}, {'width': 111, 'height': 58, 'demand': 1}], 'bin_width': 160, 'bin_height': 94, 'is_strip_packing': False, 'solution': [{'item_type': 0, 'x': 23, 'y': 12, 'width': 26, 'height': 57}, {'item_type': 1, 'x': 73, 'y': 0, 'width': 31, 'height': 5}, {'item_type': 2, 'x': 24, 'y': 69, 'width': 25, 'height': 14}, {'item_type': 3, 'x': 0, 'y': 0, 'width': 23, 'height': 72}, {'item_type': 4, 'x': 23, 'y': 0, 'width': 50, 'height': 12}, {'item_type': 5, 'x': 137, 'y': 0, 'width': 21, 'height': 25}, {'item_type': 6, 'x': 73, 'y': 5, 'width': 64, 'height': 19}, {'item_type': 7, 'x': 49, 'y': 25, 'width': 111, 'height': 58}], 'obj': 83.0, 'is_nontrivial': True, 'problem_type': '2SP'}","[{'item_type': 0, 'x': 23, 'y': 12, 'width': 26, 'height': 57}, {'item_type': 1, 'x': 73, 'y': 0, 'width': 31, 'height': 5}, {'item_type': 2, 'x': 24, 'y': 69, 'width': 25, 'height': 14}, {'item_type': 3, 'x': 0, 'y': 0, 'width': 23, 'height': 72}, {'item_type': 4, 'x': 23, 'y': 0, 'width': 50, 'height': 12}, {'item_type': 5, 'x': 137, 'y': 0, 'width': 21, 'height': 25}, {'item_type': 6, 'x': 73, 'y': 5, 'width': 64, 'height': 19}, {'item_type': 7, 'x': 49, 'y': 25, 'width': 111, 'height': 58}]",83.0,"{'problem_type': '2SP', 'bin_width': 160, 'bin_height': 94, 'items': [{'item_id': 1, 'width': 26, 'height': 57}, {'item_id': 2, 'width': 31, 'height': 5}, {'item_id': 3, 'width': 25, 'height': 14}, {'item_id': 4, 'width': 23, 'height': 72}, {'item_id': 5, 'width': 50, 'height': 12}, {'item_id': 6, 'width': 21, 'height': 25}, {'item_id': 7, 'width': 64, 'height': 19}, {'item_id': 8, 'width': 111, 'height': 58}], 'num_item_types': 8}","[{'item_type': 1, 'x': 23, 'y': 12, 'width': 26, 'height': 57}, {'item_type': 2, 'x': 73, 'y': 0, 'width': 31, 'height': 5}, {'item_type': 3, 'x': 24, 'y': 69, 'width': 25, 'height': 14}, {'item_type': 4, 'x': 0, 'y': 0, 'width': 23, 'height': 72}, {'item_type': 5, 'x': 23, 'y': 0, 'width': 50, 'height': 12}, {'item_type': 6, 'x': 137, 'y': 0, 'width': 21, 'height': 25}, {'item_type': 7, 'x': 73, 'y': 5, 'width': 64, 'height': 19}, {'item_type': 8, 'x': 49, 'y': 25, 'width': 111, 'height': 58}]",28,markdown_table,1
2SP,2SP,"Recently at a flea market someone laid out a long, fixed-width strip to show price tags, and they needed to arrange a collection of rectangular tags on it. Each tag has to be used once, placed neatly with edges matching the strip (no rotations), kept completely inside the strip, and not overlapping any other tag. The only decisions are the left and bottom coordinates of each tag’s bottom-left corner. A smarter layout keeps the whole display as compact as possible up the wall — take each tag’s bottom position plus its own height, and the tallest of those numbers tells how tall the setup is; the aim is to make that number as small as possible. The precise sizes and tags follow below.

{
  ""display_strip_width"": 160,
  ""display_strip_height_limit"": 73,
  ""items"": [
    {
      ""tag_id"": ""A"",
      ""tag_width"": 22,
      ""tag_height"": 47
    },
    {
      ""tag_id"": ""B"",
      ""tag_width"": 30,
      ""tag_height"": 8
    },
    {
      ""tag_id"": ""C"",
      ""tag_width"": 61,
      ""tag_height"": 13
    },
    {
      ""tag_id"": ""D"",
      ""tag_width"": 30,
      ""tag_height"": 51
    },
    {
      ""tag_id"": ""E"",
      ""tag_width"": 6,
      ""tag_height"": 19
    },
    {
      ""tag_id"": ""F"",
      ""tag_width"": 83,
      ""tag_height"": 16
    },
    {
      ""tag_id"": ""G"",
      ""tag_width"": 62,
      ""tag_height"": 12
    },
    {
      ""tag_id"": ""H"",
      ""tag_width"": 8,
      ""tag_height"": 14
    },
    {
      ""tag_id"": ""I"",
      ""tag_width"": 23,
      ""tag_height"": 31
    },
    {
      ""tag_id"": ""J"",
      ""tag_width"": 30,
      ""tag_height"": 56
    }
  ]
}

If you want to pass me a proposed layout, just send it in the simple JSON shape below — it's the form I expect, nothing fancier.

{
  ""solution"": [{""item_type"": <tag_type_id>, ""x"": 0, ""y"": 0, ""width"": 10, ""height"": 5}, ...]
}

This little sketch means: each object in the ""solution"" list is one tag placed on the strip. ""item_type"" picks which tag (use the exact tag identifier from the instance), ""x"" and ""y"" are the left and bottom coordinates where you place that tag, and ""width"" and ""height"" are the tag's own dimensions. Think of it like filling out a simple placement form — one line per tag.

This is just the shape I need, not a real answer. And please use the identifiers exactly as they appear in the instance input — do not rename them or invent new labels. Valid identifiers look like plain numbers such as “1” or “23”, single capital letters like “A” or “B”, or a capital letter followed by digits like “A1” or “X7”.","{'items': [{'width': 22, 'height': 47, 'demand': 1}, {'width': 30, 'height': 8, 'demand': 1}, {'width': 61, 'height': 13, 'demand': 1}, {'width': 30, 'height': 51, 'demand': 1}, {'width': 6, 'height': 19, 'demand': 1}, {'width': 83, 'height': 16, 'demand': 1}, {'width': 62, 'height': 12, 'demand': 1}, {'width': 8, 'height': 14, 'demand': 1}, {'width': 23, 'height': 31, 'demand': 1}, {'width': 30, 'height': 56, 'demand': 1}], 'bin_width': 160, 'bin_height': 73, 'is_strip_packing': False, 'solution': [{'item_type': 0, 'x': 38, 'y': 16, 'width': 22, 'height': 47}, {'item_type': 1, 'x': 94, 'y': 43, 'width': 30, 'height': 8}, {'item_type': 2, 'x': 60, 'y': 16, 'width': 61, 'height': 13}, {'item_type': 3, 'x': 124, 'y': 0, 'width': 30, 'height': 51}, {'item_type': 4, 'x': 154, 'y': 44, 'width': 6, 'height': 19}, {'item_type': 5, 'x': 38, 'y': 0, 'width': 83, 'height': 16}, {'item_type': 6, 'x': 92, 'y': 51, 'width': 62, 'height': 12}, {'item_type': 7, 'x': 0, 'y': 0, 'width': 8, 'height': 14}, {'item_type': 8, 'x': 60, 'y': 32, 'width': 23, 'height': 31}, {'item_type': 9, 'x': 8, 'y': 0, 'width': 30, 'height': 56}], 'obj': 63.0, 'is_nontrivial': True, 'problem_type': '2SP'}","[{'item_type': 0, 'x': 38, 'y': 16, 'width': 22, 'height': 47}, {'item_type': 1, 'x': 94, 'y': 43, 'width': 30, 'height': 8}, {'item_type': 2, 'x': 60, 'y': 16, 'width': 61, 'height': 13}, {'item_type': 3, 'x': 124, 'y': 0, 'width': 30, 'height': 51}, {'item_type': 4, 'x': 154, 'y': 44, 'width': 6, 'height': 19}, {'item_type': 5, 'x': 38, 'y': 0, 'width': 83, 'height': 16}, {'item_type': 6, 'x': 92, 'y': 51, 'width': 62, 'height': 12}, {'item_type': 7, 'x': 0, 'y': 0, 'width': 8, 'height': 14}, {'item_type': 8, 'x': 60, 'y': 32, 'width': 23, 'height': 31}, {'item_type': 9, 'x': 8, 'y': 0, 'width': 30, 'height': 56}]",63.0,"{'problem_type': '2SP', 'bin_width': 160, 'bin_height': 73, 'items': [{'item_id': 'A', 'width': 22, 'height': 47}, {'item_id': 'B', 'width': 30, 'height': 8}, {'item_id': 'C', 'width': 61, 'height': 13}, {'item_id': 'D', 'width': 30, 'height': 51}, {'item_id': 'E', 'width': 6, 'height': 19}, {'item_id': 'F', 'width': 83, 'height': 16}, {'item_id': 'G', 'width': 62, 'height': 12}, {'item_id': 'H', 'width': 8, 'height': 14}, {'item_id': 'I', 'width': 23, 'height': 31}, {'item_id': 'J', 'width': 30, 'height': 56}], 'num_item_types': 10}","[{'item_type': 'A', 'x': 38, 'y': 16, 'width': 22, 'height': 47}, {'item_type': 'B', 'x': 94, 'y': 43, 'width': 30, 'height': 8}, {'item_type': 'C', 'x': 60, 'y': 16, 'width': 61, 'height': 13}, {'item_type': 'D', 'x': 124, 'y': 0, 'width': 30, 'height': 51}, {'item_type': 'E', 'x': 154, 'y': 44, 'width': 6, 'height': 19}, {'item_type': 'F', 'x': 38, 'y': 0, 'width': 83, 'height': 16}, {'item_type': 'G', 'x': 92, 'y': 51, 'width': 62, 'height': 12}, {'item_type': 'H', 'x': 0, 'y': 0, 'width': 8, 'height': 14}, {'item_type': 'I', 'x': 60, 'y': 32, 'width': 23, 'height': 31}, {'item_type': 'J', 'x': 8, 'y': 0, 'width': 30, 'height': 56}]",29,json,names
2SP,2SP,"I’m trying to arrange a bunch of rectangular recipe cards on a narrow kitchen wall panel that has a fixed width. Each card has to go up once, straight as it is (no turning sideways), and every card needs to sit fully inside the panel without sitting on top of another. The idea is to place each card so the whole display doesn’t stick up higher than it needs to; the final height is just the highest top edge of any card (so for a card that sits y units above the bottom, its top reaches y plus the card’s height). For every card I’ll say how far its bottom-left corner sits from the left edge and how far it sits from the bottom edge. The exact card sizes and the panel width are shown below.

- **panel_width**: 160
- **panel_max_height**: 19

| card_id | card_width | card_height |
|---|---|---|
| 0 | 28 | 9 |
| 1 | 23 | 12 |
| 2 | 3 | 4 |
| 3 | 94 | 14 |
| 4 | 6 | 13 |
| 5 | 16 | 3 |
| 6 | 17 | 9 |

Also, to make it easy to pass around a proposed layout, I'll show the placement using a tiny JSON snippet that follows the shape I use below.

{
  ""solution"": [{""item_type"": ""<card_type_id>"", ""x"": 0, ""y"": 0, ""width"": 10, ""height"": 5}]
}

This just means: ""solution"" is a list of cards to place. Each entry names the card type (item_type), where its bottom-left corner sits from the left (x) and from the bottom (y), and the card's own width and height. It's just a sketch of the shape I expect, not the actual final placement.

Please make sure to use the exact identifiers from the instance input — no renaming and no new labels. 
- for example: ""Valid identifiers look like plain numbers such as “1” or “23”, single capital letters like “A” or “B”, or a capital letter followed by digits like “A1” or “X7”.""","{'items': [{'width': 28, 'height': 9, 'demand': 1}, {'width': 23, 'height': 12, 'demand': 1}, {'width': 3, 'height': 4, 'demand': 1}, {'width': 94, 'height': 14, 'demand': 1}, {'width': 6, 'height': 13, 'demand': 1}, {'width': 16, 'height': 3, 'demand': 1}, {'width': 17, 'height': 9, 'demand': 1}], 'bin_width': 160, 'bin_height': 19, 'is_strip_packing': False, 'solution': [{'item_type': 0, 'x': 128, 'y': 9, 'width': 28, 'height': 9}, {'item_type': 1, 'x': 0, 'y': 0, 'width': 23, 'height': 12}, {'item_type': 2, 'x': 23, 'y': 0, 'width': 3, 'height': 4}, {'item_type': 3, 'x': 34, 'y': 0, 'width': 94, 'height': 14}, {'item_type': 4, 'x': 28, 'y': 0, 'width': 6, 'height': 13}, {'item_type': 5, 'x': 34, 'y': 15, 'width': 16, 'height': 3}, {'item_type': 6, 'x': 143, 'y': 0, 'width': 17, 'height': 9}], 'obj': 18.0, 'is_nontrivial': True, 'problem_type': '2SP'}","[{'item_type': 0, 'x': 128, 'y': 9, 'width': 28, 'height': 9}, {'item_type': 1, 'x': 0, 'y': 0, 'width': 23, 'height': 12}, {'item_type': 2, 'x': 23, 'y': 0, 'width': 3, 'height': 4}, {'item_type': 3, 'x': 34, 'y': 0, 'width': 94, 'height': 14}, {'item_type': 4, 'x': 28, 'y': 0, 'width': 6, 'height': 13}, {'item_type': 5, 'x': 34, 'y': 15, 'width': 16, 'height': 3}, {'item_type': 6, 'x': 143, 'y': 0, 'width': 17, 'height': 9}]",18.0,"{'problem_type': '2SP', 'bin_width': 160, 'bin_height': 19, 'items': [{'item_id': 0, 'width': 28, 'height': 9}, {'item_id': 1, 'width': 23, 'height': 12}, {'item_id': 2, 'width': 3, 'height': 4}, {'item_id': 3, 'width': 94, 'height': 14}, {'item_id': 4, 'width': 6, 'height': 13}, {'item_id': 5, 'width': 16, 'height': 3}, {'item_id': 6, 'width': 17, 'height': 9}], 'num_item_types': 7}","[{'item_type': 0, 'x': 128, 'y': 9, 'width': 28, 'height': 9}, {'item_type': 1, 'x': 0, 'y': 0, 'width': 23, 'height': 12}, {'item_type': 2, 'x': 23, 'y': 0, 'width': 3, 'height': 4}, {'item_type': 3, 'x': 34, 'y': 0, 'width': 94, 'height': 14}, {'item_type': 4, 'x': 28, 'y': 0, 'width': 6, 'height': 13}, {'item_type': 5, 'x': 34, 'y': 15, 'width': 16, 'height': 3}, {'item_type': 6, 'x': 143, 'y': 0, 'width': 17, 'height': 9}]",30,markdown_table,0
2SP,2SP,"On the job, the task was to “Tetris” a set of cabinet doors onto a vertical test board with a fixed width, keeping each door square to the board. What needs deciding is the horizontal distance from the left and the vertical distance from the bottom for every door’s bottom-left corner, placing each door exactly once, never overlapping, and keeping all of them inside the board. The winning layout is the one with the lowest tallest top-edge — check each door’s top (its bottom position plus its height) and the greatest of those is how tall the arrangement is. The concrete sizes and the board width follow below.

The test stand had a fixed width of 160 and a vertical height limit of 26.
Door 1 was 4 wide and 10 tall; it was to be placed once with its bottom-left corner inside the stand, square to the board and not overlapping any other door.
Door 2 was 30 wide and 16 tall; it was to be placed once with its bottom-left corner inside the stand, square to the board and not overlapping any other door.
Door 3 was 2 wide and 7 tall; it was to be placed once with its bottom-left corner inside the stand, square to the board and not overlapping any other door.
Door 4 was 30 wide and 6 tall; it was to be placed once with its bottom-left corner inside the stand, square to the board and not overlapping any other door.
Door 5 was 36 wide and 11 tall; it was to be placed once with its bottom-left corner inside the stand, square to the board and not overlapping any other door.
Door 6 was 3 wide and 14 tall; it was to be placed once with its bottom-left corner inside the stand, square to the board and not overlapping any other door.
Door 7 was 6 wide and 20 tall; it was to be placed once with its bottom-left corner inside the stand, square to the board and not overlapping any other door.
Door 8 was 74 wide and 14 tall; it was to be placed once with its bottom-left corner inside the stand, square to the board and not overlapping any other door.
Door 9 was 38 wide and 11 tall; it was to be placed once with its bottom-left corner inside the stand, square to the board and not overlapping any other door.
Door 10 was 7 wide and 19 tall; it was to be placed once with its bottom-left corner inside the stand, square to the board and not overlapping any other door.
The objective was to minimize the tallest top edge across all placed doors.

You can just give the layout in a tiny JSON snippet like this — super simple and easy to fill in after you try a packing.

{
  ""solution"": [{""item_type"": <door_type_id>, ""x"": 0, ""y"": 0, ""width"": 10, ""height"": 5}, ...]
}

Think of each array entry as one door on the board: item_type is the door type identifier, x and y are the horizontal distance from the left and the vertical distance from the bottom to the door’s bottom-left corner, and width/height are the door’s size. That JSON is just a sketch of the shape I expect, not the final answer.

Please use the exact identifiers from the instance input — don't rename them or invent new labels. 
- for example: ""Valid identifiers look like plain numbers such as “1” or “23”, single capital letters like “A” or “B”, or a capital letter followed by digits like “A1” or “X7”.""","{'items': [{'width': 4, 'height': 10, 'demand': 1}, {'width': 30, 'height': 16, 'demand': 1}, {'width': 2, 'height': 7, 'demand': 1}, {'width': 30, 'height': 6, 'demand': 1}, {'width': 36, 'height': 11, 'demand': 1}, {'width': 3, 'height': 14, 'demand': 1}, {'width': 6, 'height': 20, 'demand': 1}, {'width': 74, 'height': 14, 'demand': 1}, {'width': 38, 'height': 11, 'demand': 1}, {'width': 7, 'height': 19, 'demand': 1}], 'bin_width': 160, 'bin_height': 26, 'is_strip_packing': False, 'solution': [{'item_type': 0, 'x': 3, 'y': 12, 'width': 4, 'height': 10}, {'item_type': 1, 'x': 49, 'y': 6, 'width': 30, 'height': 16}, {'item_type': 2, 'x': 3, 'y': 0, 'width': 2, 'height': 7}, {'item_type': 3, 'x': 49, 'y': 0, 'width': 30, 'height': 6}, {'item_type': 4, 'x': 7, 'y': 11, 'width': 36, 'height': 11}, {'item_type': 5, 'x': 0, 'y': 0, 'width': 3, 'height': 14}, {'item_type': 6, 'x': 43, 'y': 0, 'width': 6, 'height': 20}, {'item_type': 7, 'x': 86, 'y': 6, 'width': 74, 'height': 14}, {'item_type': 8, 'x': 5, 'y': 0, 'width': 38, 'height': 11}, {'item_type': 9, 'x': 79, 'y': 0, 'width': 7, 'height': 19}], 'obj': 22.0, 'is_nontrivial': True, 'problem_type': '2SP'}","[{'item_type': 0, 'x': 3, 'y': 12, 'width': 4, 'height': 10}, {'item_type': 1, 'x': 49, 'y': 6, 'width': 30, 'height': 16}, {'item_type': 2, 'x': 3, 'y': 0, 'width': 2, 'height': 7}, {'item_type': 3, 'x': 49, 'y': 0, 'width': 30, 'height': 6}, {'item_type': 4, 'x': 7, 'y': 11, 'width': 36, 'height': 11}, {'item_type': 5, 'x': 0, 'y': 0, 'width': 3, 'height': 14}, {'item_type': 6, 'x': 43, 'y': 0, 'width': 6, 'height': 20}, {'item_type': 7, 'x': 86, 'y': 6, 'width': 74, 'height': 14}, {'item_type': 8, 'x': 5, 'y': 0, 'width': 38, 'height': 11}, {'item_type': 9, 'x': 79, 'y': 0, 'width': 7, 'height': 19}]",22.0,"{'problem_type': '2SP', 'bin_width': 160, 'bin_height': 26, 'items': [{'item_id': 1, 'width': 4, 'height': 10}, {'item_id': 2, 'width': 30, 'height': 16}, {'item_id': 3, 'width': 2, 'height': 7}, {'item_id': 4, 'width': 30, 'height': 6}, {'item_id': 5, 'width': 36, 'height': 11}, {'item_id': 6, 'width': 3, 'height': 14}, {'item_id': 7, 'width': 6, 'height': 20}, {'item_id': 8, 'width': 74, 'height': 14}, {'item_id': 9, 'width': 38, 'height': 11}, {'item_id': 10, 'width': 7, 'height': 19}], 'num_item_types': 10}","[{'item_type': 1, 'x': 3, 'y': 12, 'width': 4, 'height': 10}, {'item_type': 2, 'x': 49, 'y': 6, 'width': 30, 'height': 16}, {'item_type': 3, 'x': 3, 'y': 0, 'width': 2, 'height': 7}, {'item_type': 4, 'x': 49, 'y': 0, 'width': 30, 'height': 6}, {'item_type': 5, 'x': 7, 'y': 11, 'width': 36, 'height': 11}, {'item_type': 6, 'x': 0, 'y': 0, 'width': 3, 'height': 14}, {'item_type': 7, 'x': 43, 'y': 0, 'width': 6, 'height': 20}, {'item_type': 8, 'x': 86, 'y': 6, 'width': 74, 'height': 14}, {'item_type': 9, 'x': 5, 'y': 0, 'width': 38, 'height': 11}, {'item_type': 10, 'x': 79, 'y': 0, 'width': 7, 'height': 19}]",31,nl,1
2SP,2SP,"We have a narrow hanging bar in the gallery and a pile of rectangular canvases to put up. Everything has to be hung exactly once, perfectly vertical and aligned with the bar, with no overlaps and nothing sticking outside the bar’s boundaries. The aim is simple: keep the overall hanging as short as you can so the highest canvas top is as low as possible — the overall height equals the top edge of the tallest canvas. For each piece, note the leftward offset from the rail’s left edge and the upward offset from the rail base to the canvas’s bottom-left corner. The specific sizes and the rail width appear below.

The rail is 160 wide and the vertical limit is 63.
Canvas 1 is 53 wide and 28 tall; note its left-offset and bottom-offset.
Canvas 2 is 21 wide and 13 tall; note its left-offset and bottom-offset.
Canvas 3 is 25 wide and 48 tall; note its left-offset and bottom-offset.
Canvas 4 is 1 wide and 3 tall; note its left-offset and bottom-offset.
Canvas 5 is 10 wide and 13 tall; note its left-offset and bottom-offset.
Canvas 6 is 57 wide and 27 tall; note its left-offset and bottom-offset.
Canvas 7 is 2 wide and 12 tall; note its left-offset and bottom-offset.
Canvas 8 is 49 wide and 38 tall; note its left-offset and bottom-offset.
We must place every canvas exactly once, perfectly vertical and aligned with the rail, with no overlaps and nothing extending beyond the 160 by 63 area.

Oh, and when you send the final hanging plan, just pop it into a little JSON sketch like this so it's easy to read and check:

{
  ""solution"": [{""item_type"": <canvas_id>, ""x"": 0, ""y"": 0, ""width"": 10, ""height"": 5}, ...]
}

This just means: ""solution"" is the list of canvases you're hanging. Each entry gives the canvas identifier (item_type), the left offset x and bottom offset y, and the canvas width and height. Think of it as a simple form: which canvas, where its bottom-left corner sits, and how big it is. It's only a sketch of the shape I expect, not your actual placement.

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”.","{'items': [{'width': 53, 'height': 28, 'demand': 1}, {'width': 21, 'height': 13, 'demand': 1}, {'width': 25, 'height': 48, 'demand': 1}, {'width': 1, 'height': 3, 'demand': 1}, {'width': 10, 'height': 13, 'demand': 1}, {'width': 57, 'height': 27, 'demand': 1}, {'width': 2, 'height': 12, 'demand': 1}, {'width': 49, 'height': 38, 'demand': 1}], 'bin_width': 160, 'bin_height': 63, 'is_strip_packing': False, 'solution': [{'item_type': 0, 'x': 107, 'y': 27, 'width': 53, 'height': 28}, {'item_type': 1, 'x': 0, 'y': 0, 'width': 21, 'height': 13}, {'item_type': 2, 'x': 78, 'y': 0, 'width': 25, 'height': 48}, {'item_type': 3, 'x': 0, 'y': 33, 'width': 1, 'height': 3}, {'item_type': 4, 'x': 0, 'y': 13, 'width': 10, 'height': 13}, {'item_type': 5, 'x': 103, 'y': 0, 'width': 57, 'height': 27}, {'item_type': 6, 'x': 0, 'y': 36, 'width': 2, 'height': 12}, {'item_type': 7, 'x': 21, 'y': 0, 'width': 49, 'height': 38}], 'obj': 55.0, 'is_nontrivial': True, 'problem_type': '2SP'}","[{'item_type': 0, 'x': 107, 'y': 27, 'width': 53, 'height': 28}, {'item_type': 1, 'x': 0, 'y': 0, 'width': 21, 'height': 13}, {'item_type': 2, 'x': 78, 'y': 0, 'width': 25, 'height': 48}, {'item_type': 3, 'x': 0, 'y': 33, 'width': 1, 'height': 3}, {'item_type': 4, 'x': 0, 'y': 13, 'width': 10, 'height': 13}, {'item_type': 5, 'x': 103, 'y': 0, 'width': 57, 'height': 27}, {'item_type': 6, 'x': 0, 'y': 36, 'width': 2, 'height': 12}, {'item_type': 7, 'x': 21, 'y': 0, 'width': 49, 'height': 38}]",55.0,"{'problem_type': '2SP', 'bin_width': 160, 'bin_height': 63, 'items': [{'item_id': 1, 'width': 53, 'height': 28}, {'item_id': 2, 'width': 21, 'height': 13}, {'item_id': 3, 'width': 25, 'height': 48}, {'item_id': 4, 'width': 1, 'height': 3}, {'item_id': 5, 'width': 10, 'height': 13}, {'item_id': 6, 'width': 57, 'height': 27}, {'item_id': 7, 'width': 2, 'height': 12}, {'item_id': 8, 'width': 49, 'height': 38}], 'num_item_types': 8}","[{'item_type': 1, 'x': 107, 'y': 27, 'width': 53, 'height': 28}, {'item_type': 2, 'x': 0, 'y': 0, 'width': 21, 'height': 13}, {'item_type': 3, 'x': 78, 'y': 0, 'width': 25, 'height': 48}, {'item_type': 4, 'x': 0, 'y': 33, 'width': 1, 'height': 3}, {'item_type': 5, 'x': 0, 'y': 13, 'width': 10, 'height': 13}, {'item_type': 6, 'x': 103, 'y': 0, 'width': 57, 'height': 27}, {'item_type': 7, 'x': 0, 'y': 36, 'width': 2, 'height': 12}, {'item_type': 8, 'x': 21, 'y': 0, 'width': 49, 'height': 38}]",32,nl,1
2SP,2SP,"A friend of mine has a narrow vertical slot and several mat boards to slide in; each board must go in one time only, lie flat without any angle, avoid overlapping with others, and stay fully inside the slot. The arrangement that’s preferred is the one where the highest top of any board is as low as possible — that highest top edge’s vertical coordinate is the overall height to watch. Also specify, for each board, how far its bottom-left corner is from the left wall and how far up it is from the bottom. The concrete measurements are listed below.

The slot's inner horizontal width is 160 and the overall vertical height to be minimized (the used height) is 52.
Board A is 28 wide and 40 high; give its bottom-left corner's distance from the left wall and its distance up from the bottom.
Board B is 8 wide and 36 high; give its bottom-left corner's distance from the left wall and its distance up from the bottom.
Board C is 63 wide and 18 high; give its bottom-left corner's distance from the left wall and its distance up from the bottom.
Board D is 4 wide and 17 high; give its bottom-left corner's distance from the left wall and its distance up from the bottom.
Board E is 87 wide and 30 high; give its bottom-left corner's distance from the left wall and its distance up from the bottom.
Board F is 82 wide and 12 high; give its bottom-left corner's distance from the left wall and its distance up from the bottom.
Have my friend list each board that way so the packing stays within 160 and attains used height 52.

Also, just so we're on the same page about the reply format, please use this JSON layout for the placement sketch:

{
  ""solution"": [{""item_type"": <board_type_id>, ""x"": 0, ""y"": 0, ""width"": 10, ""height"": 5}, ...]
}

Here’s what the bits mean in plain words: ""solution"" is a list of the boards you slide in; each entry gives the board's type (item_type), where its bottom-left corner sits from the left and bottom (x and y), and the board's own size (width and height). Think of it like a simple form to fill out — not the final packing, just the shape I expect.

A quick reminder: the JSON above is only a sketch of the expected shape, not the actual answer. Use the exact identifiers from the instance input when you fill it in — don't rename them and don't add 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”.","{'items': [{'width': 28, 'height': 40, 'demand': 1}, {'width': 8, 'height': 36, 'demand': 1}, {'width': 63, 'height': 18, 'demand': 1}, {'width': 4, 'height': 17, 'demand': 1}, {'width': 87, 'height': 30, 'demand': 1}, {'width': 82, 'height': 12, 'demand': 1}], 'bin_width': 160, 'bin_height': 52, 'is_strip_packing': False, 'solution': [{'item_type': 0, 'x': 0, 'y': 0, 'width': 28, 'height': 40}, {'item_type': 1, 'x': 28, 'y': 0, 'width': 8, 'height': 36}, {'item_type': 2, 'x': 82, 'y': 34, 'width': 63, 'height': 18}, {'item_type': 3, 'x': 156, 'y': 0, 'width': 4, 'height': 17}, {'item_type': 4, 'x': 69, 'y': 0, 'width': 87, 'height': 30}, {'item_type': 5, 'x': 0, 'y': 40, 'width': 82, 'height': 12}], 'obj': 52.0, 'is_nontrivial': True, 'problem_type': '2SP'}","[{'item_type': 0, 'x': 0, 'y': 0, 'width': 28, 'height': 40}, {'item_type': 1, 'x': 28, 'y': 0, 'width': 8, 'height': 36}, {'item_type': 2, 'x': 82, 'y': 34, 'width': 63, 'height': 18}, {'item_type': 3, 'x': 156, 'y': 0, 'width': 4, 'height': 17}, {'item_type': 4, 'x': 69, 'y': 0, 'width': 87, 'height': 30}, {'item_type': 5, 'x': 0, 'y': 40, 'width': 82, 'height': 12}]",52.0,"{'problem_type': '2SP', 'bin_width': 160, 'bin_height': 52, 'items': [{'item_id': 'A', 'width': 28, 'height': 40}, {'item_id': 'B', 'width': 8, 'height': 36}, {'item_id': 'C', 'width': 63, 'height': 18}, {'item_id': 'D', 'width': 4, 'height': 17}, {'item_id': 'E', 'width': 87, 'height': 30}, {'item_id': 'F', 'width': 82, 'height': 12}], 'num_item_types': 6}","[{'item_type': 'A', 'x': 0, 'y': 0, 'width': 28, 'height': 40}, {'item_type': 'B', 'x': 28, 'y': 0, 'width': 8, 'height': 36}, {'item_type': 'C', 'x': 82, 'y': 34, 'width': 63, 'height': 18}, {'item_type': 'D', 'x': 156, 'y': 0, 'width': 4, 'height': 17}, {'item_type': 'E', 'x': 69, 'y': 0, 'width': 87, 'height': 30}, {'item_type': 'F', 'x': 0, 'y': 40, 'width': 82, 'height': 12}]",33,nl,names
2SP,2SP,"We watched a merchandiser lay out a set of rectangular fabric samples along a fixed-width wall. The idea was to place exactly one of each sample, align them straight (no rotation), and decide each sample’s position by how far in from the left wall its bottom-left corner sits and how far up from the bottom it starts. Everything had to fit inside the strip and not cover any other sample; the better layouts kept the highest top edge lower, because the overall height used is just the height of that topmost edge. The specific sample dimensions and strip details appear below.

{
  ""wall_strip_width"": 160,
  ""wall_strip_height_limit"": 88,
  ""items"": [
    {
      ""sample_id"": 1,
      ""sample_width"": 40,
      ""sample_height"": 22
    },
    {
      ""sample_id"": 2,
      ""sample_width"": 35,
      ""sample_height"": 67
    },
    {
      ""sample_id"": 3,
      ""sample_width"": 14,
      ""sample_height"": 50
    },
    {
      ""sample_id"": 4,
      ""sample_width"": 19,
      ""sample_height"": 40
    },
    {
      ""sample_id"": 5,
      ""sample_width"": 68,
      ""sample_height"": 44
    },
    {
      ""sample_id"": 6,
      ""sample_width"": 51,
      ""sample_height"": 24
    },
    {
      ""sample_id"": 7,
      ""sample_width"": 38,
      ""sample_height"": 37
    }
  ]
}

I'll sketch the layout reply in a tiny JSON form so it's easy to copy into whatever you're using. It should follow this shape:

{
  ""solution"": [{""item_type"": <sample_type_id>, ""x"": 0, ""y"": 0, ""width"": 10, ""height"": 5}, ...]
}

Here, ""item_type"" is the ID for a fabric sample (kept as a placeholder <sample_type_id>), x and y are how far in from the left wall and up from the bottom the sample's bottom-left corner sits, and width/height are the sample's size. Think of this as a simple form: one object per sample with its position and size. It's just a sketch of the expected shape, not the actual placement.

Please remember 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”.","{'items': [{'width': 40, 'height': 22, 'demand': 1}, {'width': 35, 'height': 67, 'demand': 1}, {'width': 14, 'height': 50, 'demand': 1}, {'width': 19, 'height': 40, 'demand': 1}, {'width': 68, 'height': 44, 'demand': 1}, {'width': 51, 'height': 24, 'demand': 1}, {'width': 38, 'height': 37, 'demand': 1}], 'bin_width': 160, 'bin_height': 88, 'is_strip_packing': False, 'solution': [{'item_type': 0, 'x': 61, 'y': 0, 'width': 40, 'height': 22}, {'item_type': 1, 'x': 125, 'y': 0, 'width': 35, 'height': 67}, {'item_type': 2, 'x': 68, 'y': 24, 'width': 14, 'height': 50}, {'item_type': 3, 'x': 106, 'y': 0, 'width': 19, 'height': 40}, {'item_type': 4, 'x': 0, 'y': 24, 'width': 68, 'height': 44}, {'item_type': 5, 'x': 10, 'y': 0, 'width': 51, 'height': 24}, {'item_type': 6, 'x': 82, 'y': 40, 'width': 38, 'height': 37}], 'obj': 77.0, 'is_nontrivial': True, 'problem_type': '2SP'}","[{'item_type': 0, 'x': 61, 'y': 0, 'width': 40, 'height': 22}, {'item_type': 1, 'x': 125, 'y': 0, 'width': 35, 'height': 67}, {'item_type': 2, 'x': 68, 'y': 24, 'width': 14, 'height': 50}, {'item_type': 3, 'x': 106, 'y': 0, 'width': 19, 'height': 40}, {'item_type': 4, 'x': 0, 'y': 24, 'width': 68, 'height': 44}, {'item_type': 5, 'x': 10, 'y': 0, 'width': 51, 'height': 24}, {'item_type': 6, 'x': 82, 'y': 40, 'width': 38, 'height': 37}]",77.0,"{'problem_type': '2SP', 'bin_width': 160, 'bin_height': 88, 'items': [{'item_id': 1, 'width': 40, 'height': 22}, {'item_id': 2, 'width': 35, 'height': 67}, {'item_id': 3, 'width': 14, 'height': 50}, {'item_id': 4, 'width': 19, 'height': 40}, {'item_id': 5, 'width': 68, 'height': 44}, {'item_id': 6, 'width': 51, 'height': 24}, {'item_id': 7, 'width': 38, 'height': 37}], 'num_item_types': 7}","[{'item_type': 1, 'x': 61, 'y': 0, 'width': 40, 'height': 22}, {'item_type': 2, 'x': 125, 'y': 0, 'width': 35, 'height': 67}, {'item_type': 3, 'x': 68, 'y': 24, 'width': 14, 'height': 50}, {'item_type': 4, 'x': 106, 'y': 0, 'width': 19, 'height': 40}, {'item_type': 5, 'x': 0, 'y': 24, 'width': 68, 'height': 44}, {'item_type': 6, 'x': 10, 'y': 0, 'width': 51, 'height': 24}, {'item_type': 7, 'x': 82, 'y': 40, 'width': 38, 'height': 37}]",34,json,1
2SP,2SP,"I run a little glass shop and need to lay out one of each rectangular window pane on a long stacking board that has a fixed width. The job is to pick where each pane sits by choosing the position of its bottom-left corner measured from the left edge and the bottom edge of the board, keeping every pane straight (no tilting), completely inside the board, and never overlapping another. A better layout is simply the one that keeps the top edges of the panes as low as possible — check the layout by finding the highest top edge among all panes, and the lower that highest top edge is, the better the packing. The exact pane sizes and the board measurements are shown below.

{
  ""stacking_board_width"": 80,
  ""stacking_board_height"": 17,
  ""items"": [
    {
      ""pane_id"": 0,
      ""pane_width"": 4,
      ""pane_height"": 3
    },
    {
      ""pane_id"": 1,
      ""pane_width"": 16,
      ""pane_height"": 5
    },
    {
      ""pane_id"": 2,
      ""pane_width"": 34,
      ""pane_height"": 11
    },
    {
      ""pane_id"": 3,
      ""pane_width"": 3,
      ""pane_height"": 5
    },
    {
      ""pane_id"": 4,
      ""pane_width"": 10,
      ""pane_height"": 6
    },
    {
      ""pane_id"": 5,
      ""pane_width"": 40,
      ""pane_height"": 13
    },
    {
      ""pane_id"": 6,
      ""pane_width"": 4,
      ""pane_height"": 4
    },
    {
      ""pane_id"": 7,
      ""pane_width"": 7,
      ""pane_height"": 6
    }
  ]
}

When you send the layout back, just use a little JSON like this so I can read where each pane goes — nothing fancy, just that shape.

{
  ""solution"": [{""item_type"": <pane_type_id>, ""x"": 0, ""y"": 0, ""width"": 10, ""height"": 5}, ...]
}

This shows the shape I expect: each entry in ""solution"" is one pane. ""item_type"" is the pane identifier (use the exact identifier from the instance), ""x"" and ""y"" are the bottom-left coordinates measured from the left and bottom edges of the board, and ""width"" and ""height"" are the pane’s size. The numbers above are just examples to show the shape — treat this as a sketch, not the final answer.

Quick reminder: all identifiers must be used exactly as they appear in the instance input — no renaming and no new labels.
- for example: ""Valid identifiers look like plain numbers such as “1” or “23”, single capital letters like “A” or “B”, or a capital letter followed by digits like “A1” or “X7”.""","{'items': [{'width': 4, 'height': 3, 'demand': 1}, {'width': 16, 'height': 5, 'demand': 1}, {'width': 34, 'height': 11, 'demand': 1}, {'width': 3, 'height': 5, 'demand': 1}, {'width': 10, 'height': 6, 'demand': 1}, {'width': 40, 'height': 13, 'demand': 1}, {'width': 4, 'height': 4, 'demand': 1}, {'width': 7, 'height': 6, 'demand': 1}], 'bin_width': 80, 'bin_height': 17, 'is_strip_packing': False, 'solution': [{'item_type': 0, 'x': 38, 'y': 0, 'width': 4, 'height': 3}, {'item_type': 1, 'x': 3, 'y': 12, 'width': 16, 'height': 5}, {'item_type': 2, 'x': 4, 'y': 0, 'width': 34, 'height': 11}, {'item_type': 3, 'x': 0, 'y': 12, 'width': 3, 'height': 5}, {'item_type': 4, 'x': 19, 'y': 11, 'width': 10, 'height': 6}, {'item_type': 5, 'x': 40, 'y': 4, 'width': 40, 'height': 13}, {'item_type': 6, 'x': 0, 'y': 8, 'width': 4, 'height': 4}, {'item_type': 7, 'x': 29, 'y': 11, 'width': 7, 'height': 6}], 'obj': 17.0, 'is_nontrivial': True, 'problem_type': '2SP'}","[{'item_type': 0, 'x': 38, 'y': 0, 'width': 4, 'height': 3}, {'item_type': 1, 'x': 3, 'y': 12, 'width': 16, 'height': 5}, {'item_type': 2, 'x': 4, 'y': 0, 'width': 34, 'height': 11}, {'item_type': 3, 'x': 0, 'y': 12, 'width': 3, 'height': 5}, {'item_type': 4, 'x': 19, 'y': 11, 'width': 10, 'height': 6}, {'item_type': 5, 'x': 40, 'y': 4, 'width': 40, 'height': 13}, {'item_type': 6, 'x': 0, 'y': 8, 'width': 4, 'height': 4}, {'item_type': 7, 'x': 29, 'y': 11, 'width': 7, 'height': 6}]",17.0,"{'problem_type': '2SP', 'bin_width': 80, 'bin_height': 17, 'items': [{'item_id': 0, 'width': 4, 'height': 3}, {'item_id': 1, 'width': 16, 'height': 5}, {'item_id': 2, 'width': 34, 'height': 11}, {'item_id': 3, 'width': 3, 'height': 5}, {'item_id': 4, 'width': 10, 'height': 6}, {'item_id': 5, 'width': 40, 'height': 13}, {'item_id': 6, 'width': 4, 'height': 4}, {'item_id': 7, 'width': 7, 'height': 6}], 'num_item_types': 8}","[{'item_type': 0, 'x': 38, 'y': 0, 'width': 4, 'height': 3}, {'item_type': 1, 'x': 3, 'y': 12, 'width': 16, 'height': 5}, {'item_type': 2, 'x': 4, 'y': 0, 'width': 34, 'height': 11}, {'item_type': 3, 'x': 0, 'y': 12, 'width': 3, 'height': 5}, {'item_type': 4, 'x': 19, 'y': 11, 'width': 10, 'height': 6}, {'item_type': 5, 'x': 40, 'y': 4, 'width': 40, 'height': 13}, {'item_type': 6, 'x': 0, 'y': 8, 'width': 4, 'height': 4}, {'item_type': 7, 'x': 29, 'y': 11, 'width': 7, 'height': 6}]",35,json,0
2SP,2SP,"We have a roll with a set width and a pile of different stickers that all have to fit: one copy of each, placed straight (no rotation), entirely inside the roll, and not overlapping one another. For each sticker someone picks how far it should sit from the left margin and how far up from the bottom margin, and that determines its spot. The aim is to keep the roll as short as possible — the length that matters is the highest point any sticker’s top edge reaches. The exact sticker dimensions and the roll width are listed below.

{
  ""roll_width"": 160,
  ""roll_height_limit"": 75,
  ""items"": [
    {
      ""sticker_id"": 0,
      ""sticker_width"": 112,
      ""sticker_height"": 22
    },
    {
      ""sticker_id"": 1,
      ""sticker_width"": 4,
      ""sticker_height"": 9
    },
    {
      ""sticker_id"": 2,
      ""sticker_width"": 52,
      ""sticker_height"": 43
    },
    {
      ""sticker_id"": 3,
      ""sticker_width"": 26,
      ""sticker_height"": 57
    },
    {
      ""sticker_id"": 4,
      ""sticker_width"": 24,
      ""sticker_height"": 52
    }
  ]
}

You can just give the placement as a little JSON snippet so it's easy to check. Something like this:

{
  ""solution"": [{""item_type"": <sticker_type_id>, ""x"": 0, ""y"": 0, ""width"": 10, ""height"": 5}, ...]
}

This shows the shape I expect: a ""solution"" list of sticker placements. Each object says which sticker type it is (item_type), where its bottom-left corner sits from the left and bottom edges (x and y), and the sticker's own size (width and height). Think of it like filling out a simple form for each sticker — this block is just an example of the shape, not the real packing.

Please make sure to use the exact identifiers from the instance input — don't rename them or invent new labels. Valid identifiers look like plain numbers such as ""1"" or ""23"", single capital letters like ""A"" or ""B"", or a capital letter followed by digits like ""A1"" or ""X7"".","{'items': [{'width': 112, 'height': 22, 'demand': 1}, {'width': 4, 'height': 9, 'demand': 1}, {'width': 52, 'height': 43, 'demand': 1}, {'width': 26, 'height': 57, 'demand': 1}, {'width': 24, 'height': 52, 'demand': 1}], 'bin_width': 160, 'bin_height': 75, 'is_strip_packing': False, 'solution': [{'item_type': 0, 'x': 48, 'y': 0, 'width': 112, 'height': 22}, {'item_type': 1, 'x': 102, 'y': 65, 'width': 4, 'height': 9}, {'item_type': 2, 'x': 26, 'y': 22, 'width': 52, 'height': 43}, {'item_type': 3, 'x': 0, 'y': 0, 'width': 26, 'height': 57}, {'item_type': 4, 'x': 78, 'y': 22, 'width': 24, 'height': 52}], 'obj': 74.0, 'is_nontrivial': True, 'problem_type': '2SP'}","[{'item_type': 0, 'x': 48, 'y': 0, 'width': 112, 'height': 22}, {'item_type': 1, 'x': 102, 'y': 65, 'width': 4, 'height': 9}, {'item_type': 2, 'x': 26, 'y': 22, 'width': 52, 'height': 43}, {'item_type': 3, 'x': 0, 'y': 0, 'width': 26, 'height': 57}, {'item_type': 4, 'x': 78, 'y': 22, 'width': 24, 'height': 52}]",74.0,"{'problem_type': '2SP', 'bin_width': 160, 'bin_height': 75, 'items': [{'item_id': 0, 'width': 112, 'height': 22}, {'item_id': 1, 'width': 4, 'height': 9}, {'item_id': 2, 'width': 52, 'height': 43}, {'item_id': 3, 'width': 26, 'height': 57}, {'item_id': 4, 'width': 24, 'height': 52}], 'num_item_types': 5}","[{'item_type': 0, 'x': 48, 'y': 0, 'width': 112, 'height': 22}, {'item_type': 1, 'x': 102, 'y': 65, 'width': 4, 'height': 9}, {'item_type': 2, 'x': 26, 'y': 22, 'width': 52, 'height': 43}, {'item_type': 3, 'x': 0, 'y': 0, 'width': 26, 'height': 57}, {'item_type': 4, 'x': 78, 'y': 22, 'width': 24, 'height': 52}]",36,json,0
2SP,2SP,"We got a note from a carpenter asking our crew to arrange one copy of each rectangular shelf backing on a board that has a fixed width. For each backing the plan was to decide its bottom-left position — how many centimeters from the left side and how many from the bottom — keep every piece axis-aligned (no rotations), keep them completely inside the board edges, and avoid any overlap or duplicates. Better layouts are the ones where the highest top edge of all the backings ends up as low as possible; that highest top edge is what measures the total height used. The concrete piece dimensions and board size appear below.

# board_width_cm=160
# board_max_height_cm=116
backing_id,backing_width_cm,backing_height_cm
1,58,12
2,33,32
3,32,63
4,16,48
5,54,14
6,63,32
7,65,55
8,35,89

Oh, and when you send the layout back, just follow this simple JSON shape so we can read it automatically:

{
  ""solution"": [{""item_type"": <backing_id>, ""x"": 0, ""y"": 0, ""width"": 10, ""height"": 5}, ...]
}

This little sketch means: each entry in ""solution"" is one backing placed on the board. ""item_type"" (here I used <backing_id> to match the story) is the identifier for which backing it is, ""x"" and ""y"" are the bottom-left coordinates (how far from the left and bottom edges), and ""width""/""height"" are the backing's size. It's just a template of the shape we expect — not the final placement.

Please make sure you use the exact identifiers from the instance input — don't rename them or invent new labels. 
- ""Valid identifiers look like plain numbers such as “1” or “23”, single capital letters like “A” or “B”, or a capital letter followed by digits like “A1” or “X7”.""","{'items': [{'width': 58, 'height': 12, 'demand': 1}, {'width': 33, 'height': 32, 'demand': 1}, {'width': 32, 'height': 63, 'demand': 1}, {'width': 16, 'height': 48, 'demand': 1}, {'width': 54, 'height': 14, 'demand': 1}, {'width': 63, 'height': 32, 'demand': 1}, {'width': 65, 'height': 55, 'demand': 1}, {'width': 35, 'height': 89, 'demand': 1}], 'bin_width': 160, 'bin_height': 116, 'is_strip_packing': False, 'solution': [{'item_type': 0, 'x': 0, 'y': 0, 'width': 58, 'height': 12}, {'item_type': 1, 'x': 35, 'y': 63, 'width': 33, 'height': 32}, {'item_type': 2, 'x': 58, 'y': 0, 'width': 32, 'height': 63}, {'item_type': 3, 'x': 35, 'y': 12, 'width': 16, 'height': 48}, {'item_type': 4, 'x': 95, 'y': 87, 'width': 54, 'height': 14}, {'item_type': 5, 'x': 90, 'y': 55, 'width': 63, 'height': 32}, {'item_type': 6, 'x': 90, 'y': 0, 'width': 65, 'height': 55}, {'item_type': 7, 'x': 0, 'y': 12, 'width': 35, 'height': 89}], 'obj': 101.0, 'is_nontrivial': True, 'problem_type': '2SP'}","[{'item_type': 0, 'x': 0, 'y': 0, 'width': 58, 'height': 12}, {'item_type': 1, 'x': 35, 'y': 63, 'width': 33, 'height': 32}, {'item_type': 2, 'x': 58, 'y': 0, 'width': 32, 'height': 63}, {'item_type': 3, 'x': 35, 'y': 12, 'width': 16, 'height': 48}, {'item_type': 4, 'x': 95, 'y': 87, 'width': 54, 'height': 14}, {'item_type': 5, 'x': 90, 'y': 55, 'width': 63, 'height': 32}, {'item_type': 6, 'x': 90, 'y': 0, 'width': 65, 'height': 55}, {'item_type': 7, 'x': 0, 'y': 12, 'width': 35, 'height': 89}]",101.0,"{'problem_type': '2SP', 'bin_width': 160, 'bin_height': 116, 'items': [{'item_id': 1, 'width': 58, 'height': 12}, {'item_id': 2, 'width': 33, 'height': 32}, {'item_id': 3, 'width': 32, 'height': 63}, {'item_id': 4, 'width': 16, 'height': 48}, {'item_id': 5, 'width': 54, 'height': 14}, {'item_id': 6, 'width': 63, 'height': 32}, {'item_id': 7, 'width': 65, 'height': 55}, {'item_id': 8, 'width': 35, 'height': 89}], 'num_item_types': 8}","[{'item_type': 1, 'x': 0, 'y': 0, 'width': 58, 'height': 12}, {'item_type': 2, 'x': 35, 'y': 63, 'width': 33, 'height': 32}, {'item_type': 3, 'x': 58, 'y': 0, 'width': 32, 'height': 63}, {'item_type': 4, 'x': 35, 'y': 12, 'width': 16, 'height': 48}, {'item_type': 5, 'x': 95, 'y': 87, 'width': 54, 'height': 14}, {'item_type': 6, 'x': 90, 'y': 55, 'width': 63, 'height': 32}, {'item_type': 7, 'x': 90, 'y': 0, 'width': 65, 'height': 55}, {'item_type': 8, 'x': 0, 'y': 12, 'width': 35, 'height': 89}]",37,csv,1
2SP,2SP,"Someone in the shipping team asked for one copy of every rectangular parcel to be placed on a fixed-width pallet, with the only choice being where each parcel’s bottom-left corner goes relative to the pallet’s left and bottom edges. Each box must lie flat and straight with the pallet edges, remain entirely inside the pallet area, and not cover any other box. The success of a layout is judged by the tallest parcel top — look at each parcel’s bottom position plus its height and take the highest value; the lower that number, the better. The exact pallet dimensions and parcel measurements are shown below.

{
  ""pallet_width"": 160,
  ""pallet_height_limit"": 41,
  ""items"": [
    {
      ""parcel_id"": ""A"",
      ""parcel_width"": 57,
      ""parcel_height"": 17
    },
    {
      ""parcel_id"": ""B"",
      ""parcel_width"": 73,
      ""parcel_height"": 18
    },
    {
      ""parcel_id"": ""C"",
      ""parcel_width"": 19,
      ""parcel_height"": 31
    },
    {
      ""parcel_id"": ""D"",
      ""parcel_width"": 18,
      ""parcel_height"": 24
    },
    {
      ""parcel_id"": ""E"",
      ""parcel_width"": 23,
      ""parcel_height"": 31
    },
    {
      ""parcel_id"": ""F"",
      ""parcel_width"": 7,
      ""parcel_height"": 6
    }
  ]
}

If it helps, I’ll put the layout in a little JSON snippet so it’s easy to read and parse — something like this is what I expect to return for a proposed packing:

{
  ""solution"": [{""item_type"": <parcel_type_id>, ""x"": 0, ""y"": 0, ""width"": 10, ""height"": 5}, ...]
}

Here’s what each bit means in plain terms: item_type is the identifier for the parcel type you’re placing, x and y are where that parcel’s bottom-left corner sits measured from the pallet’s left and bottom edges, and width and height are the parcel’s own dimensions. Think of it like filling out a simple form for each box: which box, where it sits, and how big it is.

This JSON is just a sketch of the expected shape — not the final placement — so don’t treat the example numbers or the placeholder as a real solution.

Please also make sure to use the exact identifiers from the instance input — don’t rename them or invent new labels. For example: Valid identifiers look like plain numbers such as “1” or “23”, single capital letters like “A” or “B”, or a capital letter followed by digits like “A1” or “X7”.","{'items': [{'width': 57, 'height': 17, 'demand': 1}, {'width': 73, 'height': 18, 'demand': 1}, {'width': 19, 'height': 31, 'demand': 1}, {'width': 18, 'height': 24, 'demand': 1}, {'width': 23, 'height': 31, 'demand': 1}, {'width': 7, 'height': 6, 'demand': 1}], 'bin_width': 160, 'bin_height': 41, 'is_strip_packing': False, 'solution': [{'item_type': 0, 'x': 0, 'y': 18, 'width': 57, 'height': 17}, {'item_type': 1, 'x': 0, 'y': 0, 'width': 73, 'height': 18}, {'item_type': 2, 'x': 100, 'y': 0, 'width': 19, 'height': 31}, {'item_type': 3, 'x': 119, 'y': 0, 'width': 18, 'height': 24}, {'item_type': 4, 'x': 137, 'y': 0, 'width': 23, 'height': 31}, {'item_type': 5, 'x': 57, 'y': 24, 'width': 7, 'height': 6}], 'obj': 35.0, 'is_nontrivial': True, 'problem_type': '2SP'}","[{'item_type': 0, 'x': 0, 'y': 18, 'width': 57, 'height': 17}, {'item_type': 1, 'x': 0, 'y': 0, 'width': 73, 'height': 18}, {'item_type': 2, 'x': 100, 'y': 0, 'width': 19, 'height': 31}, {'item_type': 3, 'x': 119, 'y': 0, 'width': 18, 'height': 24}, {'item_type': 4, 'x': 137, 'y': 0, 'width': 23, 'height': 31}, {'item_type': 5, 'x': 57, 'y': 24, 'width': 7, 'height': 6}]",35.0,"{'problem_type': '2SP', 'bin_width': 160, 'bin_height': 41, 'items': [{'item_id': 'A', 'width': 57, 'height': 17}, {'item_id': 'B', 'width': 73, 'height': 18}, {'item_id': 'C', 'width': 19, 'height': 31}, {'item_id': 'D', 'width': 18, 'height': 24}, {'item_id': 'E', 'width': 23, 'height': 31}, {'item_id': 'F', 'width': 7, 'height': 6}], 'num_item_types': 6}","[{'item_type': 'A', 'x': 0, 'y': 18, 'width': 57, 'height': 17}, {'item_type': 'B', 'x': 0, 'y': 0, 'width': 73, 'height': 18}, {'item_type': 'C', 'x': 100, 'y': 0, 'width': 19, 'height': 31}, {'item_type': 'D', 'x': 119, 'y': 0, 'width': 18, 'height': 24}, {'item_type': 'E', 'x': 137, 'y': 0, 'width': 23, 'height': 31}, {'item_type': 'F', 'x': 57, 'y': 24, 'width': 7, 'height': 6}]",38,json,names
2SP,2SP,"There’s a mounting strip in the gallery and an installer wants every rectangular banner displayed on it — one copy of each. For each banner someone must pick where its bottom-left corner sits: how many centimeters from the left edge and how many from the floor. Banners stay aligned with the strip (no rotation), must lie completely inside the strip, and may not overlap; every banner goes up exactly once. The goal is to pack them so the highest top edge among them is as low as possible — that height is what counts for the total space used. The concrete sizes and details are shown below.

The strip is 160 cm wide and has a vertical limit of 33 cm.
Banner 0 is 2 cm wide and 9 cm tall.
Banner 1 is 14 cm wide and 18 cm tall.
Banner 2 is 123 cm wide and 19 cm tall.
Banner 3 is 7 cm wide and 25 cm tall.
Banner 4 is 32 cm wide and 12 cm tall.
Banner 5 is 3 cm wide and 7 cm tall.
Place every banner once within those bounds, without overlap, aiming to minimize the highest top edge.

You can just send the packing as a little JSON snippet like this so I know where each banner’s bottom-left corner goes.

{
  ""solution"": [{""item_type"": <banner_type_id>, ""x"": 0, ""y"": 0, ""width"": 10, ""height"": 5}, ...]
}

Think of that as a simple form: each array entry is one banner. item_type is the banner’s identifier, x and y are how many centimeters from the left edge and the floor the bottom-left corner sits, and width/height are the banner’s own size. It’s just the shape I expect the answer to have, not the actual packing.

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"".""","{'items': [{'width': 2, 'height': 9, 'demand': 1}, {'width': 14, 'height': 18, 'demand': 1}, {'width': 123, 'height': 19, 'demand': 1}, {'width': 7, 'height': 25, 'demand': 1}, {'width': 32, 'height': 12, 'demand': 1}, {'width': 3, 'height': 7, 'demand': 1}], 'bin_width': 160, 'bin_height': 33, 'is_strip_packing': False, 'solution': [{'item_type': 0, 'x': 0, 'y': 0, 'width': 2, 'height': 9}, {'item_type': 1, 'x': 0, 'y': 9, 'width': 14, 'height': 18}, {'item_type': 2, 'x': 24, 'y': 12, 'width': 123, 'height': 19}, {'item_type': 3, 'x': 17, 'y': 0, 'width': 7, 'height': 25}, {'item_type': 4, 'x': 24, 'y': 0, 'width': 32, 'height': 12}, {'item_type': 5, 'x': 14, 'y': 24, 'width': 3, 'height': 7}], 'obj': 31.0, 'is_nontrivial': True, 'problem_type': '2SP'}","[{'item_type': 0, 'x': 0, 'y': 0, 'width': 2, 'height': 9}, {'item_type': 1, 'x': 0, 'y': 9, 'width': 14, 'height': 18}, {'item_type': 2, 'x': 24, 'y': 12, 'width': 123, 'height': 19}, {'item_type': 3, 'x': 17, 'y': 0, 'width': 7, 'height': 25}, {'item_type': 4, 'x': 24, 'y': 0, 'width': 32, 'height': 12}, {'item_type': 5, 'x': 14, 'y': 24, 'width': 3, 'height': 7}]",31.0,"{'problem_type': '2SP', 'bin_width': 160, 'bin_height': 33, 'items': [{'item_id': 0, 'width': 2, 'height': 9}, {'item_id': 1, 'width': 14, 'height': 18}, {'item_id': 2, 'width': 123, 'height': 19}, {'item_id': 3, 'width': 7, 'height': 25}, {'item_id': 4, 'width': 32, 'height': 12}, {'item_id': 5, 'width': 3, 'height': 7}], 'num_item_types': 6}","[{'item_type': 0, 'x': 0, 'y': 0, 'width': 2, 'height': 9}, {'item_type': 1, 'x': 0, 'y': 9, 'width': 14, 'height': 18}, {'item_type': 2, 'x': 24, 'y': 12, 'width': 123, 'height': 19}, {'item_type': 3, 'x': 17, 'y': 0, 'width': 7, 'height': 25}, {'item_type': 4, 'x': 24, 'y': 0, 'width': 32, 'height': 12}, {'item_type': 5, 'x': 14, 'y': 24, 'width': 3, 'height': 7}]",39,nl,0
2SP,2SP,"In a small studio the task was to fit a set of rectangular pattern panels across a wall strip with a fixed width. For each panel the placement is recorded by the distance of its bottom-left corner from the left edge and from the floor; panels must sit square with the wall (no rotation), remain entirely within the strip’s sides, never overlap, and exactly one copy of each pattern must be used. A layout is judged better when the tallest top edge is lower — measure from the floor up to the highest top of any panel, and aim to make that number small. The concrete dimensions and details are provided below.

{
  ""strip_width"": 160,
  ""strip_max_height"": 108,
  ""items"": [
    {
      ""panel_id"": ""A"",
      ""panel_width"": 7,
      ""panel_height"": 32
    },
    {
      ""panel_id"": ""B"",
      ""panel_width"": 83,
      ""panel_height"": 32
    },
    {
      ""panel_id"": ""C"",
      ""panel_width"": 44,
      ""panel_height"": 60
    },
    {
      ""panel_id"": ""D"",
      ""panel_width"": 63,
      ""panel_height"": 83
    },
    {
      ""panel_id"": ""E"",
      ""panel_width"": 26,
      ""panel_height"": 11
    },
    {
      ""panel_id"": ""F"",
      ""panel_width"": 107,
      ""panel_height"": 19
    },
    {
      ""panel_id"": ""G"",
      ""panel_width"": 20,
      ""panel_height"": 5
    },
    {
      ""panel_id"": ""H"",
      ""panel_width"": 21,
      ""panel_height"": 44
    }
  ]
}

Also, when you send back a candidate layout, a little JSON like the one below makes it easy to read and check — just one entry per panel:

{
  ""solution"": [{""item_type"": <panel_type_id>, ""x"": 0, ""y"": 0, ""width"": 10, ""height"": 5}, ...]
}

Here’s what those fields mean in plain terms: each object in ""solution"" is one panel placement. ""item_type"" is the panel’s identifier (use the exact identifier from the instance), ""x"" and ""y"" are how far the panel’s bottom-left corner is from the left wall and the floor respectively, and ""width"" and ""height"" are the panel’s own size. This JSON is just a sketch of the shape I’m expecting, not the final answer.

Please be sure to use the identifiers exactly as they appear in the instance input — no renaming and no new labels. Valid identifiers look like plain numbers such as “1” or “23”, single capital letters like “A” or “B”, or a capital letter followed by digits like “A1” or “X7”.","{'items': [{'width': 7, 'height': 32, 'demand': 1}, {'width': 83, 'height': 32, 'demand': 1}, {'width': 44, 'height': 60, 'demand': 1}, {'width': 63, 'height': 83, 'demand': 1}, {'width': 26, 'height': 11, 'demand': 1}, {'width': 107, 'height': 19, 'demand': 1}, {'width': 20, 'height': 5, 'demand': 1}, {'width': 21, 'height': 44, 'demand': 1}], 'bin_width': 160, 'bin_height': 108, 'is_strip_packing': False, 'solution': [{'item_type': 0, 'x': 0, 'y': 75, 'width': 7, 'height': 32}, {'item_type': 1, 'x': 70, 'y': 75, 'width': 83, 'height': 32}, {'item_type': 2, 'x': 116, 'y': 11, 'width': 44, 'height': 60}, {'item_type': 3, 'x': 7, 'y': 19, 'width': 63, 'height': 83}, {'item_type': 4, 'x': 114, 'y': 0, 'width': 26, 'height': 11}, {'item_type': 5, 'x': 0, 'y': 0, 'width': 107, 'height': 19}, {'item_type': 6, 'x': 140, 'y': 0, 'width': 20, 'height': 5}, {'item_type': 7, 'x': 70, 'y': 19, 'width': 21, 'height': 44}], 'obj': 107.0, 'is_nontrivial': True, 'problem_type': '2SP'}","[{'item_type': 0, 'x': 0, 'y': 75, 'width': 7, 'height': 32}, {'item_type': 1, 'x': 70, 'y': 75, 'width': 83, 'height': 32}, {'item_type': 2, 'x': 116, 'y': 11, 'width': 44, 'height': 60}, {'item_type': 3, 'x': 7, 'y': 19, 'width': 63, 'height': 83}, {'item_type': 4, 'x': 114, 'y': 0, 'width': 26, 'height': 11}, {'item_type': 5, 'x': 0, 'y': 0, 'width': 107, 'height': 19}, {'item_type': 6, 'x': 140, 'y': 0, 'width': 20, 'height': 5}, {'item_type': 7, 'x': 70, 'y': 19, 'width': 21, 'height': 44}]",107.0,"{'problem_type': '2SP', 'bin_width': 160, 'bin_height': 108, 'items': [{'item_id': 'A', 'width': 7, 'height': 32}, {'item_id': 'B', 'width': 83, 'height': 32}, {'item_id': 'C', 'width': 44, 'height': 60}, {'item_id': 'D', 'width': 63, 'height': 83}, {'item_id': 'E', 'width': 26, 'height': 11}, {'item_id': 'F', 'width': 107, 'height': 19}, {'item_id': 'G', 'width': 20, 'height': 5}, {'item_id': 'H', 'width': 21, 'height': 44}], 'num_item_types': 8}","[{'item_type': 'A', 'x': 0, 'y': 75, 'width': 7, 'height': 32}, {'item_type': 'B', 'x': 70, 'y': 75, 'width': 83, 'height': 32}, {'item_type': 'C', 'x': 116, 'y': 11, 'width': 44, 'height': 60}, {'item_type': 'D', 'x': 7, 'y': 19, 'width': 63, 'height': 83}, {'item_type': 'E', 'x': 114, 'y': 0, 'width': 26, 'height': 11}, {'item_type': 'F', 'x': 0, 'y': 0, 'width': 107, 'height': 19}, {'item_type': 'G', 'x': 140, 'y': 0, 'width': 20, 'height': 5}, {'item_type': 'H', 'x': 70, 'y': 19, 'width': 21, 'height': 44}]",40,json,names
2SP,2SP,"I was watching a window stylist fiddle with a long display shelf the other day — they had one of each rectangular prop and had to decide exactly where to put each one by choosing how far from the left edge and how high off the shelf each should sit. They couldn’t tilt anything, everything had to sit straight, fit entirely inside the shelf, and nothing could overlap or be left out or doubled up. The neatness of the arrangement was judged by how tall the whole display ended up: measure from the bottom of the shelf to the highest top edge of any prop, and the lower that number, the better the layout. The specific sizes and the shelf width will be shown below.

# shelf_width=160
# shelf_height_limit=172
prop_id,prop_width,prop_height
1,55,18
2,75,22
3,11,31
4,44,9
5,22,107
6,28,74
7,99,22
8,39,68
9,63,132

Oh, and when you send the layout back, a simple JSON sketch like the one below is perfect — it just lists each prop with where it sits and how big it is.

{
  ""solution"": [{""item_type"": <prop_type_id>, ""x"": 0, ""y"": 0, ""width"": 10, ""height"": 5}, ...]
}

This little block means: ""solution"" is the list of placed props; each object inside gives the prop's type (the placeholder there tells you which prop), the x and y distance from the left and bottom edges, and the prop's width and height. Think of it like a form: pick a prop, say how far right and how high it sits, and confirm its size. It's just the shape I expect your final answer to follow — not the final placement itself.

Please use the exact identifiers from the instance input when you fill that in — 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”.""","{'items': [{'width': 55, 'height': 18, 'demand': 1}, {'width': 75, 'height': 22, 'demand': 1}, {'width': 11, 'height': 31, 'demand': 1}, {'width': 44, 'height': 9, 'demand': 1}, {'width': 22, 'height': 107, 'demand': 1}, {'width': 28, 'height': 74, 'demand': 1}, {'width': 99, 'height': 22, 'demand': 1}, {'width': 39, 'height': 68, 'demand': 1}, {'width': 63, 'height': 132, 'demand': 1}], 'bin_width': 160, 'bin_height': 172, 'is_strip_packing': False, 'solution': [{'item_type': 0, 'x': 105, 'y': 44, 'width': 55, 'height': 18}, {'item_type': 1, 'x': 85, 'y': 22, 'width': 75, 'height': 22}, {'item_type': 2, 'x': 93, 'y': 44, 'width': 11, 'height': 31}, {'item_type': 3, 'x': 11, 'y': 0, 'width': 44, 'height': 9}, {'item_type': 4, 'x': 71, 'y': 47, 'width': 22, 'height': 107}, {'item_type': 5, 'x': 93, 'y': 75, 'width': 28, 'height': 74}, {'item_type': 6, 'x': 61, 'y': 0, 'width': 99, 'height': 22}, {'item_type': 7, 'x': 121, 'y': 62, 'width': 39, 'height': 68}, {'item_type': 8, 'x': 0, 'y': 22, 'width': 63, 'height': 132}], 'obj': 154.0, 'is_nontrivial': True, 'problem_type': '2SP'}","[{'item_type': 0, 'x': 105, 'y': 44, 'width': 55, 'height': 18}, {'item_type': 1, 'x': 85, 'y': 22, 'width': 75, 'height': 22}, {'item_type': 2, 'x': 93, 'y': 44, 'width': 11, 'height': 31}, {'item_type': 3, 'x': 11, 'y': 0, 'width': 44, 'height': 9}, {'item_type': 4, 'x': 71, 'y': 47, 'width': 22, 'height': 107}, {'item_type': 5, 'x': 93, 'y': 75, 'width': 28, 'height': 74}, {'item_type': 6, 'x': 61, 'y': 0, 'width': 99, 'height': 22}, {'item_type': 7, 'x': 121, 'y': 62, 'width': 39, 'height': 68}, {'item_type': 8, 'x': 0, 'y': 22, 'width': 63, 'height': 132}]",154.0,"{'problem_type': '2SP', 'bin_width': 160, 'bin_height': 172, 'items': [{'item_id': 1, 'width': 55, 'height': 18}, {'item_id': 2, 'width': 75, 'height': 22}, {'item_id': 3, 'width': 11, 'height': 31}, {'item_id': 4, 'width': 44, 'height': 9}, {'item_id': 5, 'width': 22, 'height': 107}, {'item_id': 6, 'width': 28, 'height': 74}, {'item_id': 7, 'width': 99, 'height': 22}, {'item_id': 8, 'width': 39, 'height': 68}, {'item_id': 9, 'width': 63, 'height': 132}], 'num_item_types': 9}","[{'item_type': 1, 'x': 105, 'y': 44, 'width': 55, 'height': 18}, {'item_type': 2, 'x': 85, 'y': 22, 'width': 75, 'height': 22}, {'item_type': 3, 'x': 93, 'y': 44, 'width': 11, 'height': 31}, {'item_type': 4, 'x': 11, 'y': 0, 'width': 44, 'height': 9}, {'item_type': 5, 'x': 71, 'y': 47, 'width': 22, 'height': 107}, {'item_type': 6, 'x': 93, 'y': 75, 'width': 28, 'height': 74}, {'item_type': 7, 'x': 61, 'y': 0, 'width': 99, 'height': 22}, {'item_type': 8, 'x': 121, 'y': 62, 'width': 39, 'height': 68}, {'item_type': 9, 'x': 0, 'y': 22, 'width': 63, 'height': 132}]",41,csv,1
2SP,2SP,"There’s a small design job: place one of every rectangular insert onto a sleeve that has a set width, by specifying each insert’s lower-left corner in terms of distance from the left and from the bottom. Each insert must sit straight (sides parallel to the sleeve), be completely inside the sleeve boundaries, and never overlap another insert — exactly one copy of each is allowed. The layout that’s preferred is the one where the highest top edge across all inserts is as low as possible — find each insert’s bottom position plus its height, and the largest of those values is the overall height used, which should be kept small. The specific sizes and measurements follow below.

The sleeve inner width is 64 and the sleeve height limit is 29.
Insert 0, width 3, height 14: specify its lower-left corner as distances from the left and from the bottom.
Insert 1, width 2, height 2: specify its lower-left corner as distances from the left and from the bottom.
Insert 2, width 2, height 2: specify its lower-left corner as distances from the left and from the bottom.
Insert 3, width 9, height 22: specify its lower-left corner as distances from the left and from the bottom.
Insert 4, width 22, height 2: specify its lower-left corner as distances from the left and from the bottom.
Insert 5, width 13, height 7: specify its lower-left corner as distances from the left and from the bottom.
Insert 6, width 25, height 5: specify its lower-left corner as distances from the left and from the bottom.
Insert 7, width 3, height 22: specify its lower-left corner as distances from the left and from the bottom.
Insert 8, width 37, height 22: specify its lower-left corner as distances from the left and from the bottom.
Ensure every insert is placed straight, fully inside the sleeve, and non-overlapping; keep the highest top edge (each bottom + height) as low as possible while respecting the sleeve width 64 and height limit 29.

Also, when you send the layout back, please use this JSON shape so it's easy to parse:

{
  ""solution"": [{""item_type"": <insert_type_id>, ""x"": 0, ""y"": 0, ""width"": 10, ""height"": 5}, ...]
}

This little sketch means: each entry in ""solution"" is one insert placement. ""item_type"" is the insert type identifier from the instance, ""x"" and ""y"" are the left and bottom offsets for that insert, and ""width"" and ""height"" are its size. It's just an example of the shape I need — not the real answer.

Please use the identifiers exactly as they appear in the instance input — do not rename 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"".","{'items': [{'width': 3, 'height': 14, 'demand': 1}, {'width': 2, 'height': 2, 'demand': 1}, {'width': 2, 'height': 2, 'demand': 1}, {'width': 9, 'height': 22, 'demand': 1}, {'width': 22, 'height': 2, 'demand': 1}, {'width': 13, 'height': 7, 'demand': 1}, {'width': 25, 'height': 5, 'demand': 1}, {'width': 3, 'height': 22, 'demand': 1}, {'width': 37, 'height': 22, 'demand': 1}], 'bin_width': 64, 'bin_height': 29, 'is_strip_packing': False, 'solution': [{'item_type': 0, 'x': 37, 'y': 0, 'width': 3, 'height': 14}, {'item_type': 1, 'x': 0, 'y': 22, 'width': 2, 'height': 2}, {'item_type': 2, 'x': 0, 'y': 24, 'width': 2, 'height': 2}, {'item_type': 3, 'x': 55, 'y': 0, 'width': 9, 'height': 22}, {'item_type': 4, 'x': 6, 'y': 22, 'width': 22, 'height': 2}, {'item_type': 5, 'x': 37, 'y': 14, 'width': 13, 'height': 7}, {'item_type': 6, 'x': 37, 'y': 22, 'width': 25, 'height': 5}, {'item_type': 7, 'x': 50, 'y': 0, 'width': 3, 'height': 22}, {'item_type': 8, 'x': 0, 'y': 0, 'width': 37, 'height': 22}], 'obj': 27.0, 'is_nontrivial': True, 'problem_type': '2SP'}","[{'item_type': 0, 'x': 37, 'y': 0, 'width': 3, 'height': 14}, {'item_type': 1, 'x': 0, 'y': 22, 'width': 2, 'height': 2}, {'item_type': 2, 'x': 0, 'y': 24, 'width': 2, 'height': 2}, {'item_type': 3, 'x': 55, 'y': 0, 'width': 9, 'height': 22}, {'item_type': 4, 'x': 6, 'y': 22, 'width': 22, 'height': 2}, {'item_type': 5, 'x': 37, 'y': 14, 'width': 13, 'height': 7}, {'item_type': 6, 'x': 37, 'y': 22, 'width': 25, 'height': 5}, {'item_type': 7, 'x': 50, 'y': 0, 'width': 3, 'height': 22}, {'item_type': 8, 'x': 0, 'y': 0, 'width': 37, 'height': 22}]",27.0,"{'problem_type': '2SP', 'bin_width': 64, 'bin_height': 29, 'items': [{'item_id': 0, 'width': 3, 'height': 14}, {'item_id': 1, 'width': 2, 'height': 2}, {'item_id': 2, 'width': 2, 'height': 2}, {'item_id': 3, 'width': 9, 'height': 22}, {'item_id': 4, 'width': 22, 'height': 2}, {'item_id': 5, 'width': 13, 'height': 7}, {'item_id': 6, 'width': 25, 'height': 5}, {'item_id': 7, 'width': 3, 'height': 22}, {'item_id': 8, 'width': 37, 'height': 22}], 'num_item_types': 9}","[{'item_type': 0, 'x': 37, 'y': 0, 'width': 3, 'height': 14}, {'item_type': 1, 'x': 0, 'y': 22, 'width': 2, 'height': 2}, {'item_type': 2, 'x': 0, 'y': 24, 'width': 2, 'height': 2}, {'item_type': 3, 'x': 55, 'y': 0, 'width': 9, 'height': 22}, {'item_type': 4, 'x': 6, 'y': 22, 'width': 22, 'height': 2}, {'item_type': 5, 'x': 37, 'y': 14, 'width': 13, 'height': 7}, {'item_type': 6, 'x': 37, 'y': 22, 'width': 25, 'height': 5}, {'item_type': 7, 'x': 50, 'y': 0, 'width': 3, 'height': 22}, {'item_type': 8, 'x': 0, 'y': 0, 'width': 37, 'height': 22}]",42,nl,0
2SP,2SP,"Someone at the fair is trying to squeeze a bunch of rectangular mats into a single booth with a fixed width and needs a tidy plan. The rule is one mat of each type, placed upright (edges parallel to the booth), completely inside the borders, with each position given by horizontal and vertical offsets from the left and bottom, and absolutely no overlaps. What counts as a good plan is simply how little vertical space it wastes — the used height is the topmost point reached by any mat. The exact sizes and the booth width will be shown below.

- **booth_width**: 40
- **booth_height_limit**: 28

| mat_id | mat_width | mat_height |
|---|---|---|
| 0 | 3 | 5 |
| 1 | 35 | 12 |
| 2 | 4 | 15 |
| 3 | 3 | 5 |
| 4 | 4 | 3 |
| 5 | 4 | 21 |
| 6 | 3 | 5 |
| 7 | 7 | 5 |
| 8 | 5 | 5 |

Oh, and before you send anything back, just drop the packing plan into a little JSON like this so it's easy to read programmatically — nothing fancy, just a simple list of placements.

{
  ""solution"": [{""item_type"": <mat_type_id>, ""x"": 0, ""y"": 0, ""width"": 10, ""height"": 5}, ...]
}

This is just a sketch of the shape I expect: ""solution"" is an array, each entry is one mat placement giving which mat type it is, the bottom-left x and y offsets from the booth's left and bottom edges, and the mat's width and height. Think of it like filling in a short form for each mat.

The JSON above is only an example of the format — not the actual answer. 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”.","{'items': [{'width': 3, 'height': 5, 'demand': 1}, {'width': 35, 'height': 12, 'demand': 1}, {'width': 4, 'height': 15, 'demand': 1}, {'width': 3, 'height': 5, 'demand': 1}, {'width': 4, 'height': 3, 'demand': 1}, {'width': 4, 'height': 21, 'demand': 1}, {'width': 3, 'height': 5, 'demand': 1}, {'width': 7, 'height': 5, 'demand': 1}, {'width': 5, 'height': 5, 'demand': 1}], 'bin_width': 40, 'bin_height': 28, 'is_strip_packing': False, 'solution': [{'item_type': 0, 'x': 1, 'y': 0, 'width': 3, 'height': 5}, {'item_type': 1, 'x': 5, 'y': 16, 'width': 35, 'height': 12}, {'item_type': 2, 'x': 7, 'y': 0, 'width': 4, 'height': 15}, {'item_type': 3, 'x': 4, 'y': 5, 'width': 3, 'height': 5}, {'item_type': 4, 'x': 11, 'y': 0, 'width': 4, 'height': 3}, {'item_type': 5, 'x': 0, 'y': 7, 'width': 4, 'height': 21}, {'item_type': 6, 'x': 4, 'y': 11, 'width': 3, 'height': 5}, {'item_type': 7, 'x': 12, 'y': 8, 'width': 7, 'height': 5}, {'item_type': 8, 'x': 12, 'y': 3, 'width': 5, 'height': 5}], 'obj': 28.0, 'is_nontrivial': True, 'problem_type': '2SP'}","[{'item_type': 0, 'x': 1, 'y': 0, 'width': 3, 'height': 5}, {'item_type': 1, 'x': 5, 'y': 16, 'width': 35, 'height': 12}, {'item_type': 2, 'x': 7, 'y': 0, 'width': 4, 'height': 15}, {'item_type': 3, 'x': 4, 'y': 5, 'width': 3, 'height': 5}, {'item_type': 4, 'x': 11, 'y': 0, 'width': 4, 'height': 3}, {'item_type': 5, 'x': 0, 'y': 7, 'width': 4, 'height': 21}, {'item_type': 6, 'x': 4, 'y': 11, 'width': 3, 'height': 5}, {'item_type': 7, 'x': 12, 'y': 8, 'width': 7, 'height': 5}, {'item_type': 8, 'x': 12, 'y': 3, 'width': 5, 'height': 5}]",28.0,"{'problem_type': '2SP', 'bin_width': 40, 'bin_height': 28, 'items': [{'item_id': 0, 'width': 3, 'height': 5}, {'item_id': 1, 'width': 35, 'height': 12}, {'item_id': 2, 'width': 4, 'height': 15}, {'item_id': 3, 'width': 3, 'height': 5}, {'item_id': 4, 'width': 4, 'height': 3}, {'item_id': 5, 'width': 4, 'height': 21}, {'item_id': 6, 'width': 3, 'height': 5}, {'item_id': 7, 'width': 7, 'height': 5}, {'item_id': 8, 'width': 5, 'height': 5}], 'num_item_types': 9}","[{'item_type': 0, 'x': 1, 'y': 0, 'width': 3, 'height': 5}, {'item_type': 1, 'x': 5, 'y': 16, 'width': 35, 'height': 12}, {'item_type': 2, 'x': 7, 'y': 0, 'width': 4, 'height': 15}, {'item_type': 3, 'x': 4, 'y': 5, 'width': 3, 'height': 5}, {'item_type': 4, 'x': 11, 'y': 0, 'width': 4, 'height': 3}, {'item_type': 5, 'x': 0, 'y': 7, 'width': 4, 'height': 21}, {'item_type': 6, 'x': 4, 'y': 11, 'width': 3, 'height': 5}, {'item_type': 7, 'x': 12, 'y': 8, 'width': 7, 'height': 5}, {'item_type': 8, 'x': 12, 'y': 3, 'width': 5, 'height': 5}]",43,markdown_table,0
2SP,2SP,"Many people picture seed trays stacked messily, but on this narrow bench every rectangular tray had to be placed carefully, one copy of each. The plan called for deciding, for each tray, the bottom-left placement (how far from the left rail and how far up from the bench), keeping them all straight, entirely on the bench, and never overlapping another tray. The point of the exercise was to keep the whole arrangement short: check the top edge of every tray, take the one that sits highest above the bench floor, and aim to make that height as small as possible. Specific tray dimensions and the bench width are given below.

{
  ""bench_width"": 160,
  ""bench_height"": 45,
  ""items"": [
    {
      ""tray_type_id"": 1,
      ""tray_width"": 27,
      ""tray_height"": 18
    },
    {
      ""tray_type_id"": 2,
      ""tray_width"": 18,
      ""tray_height"": 5
    },
    {
      ""tray_type_id"": 3,
      ""tray_width"": 77,
      ""tray_height"": 25
    },
    {
      ""tray_type_id"": 4,
      ""tray_width"": 13,
      ""tray_height"": 5
    },
    {
      ""tray_type_id"": 5,
      ""tray_width"": 46,
      ""tray_height"": 34
    },
    {
      ""tray_type_id"": 6,
      ""tray_width"": 58,
      ""tray_height"": 20
    },
    {
      ""tray_type_id"": 7,
      ""tray_width"": 4,
      ""tray_height"": 9
    }
  ]
}

If you want to tell me a specific placement, just drop it in a little JSON like this — nice and simple, nothing fancy:

{
  ""solution"": [{""item_type"": <tray_type_id>, ""x"": 0, ""y"": 0, ""width"": 10, ""height"": 5}, ...]
}

Think of it like a short form: item_type is the tray label, x is how far from the left rail the tray's bottom-left corner sits, y is how high up from the bench floor that same corner sits, and width/height are the tray's size. Super informal — just a sketch of the shape I expect, not the actual answer.

Please make sure to use the exact identifiers from the instance input — don't rename them or invent new ones.
- for example: ""Valid identifiers look like plain numbers such as “1” or “23”, single capital letters like “A” or “B”, or a capital letter followed by digits like “A1” or “X7”.""","{'items': [{'width': 27, 'height': 18, 'demand': 1}, {'width': 18, 'height': 5, 'demand': 1}, {'width': 77, 'height': 25, 'demand': 1}, {'width': 13, 'height': 5, 'demand': 1}, {'width': 46, 'height': 34, 'demand': 1}, {'width': 58, 'height': 20, 'demand': 1}, {'width': 4, 'height': 9, 'demand': 1}], 'bin_width': 160, 'bin_height': 45, 'is_strip_packing': False, 'solution': [{'item_type': 0, 'x': 58, 'y': 0, 'width': 27, 'height': 18}, {'item_type': 1, 'x': 90, 'y': 40, 'width': 18, 'height': 5}, {'item_type': 2, 'x': 13, 'y': 20, 'width': 77, 'height': 25}, {'item_type': 3, 'x': 0, 'y': 34, 'width': 13, 'height': 5}, {'item_type': 4, 'x': 114, 'y': 0, 'width': 46, 'height': 34}, {'item_type': 5, 'x': 0, 'y': 0, 'width': 58, 'height': 20}, {'item_type': 6, 'x': 90, 'y': 18, 'width': 4, 'height': 9}], 'obj': 45.0, 'is_nontrivial': True, 'problem_type': '2SP'}","[{'item_type': 0, 'x': 58, 'y': 0, 'width': 27, 'height': 18}, {'item_type': 1, 'x': 90, 'y': 40, 'width': 18, 'height': 5}, {'item_type': 2, 'x': 13, 'y': 20, 'width': 77, 'height': 25}, {'item_type': 3, 'x': 0, 'y': 34, 'width': 13, 'height': 5}, {'item_type': 4, 'x': 114, 'y': 0, 'width': 46, 'height': 34}, {'item_type': 5, 'x': 0, 'y': 0, 'width': 58, 'height': 20}, {'item_type': 6, 'x': 90, 'y': 18, 'width': 4, 'height': 9}]",45.0,"{'problem_type': '2SP', 'bin_width': 160, 'bin_height': 45, 'items': [{'item_id': 1, 'width': 27, 'height': 18}, {'item_id': 2, 'width': 18, 'height': 5}, {'item_id': 3, 'width': 77, 'height': 25}, {'item_id': 4, 'width': 13, 'height': 5}, {'item_id': 5, 'width': 46, 'height': 34}, {'item_id': 6, 'width': 58, 'height': 20}, {'item_id': 7, 'width': 4, 'height': 9}], 'num_item_types': 7}","[{'item_type': 1, 'x': 58, 'y': 0, 'width': 27, 'height': 18}, {'item_type': 2, 'x': 90, 'y': 40, 'width': 18, 'height': 5}, {'item_type': 3, 'x': 13, 'y': 20, 'width': 77, 'height': 25}, {'item_type': 4, 'x': 0, 'y': 34, 'width': 13, 'height': 5}, {'item_type': 5, 'x': 114, 'y': 0, 'width': 46, 'height': 34}, {'item_type': 6, 'x': 0, 'y': 0, 'width': 58, 'height': 20}, {'item_type': 7, 'x': 90, 'y': 18, 'width': 4, 'height': 9}]",44,json,1
2SP,2SP,"Recently a team had to organize a batch of rectangular print jobs onto a single-strip feeder with a set width. The rule was to put one copy of each job down, keep each print lined up with the feeder edges (so no turning), make sure every print sits fully inside the strip, and never let prints overlap. For each job they wrote down the x and y of its bottom-left corner measured from the left and bottom of the feeder. The measure of a good layout is how low the highest top edge sits — that highest top edge is just the maximum vertical reach of any print. The detailed list of sizes and the strip width is shown below.

{
  ""strip_width"": 160,
  ""feeder_max_height"": 28,
  ""items"": [
    {
      ""job_id"": 1,
      ""print_width"": 9,
      ""print_height"": 6
    },
    {
      ""job_id"": 2,
      ""print_width"": 93,
      ""print_height"": 18
    },
    {
      ""job_id"": 3,
      ""print_width"": 17,
      ""print_height"": 5
    },
    {
      ""job_id"": 4,
      ""print_width"": 42,
      ""print_height"": 21
    },
    {
      ""job_id"": 5,
      ""print_width"": 2,
      ""print_height"": 12
    }
  ]
}

If you want to return a layout, just use a small JSON snippet like the one below so it's easy to parse and check. Here's the shape I expect:

{
  ""solution"": [{""item_type"": <print_job_id>, ""x"": 0, ""y"": 0, ""width"": 10, ""height"": 5}]
}

This is just a sketch of the shape, not the actual answer. In plain terms: ""solution"" is a list of placements; each entry gives the job identifier, the x/y of the bottom-left corner (from the left and bottom of the feeder), and the job's width and height.

Please make sure all identifiers you use match the instance input exactly — don't rename them or invent new labels. Valid identifiers look like these examples:
- ""1"" or ""23""
- ""A"" or ""B""
- ""A1"" or ""X7""","{'items': [{'width': 9, 'height': 6, 'demand': 1}, {'width': 93, 'height': 18, 'demand': 1}, {'width': 17, 'height': 5, 'demand': 1}, {'width': 42, 'height': 21, 'demand': 1}, {'width': 2, 'height': 12, 'demand': 1}], 'bin_width': 160, 'bin_height': 28, 'is_strip_packing': False, 'solution': [{'item_type': 0, 'x': 0, 'y': 0, 'width': 9, 'height': 6}, {'item_type': 1, 'x': 61, 'y': 3, 'width': 93, 'height': 18}, {'item_type': 2, 'x': 2, 'y': 6, 'width': 17, 'height': 5}, {'item_type': 3, 'x': 19, 'y': 0, 'width': 42, 'height': 21}, {'item_type': 4, 'x': 0, 'y': 9, 'width': 2, 'height': 12}], 'obj': 21.0, 'is_nontrivial': False, 'problem_type': '2SP'}","[{'item_type': 0, 'x': 0, 'y': 0, 'width': 9, 'height': 6}, {'item_type': 1, 'x': 61, 'y': 3, 'width': 93, 'height': 18}, {'item_type': 2, 'x': 2, 'y': 6, 'width': 17, 'height': 5}, {'item_type': 3, 'x': 19, 'y': 0, 'width': 42, 'height': 21}, {'item_type': 4, 'x': 0, 'y': 9, 'width': 2, 'height': 12}]",21.0,"{'problem_type': '2SP', 'bin_width': 160, 'bin_height': 28, 'items': [{'item_id': 1, 'width': 9, 'height': 6}, {'item_id': 2, 'width': 93, 'height': 18}, {'item_id': 3, 'width': 17, 'height': 5}, {'item_id': 4, 'width': 42, 'height': 21}, {'item_id': 5, 'width': 2, 'height': 12}], 'num_item_types': 5}","[{'item_type': 1, 'x': 0, 'y': 0, 'width': 9, 'height': 6}, {'item_type': 2, 'x': 61, 'y': 3, 'width': 93, 'height': 18}, {'item_type': 3, 'x': 2, 'y': 6, 'width': 17, 'height': 5}, {'item_type': 4, 'x': 19, 'y': 0, 'width': 42, 'height': 21}, {'item_type': 5, 'x': 0, 'y': 9, 'width': 2, 'height': 12}]",45,json,1
2SP,2SP,"Recently a studio project involved tucking a set of rectangular display boards onto a single fixed-width strip, one of each design. Each board had to sit without rotation, fully inside the strip, and be placed by giving how far its bottom-left corner is from the left side and from the bottom. Overlap was forbidden, and every board had to be used exactly once — no leftovers, no extras. The whole point was to make the highest top edge among the boards as small as possible — that top edge’s vertical coordinate is the total height used. The detailed list of board sizes and the strip width follows below.

The strip had width 160 and the packing height to be minimized was 29.
Board 0 measured 27 wide and 13 tall.
Board 1 measured 18 wide and 22 tall.
Board 2 measured 64 wide and 17 tall.
Board 3 measured 63 wide and 12 tall.
Board 4 measured 55 wide and 12 tall.
Each board had to be placed axis-aligned, non-overlapping, and fully inside the strip.

If you want to send a layout back, a handy way is to use a little JSON snippet so everything is clear and machine-readable. I usually sketch placements like this:

{
  ""solution"": [{""item_type"": <board_type_id>, ""x"": 0, ""y"": 0, ""width"": 10, ""height"": 5}, ...]
}

This JSON just lists each placed board: item_type is the board identifier, x and y are how far the bottom-left corner sits from the left and bottom edges respectively, and width/height are the board’s dimensions. Think of it like a simple form — this is only a sketch of the expected shape, not the final answer.

Please be sure to 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”.""","{'items': [{'width': 27, 'height': 13, 'demand': 1}, {'width': 18, 'height': 22, 'demand': 1}, {'width': 64, 'height': 17, 'demand': 1}, {'width': 63, 'height': 12, 'demand': 1}, {'width': 55, 'height': 12, 'demand': 1}], 'bin_width': 160, 'bin_height': 29, 'is_strip_packing': False, 'solution': [{'item_type': 0, 'x': 18, 'y': 12, 'width': 27, 'height': 13}, {'item_type': 1, 'x': 0, 'y': 0, 'width': 18, 'height': 22}, {'item_type': 2, 'x': 96, 'y': 12, 'width': 64, 'height': 17}, {'item_type': 3, 'x': 18, 'y': 0, 'width': 63, 'height': 12}, {'item_type': 4, 'x': 105, 'y': 0, 'width': 55, 'height': 12}], 'obj': 29.0, 'is_nontrivial': True, 'problem_type': '2SP'}","[{'item_type': 0, 'x': 18, 'y': 12, 'width': 27, 'height': 13}, {'item_type': 1, 'x': 0, 'y': 0, 'width': 18, 'height': 22}, {'item_type': 2, 'x': 96, 'y': 12, 'width': 64, 'height': 17}, {'item_type': 3, 'x': 18, 'y': 0, 'width': 63, 'height': 12}, {'item_type': 4, 'x': 105, 'y': 0, 'width': 55, 'height': 12}]",29.0,"{'problem_type': '2SP', 'bin_width': 160, 'bin_height': 29, 'items': [{'item_id': 0, 'width': 27, 'height': 13}, {'item_id': 1, 'width': 18, 'height': 22}, {'item_id': 2, 'width': 64, 'height': 17}, {'item_id': 3, 'width': 63, 'height': 12}, {'item_id': 4, 'width': 55, 'height': 12}], 'num_item_types': 5}","[{'item_type': 0, 'x': 18, 'y': 12, 'width': 27, 'height': 13}, {'item_type': 1, 'x': 0, 'y': 0, 'width': 18, 'height': 22}, {'item_type': 2, 'x': 96, 'y': 12, 'width': 64, 'height': 17}, {'item_type': 3, 'x': 18, 'y': 0, 'width': 63, 'height': 12}, {'item_type': 4, 'x': 105, 'y': 0, 'width': 55, 'height': 12}]",46,nl,0
2SP,2SP,"Recently the staging team needed help arranging rectangular floor panels across a runner that won’t change width. For each panel they needed to pick two numbers — how far from the left edge and how far from the bottom edge its bottom-left corner would be — making sure every panel’s edges run parallel to the runner (no twisting), every panel stays completely inside the runner, and panels don’t overlap. The idea was to make the whole setup as short as possible, which you read as the highest top edge among the panels; the lower that maximum top point, the better the plan. Each panel appears once, and the exact items and measurements are shown below.

# runner_width=160
# runner_height_bound=41
panel_id,panel_width,panel_height
A,44,9
B,75,22
C,11,31
D,31,27
E,70,14

If you want to hand me a candidate layout, a neat little JSON sketch works best — nothing fancy, just a ""solution"" list with one object per panel saying which panel type it is and where and how big it sits. Here's the shape I expect:

{
  ""solution"": [{""item_type"": <panel_type_id>, ""x"": 0, ""y"": 0, ""width"": 10, ""height"": 5}, ...]
}

That block is just an example of the shape: each entry represents one panel. ""item_type"" is the panel type identifier, ""x"" and ""y"" give the panel's bottom-left corner (how far from the left and bottom edges), and ""width"" / ""height"" are the panel's size. Think of it like filling out a simple form for each panel — the JSON is the form template, not your final answer.

Please make sure to use the exact identifiers given 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”.","{'items': [{'width': 44, 'height': 9, 'demand': 1}, {'width': 75, 'height': 22, 'demand': 1}, {'width': 11, 'height': 31, 'demand': 1}, {'width': 31, 'height': 27, 'demand': 1}, {'width': 70, 'height': 14, 'demand': 1}], 'bin_width': 160, 'bin_height': 41, 'is_strip_packing': False, 'solution': [{'item_type': 0, 'x': 0, 'y': 0, 'width': 44, 'height': 9}, {'item_type': 1, 'x': 85, 'y': 14, 'width': 75, 'height': 22}, {'item_type': 2, 'x': 74, 'y': 0, 'width': 11, 'height': 31}, {'item_type': 3, 'x': 0, 'y': 9, 'width': 31, 'height': 27}, {'item_type': 4, 'x': 90, 'y': 0, 'width': 70, 'height': 14}], 'obj': 36.0, 'is_nontrivial': True, 'problem_type': '2SP'}","[{'item_type': 0, 'x': 0, 'y': 0, 'width': 44, 'height': 9}, {'item_type': 1, 'x': 85, 'y': 14, 'width': 75, 'height': 22}, {'item_type': 2, 'x': 74, 'y': 0, 'width': 11, 'height': 31}, {'item_type': 3, 'x': 0, 'y': 9, 'width': 31, 'height': 27}, {'item_type': 4, 'x': 90, 'y': 0, 'width': 70, 'height': 14}]",36.0,"{'problem_type': '2SP', 'bin_width': 160, 'bin_height': 41, 'items': [{'item_id': 'A', 'width': 44, 'height': 9}, {'item_id': 'B', 'width': 75, 'height': 22}, {'item_id': 'C', 'width': 11, 'height': 31}, {'item_id': 'D', 'width': 31, 'height': 27}, {'item_id': 'E', 'width': 70, 'height': 14}], 'num_item_types': 5}","[{'item_type': 'A', 'x': 0, 'y': 0, 'width': 44, 'height': 9}, {'item_type': 'B', 'x': 85, 'y': 14, 'width': 75, 'height': 22}, {'item_type': 'C', 'x': 74, 'y': 0, 'width': 11, 'height': 31}, {'item_type': 'D', 'x': 0, 'y': 9, 'width': 31, 'height': 27}, {'item_type': 'E', 'x': 90, 'y': 0, 'width': 70, 'height': 14}]",47,csv,names
2SP,2SP,"On a typical shop day there’s a pile of rectangular patterns that all have to be fitted onto a cutter with a fixed usable width, one copy of each. Every pattern is put down so its sides run with the bed’s sides, fully inside the usable area and not overlapping anything else. Each pattern’s position is set by its left and bottom offsets, and the whole job wants the shortest possible run in the stacking direction — you measure that by finding each piece’s top edge (where it starts vertically plus its height) and using the tallest of those as the total length used. The detailed pattern sizes and the bed width follow below.

{
  ""bed_usable_width"": 160,
  ""bed_max_length"": 28,
  ""items"": [
    {
      ""pattern_id"": ""A"",
      ""pattern_width"": 13,
      ""pattern_length"": 4
    },
    {
      ""pattern_id"": ""B"",
      ""pattern_width"": 56,
      ""pattern_length"": 19
    },
    {
      ""pattern_id"": ""C"",
      ""pattern_width"": 47,
      ""pattern_length"": 12
    },
    {
      ""pattern_id"": ""D"",
      ""pattern_width"": 14,
      ""pattern_length"": 4
    },
    {
      ""pattern_id"": ""E"",
      ""pattern_width"": 13,
      ""pattern_length"": 9
    },
    {
      ""pattern_id"": ""F"",
      ""pattern_width"": 5,
      ""pattern_length"": 1
    },
    {
      ""pattern_id"": ""G"",
      ""pattern_width"": 19,
      ""pattern_length"": 21
    },
    {
      ""pattern_id"": ""H"",
      ""pattern_width"": 55,
      ""pattern_length"": 15
    },
    {
      ""pattern_id"": ""I"",
      ""pattern_width"": 10,
      ""pattern_length"": 2
    },
    {
      ""pattern_id"": ""J"",
      ""pattern_width"": 14,
      ""pattern_length"": 10
    }
  ]
}

You can just return the packing as a little JSON snippet like this — easy to read and I can parse it straight away:

{
  ""solution"": [{""item_type"": <pattern_type_id>, ""x"": 0, ""y"": 0, ""width"": 10, ""height"": 5}, ...]
}

This shows a list under ""solution"" where each entry names which pattern type is placed (item_type), the left/bottom offsets (x and y) and the pattern’s size (width and height). Think of it as a short form: one line per pattern saying which pattern, where it sits, and how big it is. It’s just a sketch of the shape I expect, not the final packing itself.

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”.""","{'items': [{'width': 13, 'height': 4, 'demand': 1}, {'width': 56, 'height': 19, 'demand': 1}, {'width': 47, 'height': 12, 'demand': 1}, {'width': 14, 'height': 4, 'demand': 1}, {'width': 13, 'height': 9, 'demand': 1}, {'width': 5, 'height': 1, 'demand': 1}, {'width': 19, 'height': 21, 'demand': 1}, {'width': 55, 'height': 15, 'demand': 1}, {'width': 10, 'height': 2, 'demand': 1}, {'width': 14, 'height': 10, 'demand': 1}], 'bin_width': 160, 'bin_height': 28, 'is_strip_packing': False, 'solution': [{'item_type': 0, 'x': 0, 'y': 0, 'width': 13, 'height': 4}, {'item_type': 1, 'x': 0, 'y': 4, 'width': 56, 'height': 19}, {'item_type': 2, 'x': 56, 'y': 0, 'width': 47, 'height': 12}, {'item_type': 3, 'x': 146, 'y': 23, 'width': 14, 'height': 4}, {'item_type': 4, 'x': 128, 'y': 0, 'width': 13, 'height': 9}, {'item_type': 5, 'x': 13, 'y': 0, 'width': 5, 'height': 1}, {'item_type': 6, 'x': 141, 'y': 2, 'width': 19, 'height': 21}, {'item_type': 7, 'x': 56, 'y': 12, 'width': 55, 'height': 15}, {'item_type': 8, 'x': 0, 'y': 25, 'width': 10, 'height': 2}, {'item_type': 9, 'x': 127, 'y': 9, 'width': 14, 'height': 10}], 'obj': 27.0, 'is_nontrivial': True, 'problem_type': '2SP'}","[{'item_type': 0, 'x': 0, 'y': 0, 'width': 13, 'height': 4}, {'item_type': 1, 'x': 0, 'y': 4, 'width': 56, 'height': 19}, {'item_type': 2, 'x': 56, 'y': 0, 'width': 47, 'height': 12}, {'item_type': 3, 'x': 146, 'y': 23, 'width': 14, 'height': 4}, {'item_type': 4, 'x': 128, 'y': 0, 'width': 13, 'height': 9}, {'item_type': 5, 'x': 13, 'y': 0, 'width': 5, 'height': 1}, {'item_type': 6, 'x': 141, 'y': 2, 'width': 19, 'height': 21}, {'item_type': 7, 'x': 56, 'y': 12, 'width': 55, 'height': 15}, {'item_type': 8, 'x': 0, 'y': 25, 'width': 10, 'height': 2}, {'item_type': 9, 'x': 127, 'y': 9, 'width': 14, 'height': 10}]",27.0,"{'problem_type': '2SP', 'bin_width': 160, 'bin_height': 28, 'items': [{'item_id': 'A', 'width': 13, 'height': 4}, {'item_id': 'B', 'width': 56, 'height': 19}, {'item_id': 'C', 'width': 47, 'height': 12}, {'item_id': 'D', 'width': 14, 'height': 4}, {'item_id': 'E', 'width': 13, 'height': 9}, {'item_id': 'F', 'width': 5, 'height': 1}, {'item_id': 'G', 'width': 19, 'height': 21}, {'item_id': 'H', 'width': 55, 'height': 15}, {'item_id': 'I', 'width': 10, 'height': 2}, {'item_id': 'J', 'width': 14, 'height': 10}], 'num_item_types': 10}","[{'item_type': 'A', 'x': 0, 'y': 0, 'width': 13, 'height': 4}, {'item_type': 'B', 'x': 0, 'y': 4, 'width': 56, 'height': 19}, {'item_type': 'C', 'x': 56, 'y': 0, 'width': 47, 'height': 12}, {'item_type': 'D', 'x': 146, 'y': 23, 'width': 14, 'height': 4}, {'item_type': 'E', 'x': 128, 'y': 0, 'width': 13, 'height': 9}, {'item_type': 'F', 'x': 13, 'y': 0, 'width': 5, 'height': 1}, {'item_type': 'G', 'x': 141, 'y': 2, 'width': 19, 'height': 21}, {'item_type': 'H', 'x': 56, 'y': 12, 'width': 55, 'height': 15}, {'item_type': 'I', 'x': 0, 'y': 25, 'width': 10, 'height': 2}, {'item_type': 'J', 'x': 127, 'y': 9, 'width': 14, 'height': 10}]",48,json,names
2SP,2SP,"Many people storing glass think of it like a narrow shelf where every different rectangular sheet must stand upright, flush to the slot sides, one copy each, and never overlapping. The challenge comes down to picking a left/right position and a bottom offset for every panel so they all sit inside the slot without touching one another improperly, and every single sheet type is used exactly once. The layout is judged by the tallest top edge — the overall height equals the distance from the slot bottom to the highest panel top — and the better the plan, the lower that number ends up. The concrete sizes and slot width are given below.

Slot inner width is 160 and slot height capacity is 34.
Sheet A is a rectangle of width 5 and height 12 and must be placed upright once inside the slot.
Sheet B is a rectangle of width 21 and height 26 and must be placed upright once inside the slot.
Sheet C is a rectangle of width 7 and height 24 and must be placed upright once inside the slot.
Sheet D is a rectangle of width 1 and height 1 and must be placed upright once inside the slot.
Sheet E is a rectangle of width 76 and height 13 and must be placed upright once inside the slot.
Sheet F is a rectangle of width 15 and height 13 and must be placed upright once inside the slot.
Sheet G is a rectangle of width 97 and height 21 and must be placed upright once inside the slot.
Sheet H is a rectangle of width 15 and height 11 and must be placed upright once inside the slot.
Sheet I is a rectangle of width 9 and height 5 and must be placed upright once inside the slot.
Sheet J is a rectangle of width 21 and height 20 and must be placed upright once inside the slot.
The goal remains to minimize the highest top edge when all sheets are placed inside the 160×34 slot.

If you want to send me a proposed layout, a neat way is to follow a tiny JSON sketch that lists every panel and where its bottom-left corner sits. Use this shape so I can read it easily:

{
  ""solution"": [{""item_type"": <panel_type_id>, ""x"": 0, ""y"": 0, ""width"": 10, ""height"": 5}, ...]
}

solution is just the array of placements. Each object is one panel type:
- item_type: the panel identifier (keep the exact id from the instance)
- x and y: how far the panel's bottom-left corner is from the left and bottom edges
- width and height: the panel's given dimensions

This block is only a sketch of the shape I expect, not your actual packing — fill it with the real identifiers and coordinates when you reply.

Please make sure to use the identifiers exactly as they appear in the instance input — no renaming and no new labels. Valid identifiers look like plain numbers such as “1” or “23”, single capital letters like “A” or “B”, or a capital letter followed by digits like “A1” or “X7”.","{'items': [{'width': 5, 'height': 12, 'demand': 1}, {'width': 21, 'height': 26, 'demand': 1}, {'width': 7, 'height': 24, 'demand': 1}, {'width': 1, 'height': 1, 'demand': 1}, {'width': 76, 'height': 13, 'demand': 1}, {'width': 15, 'height': 13, 'demand': 1}, {'width': 97, 'height': 21, 'demand': 1}, {'width': 15, 'height': 11, 'demand': 1}, {'width': 9, 'height': 5, 'demand': 1}, {'width': 21, 'height': 20, 'demand': 1}], 'bin_width': 160, 'bin_height': 34, 'is_strip_packing': False, 'solution': [{'item_type': 0, 'x': 0, 'y': 1, 'width': 5, 'height': 12}, {'item_type': 1, 'x': 12, 'y': 6, 'width': 21, 'height': 26}, {'item_type': 2, 'x': 5, 'y': 10, 'width': 7, 'height': 24}, {'item_type': 3, 'x': 0, 'y': 0, 'width': 1, 'height': 1}, {'item_type': 4, 'x': 54, 'y': 21, 'width': 76, 'height': 13}, {'item_type': 5, 'x': 33, 'y': 0, 'width': 15, 'height': 13}, {'item_type': 6, 'x': 63, 'y': 0, 'width': 97, 'height': 21}, {'item_type': 7, 'x': 48, 'y': 0, 'width': 15, 'height': 11}, {'item_type': 8, 'x': 12, 'y': 1, 'width': 9, 'height': 5}, {'item_type': 9, 'x': 33, 'y': 14, 'width': 21, 'height': 20}], 'obj': 34.0, 'is_nontrivial': True, 'problem_type': '2SP'}","[{'item_type': 0, 'x': 0, 'y': 1, 'width': 5, 'height': 12}, {'item_type': 1, 'x': 12, 'y': 6, 'width': 21, 'height': 26}, {'item_type': 2, 'x': 5, 'y': 10, 'width': 7, 'height': 24}, {'item_type': 3, 'x': 0, 'y': 0, 'width': 1, 'height': 1}, {'item_type': 4, 'x': 54, 'y': 21, 'width': 76, 'height': 13}, {'item_type': 5, 'x': 33, 'y': 0, 'width': 15, 'height': 13}, {'item_type': 6, 'x': 63, 'y': 0, 'width': 97, 'height': 21}, {'item_type': 7, 'x': 48, 'y': 0, 'width': 15, 'height': 11}, {'item_type': 8, 'x': 12, 'y': 1, 'width': 9, 'height': 5}, {'item_type': 9, 'x': 33, 'y': 14, 'width': 21, 'height': 20}]",34.0,"{'problem_type': '2SP', 'bin_width': 160, 'bin_height': 34, 'items': [{'item_id': 'A', 'width': 5, 'height': 12}, {'item_id': 'B', 'width': 21, 'height': 26}, {'item_id': 'C', 'width': 7, 'height': 24}, {'item_id': 'D', 'width': 1, 'height': 1}, {'item_id': 'E', 'width': 76, 'height': 13}, {'item_id': 'F', 'width': 15, 'height': 13}, {'item_id': 'G', 'width': 97, 'height': 21}, {'item_id': 'H', 'width': 15, 'height': 11}, {'item_id': 'I', 'width': 9, 'height': 5}, {'item_id': 'J', 'width': 21, 'height': 20}], 'num_item_types': 10}","[{'item_type': 'A', 'x': 0, 'y': 1, 'width': 5, 'height': 12}, {'item_type': 'B', 'x': 12, 'y': 6, 'width': 21, 'height': 26}, {'item_type': 'C', 'x': 5, 'y': 10, 'width': 7, 'height': 24}, {'item_type': 'D', 'x': 0, 'y': 0, 'width': 1, 'height': 1}, {'item_type': 'E', 'x': 54, 'y': 21, 'width': 76, 'height': 13}, {'item_type': 'F', 'x': 33, 'y': 0, 'width': 15, 'height': 13}, {'item_type': 'G', 'x': 63, 'y': 0, 'width': 97, 'height': 21}, {'item_type': 'H', 'x': 48, 'y': 0, 'width': 15, 'height': 11}, {'item_type': 'I', 'x': 12, 'y': 1, 'width': 9, 'height': 5}, {'item_type': 'J', 'x': 33, 'y': 14, 'width': 21, 'height': 20}]",49,nl,names
2SP,2SP,"We’ve got a rigid strip of fixed width and a bunch of rectangular tiles, one sample of every design, and the job is to place them all on the strip so their sides run parallel to the strip borders. Each tile is put down by deciding how far it’s shifted from the left edge and how far it’s lifted from the bottom; tiles must lie fully inside the strip and mustn’t overlap. What makes one arrangement nicer than another is how low the topmost tile sits — find the top edge of each tile and the highest of those determines the total height of the packing, and the lower that number the better. No tile can be left out or added more than once. The specific instance setup follows below.

We've got a strip with internal width 160 and an optional height limit 112.
Tile 0: place one copy of size 25 by 77 with its sides parallel to the strip, fully inside and not overlapping other tiles.
Tile 1: place one copy of size 49 by 86 with its sides parallel to the strip, fully inside and not overlapping other tiles.
Tile 2: place one copy of size 33 by 17 with its sides parallel to the strip, fully inside and not overlapping other tiles.
Tile 3: place one copy of size 34 by 51 with its sides parallel to the strip, fully inside and not overlapping other tiles.
Tile 4: place one copy of size 6 by 11 with its sides parallel to the strip, fully inside and not overlapping other tiles.
Tile 5: place one copy of size 50 by 41 with its sides parallel to the strip, fully inside and not overlapping other tiles.
Tile 6: place one copy of size 10 by 30 with its sides parallel to the strip, fully inside and not overlapping other tiles.
Tile 7: place one copy of size 48 by 23 with its sides parallel to the strip, fully inside and not overlapping other tiles.
Tile 8: place one copy of size 45 by 11 with its sides parallel to the strip, fully inside and not overlapping other tiles.
Tile 9: place one copy of size 55 by 52 with its sides parallel to the strip, fully inside and not overlapping other tiles.
Place every tile exactly once; the quantity to minimize is the maximum top edge over all tiles.

And hey, when you send the placement back, a little JSON sketch like the one below is exactly the shape I’m expecting — nothing fancy, just the form filled out with the placements.

{
  ""solution"": [{""item_type"": <tile_type_id>, ""x"": 0, ""y"": 0, ""width"": 10, ""height"": 5}, ...]
}

This is just a friendly form: each entry in ""solution"" is one of the tiles. ""item_type"" is the tile’s identifier, ""x"" and ""y"" are how far it sits from the left and bottom edges, and ""width"" and ""height"" are the tile’s sizes. Think of it like filling in a simple placement form rather than a technical file — the JSON is only a sketch of the expected shape, not the actual answer.

Please make sure you use the exact identifiers from the instance input — don’t rename them or invent new ones. Valid identifiers look like plain numbers such as “1” or “23”, single capital letters like “A” or “B”, or a capital letter followed by digits like “A1” or “X7”.","{'items': [{'width': 25, 'height': 77, 'demand': 1}, {'width': 49, 'height': 86, 'demand': 1}, {'width': 33, 'height': 17, 'demand': 1}, {'width': 34, 'height': 51, 'demand': 1}, {'width': 6, 'height': 11, 'demand': 1}, {'width': 50, 'height': 41, 'demand': 1}, {'width': 10, 'height': 30, 'demand': 1}, {'width': 48, 'height': 23, 'demand': 1}, {'width': 45, 'height': 11, 'demand': 1}, {'width': 55, 'height': 52, 'demand': 1}], 'bin_width': 160, 'bin_height': 112, 'is_strip_packing': False, 'solution': [{'item_type': 0, 'x': 0, 'y': 23, 'width': 25, 'height': 77}, {'item_type': 1, 'x': 111, 'y': 0, 'width': 49, 'height': 86}, {'item_type': 2, 'x': 111, 'y': 86, 'width': 33, 'height': 17}, {'item_type': 3, 'x': 25, 'y': 53, 'width': 34, 'height': 51}, {'item_type': 4, 'x': 48, 'y': 0, 'width': 6, 'height': 11}, {'item_type': 5, 'x': 61, 'y': 63, 'width': 50, 'height': 41}, {'item_type': 6, 'x': 25, 'y': 23, 'width': 10, 'height': 30}, {'item_type': 7, 'x': 0, 'y': 0, 'width': 48, 'height': 23}, {'item_type': 8, 'x': 66, 'y': 52, 'width': 45, 'height': 11}, {'item_type': 9, 'x': 56, 'y': 0, 'width': 55, 'height': 52}], 'obj': 104.0, 'is_nontrivial': True, 'problem_type': '2SP'}","[{'item_type': 0, 'x': 0, 'y': 23, 'width': 25, 'height': 77}, {'item_type': 1, 'x': 111, 'y': 0, 'width': 49, 'height': 86}, {'item_type': 2, 'x': 111, 'y': 86, 'width': 33, 'height': 17}, {'item_type': 3, 'x': 25, 'y': 53, 'width': 34, 'height': 51}, {'item_type': 4, 'x': 48, 'y': 0, 'width': 6, 'height': 11}, {'item_type': 5, 'x': 61, 'y': 63, 'width': 50, 'height': 41}, {'item_type': 6, 'x': 25, 'y': 23, 'width': 10, 'height': 30}, {'item_type': 7, 'x': 0, 'y': 0, 'width': 48, 'height': 23}, {'item_type': 8, 'x': 66, 'y': 52, 'width': 45, 'height': 11}, {'item_type': 9, 'x': 56, 'y': 0, 'width': 55, 'height': 52}]",104.0,"{'problem_type': '2SP', 'bin_width': 160, 'bin_height': 112, 'items': [{'item_id': 0, 'width': 25, 'height': 77}, {'item_id': 1, 'width': 49, 'height': 86}, {'item_id': 2, 'width': 33, 'height': 17}, {'item_id': 3, 'width': 34, 'height': 51}, {'item_id': 4, 'width': 6, 'height': 11}, {'item_id': 5, 'width': 50, 'height': 41}, {'item_id': 6, 'width': 10, 'height': 30}, {'item_id': 7, 'width': 48, 'height': 23}, {'item_id': 8, 'width': 45, 'height': 11}, {'item_id': 9, 'width': 55, 'height': 52}], 'num_item_types': 10}","[{'item_type': 0, 'x': 0, 'y': 23, 'width': 25, 'height': 77}, {'item_type': 1, 'x': 111, 'y': 0, 'width': 49, 'height': 86}, {'item_type': 2, 'x': 111, 'y': 86, 'width': 33, 'height': 17}, {'item_type': 3, 'x': 25, 'y': 53, 'width': 34, 'height': 51}, {'item_type': 4, 'x': 48, 'y': 0, 'width': 6, 'height': 11}, {'item_type': 5, 'x': 61, 'y': 63, 'width': 50, 'height': 41}, {'item_type': 6, 'x': 25, 'y': 23, 'width': 10, 'height': 30}, {'item_type': 7, 'x': 0, 'y': 0, 'width': 48, 'height': 23}, {'item_type': 8, 'x': 66, 'y': 52, 'width': 45, 'height': 11}, {'item_type': 9, 'x': 56, 'y': 0, 'width': 55, 'height': 52}]",50,nl,0