Пример #1
0
 public static void main(String[] args) {
   ExampleRunner.eq(1, 3, new Cut().getMaximum(new int[] {13, 20, 13}, 2));
   ExampleRunner.eq(2, 0, new Cut().getMaximum(new int[] {5, 5, 5, 5}, 2));
   ExampleRunner.eq(3, 5, new Cut().getMaximum(new int[] {34, 10, 48}, 4));
   ExampleRunner.eq(4, 16, new Cut().getMaximum(new int[] {30, 50, 30, 50}, 350));
   ExampleRunner.eq(5, 0, new Cut().getMaximum(new int[] {1}, 1));
   ExampleRunner.eq(6, 1, new Cut().getMaximum(new int[] {10}, 1));
   ExampleRunner.eq(7, 2, new Cut().getMaximum(new int[] {20}, 1));
   ExampleRunner.eq(8, 3, new Cut().getMaximum(new int[] {25, 15}, 3));
   ExampleRunner.eq(9, 3, new Cut().getMaximum(new int[] {25, 15}, 4));
   ExampleRunner.eq(10, 3, new Cut().getMaximum(new int[] {25, 15}, 5));
   ExampleRunner.eq(
       11,
       52,
       new Cut()
           .getMaximum(
               new int[] {
                 10, 10, 10, 10, 10, 50, 10, 10, 10, 10, 10, 10, 10, 10, 10, 10, 10, 10, 10, 10,
                 10, 10, 10, 10, 10, 10, 10, 10, 10, 10, 10, 10, 10, 10, 10, 10, 10, 10, 10, 10,
                 10, 10, 10, 10, 10, 10, 10, 10, 10, 10
               },
               3));
   ExampleRunner.eq(
       12,
       54,
       new Cut()
           .getMaximum(
               new int[] {
                 10, 10, 10, 10, 10, 50, 10, 10, 10, 10, 10, 10, 10, 10, 10, 10, 10, 10, 10, 10,
                 10, 10, 10, 10, 10, 10, 10, 10, 10, 10, 10, 10, 10, 10, 10, 10, 10, 10, 10, 10,
                 10, 10, 10, 10, 10, 10, 10, 10, 10, 10
               },
               4));
   ExampleRunner.eq(
       13,
       54,
       new Cut()
           .getMaximum(
               new int[] {
                 10, 10, 10, 10, 10, 50, 10, 10, 10, 10, 10, 10, 10, 10, 10, 10, 10, 10, 10, 10,
                 10, 10, 10, 10, 10, 10, 10, 10, 10, 10, 10, 10, 10, 10, 10, 10, 10, 10, 10, 10,
                 10, 10, 10, 10, 10, 10, 10, 10, 10, 10
               },
               5));
   ExampleRunner.eq(
       14,
       54,
       new Cut()
           .getMaximum(
               new int[] {
                 10, 10, 10, 10, 10, 50, 10, 10, 10, 10, 10, 10, 10, 10, 10, 10, 10, 10, 10, 10,
                 10, 10, 10, 10, 10, 10, 10, 10, 10, 10, 10, 10, 10, 10, 10, 10, 10, 10, 10, 10,
                 10, 10, 10, 10, 10, 10, 10, 10, 10, 10
               },
               1000));
   ExampleRunner.eq(15, 99, new Cut().getMaximum(new int[] {999}, 99));
   ExampleRunner.eq(16, 99, new Cut().getMaximum(new int[] {999}, 100));
   ExampleRunner.eq(17, 22, new Cut().getMaximum(new int[] {143, 32, 59, 128, 147}, 22));
   ExampleRunner.eq(
       18,
       143,
       new Cut()
           .getMaximum(
               new int[] {121, 117, 133, 169, 52, 71, 83, 112, 97, 53, 191, 173, 41, 124, 72},
               143));
   ExampleRunner.eq(
       19,
       229,
       new Cut()
           .getMaximum(
               new int[] {
                 41, 22, 11, 159, 178, 37, 182, 182, 123, 95, 98, 19, 122, 2, 88, 175, 87, 62, 83,
                 139, 179, 37, 131, 15, 146
               },
               229));
   ExampleRunner.eq(
       20,
       372,
       new Cut()
           .getMaximum(
               new int[] {
                 111, 163, 139, 108, 97, 125, 44, 92, 156, 49, 194, 142, 132, 42, 41, 67, 56, 176,
                 47, 175, 176, 154, 169, 13, 135, 133, 128, 188, 107, 7, 175, 4, 188, 59, 111
               },
               385));
   ExampleRunner.eq(
       21,
       471,
       new Cut()
           .getMaximum(
               new int[] {
                 19, 87, 158, 158, 128, 94, 152, 168, 12, 158, 51, 24, 87, 101, 141, 174, 165, 174,
                 155, 107, 129, 78, 194, 129, 61, 75, 175, 66, 18, 116, 186, 129, 178, 5, 53, 65,
                 4, 196, 144, 41, 136, 85, 131, 107, 139
               },
               497));
   ExampleRunner.eq(22, 276, new Cut().getMaximum(new int[] {128, 553, 964, 371, 769}, 276));
   ExampleRunner.eq(
       23,
       816,
       new Cut()
           .getMaximum(
               new int[] {
                 957, 653, 962, 452, 709, 985, 742, 705, 991, 153, 108, 683, 684, 21, 312
               },
               816));
   ExampleRunner.eq(
       24,
       902,
       new Cut()
           .getMaximum(
               new int[] {
                 739, 618, 127, 164, 38, 961, 437, 61, 63, 463, 214, 528, 111, 949, 76, 706, 946,
                 292, 478, 25, 502, 372, 524, 807, 741
               },
               902));
   ExampleRunner.eq(
       25,
       1000,
       new Cut()
           .getMaximum(
               new int[] {
                 537, 355, 775, 222, 801, 146, 938, 808, 206, 526, 281, 82, 411, 206, 934, 476,
                 405, 697, 939, 63, 483, 521, 208, 675, 647, 414, 509, 998, 889, 203, 831, 948,
                 605, 619, 597
               },
               1000));
   ExampleRunner.eq(
       26,
       1000,
       new Cut()
           .getMaximum(
               new int[] {
                 426, 729, 121, 319, 647, 459, 117, 37, 107, 223, 526, 117, 695, 584, 845, 216,
                 114, 986, 831, 586, 448, 182, 894, 426, 775, 481, 426, 782, 745, 908, 37, 835,
                 471, 579, 775, 15, 755, 74, 439, 836, 73, 797, 268, 32, 579
               },
               1000));
   ExampleRunner.eq(27, 53, new Cut().getMaximum(new int[] {120, 100, 130, 190, 140, 40}, 48));
   ExampleRunner.eq(
       28,
       175,
       new Cut()
           .getMaximum(
               new int[] {160, 60, 10, 30, 200, 60, 100, 180, 200, 100, 170, 180, 60, 200, 40},
               163));
   ExampleRunner.eq(
       29,
       280,
       new Cut()
           .getMaximum(
               new int[] {
                 100, 120, 120, 150, 20, 50, 120, 110, 160, 180, 110, 200, 50, 70, 180, 30, 80,
                 140, 80, 180, 60, 150, 200, 140
               },
               280));
   ExampleRunner.eq(
       30,
       341,
       new Cut()
           .getMaximum(
               new int[] {
                 20, 40, 60, 90, 40, 150, 130, 50, 200, 110, 50, 80, 70, 130, 160, 80, 40, 110,
                 200, 50, 20, 40, 100, 170, 180, 170, 180, 150, 30, 190, 30, 160, 130
               },
               353));
   ExampleRunner.eq(
       31,
       486,
       new Cut()
           .getMaximum(
               new int[] {
                 60, 40, 90, 190, 170, 90, 80, 70, 100, 180, 160, 130, 10, 200, 30, 170, 130, 150,
                 150, 170, 120, 140, 110, 160, 160, 60, 120, 70, 190, 60, 100, 60, 70, 190, 20,
                 170, 140, 170, 150, 130, 70, 30
               },
               510));
   ExampleRunner.eq(32, 185, new Cut().getMaximum(new int[] {580, 450, 340, 10, 190, 280}, 185));
   ExampleRunner.eq(
       33,
       492,
       new Cut()
           .getMaximum(
               new int[] {230, 90, 600, 510, 180, 240, 220, 10, 530, 760, 600, 10, 420, 380, 800},
               478));
   ExampleRunner.eq(
       34,
       873,
       new Cut()
           .getMaximum(
               new int[] {
                 270, 320, 610, 40, 760, 620, 700, 440, 450, 230, 770, 230, 40, 510, 340, 780, 50,
                 520, 300, 180, 20, 520, 800, 610
               },
               851));
   ExampleRunner.eq(
       35,
       1027,
       new Cut()
           .getMaximum(
               new int[] {
                 290, 490, 130, 740, 700, 300, 210, 800, 350, 320, 520, 50, 260, 610, 730, 560,
                 140, 670, 180, 170, 530, 690, 720, 640, 10, 240, 680, 780, 710, 570, 120, 420, 110
               },
               1000));
   ExampleRunner.eq(
       36,
       1031,
       new Cut()
           .getMaximum(
               new int[] {
                 570, 380, 740, 300, 650, 650, 230, 130, 360, 130, 570, 330, 240, 700, 360, 650,
                 350, 180, 80, 60, 560, 280, 350, 490, 670, 590, 730, 500, 20, 790, 160, 130, 220,
                 540, 540, 360, 700, 310, 500, 660, 120, 440
               },
               1000));
   ExampleRunner.eq(37, 155, new Cut().getMaximum(new int[] {220, 120, 353, 470, 393}, 155));
   ExampleRunner.eq(
       38,
       241,
       new Cut()
           .getMaximum(
               new int[] {45, 490, 363, 30, 161, 315, 490, 187, 190, 90, 100, 233, 60, 414}, 234));
   ExampleRunner.eq(
       39,
       599,
       new Cut()
           .getMaximum(
               new int[] {
                 429, 170, 255, 489, 290, 116, 480, 408, 180, 450, 470, 228, 329, 310, 59, 390,
                 211, 410, 413, 350, 460, 472, 182
               },
               588));
   ExampleRunner.eq(
       40,
       542,
       new Cut()
           .getMaximum(
               new int[] {
                 187, 328, 420, 60, 2, 155, 380, 270, 110, 380, 34, 365, 4, 203, 248, 490, 410,
                 290, 440, 383, 380, 36, 175, 44, 360, 260, 387, 360, 73, 272, 210, 35
               },
               527));
   ExampleRunner.eq(
       41,
       687,
       new Cut()
           .getMaximum(
               new int[] {
                 49, 49, 235, 453, 199, 60, 266, 10, 250, 148, 175, 260, 314, 433, 373, 141, 138,
                 230, 204, 390, 450, 180, 460, 455, 360, 240, 470, 190, 280, 240, 434, 12, 63, 200,
                 280, 70, 403, 345, 50, 409, 22
               },
               668));
   ExampleRunner.eq(
       42,
       687,
       new Cut().getMaximum(new int[] {613, 930, 903, 574, 370, 390, 769, 992, 851, 502}, 687));
   ExampleRunner.eq(
       43,
       726,
       new Cut()
           .getMaximum(
               new int[] {
                 109, 213, 300, 845, 836, 448, 40, 240, 240, 214, 961, 240, 94, 330, 430, 552, 980,
                 450, 135, 363
               },
               717));
   ExampleRunner.eq(
       44,
       1015,
       new Cut()
           .getMaximum(
               new int[] {
                 942, 923, 300, 619, 980, 906, 530, 810, 920, 220, 520, 760, 350, 450, 568, 500,
                 969, 66, 151, 690, 488, 600, 541, 360, 931, 543, 240, 564, 387, 888
               },
               1000));
   ExampleRunner.eq(
       45,
       1019,
       new Cut()
           .getMaximum(
               new int[] {
                 930, 40, 959, 303, 270, 600, 690, 844, 978, 557, 370, 932, 513, 960, 490, 770,
                 613, 896, 115, 1000, 811, 640, 752, 460, 700, 997, 350, 492, 241, 419, 580, 858,
                 920, 300, 310, 810, 70, 520, 976, 928
               },
               1000));
   ExampleRunner.eq(
       46,
       1023,
       new Cut()
           .getMaximum(
               new int[] {
                 916, 60, 80, 863, 13, 84, 679, 719, 830, 851, 621, 359, 830, 432, 180, 746, 80,
                 140, 420, 167, 138, 250, 352, 461, 960, 260, 230, 760, 448, 660, 40, 153, 358,
                 440, 390, 850, 870, 850, 300, 292, 760, 140, 960, 570, 520, 980, 756, 722, 908,
                 772
               },
               1000));
   ExampleRunner.eq(
       47,
       1035,
       new Cut()
           .getMaximum(
               new int[] {
                 430, 440, 300, 60, 20, 70, 540, 460, 160, 680, 430, 720, 280, 210, 530, 290, 960,
                 30, 200, 110, 320, 830, 470, 10, 240, 150, 810, 800, 150, 80, 20, 460, 660, 460,
                 10, 430, 750, 620, 190, 610, 660, 720, 400, 310, 910, 800, 720, 740, 790, 270
               },
               1000));
   ExampleRunner.eq(
       48,
       1000,
       new Cut()
           .getMaximum(
               new int[] {
                 854, 849, 701, 162, 326, 767, 159, 218, 37, 632, 71, 29, 844, 735, 47, 914, 353,
                 954, 125, 254, 968, 901, 226, 981, 423, 247, 952, 747, 523, 115, 709, 393, 672,
                 366, 325, 989, 504, 228, 203, 951, 118, 879, 434, 557, 523, 509, 783, 955, 603,
                 198
               },
               1000));
   ExampleRunner.eq(
       49,
       1005,
       new Cut()
           .getMaximum(
               new int[] {
                 209, 164, 456, 162, 442, 320, 171, 192, 386, 414, 440, 259, 445, 377, 141, 176,
                 250, 184, 250, 483, 453, 1, 415, 416, 44, 313, 103, 56, 244, 118, 277, 50, 291,
                 453, 287, 82, 229, 205, 27, 267, 497, 371, 35, 276, 446, 409, 48, 293, 384, 359
               },
               1000));
   ExampleRunner.eq(
       50,
       1010,
       new Cut()
           .getMaximum(
               new int[] {
                 129, 171, 120, 15, 151, 153, 126, 507, 109, 202, 141, 258, 193, 91, 207, 18, 392,
                 32, 203, 438, 241, 18, 125, 338, 420, 121, 150, 372, 218, 187, 138, 40, 228, 50,
                 382, 122, 364, 80, 387, 30, 118, 400, 475, 220, 385, 404, 408, 389, 480, 497
               },
               1000));
   ExampleRunner.eq(
       51,
       1015,
       new Cut()
           .getMaximum(
               new int[] {
                 318, 238, 10, 214, 438, 416, 1, 470, 440, 27, 88, 253, 430, 100, 212, 315, 401,
                 478, 378, 496, 251, 184, 150, 96, 180, 441, 40, 370, 169, 88, 9, 150, 176, 266,
                 439, 72, 123, 90, 114, 230, 20, 240, 142, 215, 170, 259, 444, 381, 133, 187
               },
               1000));
   ExampleRunner.eq(
       52,
       1020,
       new Cut()
           .getMaximum(
               new int[] {
                 157, 43, 465, 510, 360, 440, 45, 48, 30, 131, 250, 374, 480, 296, 132, 440, 380,
                 80, 244, 210, 426, 420, 25, 110, 424, 189, 502, 26, 135, 380, 338, 357, 86, 490,
                 310, 455, 364, 379, 312, 370, 255, 108, 342, 176, 431, 189, 210, 240, 370, 240
               },
               1000));
   ExampleRunner.eq(
       53,
       1025,
       new Cut()
           .getMaximum(
               new int[] {
                 242, 265, 527, 433, 270, 197, 90, 350, 363, 320, 426, 396, 460, 334, 40, 130, 500,
                 15, 322, 400, 70, 400, 270, 504, 54, 170, 500, 80, 340, 360, 68, 71, 270, 540,
                 350, 511, 500, 301, 176, 460, 20, 415, 330, 2, 134, 494, 178, 355, 310, 377
               },
               1000));
   ExampleRunner.eq(
       54,
       1000,
       new Cut()
           .getMaximum(
               new int[] {
                 227, 407, 11, 418, 223, 678, 928, 166, 815, 293, 684, 282, 749, 397, 256, 836,
                 743, 776, 497, 836, 891, 19, 727, 605, 196, 93, 57, 402, 215, 265, 215, 485, 641,
                 819, 937, 122, 312, 438, 157, 173, 87, 973, 19, 152, 867, 456, 626, 702, 312, 115
               },
               1000));
   ExampleRunner.eq(
       55,
       1027,
       new Cut()
           .getMaximum(
               new int[] {
                 480, 950, 500, 100, 410, 680, 910, 380, 940, 240, 310, 700, 530, 690, 670, 800,
                 320, 570, 700, 980, 610, 110, 700, 610, 160, 870, 570, 790, 100, 740, 880, 860,
                 620, 910, 790, 860, 920, 170, 200, 30, 370, 290, 850, 480, 380, 430, 890, 330,
                 840, 960
               },
               1000));
   ExampleRunner.eq(
       56,
       100,
       new Cut()
           .getMaximum(
               new int[] {
                 9, 9, 1000, 9, 9, 9, 9, 9, 9, 9, 1000, 9, 1000, 9, 9, 9, 9, 9, 9, 9, 1000, 9, 9,
                 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 1000, 9, 9, 9, 9
               },
               99));
   ExampleRunner.eq(
       57,
       101,
       new Cut()
           .getMaximum(
               new int[] {
                 9, 1000, 9, 9, 9, 9, 1000, 9, 9, 9, 1000, 1000, 9, 1000, 9, 1000, 1000, 9, 9, 9,
                 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 1000, 9, 9, 9, 9, 1000, 9, 9, 9, 1000, 9, 9, 9, 9, 9
               },
               100));
   ExampleRunner.eq(
       58,
       102,
       new Cut()
           .getMaximum(
               new int[] {
                 9, 9, 9, 9, 9, 9, 9, 1000, 9, 1000, 9, 9, 9, 9, 9, 9, 9, 1000, 9, 1000, 9, 9, 9,
                 9, 9, 1000, 1000, 1000, 1000, 9, 9, 9, 9, 9, 1000, 1000, 9, 1000, 1000, 9, 1000,
                 1000, 9, 9, 1000, 9, 9, 9, 9, 9
               },
               101));
   ExampleRunner.eq(
       59,
       50,
       new Cut()
           .getMaximum(
               new int[] {
                 10, 10, 10, 10, 10, 10, 10, 10, 10, 10, 10, 10, 10, 10, 10, 10, 10, 10, 10, 10,
                 10, 10, 10, 10, 10, 10, 10, 10, 10, 10, 10, 10, 10, 10, 10, 10, 10, 10, 10, 10,
                 10, 10, 10, 10, 10, 10, 10, 10, 10, 10
               },
               1));
   ExampleRunner.eq(
       60,
       1050,
       new Cut()
           .getMaximum(
               new int[] {
                 1000, 1000, 1000, 1000, 1000, 1000, 1000, 1000, 1000, 1000, 20, 20, 20, 20, 20,
                 20, 20, 20, 20, 10, 10, 10, 10, 10, 10, 10, 10, 10, 10, 10, 10, 10, 10, 10, 10,
                 10, 10, 10, 10, 10, 10, 10, 10, 10, 10, 10, 10, 10, 10, 20
               },
               1000));
   ExampleRunner.eq(61, 2, new Cut().getMaximum(new int[] {30, 20, 15}, 1));
   ExampleRunner.eq(62, 3, new Cut().getMaximum(new int[] {13, 20, 13}, 2));
   ExampleRunner.eq(
       63,
       8,
       new Cut()
           .getMaximum(
               new int[] {
                 1, 2, 3, 4, 5, 30, 6, 7, 8, 9, 50, 10, 11, 12, 13, 14, 15, 16, 30, 17, 18, 50
               },
               5));
   ExampleRunner.eq(64, 9, new Cut().getMaximum(new int[] {100, 90}, 8));
   ExampleRunner.eq(65, 6, new Cut().getMaximum(new int[] {30, 50, 30, 50}, 4));
   ExampleRunner.eq(66, 2, new Cut().getMaximum(new int[] {11, 20}, 1));
   ExampleRunner.eq(67, 4, new Cut().getMaximum(new int[] {40, 20, 20}, 2));
   ExampleRunner.eq(68, 7, new Cut().getMaximum(new int[] {50, 30, 40}, 5));
   ExampleRunner.eq(69, 11, new Cut().getMaximum(new int[] {100, 90, 20}, 9));
   ExampleRunner.eq(70, 3, new Cut().getMaximum(new int[] {13, 40, 30}, 2));
   ExampleRunner.eq(71, 5, new Cut().getMaximum(new int[] {23, 50, 30, 80, 20}, 3));
   ExampleRunner.eq(72, 4, new Cut().getMaximum(new int[] {30, 20, 20}, 2));
   ExampleRunner.eq(73, 4, new Cut().getMaximum(new int[] {100, 20}, 3));
   ExampleRunner.eq(74, 5, new Cut().getMaximum(new int[] {20, 100, 20}, 3));
   ExampleRunner.eq(75, 4, new Cut().getMaximum(new int[] {31, 40}, 3));
   ExampleRunner.eq(76, 2, new Cut().getMaximum(new int[] {30, 20}, 1));
   ExampleRunner.eq(
       77, 4, new Cut().getMaximum(new int[] {10, 30, 11, 21, 20, 21, 11, 30, 10}, 1));
   ExampleRunner.eq(78, 5, new Cut().getMaximum(new int[] {25, 25, 20, 30}, 3));
   ExampleRunner.eq(79, 5, new Cut().getMaximum(new int[] {40, 30, 20}, 3));
   ExampleRunner.eq(80, 3, new Cut().getMaximum(new int[] {23, 30}, 2));
   ExampleRunner.eq(81, 2, new Cut().getMaximum(new int[] {40, 30, 20}, 1));
   ExampleRunner.eq(82, 2, new Cut().getMaximum(new int[] {40, 20}, 1));
   ExampleRunner.eq(83, 3, new Cut().getMaximum(new int[] {50, 30}, 2));
   ExampleRunner.eq(84, 7, new Cut().getMaximum(new int[] {16, 32, 50, 20}, 5));
   ExampleRunner.eq(85, 5, new Cut().getMaximum(new int[] {40, 20, 20}, 3));
   ExampleRunner.eq(
       86,
       13,
       new Cut().getMaximum(new int[] {120, 123, 45, 40, 30, 10, 20, 20, 22, 55, 30, 50}, 8));
   ExampleRunner.eq(
       87, 6, new Cut().getMaximum(new int[] {50, 60, 15, 20, 20, 20, 15, 15, 15}, 3));
   ExampleRunner.eq(
       88, 9, new Cut().getMaximum(new int[] {20, 20, 20, 30, 30, 30, 40, 40, 40, 40, 40}, 5));
   ExampleRunner.eq(89, 2, new Cut().getMaximum(new int[] {13, 20}, 1));
   ExampleRunner.eq(90, 3, new Cut().getMaximum(new int[] {40, 30}, 2));
   ExampleRunner.eq(91, 6, new Cut().getMaximum(new int[] {15, 15, 20, 20, 20, 25, 25}, 3));
   ExampleRunner.eq(92, 9, new Cut().getMaximum(new int[] {80, 40, 40}, 7));
   ExampleRunner.eq(
       93, 18, new Cut().getMaximum(new int[] {100, 20, 20, 20, 20, 20, 20, 20, 20, 20}, 9));
   ExampleRunner.eq(
       94,
       16,
       new Cut()
           .getMaximum(new int[] {50, 50, 20, 20, 20, 20, 20, 20, 20, 20, 20, 20, 20, 20}, 8));
   ExampleRunner.eq(95, 5, new Cut().getMaximum(new int[] {48, 50}, 4));
   ExampleRunner.eq(96, 3, new Cut().getMaximum(new int[] {80, 20}, 2));
   ExampleRunner.eq(97, 2, new Cut().getMaximum(new int[] {100, 20}, 1));
   ExampleRunner.eq(98, 2, new Cut().getMaximum(new int[] {13, 40, 13}, 2));
   ExampleRunner.eq(99, 6, new Cut().getMaximum(new int[] {13, 30, 20, 20, 20}, 3));
   ExampleRunner.eq(100, 6, new Cut().getMaximum(new int[] {10, 13, 14, 15, 20, 30, 40, 28}, 3));
   ExampleRunner.eq(101, 6, new Cut().getMaximum(new int[] {50, 20, 20, 20}, 3));
   ExampleRunner.eq(
       102,
       541,
       new Cut()
           .getMaximum(
               new int[] {
                 1000, 1000, 1000, 1000, 1000, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 1, 2, 3, 4, 5, 6, 7,
                 8, 9, 10, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 300, 270, 110
               },
               531));
   ExampleRunner.eq(103, 8, new Cut().getMaximum(new int[] {30, 37, 41, 20, 20, 20, 10, 10}, 3));
   ExampleRunner.eq(104, 3, new Cut().getMaximum(new int[] {31, 30}, 2));
   ExampleRunner.eq(
       105,
       901,
       new Cut()
           .getMaximum(
               new int[] {
                 931, 230, 984, 724, 288, 418, 20, 20, 401, 990, 333, 10, 11, 116, 452, 1000, 727,
                 217, 368, 165, 863, 370, 673, 997, 829, 294, 314, 480, 542, 713, 449, 897, 850,
                 209, 983, 883, 307, 738, 314, 88, 631, 441, 20, 420, 15, 10, 592, 490, 6, 999
               },
               888));
   ExampleRunner.eq(106, 3, new Cut().getMaximum(new int[] {20, 10, 13}, 1));
   ExampleRunner.eq(107, 2, new Cut().getMaximum(new int[] {23, 20}, 1));
   ExampleRunner.eq(108, 2, new Cut().getMaximum(new int[] {13, 20, 23}, 1));
   ExampleRunner.eq(
       109,
       8,
       new Cut()
           .getMaximum(new int[] {10, 21, 50, 10, 50, 50, 20, 50, 20, 50, 20, 50, 50, 31}, 3));
   ExampleRunner.eq(110, 13, new Cut().getMaximum(new int[] {100, 20, 20, 20, 20, 9}, 9));
   ExampleRunner.eq(111, 12, new Cut().getMaximum(new int[] {50, 50, 50}, 10));
   ExampleRunner.eq(112, 2, new Cut().getMaximum(new int[] {13, 20, 13}, 1));
   ExampleRunner.eq(113, 2, new Cut().getMaximum(new int[] {17, 20, 51}, 1));
   ExampleRunner.eq(114, 4, new Cut().getMaximum(new int[] {40, 35, 35}, 3));
   ExampleRunner.eq(115, 2, new Cut().getMaximum(new int[] {15, 20, 20}, 1));
   ExampleRunner.eq(116, 19, new Cut().getMaximum(new int[] {100, 100, 20}, 17));
   ExampleRunner.eq(117, 6, new Cut().getMaximum(new int[] {40, 20, 20, 20}, 3));
   ExampleRunner.eq(118, 3, new Cut().getMaximum(new int[] {31, 20}, 2));
   ExampleRunner.eq(119, 4, new Cut().getMaximum(new int[] {100, 100, 100, 20, 20}, 2));
   ExampleRunner.eq(120, 1, new Cut().getMaximum(new int[] {50}, 1));
   ExampleRunner.eq(121, 2, new Cut().getMaximum(new int[] {20}, 1));
   ExampleRunner.eq(122, 7, new Cut().getMaximum(new int[] {40, 40, 30}, 5));
   ExampleRunner.eq(123, 4, new Cut().getMaximum(new int[] {100, 20, 20}, 2));
   ExampleRunner.eq(124, 5, new Cut().getMaximum(new int[] {40, 30, 20, 40}, 3));
   ExampleRunner.eq(125, 2, new Cut().getMaximum(new int[] {50}, 2));
   ExampleRunner.eq(126, 5, new Cut().getMaximum(new int[] {20, 20, 30, 48}, 3));
   ExampleRunner.eq(127, 3, new Cut().getMaximum(new int[] {30, 33}, 2));
   ExampleRunner.eq(128, 3, new Cut().getMaximum(new int[] {1, 10, 22, 20}, 1));
   ExampleRunner.eq(129, 4, new Cut().getMaximum(new int[] {30, 40}, 3));
   ExampleRunner.eq(130, 4, new Cut().getMaximum(new int[] {30, 10}, 2));
   ExampleRunner.eq(131, 1, new Cut().getMaximum(new int[] {30}, 1));
   ExampleRunner.eq(132, 4, new Cut().getMaximum(new int[] {40, 30, 20, 20}, 2));
   ExampleRunner.eq(
       133,
       1010,
       new Cut()
           .getMaximum(
               new int[] {
                 1000, 1000, 1000, 1000, 1000, 1000, 1000, 1000, 1000, 1000, 1000, 1000, 1000,
                 1000, 1000, 1000, 1000, 1000, 1000, 1000, 1000, 1000, 1000, 1000, 1000, 1000,
                 1000, 1000, 1000, 1000, 1000, 1000, 1000, 1000, 1000, 1000, 1000, 1000, 1000,
                 1000, 1000, 1000, 1000, 1000, 1000, 1000, 1000, 1000, 1000, 1000
               },
               1000));
   ExampleRunner.eq(134, 2, new Cut().getMaximum(new int[] {13, 13, 20}, 1));
   ExampleRunner.eq(135, 4, new Cut().getMaximum(new int[] {50, 20, 20, 13}, 2));
   ExampleRunner.eq(136, 4, new Cut().getMaximum(new int[] {5, 20, 15, 20}, 2));
   ExampleRunner.eq(137, 6, new Cut().getMaximum(new int[] {23, 23, 23, 30, 33, 33, 33}, 5));
   ExampleRunner.eq(138, 3, new Cut().getMaximum(new int[] {11, 30}, 2));
   ExampleRunner.eq(139, 2, new Cut().getMaximum(new int[] {50, 20}, 1));
   ExampleRunner.eq(140, 2, new Cut().getMaximum(new int[] {15, 16, 17, 18, 19, 20}, 1));
   ExampleRunner.eq(141, 2, new Cut().getMaximum(new int[] {15, 20}, 1));
   ExampleRunner.eq(142, 3, new Cut().getMaximum(new int[] {13, 20, 10, 20}, 1));
   ExampleRunner.eq(143, 6, new Cut().getMaximum(new int[] {50, 30, 30}, 4));
   ExampleRunner.eq(144, 2, new Cut().getMaximum(new int[] {98, 72, 20, 98}, 1));
   ExampleRunner.eq(145, 4, new Cut().getMaximum(new int[] {20, 20}, 3));
   ExampleRunner.eq(146, 6, new Cut().getMaximum(new int[] {12, 22, 23, 33, 60}, 5));
   ExampleRunner.eq(147, 5, new Cut().getMaximum(new int[] {11, 50, 40, 13, 30, 20, 11}, 3));
   ExampleRunner.eq(148, 2, new Cut().getMaximum(new int[] {20, 50}, 1));
   ExampleRunner.eq(149, 3, new Cut().getMaximum(new int[] {23, 20, 10, 11}, 1));
   ExampleRunner.eq(150, 3, new Cut().getMaximum(new int[] {48, 10, 20}, 1));
   ExampleRunner.eq(151, 5, new Cut().getMaximum(new int[] {48, 34, 20}, 4));
   ExampleRunner.eq(152, 7, new Cut().getMaximum(new int[] {63, 40, 10, 20, 61}, 4));
   ExampleRunner.eq(
       153,
       1,
       new Cut()
           .getMaximum(
               new int[] {
                 1000, 1000, 1000, 1000, 1000, 1000, 1000, 1000, 1000, 1000, 1000, 1000, 1000,
                 1000, 1000, 1000, 1000, 1000, 1000, 1000, 1000, 1000, 1000, 1000, 1000, 1000,
                 1000, 1000, 1000, 1000, 1000, 1000, 1000, 1000, 1000, 1000, 1000, 1000, 1000,
                 1000, 1000, 1000, 1000, 1000, 1000, 1000, 1000, 1000, 1000, 1000
               },
               1));
   ExampleRunner.eq(154, 6, new Cut().getMaximum(new int[] {30, 40, 20, 20, 20}, 3));
   ExampleRunner.eq(155, 2, new Cut().getMaximum(new int[] {20, 22}, 1));
   ExampleRunner.eq(156, 2, new Cut().getMaximum(new int[] {10, 11, 30}, 1));
   ExampleRunner.eq(157, 5, new Cut().getMaximum(new int[] {30, 10, 20, 20}, 2));
   ExampleRunner.eq(
       158,
       1026,
       new Cut()
           .getMaximum(
               new int[] {
                 41, 320, 150, 460, 930, 700, 258, 952, 990, 820, 350, 899, 290, 400, 699, 440,
                 750, 860, 642, 10, 675, 291, 650, 126, 220, 520, 630, 17, 715, 500, 304, 160, 280,
                 30, 240, 419, 875, 340, 992, 360, 610, 60, 730, 960, 910, 928, 602, 530, 100, 907
               },
               1000));
   ExampleRunner.eq(159, 7, new Cut().getMaximum(new int[] {34, 30, 20, 20, 30}, 4));
   ExampleRunner.eq(160, 2, new Cut().getMaximum(new int[] {15, 20, 25}, 1));
   ExampleRunner.eq(161, 4, new Cut().getMaximum(new int[] {11, 11, 11, 20}, 3));
   ExampleRunner.eq(162, 2, new Cut().getMaximum(new int[] {30, 20, 30}, 1));
   ExampleRunner.eq(163, 7, new Cut().getMaximum(new int[] {50, 20, 20, 20}, 4));
   ExampleRunner.eq(164, 2, new Cut().getMaximum(new int[] {21, 20}, 1));
   ExampleRunner.eq(165, 16, new Cut().getMaximum(new int[] {30, 50, 30, 50}, 350));
   ExampleRunner.eq(166, 3, new Cut().getMaximum(new int[] {21, 57, 30}, 2));
   ExampleRunner.eq(
       167,
       6,
       new Cut()
           .getMaximum(
               new int[] {
                 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 20, 21, 21, 21, 21,
                 21, 21, 21, 21, 21, 21, 21, 21, 21, 21
               },
               5));
   ExampleRunner.eq(168, 2, new Cut().getMaximum(new int[] {50, 40}, 2));
   ExampleRunner.eq(169, 10, new Cut().getMaximum(new int[] {30, 80, 70}, 8));
   ExampleRunner.eq(170, 4, new Cut().getMaximum(new int[] {44, 40}, 3));
   ExampleRunner.eq(171, 3, new Cut().getMaximum(new int[] {30, 22}, 2));
   ExampleRunner.eq(172, 10, new Cut().getMaximum(new int[] {15, 20, 50, 20, 30, 30}, 6));
   ExampleRunner.eq(173, 3, new Cut().getMaximum(new int[] {20, 70}, 2));
   ExampleRunner.eq(174, 2, new Cut().getMaximum(new int[] {20, 23}, 1));
   ExampleRunner.eq(175, 10, new Cut().getMaximum(new int[] {50, 20, 20, 20, 20, 20}, 5));
   ExampleRunner.eq(176, 4, new Cut().getMaximum(new int[] {48, 20, 20}, 2));
   ExampleRunner.eq(177, 3, new Cut().getMaximum(new int[] {30, 45}, 2));
   ExampleRunner.eq(178, 2, new Cut().getMaximum(new int[] {20, 30}, 1));
   ExampleRunner.eq(179, 3, new Cut().getMaximum(new int[] {30, 30}, 2));
   ExampleRunner.eq(180, 3, new Cut().getMaximum(new int[] {50, 20}, 2));
   ExampleRunner.eq(181, 3, new Cut().getMaximum(new int[] {23, 30, 13, 55}, 2));
   ExampleRunner.eq(182, 3, new Cut().getMaximum(new int[] {13, 13, 20}, 2));
   ExampleRunner.eq(183, 3, new Cut().getMaximum(new int[] {20, 30}, 2));
   ExampleRunner.eq(184, 6, new Cut().getMaximum(new int[] {20, 20, 41}, 4));
   ExampleRunner.eq(185, 9, new Cut().getMaximum(new int[] {90}, 8));
   ExampleRunner.eq(186, 3, new Cut().getMaximum(new int[] {30}, 2));
   ExampleRunner.eq(187, 10, new Cut().getMaximum(new int[] {85, 60, 30, 20, 20}, 7));
   ExampleRunner.eq(188, 8, new Cut().getMaximum(new int[] {53, 53, 53, 60, 63, 63, 63}, 7));
   ExampleRunner.eq(189, 103, new Cut().getMaximum(new int[] {1000, 20, 20, 20}, 100));
   ExampleRunner.eq(190, 6, new Cut().getMaximum(new int[] {20, 30, 10}, 3));
   ExampleRunner.eq(191, 5, new Cut().getMaximum(new int[] {30, 30, 2, 17, 10}, 3));
   ExampleRunner.eq(192, 1, new Cut().getMaximum(new int[] {10}, 1));
   ExampleRunner.eq(193, 4, new Cut().getMaximum(new int[] {30, 10, 10, 10}, 1));
   ExampleRunner.eq(194, 4, new Cut().getMaximum(new int[] {50, 20}, 3));
   ExampleRunner.eq(195, 4, new Cut().getMaximum(new int[] {50, 30}, 3));
   ExampleRunner.eq(196, 9, new Cut().getMaximum(new int[] {20, 30, 40, 50}, 6));
   ExampleRunner.eq(
       197,
       3,
       new Cut()
           .getMaximum(
               new int[] {
                 1000, 1000, 1000, 1000, 1000, 1000, 1000, 1000, 1000, 1000, 1000, 1000, 1000,
                 1000, 1000, 1000, 1000, 1000, 1000, 1000, 1000, 1000, 1000, 1000, 1000, 1000,
                 1000, 1000, 1000, 1000, 1000, 1000, 1000, 1000, 1000, 1000, 1000, 30, 1000, 1000,
                 1000, 1000, 1000, 1000, 1000, 1000, 1000, 1000, 1000, 1000
               },
               2));
   ExampleRunner.eq(198, 6, new Cut().getMaximum(new int[] {30, 50, 30}, 4));
   ExampleRunner.eq(199, 3, new Cut().getMaximum(new int[] {100, 30}, 2));
   ExampleRunner.eq(200, 3, new Cut().getMaximum(new int[] {30, 31}, 2));
   ExampleRunner.eq(201, 4, new Cut().getMaximum(new int[] {100, 11, 21, 30, 20, 20}, 2));
   ExampleRunner.eq(202, 3, new Cut().getMaximum(new int[] {50}, 3));
   ExampleRunner.eq(203, 4, new Cut().getMaximum(new int[] {38, 20}, 3));
   ExampleRunner.eq(204, 4, new Cut().getMaximum(new int[] {63, 40}, 3));
   ExampleRunner.eq(205, 5, new Cut().getMaximum(new int[] {40, 20, 30, 50}, 3));
   ExampleRunner.eq(206, 1, new Cut().getMaximum(new int[] {300}, 1));
   ExampleRunner.eq(207, 1, new Cut().getMaximum(new int[] {100}, 1));
   ExampleRunner.eq(208, 2, new Cut().getMaximum(new int[] {60, 20}, 1));
   ExampleRunner.eq(209, 4, new Cut().getMaximum(new int[] {18, 18, 12, 40, 18, 18}, 3));
   ExampleRunner.eq(210, 7, new Cut().getMaximum(new int[] {50, 50, 50, 40, 30, 40}, 5));
   ExampleRunner.eq(211, 4, new Cut().getMaximum(new int[] {31, 20, 20}, 2));
   ExampleRunner.eq(212, 4, new Cut().getMaximum(new int[] {13, 13, 13, 40}, 3));
   ExampleRunner.eq(
       213, 5, new Cut().getMaximum(new int[] {11, 11, 200, 200, 20, 20, 200, 1000}, 3));
   ExampleRunner.eq(214, 3, new Cut().getMaximum(new int[] {20, 10}, 1));
   ExampleRunner.eq(215, 2, new Cut().getMaximum(new int[] {60}, 2));
   ExampleRunner.eq(216, 4, new Cut().getMaximum(new int[] {20, 20, 30}, 2));
   ExampleRunner.eq(
       217,
       0,
       new Cut().getMaximum(new int[] {1, 2, 3, 4, 5, 6, 7, 8, 9, 1, 2, 3, 4, 5, 6, 7, 8, 9}, 7));
   ExampleRunner.eq(218, 15, new Cut().getMaximum(new int[] {143, 140, 15}, 14));
   ExampleRunner.eq(219, 3, new Cut().getMaximum(new int[] {23, 23, 20}, 2));
   ExampleRunner.eq(220, 6, new Cut().getMaximum(new int[] {40, 30, 20, 20, 20}, 3));
   ExampleRunner.eq(221, 6, new Cut().getMaximum(new int[] {13, 23, 40, 20, 20, 10, 33}, 3));
   ExampleRunner.eq(
       222, 16, new Cut().getMaximum(new int[] {100, 100, 100, 19, 29, 39, 13, 33}, 15));
   ExampleRunner.eq(223, 3, new Cut().getMaximum(new int[] {13, 30}, 2));
   ExampleRunner.eq(224, 2, new Cut().getMaximum(new int[] {12, 12, 20}, 1));
   ExampleRunner.eq(225, 7, new Cut().getMaximum(new int[] {30, 10, 10, 10, 50}, 3));
   ExampleRunner.eq(226, 2, new Cut().getMaximum(new int[] {39, 20, 20}, 1));
   ExampleRunner.eq(227, 3, new Cut().getMaximum(new int[] {35, 100, 30}, 2));
   ExampleRunner.eq(228, 4, new Cut().getMaximum(new int[] {34, 28}, 4));
   ExampleRunner.eq(229, 2, new Cut().getMaximum(new int[] {5, 5, 15, 20}, 1));
   ExampleRunner.eq(230, 9, new Cut().getMaximum(new int[] {70, 30, 30, 30}, 6));
   ExampleRunner.eq(231, 3, new Cut().getMaximum(new int[] {13, 13, 13, 30}, 2));
   ExampleRunner.eq(232, 8, new Cut().getMaximum(new int[] {50, 20, 20, 20, 20}, 4));
   ExampleRunner.eq(233, 2, new Cut().getMaximum(new int[] {34, 30, 20}, 1));
   ExampleRunner.eq(234, 5, new Cut().getMaximum(new int[] {40, 20, 30}, 3));
   ExampleRunner.eq(235, 2, new Cut().getMaximum(new int[] {27}, 5));
   ExampleRunner.eq(236, 2, new Cut().getMaximum(new int[] {2, 30, 20}, 1));
   ExampleRunner.eq(237, 3, new Cut().getMaximum(new int[] {10, 20}, 1));
   ExampleRunner.eq(238, 2, new Cut().getMaximum(new int[] {15, 20, 35}, 1));
   ExampleRunner.eq(239, 2, new Cut().getMaximum(new int[] {12, 20}, 1));
   ExampleRunner.eq(
       240,
       9,
       new Cut().getMaximum(new int[] {19, 20, 23, 25, 72, 51, 40, 30, 20, 16, 10, 12}, 5));
   ExampleRunner.eq(241, 4, new Cut().getMaximum(new int[] {19, 40, 63}, 3));
   ExampleRunner.eq(242, 4, new Cut().getMaximum(new int[] {20, 20}, 2));
   ExampleRunner.eq(243, 2, new Cut().getMaximum(new int[] {13, 20, 13, 23, 36}, 1));
   ExampleRunner.eq(
       244,
       13,
       new Cut().getMaximum(new int[] {90, 120, 123, 45, 40, 30, 10, 20, 20, 22, 55, 30, 50}, 8));
   ExampleRunner.eq(245, 6, new Cut().getMaximum(new int[] {60, 101}, 5));
   ExampleRunner.eq(246, 12, new Cut().getMaximum(new int[] {100, 40, 40, 40}, 9));
   ExampleRunner.eq(247, 5, new Cut().getMaximum(new int[] {10, 50, 40, 25}, 3));
   ExampleRunner.eq(248, 3, new Cut().getMaximum(new int[] {30, 50, 30, 50}, 2));
   ExampleRunner.eq(249, 4, new Cut().getMaximum(new int[] {40}, 3));
   ExampleRunner.eq(250, 4, new Cut().getMaximum(new int[] {50, 50, 30}, 3));
   ExampleRunner.eq(251, 1, new Cut().getMaximum(new int[] {30, 30}, 1));
   ExampleRunner.eq(252, 2, new Cut().getMaximum(new int[] {40, 20, 30}, 1));
   ExampleRunner.eq(253, 8, new Cut().getMaximum(new int[] {63, 40, 20, 10, 10}, 4));
   ExampleRunner.eq(254, 4, new Cut().getMaximum(new int[] {13, 13, 13, 30, 40}, 3));
   ExampleRunner.eq(255, 5, new Cut().getMaximum(new int[] {30, 30, 20}, 3));
   ExampleRunner.eq(256, 9, new Cut().getMaximum(new int[] {11, 11, 11, 30, 30, 30}, 6));
   ExampleRunner.eq(257, 6, new Cut().getMaximum(new int[] {10, 30, 20, 3}, 3));
   ExampleRunner.eq(
       258,
       17,
       new Cut().getMaximum(new int[] {10, 10, 10, 10, 10, 20, 20, 20, 20, 20, 202, 20, 20}, 6));
   ExampleRunner.eq(
       259, 11, new Cut().getMaximum(new int[] {70, 80, 23, 20, 20, 20, 13, 40, 20, 30}, 6));
   ExampleRunner.eq(
       260, 9, new Cut().getMaximum(new int[] {10, 10, 10, 30, 30, 21, 21, 41, 45, 49}, 4));
   ExampleRunner.eq(
       261, 12, new Cut().getMaximum(new int[] {60, 20, 20, 20, 20, 20, 20, 20, 20}, 6));
   ExampleRunner.eq(262, 25, new Cut().getMaximum(new int[] {50, 50, 50, 50, 50}, 20));
   ExampleRunner.eq(
       263, 2, new Cut().getMaximum(new int[] {30, 50, 60, 50, 40, 20, 40, 30, 60, 80}, 1));
   ExampleRunner.eq(264, 2, new Cut().getMaximum(new int[] {13, 23, 20}, 1));
   ExampleRunner.eq(265, 9, new Cut().getMaximum(new int[] {60, 20, 20, 20, 20}, 5));
   ExampleRunner.eq(266, 6, new Cut().getMaximum(new int[] {30, 20, 20, 17, 10}, 3));
   ExampleRunner.eq(267, 5, new Cut().getMaximum(new int[] {15, 20, 30}, 3));
   ExampleRunner.eq(268, 5, new Cut().getMaximum(new int[] {60, 30, 20}, 3));
   ExampleRunner.eq(269, 3, new Cut().getMaximum(new int[] {73, 20}, 2));
   ExampleRunner.eq(270, 5, new Cut().getMaximum(new int[] {20, 30, 50}, 3));
   ExampleRunner.eq(271, 7, new Cut().getMaximum(new int[] {100, 105}, 7));
   ExampleRunner.eq(272, 1, new Cut().getMaximum(new int[] {34}, 1));
   ExampleRunner.eq(273, 10, new Cut().getMaximum(new int[] {99, 100, 999}, 9));
   ExampleRunner.eq(274, 3, new Cut().getMaximum(new int[] {15, 15, 30}, 2));
   ExampleRunner.eq(275, 2, new Cut().getMaximum(new int[] {20, 21}, 1));
   ExampleRunner.eq(276, 9, new Cut().getMaximum(new int[] {70, 30, 30, 30, 30}, 6));
   ExampleRunner.eq(277, 5, new Cut().getMaximum(new int[] {35, 30, 10, 10}, 2));
   ExampleRunner.eq(278, 1, new Cut().getMaximum(new int[] {40}, 1));
   ExampleRunner.eq(279, 7, new Cut().getMaximum(new int[] {30, 50, 40, 50}, 5));
   ExampleRunner.eq(280, 7, new Cut().getMaximum(new int[] {20, 20, 30, 30}, 4));
   ExampleRunner.eq(
       281,
       9,
       new Cut()
           .getMaximum(new int[] {19, 20, 23, 25, 72, 51, 40, 30, 20, 16, 10, 12, 13, 14}, 5));
   ExampleRunner.eq(282, 2, new Cut().getMaximum(new int[] {13, 20, 33}, 1));
   ExampleRunner.eq(283, 3, new Cut().getMaximum(new int[] {100}, 3));
   ExampleRunner.eq(284, 11, new Cut().getMaximum(new int[] {70, 80, 20, 20, 20, 40, 20, 30}, 6));
   ExampleRunner.eq(285, 7, new Cut().getMaximum(new int[] {13, 13, 13, 30, 40}, 5));
   ExampleRunner.eq(286, 6, new Cut().getMaximum(new int[] {1000, 10}, 5));
   ExampleRunner.eq(287, 7, new Cut().getMaximum(new int[] {55, 50, 50, 50, 40, 30, 40}, 5));
   ExampleRunner.eq(288, 10, new Cut().getMaximum(new int[] {11, 21, 31, 41, 51, 100}, 9));
   ExampleRunner.eq(
       289,
       50,
       new Cut()
           .getMaximum(
               new int[] {
                 10, 10, 10, 10, 10, 10, 10, 10, 10, 10, 10, 10, 10, 10, 10, 10, 10, 10, 10, 10,
                 10, 10, 10, 10, 10, 10, 10, 10, 10, 10, 10, 10, 10, 10, 10, 10, 10, 10, 10, 10,
                 10, 10, 10, 10, 10, 10, 10, 10, 10, 10
               },
               1000));
   ExampleRunner.eq(290, 3, new Cut().getMaximum(new int[] {7, 74, 20}, 2));
   ExampleRunner.eq(291, 6, new Cut().getMaximum(new int[] {40, 20, 20, 20, 20}, 3));
 }
 public static void main(String[] args) {
   ExampleRunner.eq(
       1, "1000", new MultiplesWithLimit().minMultiples(8, new int[] {2, 3, 4, 5, 6, 7, 8, 9}));
   ExampleRunner.eq(
       2,
       "222...222(9 digits)",
       new MultiplesWithLimit().minMultiples(9, new int[] {1, 3, 4, 5, 6, 7, 8, 9}));
   ExampleRunner.eq(3, "3668", new MultiplesWithLimit().minMultiples(524, new int[] {5, 2, 4}));
   ExampleRunner.eq(4, "IMPOSSIBLE", new MultiplesWithLimit().minMultiples(10000, new int[] {0}));
   ExampleRunner.eq(
       5,
       "IMPOSSIBLE",
       new MultiplesWithLimit().minMultiples(1, new int[] {0, 1, 2, 3, 4, 5, 6, 7, 8, 9}));
   ExampleRunner.eq(
       6,
       "777...777(666 digits)",
       new MultiplesWithLimit().minMultiples(2007, new int[] {1, 2, 3, 4, 5, 6, 8, 9, 0}));
   ExampleRunner.eq(7, "400", new MultiplesWithLimit().minMultiples(100, new int[] {1, 2, 3}));
   ExampleRunner.eq(8, "200", new MultiplesWithLimit().minMultiples(200, new int[] {3, 4, 5}));
   ExampleRunner.eq(
       9, "99992", new MultiplesWithLimit().minMultiples(862, new int[] {1, 4, 6, 7, 8}));
   ExampleRunner.eq(
       10, "2332888", new MultiplesWithLimit().minMultiples(7048, new int[] {1, 4, 5, 6, 7, 9}));
   ExampleRunner.eq(
       11,
       "9199499",
       new MultiplesWithLimit().minMultiples(4261, new int[] {0, 2, 3, 5, 6, 7, 8}));
   ExampleRunner.eq(
       12, "96138", new MultiplesWithLimit().minMultiples(6867, new int[] {0, 4, 5, 7}));
   ExampleRunner.eq(
       13, "6479697", new MultiplesWithLimit().minMultiples(9543, new int[] {0, 1, 2, 3, 5, 8}));
   ExampleRunner.eq(
       14, "44046", new MultiplesWithLimit().minMultiples(7341, new int[] {1, 2, 3, 5, 7, 9}));
   ExampleRunner.eq(
       15, "21024", new MultiplesWithLimit().minMultiples(7008, new int[] {3, 5, 6, 7, 8}));
   ExampleRunner.eq(
       16, "337312", new MultiplesWithLimit().minMultiples(4064, new int[] {0, 4, 5, 6, 8, 9}));
   ExampleRunner.eq(17, "10388", new MultiplesWithLimit().minMultiples(5194, new int[] {4, 5, 7}));
   ExampleRunner.eq(
       18, "387030", new MultiplesWithLimit().minMultiples(4074, new int[] {1, 2, 4, 5, 6}));
   ExampleRunner.eq(
       19,
       "444...404(14 digits)",
       new MultiplesWithLimit().minMultiples(8794, new int[] {1, 2, 3, 5, 6, 7, 8, 9}));
   ExampleRunner.eq(
       20, "466704", new MultiplesWithLimit().minMultiples(9723, new int[] {1, 2, 3, 8, 9}));
   ExampleRunner.eq(
       21, "IMPOSSIBLE", new MultiplesWithLimit().minMultiples(1940, new int[] {0, 3, 4, 8, 9}));
   ExampleRunner.eq(
       22, "20600", new MultiplesWithLimit().minMultiples(824, new int[] {1, 3, 4, 8, 9}));
   ExampleRunner.eq(23, "19598", new MultiplesWithLimit().minMultiples(9799, new int[] {4, 7}));
   ExampleRunner.eq(
       24, "700050", new MultiplesWithLimit().minMultiples(9334, new int[] {1, 2, 3, 6, 8}));
   ExampleRunner.eq(
       25, "IMPOSSIBLE", new MultiplesWithLimit().minMultiples(5310, new int[] {0, 1, 4, 6, 9}));
   ExampleRunner.eq(
       26, "11556", new MultiplesWithLimit().minMultiples(1926, new int[] {2, 4, 8, 9}));
   ExampleRunner.eq(
       27, "2421", new MultiplesWithLimit().minMultiples(2421, new int[] {0, 6, 8, 9}));
   ExampleRunner.eq(
       28, "6876", new MultiplesWithLimit().minMultiples(1719, new int[] {0, 1, 2, 4}));
   ExampleRunner.eq(29, "7556", new MultiplesWithLimit().minMultiples(3778, new int[] {2, 3, 8}));
   ExampleRunner.eq(
       30, "IMPOSSIBLE", new MultiplesWithLimit().minMultiples(4990, new int[] {0, 3, 8, 9}));
   ExampleRunner.eq(
       31,
       "IMPOSSIBLE",
       new MultiplesWithLimit().minMultiples(5570, new int[] {0, 3, 4, 7, 8, 9}));
   ExampleRunner.eq(
       32,
       "IMPOSSIBLE",
       new MultiplesWithLimit().minMultiples(5334, new int[] {0, 1, 2, 4, 6, 7, 8, 9}));
   ExampleRunner.eq(
       33, "78272", new MultiplesWithLimit().minMultiples(4892, new int[] {0, 3, 4, 9}));
   ExampleRunner.eq(34, "17424", new MultiplesWithLimit().minMultiples(8712, new int[] {0, 8, 9}));
   ExampleRunner.eq(
       35, "115560", new MultiplesWithLimit().minMultiples(2568, new int[] {2, 3, 4, 8, 9}));
   ExampleRunner.eq(
       36, "24024", new MultiplesWithLimit().minMultiples(3432, new int[] {1, 3, 5, 8}));
   ExampleRunner.eq(
       37,
       "777...777(9 digits)",
       new MultiplesWithLimit().minMultiples(2821, new int[] {1, 2, 3, 4, 5, 6, 8, 9}));
   ExampleRunner.eq(38, "67779", new MultiplesWithLimit().minMultiples(7531, new int[] {0, 3, 5}));
   ExampleRunner.eq(
       39, "11410", new MultiplesWithLimit().minMultiples(1630, new int[] {2, 5, 6, 7, 9}));
   ExampleRunner.eq(
       40, "4433", new MultiplesWithLimit().minMultiples(4433, new int[] {1, 2, 5, 7, 8, 9}));
   ExampleRunner.eq(
       41, "7272", new MultiplesWithLimit().minMultiples(1818, new int[] {0, 4, 6, 8}));
   ExampleRunner.eq(
       42, "80873", new MultiplesWithLimit().minMultiples(6221, new int[] {1, 4, 5, 6}));
   ExampleRunner.eq(43, "7032", new MultiplesWithLimit().minMultiples(3516, new int[] {1, 9}));
   ExampleRunner.eq(
       44, "101080", new MultiplesWithLimit().minMultiples(7220, new int[] {2, 3, 4, 5, 9}));
   ExampleRunner.eq(
       45, "22767207", new MultiplesWithLimit().minMultiples(9327, new int[] {1, 3, 4, 5, 8, 9}));
   ExampleRunner.eq(
       46, "18429", new MultiplesWithLimit().minMultiples(6143, new int[] {0, 3, 5, 6, 7}));
   ExampleRunner.eq(
       47, "304", new MultiplesWithLimit().minMultiples(76, new int[] {1, 6, 7, 8, 9}));
   ExampleRunner.eq(
       48, "20208", new MultiplesWithLimit().minMultiples(5052, new int[] {1, 3, 5, 6}));
   ExampleRunner.eq(
       49,
       "22977972",
       new MultiplesWithLimit().minMultiples(2818, new int[] {0, 1, 3, 4, 5, 6, 8}));
   ExampleRunner.eq(
       50,
       "IMPOSSIBLE",
       new MultiplesWithLimit().minMultiples(4910, new int[] {0, 3, 4, 5, 7, 8, 9}));
   ExampleRunner.eq(
       51, "3336", new MultiplesWithLimit().minMultiples(3336, new int[] {0, 1, 7, 8, 9}));
   ExampleRunner.eq(
       52, "2494", new MultiplesWithLimit().minMultiples(1247, new int[] {3, 5, 7, 8}));
   ExampleRunner.eq(
       53, "79948", new MultiplesWithLimit().minMultiples(7268, new int[] {0, 2, 3, 5}));
   ExampleRunner.eq(
       54, "5166716", new MultiplesWithLimit().minMultiples(2102, new int[] {0, 2, 3, 4, 8, 9}));
   ExampleRunner.eq(55, "7664", new MultiplesWithLimit().minMultiples(7664, new int[] {0, 1, 9}));
   ExampleRunner.eq(
       56, "404888", new MultiplesWithLimit().minMultiples(9416, new int[] {2, 6, 7}));
   ExampleRunner.eq(
       57, "26442", new MultiplesWithLimit().minMultiples(2034, new int[] {0, 1, 3, 5, 7, 8}));
   ExampleRunner.eq(
       58,
       "IMPOSSIBLE",
       new MultiplesWithLimit().minMultiples(8490, new int[] {0, 2, 3, 7, 8, 9}));
   ExampleRunner.eq(
       59, "23388", new MultiplesWithLimit().minMultiples(1949, new int[] {0, 1, 5, 6, 7, 9}));
   ExampleRunner.eq(
       60,
       "500...005(12 digits)",
       new MultiplesWithLimit().minMultiples(3845, new int[] {1, 2, 3, 4, 6, 7, 8, 9}));
   ExampleRunner.eq(61, "7262", new MultiplesWithLimit().minMultiples(7262, new int[] {5}));
   ExampleRunner.eq(
       62, "342545", new MultiplesWithLimit().minMultiples(9787, new int[] {1, 6, 7, 8}));
   ExampleRunner.eq(
       63, "2524", new MultiplesWithLimit().minMultiples(631, new int[] {0, 1, 3, 6, 8, 9}));
   ExampleRunner.eq(
       64, "IMPOSSIBLE", new MultiplesWithLimit().minMultiples(2660, new int[] {0, 5, 7, 8}));
   ExampleRunner.eq(
       65, "19694", new MultiplesWithLimit().minMultiples(9847, new int[] {0, 2, 7, 8}));
   ExampleRunner.eq(
       66, "5122", new MultiplesWithLimit().minMultiples(2561, new int[] {4, 6, 7, 9}));
   ExampleRunner.eq(
       67,
       "33393393",
       new MultiplesWithLimit().minMultiples(7011, new int[] {0, 1, 2, 4, 5, 6, 7}));
   ExampleRunner.eq(
       68, "494445", new MultiplesWithLimit().minMultiples(4155, new int[] {0, 1, 2, 6, 7, 8}));
   ExampleRunner.eq(
       69, "112822", new MultiplesWithLimit().minMultiples(2969, new int[] {3, 4, 5, 6, 9}));
   ExampleRunner.eq(
       70, "354855", new MultiplesWithLimit().minMultiples(8655, new int[] {0, 2, 6, 7, 9}));
   ExampleRunner.eq(
       71, "101166", new MultiplesWithLimit().minMultiples(7782, new int[] {3, 4, 5, 8, 9}));
   ExampleRunner.eq(
       72, "589944", new MultiplesWithLimit().minMultiples(1569, new int[] {0, 1, 2, 3, 6, 7}));
   ExampleRunner.eq(
       73, "9112", new MultiplesWithLimit().minMultiples(268, new int[] {3, 4, 5, 6, 7, 8}));
   ExampleRunner.eq(
       74, "6669160", new MultiplesWithLimit().minMultiples(9736, new int[] {2, 3, 4, 5, 7, 8}));
   ExampleRunner.eq(
       75, "686", new MultiplesWithLimit().minMultiples(686, new int[] {1, 2, 3, 4, 5, 7}));
   ExampleRunner.eq(76, "788", new MultiplesWithLimit().minMultiples(197, new int[] {1, 2, 3}));
   ExampleRunner.eq(
       77, "680068", new MultiplesWithLimit().minMultiples(9316, new int[] {2, 3, 4, 7, 9}));
   ExampleRunner.eq(
       78, "67522", new MultiplesWithLimit().minMultiples(9646, new int[] {1, 4, 8, 9}));
   ExampleRunner.eq(
       79,
       "3133188",
       new MultiplesWithLimit().minMultiples(1809, new int[] {0, 2, 4, 5, 6, 7, 9}));
   ExampleRunner.eq(80, "3504", new MultiplesWithLimit().minMultiples(1752, new int[] {1, 7, 8}));
   ExampleRunner.eq(
       81, "1371766", new MultiplesWithLimit().minMultiples(5422, new int[] {0, 2, 4, 5, 8, 9}));
   ExampleRunner.eq(
       82, "670677", new MultiplesWithLimit().minMultiples(2289, new int[] {1, 2, 4, 5, 8, 9}));
   ExampleRunner.eq(
       83, "5652", new MultiplesWithLimit().minMultiples(471, new int[] {0, 3, 4, 7, 8}));
   ExampleRunner.eq(84, "2166", new MultiplesWithLimit().minMultiples(1083, new int[] {4, 7, 8}));
   ExampleRunner.eq(
       85, "180208", new MultiplesWithLimit().minMultiples(6436, new int[] {3, 4, 5, 6, 7}));
   ExampleRunner.eq(
       86,
       "4555554",
       new MultiplesWithLimit().minMultiples(5073, new int[] {0, 1, 2, 3, 6, 7, 9}));
   ExampleRunner.eq(
       87, "4997", new MultiplesWithLimit().minMultiples(263, new int[] {0, 1, 2, 3, 6, 8}));
   ExampleRunner.eq(
       88, "185080", new MultiplesWithLimit().minMultiples(5288, new int[] {2, 3, 4, 6, 7, 9}));
   ExampleRunner.eq(89, "4677", new MultiplesWithLimit().minMultiples(4677, new int[] {0, 1, 5}));
   ExampleRunner.eq(
       90, "3229332", new MultiplesWithLimit().minMultiples(8681, new int[] {0, 1, 4, 6, 7, 8}));
   ExampleRunner.eq(
       91, "30163", new MultiplesWithLimit().minMultiples(4309, new int[] {4, 5, 7, 8, 9}));
   ExampleRunner.eq(
       92,
       "9112929",
       new MultiplesWithLimit().minMultiples(1227, new int[] {0, 3, 4, 5, 6, 7, 8}));
   ExampleRunner.eq(
       93, "IMPOSSIBLE", new MultiplesWithLimit().minMultiples(8610, new int[] {0, 1, 3, 4, 9}));
   ExampleRunner.eq(
       94, "703970", new MultiplesWithLimit().minMultiples(3434, new int[] {1, 2, 4, 5, 6, 8}));
   ExampleRunner.eq(
       95, "9974", new MultiplesWithLimit().minMultiples(9974, new int[] {0, 1, 3, 5, 8}));
   ExampleRunner.eq(96, "19130", new MultiplesWithLimit().minMultiples(9565, new int[] {2, 4, 5}));
   ExampleRunner.eq(97, "3904", new MultiplesWithLimit().minMultiples(3904, new int[] {6, 8}));
   ExampleRunner.eq(
       98, "698688", new MultiplesWithLimit().minMultiples(9704, new int[] {1, 2, 4, 5, 7}));
   ExampleRunner.eq(
       99, "368368", new MultiplesWithLimit().minMultiples(4784, new int[] {0, 1, 2, 4, 9}));
   ExampleRunner.eq(100, "4485", new MultiplesWithLimit().minMultiples(4485, new int[] {6, 9}));
   ExampleRunner.eq(
       101, "4774", new MultiplesWithLimit().minMultiples(4774, new int[] {3, 5, 6, 8}));
   ExampleRunner.eq(
       102,
       "IMPOSSIBLE",
       new MultiplesWithLimit().minMultiples(2060, new int[] {0, 1, 5, 6, 8, 9}));
   ExampleRunner.eq(
       103, "5520", new MultiplesWithLimit().minMultiples(1380, new int[] {1, 3, 4, 7, 8, 9}));
   ExampleRunner.eq(
       104, "17908", new MultiplesWithLimit().minMultiples(4477, new int[] {4, 5, 6}));
   ExampleRunner.eq(
       105,
       "IMPOSSIBLE",
       new MultiplesWithLimit().minMultiples(2115, new int[] {0, 1, 2, 3, 4, 5, 8, 9}));
   ExampleRunner.eq(
       106, "499149", new MultiplesWithLimit().minMultiples(8757, new int[] {2, 3, 6, 7, 8}));
   ExampleRunner.eq(107, "4480", new MultiplesWithLimit().minMultiples(560, new int[] {2, 6, 9}));
   ExampleRunner.eq(
       108, "4454", new MultiplesWithLimit().minMultiples(262, new int[] {0, 1, 2, 3, 7, 8, 9}));
   ExampleRunner.eq(
       109,
       "111...111(9972 digits)",
       new MultiplesWithLimit().minMultiples(9981, new int[] {0, 2, 3, 4, 5, 6, 7, 8, 9}));
   ExampleRunner.eq(
       110,
       "IMPOSSIBLE",
       new MultiplesWithLimit().minMultiples(1, new int[] {9, 8, 7, 6, 5, 4, 3, 2, 1}));
   ExampleRunner.eq(
       111, "9", new MultiplesWithLimit().minMultiples(1, new int[] {0, 1, 2, 3, 4, 5, 6, 7, 8}));
   ExampleRunner.eq(112, "1", new MultiplesWithLimit().minMultiples(1, new int[] {}));
   ExampleRunner.eq(113, "10", new MultiplesWithLimit().minMultiples(5, new int[] {5}));
   ExampleRunner.eq(114, "12", new MultiplesWithLimit().minMultiples(4, new int[] {4, 8}));
   ExampleRunner.eq(115, "12", new MultiplesWithLimit().minMultiples(3, new int[] {3, 6, 9}));
   ExampleRunner.eq(116, "1000", new MultiplesWithLimit().minMultiples(8, new int[] {2, 4, 6, 8}));
   ExampleRunner.eq(
       117, "77778", new MultiplesWithLimit().minMultiples(9, new int[] {1, 2, 3, 4, 5, 6, 9}));
   ExampleRunner.eq(
       118,
       "888...888(9 digits)",
       new MultiplesWithLimit().minMultiples(9, new int[] {1, 2, 3, 4, 5, 6, 7, 9}));
   ExampleRunner.eq(
       119,
       "888...888(9 digits)",
       new MultiplesWithLimit().minMultiples(9, new int[] {0, 1, 2, 3, 4, 5, 6, 7, 9}));
   ExampleRunner.eq(120, "10000", new MultiplesWithLimit().minMultiples(10000, new int[] {}));
   ExampleRunner.eq(121, "10000", new MultiplesWithLimit().minMultiples(625, new int[] {5}));
   ExampleRunner.eq(122, "111888", new MultiplesWithLimit().minMultiples(999, new int[] {9}));
   ExampleRunner.eq(123, "1007874", new MultiplesWithLimit().minMultiples(7999, new int[] {9}));
   ExampleRunner.eq(124, "11118888", new MultiplesWithLimit().minMultiples(9999, new int[] {9}));
   ExampleRunner.eq(125, "10374", new MultiplesWithLimit().minMultiples(399, new int[] {8, 9}));
   ExampleRunner.eq(126, "111776", new MultiplesWithLimit().minMultiples(998, new int[] {8, 9}));
   ExampleRunner.eq(127, "1011747", new MultiplesWithLimit().minMultiples(3999, new int[] {8, 9}));
   ExampleRunner.eq(
       128, "11117776", new MultiplesWithLimit().minMultiples(9998, new int[] {8, 9}));
   ExampleRunner.eq(129, "11008", new MultiplesWithLimit().minMultiples(172, new int[] {2, 4, 6}));
   ExampleRunner.eq(
       130, "301788", new MultiplesWithLimit().minMultiples(996, new int[] {2, 4, 6}));
   ExampleRunner.eq(
       131, "1770888", new MultiplesWithLimit().minMultiples(1992, new int[] {2, 4, 6}));
   ExampleRunner.eq(
       132, "30017988", new MultiplesWithLimit().minMultiples(9996, new int[] {2, 4, 6}));
   ExampleRunner.eq(
       133,
       "100...000(14 digits)",
       new MultiplesWithLimit().minMultiples(8192, new int[] {2, 4, 6, 8}));
   ExampleRunner.eq(
       134,
       "300...000(14 digits)",
       new MultiplesWithLimit().minMultiples(8192, new int[] {1, 2, 4, 6, 8}));
   ExampleRunner.eq(
       135,
       "500...000(14 digits)",
       new MultiplesWithLimit().minMultiples(8192, new int[] {1, 2, 3, 4, 6, 8}));
   ExampleRunner.eq(
       136,
       "111...000(18 digits)",
       new MultiplesWithLimit().minMultiples(7992, new int[] {2, 3, 4, 6, 7, 8, 9}));
   ExampleRunner.eq(
       137,
       "444...888(20 digits)",
       new MultiplesWithLimit().minMultiples(9999, new int[] {1, 2, 3, 5, 6, 7, 9}));
   ExampleRunner.eq(
       138,
       "777...000(30 digits)",
       new MultiplesWithLimit().minMultiples(7992, new int[] {1, 2, 3, 4, 5, 6, 8, 9}));
   ExampleRunner.eq(
       139,
       "888...888(36 digits)",
       new MultiplesWithLimit().minMultiples(9999, new int[] {1, 2, 3, 4, 5, 6, 7, 9}));
   ExampleRunner.eq(
       140,
       "888...888(9918 digits)",
       new MultiplesWithLimit().minMultiples(9927, new int[] {0, 1, 2, 3, 4, 5, 6, 7, 9}));
   ExampleRunner.eq(
       141,
       "999...999(9930 digits)",
       new MultiplesWithLimit().minMultiples(9931, new int[] {0, 1, 2, 3, 4, 5, 6, 7, 8}));
   ExampleRunner.eq(
       142,
       "999...999(9948 digits)",
       new MultiplesWithLimit().minMultiples(9949, new int[] {0, 1, 2, 3, 4, 5, 6, 7, 8}));
   ExampleRunner.eq(
       143,
       "999...999(9966 digits)",
       new MultiplesWithLimit().minMultiples(9967, new int[] {0, 1, 2, 3, 4, 5, 6, 7, 8}));
   ExampleRunner.eq(
       144, "1000", new MultiplesWithLimit().minMultiples(8, new int[] {2, 3, 4, 5, 6, 7, 8, 9}));
   ExampleRunner.eq(145, "3668", new MultiplesWithLimit().minMultiples(524, new int[] {5, 2, 4}));
   ExampleRunner.eq(146, "8", new MultiplesWithLimit().minMultiples(8, new int[] {}));
   ExampleRunner.eq(
       147,
       "222...222(9 digits)",
       new MultiplesWithLimit().minMultiples(9, new int[] {1, 3, 4, 5, 6, 7, 8, 9}));
   ExampleRunner.eq(
       148, "70288", new MultiplesWithLimit().minMultiples(8786, new int[] {1, 3, 5, 6, 9}));
   ExampleRunner.eq(
       149,
       "100...000(14 digits)",
       new MultiplesWithLimit().minMultiples(8192, new int[] {2, 3, 4, 5, 6, 7, 8, 9}));
   ExampleRunner.eq(150, "1", new MultiplesWithLimit().minMultiples(1, new int[] {}));
   ExampleRunner.eq(
       151,
       "777...777(10 digits)",
       new MultiplesWithLimit().minMultiples(4433, new int[] {0, 2, 4, 6, 8, 9, 3, 5}));
   ExampleRunner.eq(
       152,
       "111...111(36 digits)",
       new MultiplesWithLimit().minMultiples(9999, new int[] {0, 2, 3, 4, 5, 6, 7, 8, 9}));
   ExampleRunner.eq(
       153,
       "222...222(81 digits)",
       new MultiplesWithLimit().minMultiples(81, new int[] {0, 1, 3, 4, 5, 6, 7, 8, 9}));
   ExampleRunner.eq(
       154,
       "200...202(13 digits)",
       new MultiplesWithLimit().minMultiples(6561, new int[] {1, 3, 4, 5, 6, 7, 8, 9}));
   ExampleRunner.eq(
       155,
       "111...101(10 digits)",
       new MultiplesWithLimit().minMultiples(81, new int[] {2, 3, 4, 5, 6, 7, 8, 9}));
   ExampleRunner.eq(
       156,
       "111...111(192 digits)",
       new MultiplesWithLimit().minMultiples(9997, new int[] {0, 2, 3, 4, 5, 6, 7, 8, 9}));
   ExampleRunner.eq(
       157,
       "999...999(12 digits)",
       new MultiplesWithLimit().minMultiples(2121, new int[] {0, 1, 2, 3, 4, 5, 6, 7, 8}));
   ExampleRunner.eq(
       158,
       "111...111(36 digits)",
       new MultiplesWithLimit().minMultiples(9999, new int[] {2, 3, 4, 5, 6, 7, 8, 9, 0}));
   ExampleRunner.eq(
       159,
       "IMPOSSIBLE",
       new MultiplesWithLimit().minMultiples(1, new int[] {0, 1, 2, 3, 4, 5, 6, 7, 8, 9}));
   ExampleRunner.eq(
       160,
       "220...222(10 digits)",
       new MultiplesWithLimit().minMultiples(27, new int[] {1, 3, 4, 5, 6, 7, 8, 9}));
   ExampleRunner.eq(
       161,
       "IMPOSSIBLE",
       new MultiplesWithLimit().minMultiples(2, new int[] {1, 2, 3, 4, 5, 6, 7, 8, 9}));
   ExampleRunner.eq(
       162,
       "IMPOSSIBLE",
       new MultiplesWithLimit().minMultiples(2, new int[] {0, 2, 3, 4, 5, 6, 7, 8, 9}));
   ExampleRunner.eq(163, "9", new MultiplesWithLimit().minMultiples(9, new int[] {0}));
   ExampleRunner.eq(164, "11118888", new MultiplesWithLimit().minMultiples(9999, new int[] {9}));
   ExampleRunner.eq(
       165,
       "888...888(9 digits)",
       new MultiplesWithLimit().minMultiples(9, new int[] {1, 2, 3, 4, 5, 6, 7, 9, 0}));
   ExampleRunner.eq(166, "6561", new MultiplesWithLimit().minMultiples(6561, new int[] {7}));
   ExampleRunner.eq(
       167,
       "444...444(36 digits)",
       new MultiplesWithLimit().minMultiples(9999, new int[] {1, 2, 3, 5, 6, 7, 8, 9}));
   ExampleRunner.eq(168, "IMPOSSIBLE", new MultiplesWithLimit().minMultiples(5, new int[] {0, 5}));
   ExampleRunner.eq(
       169, "999", new MultiplesWithLimit().minMultiples(999, new int[] {1, 2, 3, 4, 5, 6}));
   ExampleRunner.eq(
       170, "8", new MultiplesWithLimit().minMultiples(1, new int[] {0, 1, 2, 3, 4, 5, 6, 7}));
   ExampleRunner.eq(
       171, "IMPOSSIBLE", new MultiplesWithLimit().minMultiples(10000, new int[] {0}));
   ExampleRunner.eq(
       172,
       "222...222(9 digits)",
       new MultiplesWithLimit().minMultiples(9, new int[] {0, 1, 3, 4, 5, 6, 7, 8, 9}));
   ExampleRunner.eq(
       173,
       "222...222(18 digits)",
       new MultiplesWithLimit().minMultiples(99, new int[] {0, 1, 3, 4, 5, 6, 7, 8, 9}));
   ExampleRunner.eq(
       174,
       "222...222(10 digits)",
       new MultiplesWithLimit().minMultiples(9091, new int[] {1, 4, 5, 6, 7, 8, 9, 0}));
   ExampleRunner.eq(
       175,
       "100...100(15 digits)",
       new MultiplesWithLimit().minMultiples(9116, new int[] {2, 3, 4, 5, 6, 7, 8, 9}));
   ExampleRunner.eq(
       176,
       "111...111(27 digits)",
       new MultiplesWithLimit().minMultiples(999, new int[] {2, 3, 4, 5, 6, 7, 8, 9}));
 }
Пример #3
0
 public static void main(String[] args) {
   ExampleRunner.eq(1, 2, new Mosquitoes().getMaximum(new int[] {1, -1}, new int[] {1, -1}, 10));
   ExampleRunner.eq(
       2, 1, new Mosquitoes().getMaximum(new int[] {100, -100}, new int[] {1, -1}, 10));
   ExampleRunner.eq(
       3,
       4,
       new Mosquitoes()
           .getMaximum(new int[] {0, -1, 10, -11, 99, -99}, new int[] {1, -1, -3, 3, 47, -47}, 3));
   ExampleRunner.eq(4, 1, new Mosquitoes().getMaximum(new int[] {5}, new int[] {2}, 8));
   ExampleRunner.eq(
       5,
       3,
       new Mosquitoes()
           .getMaximum(new int[] {12, 34, 56, 78, 90}, new int[] {-1, 2, -3, 4, -5}, 6));
   ExampleRunner.eq(6, 1, new Mosquitoes().getMaximum(new int[] {99}, new int[] {-88}, 1));
   ExampleRunner.eq(7, 1, new Mosquitoes().getMaximum(new int[] {-100}, new int[] {100}, 100));
   ExampleRunner.eq(
       8, 2, new Mosquitoes().getMaximum(new int[] {100, -100}, new int[] {100, -100}, 100));
   ExampleRunner.eq(
       9, 1, new Mosquitoes().getMaximum(new int[] {100, 97}, new int[] {99, -100}, 1));
   ExampleRunner.eq(
       10, 1, new Mosquitoes().getMaximum(new int[] {-99, -96}, new int[] {-100, 100}, 1));
   ExampleRunner.eq(
       11, 2, new Mosquitoes().getMaximum(new int[] {2, -2}, new int[] {-100, 100}, 1));
   ExampleRunner.eq(
       12,
       50,
       new Mosquitoes()
           .getMaximum(
               new int[] {
                 -68, -68, -68, -68, -68, -68, -68, -68, -68, -68, -68, -68, -68, -68, -68, -68,
                 -68, -68, -68, -68, -68, -68, -68, -68, -68, -68, -68, -68, -68, -68, -68, -68,
                 -68, -68, -68, -68, -68, -68, -68, -68, -68, -68, -68, -68, -68, -68, -68, -68,
                 -68, -68
               },
               new int[] {
                 -49, -47, -45, -43, -41, -39, -37, -35, -33, -31, -29, -27, -25, -23, -21, -19,
                 -17, -15, -13, -11, -9, -7, -5, -3, -1, 1, 3, 5, 7, 9, 11, 13, 15, 17, 19, 21, 23,
                 25, 27, 29, 31, 33, 35, 37, 39, 41, 43, 45, 47, 49
               },
               1));
   ExampleRunner.eq(
       13,
       50,
       new Mosquitoes()
           .getMaximum(
               new int[] {
                 100, 100, 100, 100, 100, 100, 100, 100, 100, 100, 100, 100, 100, 100, 100, 100,
                 100, 100, 100, 100, 100, 100, 100, 100, 100, -100, -100, -100, -100, -100, -100,
                 -100, -100, -100, -100, -100, -100, -100, -100, -100, -100, -100, -100, -100,
                 -100, -100, -100, -100, -100, -100
               },
               new int[] {
                 1, 5, 9, 13, 17, 21, 25, 29, 33, 37, 41, 45, 49, 53, 57, 61, 65, 69, 73, 77, 81,
                 85, 89, 93, 97, -1, -5, -9, -13, -17, -21, -25, -29, -33, -37, -41, -45, -49, -53,
                 -57, -61, -65, -69, -73, -77, -81, -85, -89, -93, -97
               },
               100));
   ExampleRunner.eq(
       14,
       25,
       new Mosquitoes()
           .getMaximum(
               new int[] {
                 100, 100, 100, 100, 100, 100, 100, 100, 100, 100, 100, 100, 100, 100, 100, 100,
                 100, 100, 100, 100, 100, 100, 100, 100, 100, -100, -100, -100, -100, -100, -100,
                 -100, -100, -100, -100, -100, -100, -100, -100, -100, -100, -100, -100, -100,
                 -100, -100, -100, -100, -100, -100
               },
               new int[] {
                 1, 5, 9, 13, 17, 21, 25, 29, 33, 37, 41, 45, 49, 53, 57, 61, 65, 69, 73, 77, 81,
                 85, 89, 93, 97, -1, -5, -9, -13, -17, -21, -25, -29, -33, -37, -41, -45, -49, -53,
                 -57, -61, -65, -69, -73, -77, -81, -85, -89, -93, -97
               },
               99));
   ExampleRunner.eq(
       15,
       4,
       new Mosquitoes()
           .getMaximum(
               new int[] {-34, -91, 29, -26, 92, -32, 56},
               new int[] {2, 5, -90, -39, -4, 36, -2},
               3));
   ExampleRunner.eq(
       16,
       5,
       new Mosquitoes()
           .getMaximum(
               new int[] {40, -46, -41, 83, 60, 16, 58, 49},
               new int[] {44, 3, 2, -13, -3, -1, -15, -2},
               7));
   ExampleRunner.eq(
       17,
       6,
       new Mosquitoes()
           .getMaximum(
               new int[] {6, -62, 56, -68, 88, -10, -54, 68, -29},
               new int[] {34, -35, -3, 3, -6, 0, -78, -5, 2},
               11));
   ExampleRunner.eq(18, 1, new Mosquitoes().getMaximum(new int[] {-33}, new int[] {45}, 4));
   ExampleRunner.eq(
       19, 2, new Mosquitoes().getMaximum(new int[] {-29, -27}, new int[] {25, 61}, 7));
   ExampleRunner.eq(
       20, 3, new Mosquitoes().getMaximum(new int[] {50, -90, -24}, new int[] {-57, 68, 8}, 5));
   ExampleRunner.eq(
       21,
       2,
       new Mosquitoes().getMaximum(new int[] {87, 31, 54, -71}, new int[] {57, -41, 66, 75}, 4));
   ExampleRunner.eq(
       22,
       2,
       new Mosquitoes()
           .getMaximum(new int[] {-97, -41, 21, 97, -2}, new int[] {24, -40, 72, -95, 42}, 8));
   ExampleRunner.eq(
       23,
       3,
       new Mosquitoes()
           .getMaximum(
               new int[] {78, 79, -25, 42, -20, -70, -79, 52, -98, 19},
               new int[] {85, -3, -36, -54, -96, 66, 27, 72, -11, -40},
               10));
   ExampleRunner.eq(
       24,
       4,
       new Mosquitoes()
           .getMaximum(
               new int[] {
                 -22, 47, 78, 79, 10, 50, -74, 92, -16, 6, -7, -9, 91, -31, 74, -34, 56, -23, -47,
                 -59
               },
               new int[] {
                 15, -76, -33, 69, 61, -86, -27, 85, -85, -50, 59, -18, 5, 23, 44, -63, -59, 45,
                 -11, -25
               },
               5));
   ExampleRunner.eq(
       25,
       6,
       new Mosquitoes()
           .getMaximum(
               new int[] {
                 -52, -48, -21, 36, -28, -75, 79, 39, 100, -42, 26, 42, 62, 100, 37, -40, -19, 77,
                 99, -32, -55, 99, 17, 50, 32, 12, 7, 40, 11, 23
               },
               new int[] {
                 23, 18, -20, 3, -17, -67, 41, -65, 86, -24, 81, 66, -94, -89, 10, 46, -55, -46,
                 -16, 31, 43, -19, -76, 37, -38, -60, -75, 62, 54, 78
               },
               4));
   ExampleRunner.eq(
       26,
       9,
       new Mosquitoes()
           .getMaximum(
               new int[] {
                 -85, -33, 17, -45, 73, -9, -75, -55, 97, -15, 29, -32, -70, -20, -38, -87, -70,
                 -69, 74, -9, -48, 29, 40, -93, 9, -59, 32, 73, -30, 97, -65, -7, 32, 45, -65, -58,
                 84, 46, 48, 62
               },
               new int[] {
                 26, -81, -62, 47, 65, 25, 73, 82, 71, 57, 19, 96, -6, -58, 34, -10, -96, -13, -35,
                 -25, 95, -23, 32, 76, 59, 70, -70, 30, -100, 66, 37, 11, -84, -9, -4, 75, -36, 14,
                 -68, 45
               },
               9));
   ExampleRunner.eq(
       27,
       11,
       new Mosquitoes()
           .getMaximum(
               new int[] {
                 29, -20, 77, -30, -16, -27, 10, -18, -61, 20, 75, 98, 60, 22, -38, 32, 44, 83,
                 -29, 79, 66, 91, 74, 55, -44, -73, -65, 66, -73, 73, -64, 21, 56, 68, 21, 93, 68,
                 70, 73, -3, -77, 58, -13, -64, 50, 61, 63, -55, 90, 96
               },
               new int[] {
                 85, -53, -37, -78, -84, 55, -95, 23, 71, -91, -24, 0, -23, 99, 24, 33, -100, 69,
                 31, -85, 28, -98, 27, 8, -19, 34, -58, -75, -74, -11, 43, 88, -31, 58, -59, -66,
                 50, -13, 4, -71, -36, -29, 26, -62, -38, -80, -49, 46, 44, 12
               },
               7));
   ExampleRunner.eq(
       28,
       6,
       new Mosquitoes()
           .getMaximum(
               new int[] {
                 -80, -63, 35, -15, -99, -40, 39, -51, -8, -84, 16, 28, -26, -18, -2, 48, 12, -62,
                 68, -73
               },
               new int[] {
                 -94, 88, 31, -13, -69, 82, 67, -81, 21, 47, 8, -31, -99, -22, -4, 33, 50, -70, 98,
                 -41
               },
               18));
   ExampleRunner.eq(
       29,
       15,
       new Mosquitoes()
           .getMaximum(
               new int[] {
                 32, -36, -66, -16, 6, 90, 62, 20, -75, 80, -73, 9, 40, -63, -29, -78, 25, -69, 5,
                 -98, 97, -29, 30
               },
               new int[] {
                 17, 68, -19, -31, -67, -88, -17, -41, 98, 20, 12, 52, -75, 5, -18, -4, 26, -1, 66,
                 21, -33, 79, -80
               },
               50));
   ExampleRunner.eq(
       30,
       15,
       new Mosquitoes()
           .getMaximum(
               new int[] {
                 -66, -53, -50, -63, -81, 14, 65, 78, -72, -33, -74, -45, 19, -92, 84, -48, -81,
                 -23, 88, -42, 3, -3, 93, -59, 15, 67
               },
               new int[] {
                 14, 78, 43, 95, 2, -16, -58, 18, 41, 59, -69, 27, -28, 91, -64, -94, 52, -9, -67,
                 98, -59, 94, 67, 20, 93, -19
               },
               34));
   ExampleRunner.eq(
       31,
       15,
       new Mosquitoes()
           .getMaximum(
               new int[] {
                 34, 93, 43, 69, 93, 15, 54, -73, 43, 33, -56, 31, 43, 58, 35, 96, 94, -31, -16,
                 98, 64, 87, 74, -11, -21, 83, -11, 100, -47
               },
               new int[] {
                 99, -16, 82, 89, 60, -99, 65, 57, -68, -80, -42, -94, 27, -75, -38, 86, 23, 67,
                 20, 13, 10, -8, -93, -91, 63, -22, 70, -61, -57
               },
               28));
   ExampleRunner.eq(
       32,
       18,
       new Mosquitoes()
           .getMaximum(
               new int[] {
                 -67, -17, -86, 36, -17, -49, 7, -46, -93, 63, -79, -54, -33, 26, 61, 84, -56, 52,
                 87, 82, 93, -41, 99, -28, -19, 69, 16, 79, 66, 23, 58, 1
               },
               new int[] {
                 62, 70, 87, 73, -3, 44, 1, 92, -81, 32, -93, 25, 82, 6, 72, 37, 0, -55, -35, -27,
                 -21, 99, -83, 100, -62, 11, 95, 24, -24, 71, -77, 53
               },
               35));
   ExampleRunner.eq(
       33,
       19,
       new Mosquitoes()
           .getMaximum(
               new int[] {
                 34, -13, -52, -83, -21, 97, -68, 26, -59, 96, 67, -5, 56, 40, 52, 66, 99, 99, -95,
                 57, 33, -73, -1, 77, -80, -67, 73, -91, 45, 46, 96, 54, -93, -57, 18
               },
               new int[] {
                 19, -65, -52, 63, 67, 72, -72, 77, -45, -18, -46, -29, 31, -33, 12, 99, 16, -62,
                 18, 39, -11, -54, -32, 54, -87, 71, 37, -8, -88, 0, -17, 20, -82, -28, 36
               },
               38));
   ExampleRunner.eq(
       34,
       17,
       new Mosquitoes()
           .getMaximum(
               new int[] {
                 -46, 76, 57, -28, -68, -43, -37, 44, -21, -95, -18, -5, -99, 99, 79, -96, 90, -29,
                 0, -92, 18, 63, -86, 98, -100, 1, -47, 55, 38, -97, -35, 48, 51, 74, 45, 10, 15,
                 76
               },
               new int[] {
                 63, -68, 58, 77, 20, 11, -69, -94, -53, 35, 7, 60, -24, 8, -61, 21, 95, 59, 74,
                 100, -78, 53, 14, -75, -30, -80, 80, -74, 67, -25, 19, 76, 28, -1, 90, 51, 31, 25
               },
               38));
   ExampleRunner.eq(
       35,
       11,
       new Mosquitoes()
           .getMaximum(
               new int[] {
                 32, -55, 19, 39, 71, -57, -32, -46, -30, 32, -18, 11, -91, -56, 71, 55, -99, -67,
                 64, -40, -99, -28, 16, -80, -96, -44, 96, -89, -51, -5, 71, 36, -66, 33, 82, -57,
                 66, 93, 72, -67, -90
               },
               new int[] {
                 26, -17, 82, 90, 27, 62, -32, -92, 67, -5, -73, 92, 13, 11, 64, -33, -97, 94, 6,
                 -43, 96, 57, -83, -59, 17, 76, -60, 71, -48, -61, 60, 78, 55, -45, 7, -12, -69,
                 16, 65, -38, 12
               },
               15));
   ExampleRunner.eq(
       36,
       25,
       new Mosquitoes()
           .getMaximum(
               new int[] {
                 85, -3, 96, -60, 84, 82, 17, 92, 33, 41, 57, -85, 79, -34, -81, 26, -17, -39, 54,
                 -58, -59, -48, -13, 12, -6, 49, 46, 26, -44, -40, 73, -58, -36, 1, -98, -42, 100,
                 -39, -100, -38, -17, -73, -76, 10
               },
               new int[] {
                 -32, 64, 37, -79, -80, -49, 9, 94, 46, 8, 35, 95, 90, -50, 71, 19, -55, -20, -96,
                 84, -71, -24, -30, 2, 10, 38, -41, 31, -66, 82, 25, 50, 79, 52, -18, 65, -23, 45,
                 87, 67, -39, 5, -92, -54
               },
               46));
   ExampleRunner.eq(
       37,
       28,
       new Mosquitoes()
           .getMaximum(
               new int[] {
                 -5, 44, -50, 6, -23, 59, -75, -82, -77, 34, 7, -4, -97, 40, 15, -30, -86, -45, 85,
                 -87, -60, 56, -72, -9, -81, 98, -58, -94, 99, -89, -43, 36, 61, 30, 99, 46, 59,
                 -61, -85, 9, -94, -66, -82, 36, -17, -72, 62
               },
               new int[] {
                 53, 95, 65, -27, -10, -19, 78, 76, 2, -48, 5, -29, -95, 41, 64, -49, -11, -59, 55,
                 -38, -37, 35, 40, 30, 11, 98, -34, 71, 39, 50, 29, -1, -20, -3, 10, 17, 31, 59,
                 -50, -81, 21, -23, -14, -16, 4, -88, -61
               },
               49));
   ExampleRunner.eq(
       38,
       29,
       new Mosquitoes()
           .getMaximum(
               new int[] {
                 -74, 68, 75, -99, -32, 33, 45, 37, -90, -9, 98, -7, 58, -67, -25, 95, -10, -29,
                 64, -18, -14, -22, 91, -88, -93, -70, 75, -87, 58, -56, -63, -92, 32, -84, 17,
                 -38, -5, -96, -86, 31, -42, -79, -8, 100, 50, 31, -25, -18, 81, -70
               },
               new int[] {
                 -79, 25, 89, 46, -58, 51, 73, -17, 90, 86, 13, -43, -71, -87, 79, -83, -37, 35,
                 58, 21, 24, 67, 62, -70, -7, 71, 77, 99, 54, 22, -48, 88, -88, -21, -15, -61, 68,
                 17, -9, -76, 31, 6, -38, 94, 78, 74, -52, -5, -74, -55
               },
               42));
   ExampleRunner.eq(
       39,
       5,
       new Mosquitoes()
           .getMaximum(
               new int[] {
                 -88, 47, 100, 57, 36, 61, -72, -38, 29, 96, 84, -34, 17, -79, 68, 83, -92, -39,
                 55, -18, 87, -94, 31, -5, -59, 95, -1, -99, 97, 15, -86, 13, -53, -54, 90, -51,
                 -58, -35, -92, 6, -57, 97, 41, 15, 99, 86, -5, -73, -59, -59
               },
               new int[] {
                 94, -95, 60, -14, -29, 48, -100, 64, -6, -71, 33, -13, 83, 27, 87, 49, -85, 91,
                 90, 65, -55, -64, -25, -26, -68, 2, -97, 26, -41, -51, -42, -21, 85, 43, 76, 77,
                 12, -79, 71, -83, -67, 73, 84, 51, 22, -2, 79, -86, 66, 47
               },
               1));
   ExampleRunner.eq(
       40,
       9,
       new Mosquitoes()
           .getMaximum(
               new int[] {
                 -5, -62, -15, -60, 94, 68, -8, -69, -83, -20, -47, -94, 17, -75, -18, 85, 51, 50,
                 -36, -100, -54, -13, 100, 61, -60, -3, -58, 0, 14, -80, 43, -82, 52, -27, -76, 78,
                 -81, 85, 46, -3, 22, -6, 93, -98, 15, -55, -90, 50, -30, 61
               },
               new int[] {
                 -56, -84, -35, -90, 68, -43, 29, 70, -23, -70, 67, -39, -11, 8, -55, 30, 83, -64,
                 -59, -44, 42, 47, 20, -33, -69, 46, -51, 86, 63, 23, -2, -8, 28, -10, -42, -46,
                 40, -4, -22, 19, -14, 80, 44, 79, 93, -91, 96, 22, 76, -88
               },
               5));
   ExampleRunner.eq(
       41,
       10,
       new Mosquitoes()
           .getMaximum(
               new int[] {
                 -88, -34, 100, -46, -25, -47, 92, 38, 60, 62, 6, -77, 68, 60, -51, 46, 91, -5, 11,
                 -7, -84, -89, 66, -31, 57, -77, 40, 38, 60, 34, -13, -88, -99, -85, 29, -73, -54,
                 70, -99, -87, 15, 15, 44, -35, -51, 32, 21, 4, 93, 45
               },
               new int[] {
                 -75, -66, -73, -56, 17, 71, -43, -84, -69, -80, -6, 6, 30, 29, 70, 51, -60, 87,
                 79, -85, 58, 4, -65, -34, 9, 55, 35, 61, -54, -86, 18, 81, -36, -90, 8, -13, 74,
                 97, -18, -4, 75, 43, -32, -3, -27, -82, 3, 21, -33, -63
               },
               9));
   ExampleRunner.eq(
       42,
       14,
       new Mosquitoes()
           .getMaximum(
               new int[] {
                 -88, -56, -63, 21, 19, 96, -63, 14, 83, 94, -31, 13, -82, 100, -98, -62, 21, 72,
                 -23, 31, 50, 37, -50, -28, 39, -38, -17, 66, 63, 31, -51, 33, -67, 93, -70, -50,
                 62, 97, 14, -48, -79, 56, 90, 31, 7, -94, -60, -95, -50, -12
               },
               new int[] {
                 50, -96, 37, 89, -1, 41, 33, -5, 71, -94, -36, -75, -56, 32, 29, 40, 36, -18, 74,
                 5, 22, 30, -66, 24, -17, -7, -27, -42, 2, -26, 20, 14, 88, -93, -40, -53, -61,
                 -98, 98, 11, 39, -58, -47, -15, -28, -25, -72, 62, 92, 97
               },
               13));
   ExampleRunner.eq(
       43,
       16,
       new Mosquitoes()
           .getMaximum(
               new int[] {
                 -27, 48, 62, -49, -91, -87, 48, -2, -57, 97, -20, 75, -32, -83, 19, 71, 37, 27,
                 -29, -54, -55, -72, 4, -75, 41, 74, -15, 35, -45, 50, -11, 36, 66, -79, 14, -69,
                 -54, 27, 28, 46, 11, 100, 99, -32, 52, -17, 62, -2, 0, 62
               },
               new int[] {
                 34, -89, -15, -70, 16, 64, -22, 0, -18, -14, 28, 61, 29, -39, 92, 43, -91, -13,
                 49, -32, 39, 40, -24, -55, 36, 44, 53, -56, 15, 6, -25, -80, 47, 38, -46, -31, 69,
                 65, 81, 88, -97, -19, -57, 68, 27, 91, -90, -17, 51, 42
               },
               17));
   ExampleRunner.eq(
       44,
       17,
       new Mosquitoes()
           .getMaximum(
               new int[] {
                 48, -22, -5, 62, 80, 5, -14, 52, -84, 37, -64, 74, -26, -96, 89, 54, -36, -7, 100,
                 85, -59, 62, 88, 100, 33, 91, -37, -92, -10, 31, -84, 57, -21, 1, 43, -76, -28,
                 43, 48, -34, 87, 62, 37, -87, 3, -35, -67, 16, -98, -35
               },
               new int[] {
                 76, -20, -44, -46, 85, -90, 99, 68, -100, -16, -48, -99, -41, -52, 82, -65, -43,
                 -50, 97, 60, -72, -79, 37, 89, -35, -82, -73, -97, 9, -11, 34, 19, -7, 30, -83,
                 27, 62, -69, -27, 11, 48, -95, -1, 33, -31, 75, 22, 96, 51, 21
               },
               21));
   ExampleRunner.eq(
       45,
       18,
       new Mosquitoes()
           .getMaximum(
               new int[] {
                 54, 88, 20, -42, -34, -49, -74, 84, -17, 35, -4, 87, -80, 9, 20, -12, -79, -40,
                 -8, -41, 76, 79, 38, 98, 14, 2, -26, 20, 85, 42, 87, -30, -52, -62, -23, -93, 65,
                 22, -36, 68, -39, 88, 40, -15, 17, -16, 65, -49, 3, 45
               },
               new int[] {
                 76, 82, -22, -58, 36, -27, 27, -91, -67, -45, -19, 5, 81, -50, 63, -99, -23, 44,
                 -47, -69, -97, 85, 72, -37, -24, -2, 58, -84, -7, 16, 83, -49, -75, -76, -74, 49,
                 67, 95, -8, -88, -66, 80, 92, -44, 68, 59, 28, -43, 57, -87
               },
               25));
   ExampleRunner.eq(
       46,
       20,
       new Mosquitoes()
           .getMaximum(
               new int[] {
                 100, -37, 92, -98, -58, 33, -72, -24, 88, 72, -14, -49, -56, 90, 77, -76, -94, 6,
                 53, -70, -86, 90, -81, 91, -50, -32, 60, 76, 52, 11, -13, 69, -29, -74, 8, -39,
                 -65, -63, 48, 63, -14, 73, -46, 35, -93, -52, -81, 32, -34, 77
               },
               new int[] {
                 99, 100, 18, 51, -11, -71, -66, -61, 59, 15, 36, -22, 54, -28, 80, -78, 70, 65,
                 84, -41, -95, 67, -5, 58, 83, 19, 21, 76, -10, -15, -18, 9, -68, 81, -44, 69, -98,
                 2, 38, 4, 52, -27, -9, -52, -20, 39, 97, 85, 35, 79
               },
               29));
   ExampleRunner.eq(
       47,
       23,
       new Mosquitoes()
           .getMaximum(
               new int[] {
                 71, 81, 39, 0, 46, -54, -58, 11, -46, 12, 24, 15, -11, 20, -78, -72, -32, 54, 44,
                 -46, -90, -89, -53, 85, 86, -90, 10, 20, 92, 80, -68, -32, 57, -37, -35, -9, -71,
                 -86, -69, 57, 73, -24, 22, -94, 77, 17, -18, -3, 30, -95
               },
               new int[] {
                 44, -24, -32, 92, -61, 99, -8, 27, 47, 38, 54, -4, -38, 32, -28, 79, 24, -45, -78,
                 -99, 17, -51, -100, -70, 52, -25, -59, 87, -73, -56, -87, 90, 78, 14, 49, -55, 39,
                 -14, -83, -57, 70, -42, -1, 33, -7, -84, 60, -29, -27, -35
               },
               33));
   ExampleRunner.eq(
       48,
       28,
       new Mosquitoes()
           .getMaximum(
               new int[] {
                 83, 99, -33, -35, -68, -51, 72, 30, 60, -97, 48, 3, 46, 100, -18, -80, -24, -1,
                 -44, -75, -15, 75, 16, -25, -87, -81, -25, -78, -68, -79, -43, 64, -92, -93, -43,
                 -62, 37, -84, 41, 56, 92, -79, -13, 34, 93, 35, -90, -34, -89, -3
               },
               new int[] {
                 13, -27, 84, 17, 57, 98, -48, -71, -53, 63, 51, -40, 85, 11, -57, -87, 45, -82,
                 -2, -8, -63, -33, 5, 2, -42, -21, 27, 74, -59, -49, 4, 71, -12, 29, 75, 59, -36,
                 -13, -92, 76, 28, 65, -46, -100, -14, 100, 25, 50, 9, -9
               },
               37));
   ExampleRunner.eq(
       49,
       39,
       new Mosquitoes()
           .getMaximum(
               new int[] {
                 -4, 39, 78, 23, 98, 51, 60, 89, -72, -77, -48, -86, -44, -88, 38, 69, 16, -2, -97,
                 45, -43, 45, -63, -92, -82, 48, -32, -1, -96, 41, 74, 37, -50, -37, -85, -39, 9,
                 -89, 3, 89, -76, -23, -20, 43, -84, -12, 28, -67, -57, 83
               },
               new int[] {
                 29, -20, 89, -23, -43, 83, -42, -60, -93, 27, 4, -99, -66, 41, -7, -58, 100, -44,
                 69, 96, 2, 80, 77, 22, 45, 68, 85, 91, -8, 36, -4, -3, -2, -16, -79, 33, 11, -25,
                 -52, 28, 60, 42, -50, -51, -41, 18, -71, 14, -9, 59
               },
               70));
   ExampleRunner.eq(
       50,
       46,
       new Mosquitoes()
           .getMaximum(
               new int[] {
                 -93, -57, 42, 11, -39, 66, 10, -88, -57, 21, -9, -80, -98, 52, -54, -88, -41, 59,
                 -34, -69, 32, -11, -53, -39, -41, 9, 68, 94, 8, 72, -70, -20, 71, 86, -23, 36,
                 -11, 23, 2, 59, 45, 21, -35, -13, -22, 15, -42, 17, 8, -40
               },
               new int[] {
                 -12, 78, 42, -57, 73, -72, 6, 31, 75, 21, -70, -80, 51, 0, 18, 96, 50, 59, 36, 27,
                 58, 52, 32, 67, -21, -65, 47, -63, -76, 72, -44, 48, -8, 93, 41, -59, -24, -86,
                 -23, 64, 99, 40, 76, -5, -38, -16, -55, -31, -53, 34
               },
               80));
   ExampleRunner.eq(
       51,
       46,
       new Mosquitoes()
           .getMaximum(
               new int[] {
                 -3, 39, -34, -83, 67, 41, -97, 56, 67, -94, -90, -10, 100, 2, 3, -95, 61, -95, 65,
                 66, 21, -28, -62, 99, -10, -35, 98, -86, 46, -11, 62, 28, 57, 99, 25, 0, -24, -79,
                 70, -89, -36, -71, -86, 7, 67, -52, 80, -69, -4, -58
               },
               new int[] {
                 -36, 54, 69, -78, 27, 83, 43, 63, -77, -65, 92, -73, 49, 23, -47, 85, -35, 94,
                 -71, 56, 34, 41, -23, -66, -22, -44, 21, -26, 2, -99, 100, -79, -46, -20, -19, 70,
                 22, 53, -16, -96, -30, 40, -89, -6, 58, 36, -7, -32, 87, -11
               },
               90));
   ExampleRunner.eq(
       52,
       50,
       new Mosquitoes()
           .getMaximum(
               new int[] {
                 76, -85, 23, -81, 89, 35, 40, 38, 94, -31, -60, 59, -21, 86, 26, -73, -93, -65,
                 -60, 60, -1, -92, 14, 68, 55, -46, 36, -83, -75, 2, -20, -53, 79, -25, -38, -10,
                 37, 73, 90, 29, 29, 13, 59, 52, 11, 55, 92, 27, 94, 52
               },
               new int[] {
                 14, -65, -1, 56, 12, 30, 43, 21, 16, 79, -85, -86, -50, -90, 81, -16, 69, -23,
                 -38, -61, -14, 36, 52, 58, 74, -36, -32, 25, -96, -77, 63, 40, -25, -95, -97, -64,
                 -69, -46, 89, -9, 29, 95, 61, 51, 39, -83, 15, -15, 45, 5
               },
               100));
   ExampleRunner.eq(
       53,
       4,
       new Mosquitoes().getMaximum(new int[] {-70, 79, 0, -12}, new int[] {90, -99, 0, 18}, 1));
   ExampleRunner.eq(
       54,
       6,
       new Mosquitoes()
           .getMaximum(
               new int[] {0, 43, -47, -13, 59, -6}, new int[] {1, -45, 55, 15, -65, 9}, 1));
   ExampleRunner.eq(
       55,
       8,
       new Mosquitoes()
           .getMaximum(
               new int[] {18, -1, -9, 15, 10, -55, 27, -5},
               new int[] {-31, -7, 0, -28, -20, 56, -42, -4},
               1));
   ExampleRunner.eq(
       56,
       4,
       new Mosquitoes().getMaximum(new int[] {-16, -24, -9, -13}, new int[] {0, 40, -60, -20}, 1));
   ExampleRunner.eq(
       57,
       24,
       new Mosquitoes()
           .getMaximum(
               new int[] {
                 -2, 9, 7, 5, -2, 1, -12, -18, -3, 14, -4, 1, -15, 13, -6, 14, 12, -2, 5, 15, -5,
                 16, -13, 1
               },
               new int[] {
                 7, -51, -30, -54, -12, -22, 48, 94, 30, -96, 25, -9, 85, -68, 43, -77, -81, 15,
                 -38, -92, 18, -84, 75, 3
               },
               3));
   ExampleRunner.eq(
       58,
       44,
       new Mosquitoes()
           .getMaximum(
               new int[] {
                 -22, 63, 15, -49, -2, -66, 36, -12, -14, -14, 5, -53, 40, 60, 13, -53, -22, -76,
                 27, 40, 8, -32, -52, 68, -46, -78, -42, 12, -61, 24, 59, -64, 5, -21, -76, -31,
                 -76, 26, -9, -67, -13, -34, 60, 9
               },
               new int[] {
                 27, -88, -19, 66, 1, 82, -41, 8, 20, 23, -14, 69, -59, -75, -18, 68, 25, 94, -31,
                 -47, -11, 46, 70, -84, 56, 96, 57, -17, 71, -26, -83, 87, -10, 24, 93, 45, 95,
                 -33, 4, 80, 13, 49, -72, -16
               },
               5));
   ExampleRunner.eq(
       59,
       5,
       new Mosquitoes()
           .getMaximum(new int[] {-8, -32, 46, -53, 58}, new int[] {22, 55, -88, 98, -99}, 3));
   ExampleRunner.eq(
       60,
       15,
       new Mosquitoes()
           .getMaximum(
               new int[] {-58, -69, -48, -12, -79, -98, -39, 53, -2, 88, 96, 30, 59, 84, -100},
               new int[] {30, 39, 34, 6, 45, 58, 22, -36, -3, -46, -52, -22, -38, -53, 54},
               9));
   ExampleRunner.eq(
       61,
       25,
       new Mosquitoes()
           .getMaximum(
               new int[] {
                 1, 23, 33, 7, -28, -3, -65, 87, 46, 65, 59, 10, -30, -21, -48, -33, 41, -78, -52,
                 -72, -38, -6, -24, 18, 85
               },
               new int[] {
                 11, -29, -42, -4, 27, -12, 63, -76, -54, -62, -49, 4, 20, 38, 36, 52, -36, 100,
                 62, 89, 45, 21, 16, -7, -95
               },
               15));
   ExampleRunner.eq(
       62,
       5,
       new Mosquitoes()
           .getMaximum(new int[] {-4, -64, 46, -41, -92}, new int[] {0, 51, -34, 29, 68}, 3));
   ExampleRunner.eq(
       63,
       15,
       new Mosquitoes()
           .getMaximum(
               new int[] {-35, 5, -39, 90, 58, -76, -26, 67, 35, -44, 11, 21, 31, -55, 0},
               new int[] {21, -4, 17, -48, -25, 35, 13, -30, -20, 24, -10, -13, -19, 26, 5},
               9));
   ExampleRunner.eq(
       64,
       25,
       new Mosquitoes()
           .getMaximum(
               new int[] {
                 -3, -13, -27, 23, -17, -26, 98, -55, -93, -100, 6, -71, 83, 23, -74, 51, -65, 20,
                 -77, 98, 55, 17, 91, -30, 11
               },
               new int[] {
                 9, 14, 19, -16, 5, 7, -41, 22, 40, 53, -8, 35, -30, -4, 39, -17, 24, -1, 32, -40,
                 -28, -5, -44, 11, 3
               },
               15));
   ExampleRunner.eq(
       65,
       5,
       new Mosquitoes()
           .getMaximum(new int[] {-20, 49, -10, -94, 81}, new int[] {4, -7, 3, 15, -11}, 3));
   ExampleRunner.eq(
       66,
       9,
       new Mosquitoes()
           .getMaximum(
               new int[] {63, -91, 77, -32, -89, 23, 84, 71, 54},
               new int[] {-9, 19, -11, 5, 14, -6, -15, -12, -7},
               13));
   ExampleRunner.eq(
       67,
       13,
       new Mosquitoes()
           .getMaximum(
               new int[] {73, -30, -13, 57, -87, 76, -72, 74, -1, -100, 7, -98, 28},
               new int[] {-10, 0, -2, -14, 10, -12, 14, -11, -5, 15, -3, 20, -6},
               23));
   ExampleRunner.eq(
       68,
       4,
       new Mosquitoes()
           .getMaximum(
               new int[] {-19, 83, 26, 96, -46, -76}, new int[] {1, -1, 0, -76, -31, 2}, 3));
   ExampleRunner.eq(
       69,
       4,
       new Mosquitoes().getMaximum(new int[] {-47, 61, -75, 21}, new int[] {1, -2, 2, -1}, 3));
   ExampleRunner.eq(
       70,
       4,
       new Mosquitoes()
           .getMaximum(
               new int[] {-32, 38, -17, 24, -66, 74, 48, 11},
               new int[] {-20, -56, 19, 33, 94, -26, -31, -11},
               3));
   ExampleRunner.eq(
       71,
       8,
       new Mosquitoes()
           .getMaximum(
               new int[] {52, 90, -10, 26, -2, 85, -50, -26, -35, 49, -60, -98, -40, -77, 100},
               new int[] {-56, -81, 10, -23, 73, -73, 39, 24, 33, -39, 68, 20, 62, -11, -48},
               4));
   ExampleRunner.eq(
       72,
       12,
       new Mosquitoes()
           .getMaximum(
               new int[] {
                 17, 91, 13, 3, 86, 20, 0, -1, 21, 15, 52, 90, -18, 6, -12, 98, -41, 10, 14, 16,
                 -18, -26
               },
               new int[] {
                 -45, -20, 20, 46, -86, -15, 81, 92, -57, 11, 27, 36, 49, 15, 82, 5, -99, 45, 30,
                 -60, 85, 56
               },
               5));
   ExampleRunner.eq(
       73,
       16,
       new Mosquitoes()
           .getMaximum(
               new int[] {
                 -38, -5, 46, -92, -91, -52, -30, -38, -28, 32, 17, -40, 30, 0, 31, -15, -41, -56,
                 -95, -16, -18, -1, 37, 99, 16, 5, -12, 18, 25
               },
               new int[] {
                 22, 0, -2, 24, -27, -44, 90, 87, 3, -64, -46, 96, -77, -3, 2, 38, 82, 7, -41, -47,
                 55, 13, -66, 89, -28, -12, 37, -32, 9
               },
               6));
   ExampleRunner.eq(
       74,
       4,
       new Mosquitoes()
           .getMaximum(
               new int[] {-16, -7, -43, -99, -40, -62, 66},
               new int[] {62, 0, -76, 6, -88, 3, -3},
               9));
   ExampleRunner.eq(
       75,
       4,
       new Mosquitoes()
           .getMaximum(
               new int[] {3, 34, 80, 91, -89, 79, -59, -3},
               new int[] {12, -91, 68, 34, 5, -4, 2, -1},
               13));
   ExampleRunner.eq(
       76,
       4,
       new Mosquitoes()
           .getMaximum(
               new int[] {43, 54, -67, -11, 79, -89, -50, -4, -89},
               new int[] {32, -98, 3, 0, -3, 6, 82, -75, -78},
               17));
   ExampleRunner.eq(
       77,
       5,
       new Mosquitoes()
           .getMaximum(
               new int[] {47, 15, -30, -55, 66, 6, 94, -92, -15, 51},
               new int[] {23, -1, 0, -38, -2, 61, 85, -74, 1, -3},
               21));
   ExampleRunner.eq(
       78,
       10,
       new Mosquitoes()
           .getMaximum(
               new int[] {58, -60, 77, 3, 73, 37, -83, -23, -54, 95, -49, 98, 85},
               new int[] {-70, 10, -13, -3, -12, -52, 15, 4, 9, -18, 6, -17, -49},
               9));
   ExampleRunner.eq(
       79,
       12,
       new Mosquitoes()
           .getMaximum(
               new int[] {-61, 9, 91, -80, -76, -10, 53, -11, 67, 6, 71, -86, 47, 100, -3},
               new int[] {11, 2, -19, 15, 63, 5, -7, 19, -15, -1, -16, 59, -6, -18, 1},
               13));
   ExampleRunner.eq(
       80,
       14,
       new Mosquitoes()
           .getMaximum(
               new int[] {
                 -59, 94, 82, -12, 0, -62, 98, -58, -6, -26, -48, -98, 95, 26, -34, 48, -19
               },
               new int[] {5, -88, -7, 2, -2, 8, -12, 7, 1, 4, 3, 11, -9, -4, -30, -53, 0},
               17));
   ExampleRunner.eq(
       81,
       17,
       new Mosquitoes()
           .getMaximum(
               new int[] {
                 -69, -9, 92, 49, 74, 73, 59, -19, 4, -36, 49, -65, -98, -80, -65, -22, -78, 87, 29
               },
               new int[] {
                 15, 4, -13, -8, -15, 64, -9, 1, -5, 8, -6, -36, 13, 14, 7, 6, 10, -19, -7
               },
               21));
   ExampleRunner.eq(
       82,
       20,
       new Mosquitoes()
           .getMaximum(
               new int[] {
                 3, -11, -1, -74, 36, 95, 62, -71, -34, -45, -13, 16, -32, 85, 5, 98, 46, -78, 38,
                 -56, -79, 70, -99, 17, 61, -62, 33, -44, -28, -32, 14, 69, -81, -63, 73, -66, -58,
                 4, -60, -93, 3, 85, -94, -20, -47, 75, 19, -57, -76, -81
               },
               new int[] {
                 -51, 3, -2, -54, -29, -75, -49, 60, 27, -48, 9, -16, 80, 45, -6, -82, -58, 18,
                 -36, 42, 7, 91, 89, 34, -18, 53, -27, 87, 28, 39, 95, 56, 66, 20, -65, -14, 48,
                 38, -81, 81, -74, 8, -38, 90, 40, 11, -98, 49, -80, 88
               },
               5));
   ExampleRunner.eq(
       83,
       23,
       new Mosquitoes()
           .getMaximum(
               new int[] {
                 19, 83, 64, -61, 13, 6, 81, 7, 34, -9, 35, 30, 80, 72, -22, 57, 30, 60, 46, 46,
                 60, 12, -81, 84, 43, -14, -38, 26, 34, -59, 20, -86, 46, 74, -73, 31, -77, -45,
                 -58, 92, 19, 20, 46, 15, 83, 9, -32, -4, 40, -71
               },
               new int[] {
                 -20, -66, -91, 55, -11, 40, 73, -18, -37, -29, -51, 29, -95, -42, 15, 74, -28, 7,
                 -54, -71, -45, -69, 94, 8, -65, 20, 58, -49, -19, -78, 9, 91, -53, -94, -55, 86,
                 96, 6, 66, -81, -80, -90, -63, -17, 37, 79, 43, 87, 2, 80
               },
               9));
   ExampleRunner.eq(
       84,
       25,
       new Mosquitoes()
           .getMaximum(
               new int[] {
                 -91, -67, -46, 55, -8, -93, 37, 77, 18, -18, 7, -28, -77, -22, 33, 78, -38, 41,
                 -31, 55, 48, 95, 33, 25, 1, 26, 53, -66, -65, 5, -20, 66, 16, 9, -65, -98, 63, -1,
                 -80, 81, -27, -16, -30, 28, 61, 20, -22, 80, -10, 21
               },
               new int[] {
                 -90, 44, 83, -49, 58, 72, 63, -27, 86, 5, 9, 32, 66, -99, -97, 46, -70, 39, -8,
                 -63, 26, 54, 97, -32, 3, -30, -35, -20, 61, 6, -31, -46, -11, -17, 43, 78, -66,
                 -2, -7, -68, 18, 7, 31, -13, -50, -25, 80, -10, -83, 12
               },
               13));
   ExampleRunner.eq(
       85,
       29,
       new Mosquitoes()
           .getMaximum(
               new int[] {
                 -58, -58, -39, 5, -99, -21, 53, -52, 63, 91, 46, 75, 14, -15, 23, 36, -7, 77, -37,
                 -43, 64, -55, -59, 55, -61, -1, 18, 36, 11, -53, -28, 6, -51, -68, 68, -25, -99,
                 89, 19, -82, 73, -16, 6, 72, 39, 40, 88, -67, -48, -32
               },
               new int[] {
                 12, 59, -33, -1, 74, 16, 88, -91, -63, -86, -27, 39, -22, 11, -13, -72, 9, -36,
                 -79, 20, -23, 18, 42, -46, 70, 47, -2, 15, 1, 45, 22, 31, 60, -9, -47, 13, 67,
                 -58, -28, 53, -71, 4, -19, -48, 92, -11, 77, 79, 34, -59
               },
               17));
   ExampleRunner.eq(
       86,
       26,
       new Mosquitoes()
           .getMaximum(
               new int[] {
                 -5, -32, 57, 75, -63, 81, 18, -75, 12, 28, 43, -55, -5, 40, 62, -79, 68, 84, 64,
                 80, -97, -51, -11, 76, -40, 41, -50, -99, 32, -32, -50, 94, 69, 65, 26, 79, -64,
                 -27, 44, 55, -64, 71, 10, 1, -5, -59, 36, -40, -88, 47
               },
               new int[] {
                 4, -55, -42, -59, 46, -20, -18, 55, -8, -36, 91, -33, 1, -31, -48, 61, 47, -63,
                 -98, -91, 66, 50, 5, -6, 30, 84, 36, 72, -24, 79, 39, -64, -51, -79, -23, 73, 24,
                 27, 71, 3, 49, -56, -86, -3, 2, 43, -28, -30, 7, -35
               },
               3));
   ExampleRunner.eq(
       87,
       26,
       new Mosquitoes()
           .getMaximum(
               new int[] {
                 -28, -17, 45, -63, 76, 44, 97, 1, -1, 36, 36, -81, 84, -67, 26, 41, 37, 36, 1,
                 -54, 71, 28, 7, 12, 74, 15, -26, -64, 18, -65, 64, 89, 48, 36, 2, 43, -85, -17,
                 74, 29, 94, -26, -78, -48, 12, -14, 93, -87, -62, -48
               },
               new int[] {
                 44, 15, 26, 36, -57, -25, -16, 9, -2, -20, -23, 89, 1, 38, -14, -34, 45, -22, -4,
                 11, 86, -58, 0, -12, -49, 84, -78, 39, -13, -67, -36, -54, -28, -77, -59, -31, 50,
                 7, -45, -9, -39, 12, -47, 74, 68, 6, -56, 59, -7, -70
               },
               7));
   ExampleRunner.eq(
       88,
       27,
       new Mosquitoes()
           .getMaximum(
               new int[] {
                 10, -15, -57, -67, -66, -69, 43, 13, -32, 0, -79, -80, 22, 76, 47, -89, 34, -43,
                 100, 26, -80, 44, -73, -88, 19, 7, 39, -27, -20, -30, 89, -76, -87, -20, 38, 68,
                 -86, -10, -8, -56, 50, 5, 100, -73, -48, 75, 15, -30, 96, -28
               },
               new int[] {
                 -10, 81, 34, -36, 42, -18, -31, -9, 27, -1, -77, 56, -12, 55, -32, -95, -27, -66,
                 -54, -15, 18, -33, 46, -61, -21, -2, 97, 12, 14, 25, -70, 43, 17, 15, 89, -39, 52,
                 0, 83, -41, -28, -26, 96, -44, -81, 60, 66, 13, -57, -84
               },
               11));
   ExampleRunner.eq(
       89,
       32,
       new Mosquitoes()
           .getMaximum(
               new int[] {
                 -51, 46, 42, 36, -21, -79, 55, -80, -11, 23, -8, 84, -84, -60, 46, -88, -54, 16,
                 81, 23, 2, 48, 25, 64, 65, 74, 25, 68, -71, -12, -60, 82, 50, 9, -18, 81, 44, -8,
                 17, -75, -68, -63, -24, -19, 40, -4, 21, 27, -42, 65
               },
               new int[] {
                 -85, -40, -46, 80, -7, 66, -48, 57, 12, -23, 11, -69, 73, 65, -38, 70, 28, -51,
                 -78, -25, -88, -47, -31, 77, -66, 30, 0, 81, 9, 20, 49, -90, -55, -75, 78, -63,
                 -26, 19, -18, 86, 72, 67, 32, -53, -33, 21, -11, 10, 54, -27
               },
               15));
   ExampleRunner.eq(
       90,
       30,
       new Mosquitoes()
           .getMaximum(
               new int[] {
                 86, 6, 42, 29, 34, 98, -42, -21, -6, -25, -39, -5, 38, -52, 40, 24, 61, -52, -72,
                 -14, -51, 45, -86, -50, 3, -40, 26, -78, -23, 30, -54, -8, -93, 15, 91, -6, 30,
                 25, 45, 38, -64, 4, 77, -13, -89, 59, 45, 59, 15, 44
               },
               new int[] {
                 -93, -11, 86, -34, -95, -80, 47, -16, -72, 33, 46, 0, -46, 90, -43, -26, -63, -67,
                 82, 17, 29, -44, 98, 54, -71, -47, 2, 88, 27, -31, 58, 71, 69, -21, -97, 95, -54,
                 -32, -27, -45, 79, -5, -85, -9, -23, -66, -99, -62, -22, -52
               },
               5));
   ExampleRunner.eq(
       91,
       31,
       new Mosquitoes()
           .getMaximum(
               new int[] {
                 86, 34, -92, -48, -51, -90, -32, -19, 47, -90, 46, -84, 18, -94, -19, 81, 59, -60,
                 92, 47, 45, -99, 26, 9, -35, -71, 68, 46, -98, -39, -19, 39, 13, 50, -91, 41, 73,
                 -29, -7, -67, 91, -90, -77, 69, -34, -54, 16, 14, 31, -35
               },
               new int[] {
                 -50, -72, 57, 29, 32, 86, 20, 51, -35, 54, 38, -76, -10, -78, 16, -47, -39, 44,
                 -54, -12, -28, 97, 17, -94, -15, 53, -42, -29, 61, 62, -75, -30, -11, -36, 80,
                 -58, -44, 26, 78, 41, -53, 74, -13, -43, 21, 39, -4, -2, 92, 27
               },
               9));
   ExampleRunner.eq(
       92,
       36,
       new Mosquitoes()
           .getMaximum(
               new int[] {
                 -83, 65, 5, -63, -18, 19, -45, -17, -100, -32, -92, 7, 38, -30, 47, 50, -79, 75,
                 99, -65, 99, -6, 2, -31, 48, 42, -90, 22, -64, 61, -25, -87, 59, -23, 56, -42, 12,
                 32, 85, -69, -63, 10, 98, -14, 1, -87, -23, 69, -64, 49
               },
               new int[] {
                 82, -62, 6, 55, -3, 30, 32, 19, -81, 17, 71, -14, -27, 59, -43, -50, 61, -68, 99,
                 47, -87, 11, -6, 28, -29, -69, -91, -12, 65, -60, -98, 86, -51, 26, -36, 40, -94,
                 -30, -67, 58, -74, 2, 92, 7, -4, 83, -38, 63, 78, -52
               },
               13));
   ExampleRunner.eq(
       93,
       35,
       new Mosquitoes()
           .getMaximum(
               new int[] {
                 -44, 25, 44, 37, 42, -86, 60, 37, -68, -84, 63, 10, 47, 21, 58, -16, -30, 54, -36,
                 -2, -29, 90, -42, 92, -49, 17, 26, 11, 64, -49, 57, -20, 36, 39, -58, -82, -7,
                 -88, 19, -62, -41, -18, 16, 9, -37, -22, 5, -8, 45, -20
               },
               new int[] {
                 33, -20, 25, -42, -27, 95, -99, -68, -43, 73, -70, -65, 43, -44, -82, 13, 99, -73,
                 66, -54, 26, -100, -50, -34, 100, -33, -38, 16, -95, 76, -79, 12, -40, -35, 55,
                 82, 9, 91, -5, 92, -7, 23, 0, -13, 53, 56, -86, 6, -60, 40
               },
               17));
   ExampleRunner.eq(
       94,
       4,
       new Mosquitoes()
           .getMaximum(new int[] {0, -1, 10, -11, 99, -99}, new int[] {1, -1, -3, 3, 47, -47}, 3));
   ExampleRunner.eq(95, 1, new Mosquitoes().getMaximum(new int[] {5}, new int[] {2}, 8));
   ExampleRunner.eq(96, 1, new Mosquitoes().getMaximum(new int[] {100}, new int[] {1}, 3));
   ExampleRunner.eq(
       97,
       40,
       new Mosquitoes()
           .getMaximum(
               new int[] {
                 41, -72, -80, -65, -96, 49, 51, 63, -66, -80, -71, 64, -90, -49, 23, -94, -25,
                 -51, 13, -67, 19, 12, -99, 92, -74, -95, 39, 39, 37, -57, 95, -71, -86, -51, -74,
                 75, 33, -29, 58, -52, 35, -46, -71, -17, -94, 77, 83, -83, -59, 2
               },
               new int[] {
                 86, -94, -80, -39, -60, 72, -58, 8, 12, -47, -49, -71, 34, -21, -92, -74, -28,
                 100, 29, 4, 79, 98, -91, -82, -59, -34, -51, 92, 77, 38, 51, 35, 22, -67, -90, 78,
                 -100, 53, -57, -32, 48, 31, 69, -88, -68, 97, -56, 73, -63, 87
               },
               71));
   ExampleRunner.eq(
       98,
       4,
       new Mosquitoes().getMaximum(new int[] {-100, -33, 33, 100}, new int[] {3, 1, -1, -3}, 1));
   ExampleRunner.eq(
       99,
       3,
       new Mosquitoes()
           .getMaximum(new int[] {12, 34, 56, 78, 90}, new int[] {-1, 2, -3, 4, -5}, 6));
   ExampleRunner.eq(
       100,
       50,
       new Mosquitoes()
           .getMaximum(
               new int[] {
                 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
                 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0
               },
               new int[] {
                 -100, -96, -92, -88, -84, -80, -76, -72, -68, -64, -60, -56, -52, -48, -44, -40,
                 -36, -32, -28, -24, -20, -16, -12, -8, -4, 0, 4, 8, 12, 16, 20, 24, 28, 32, 36,
                 40, 44, 48, 52, 56, 60, 64, 68, 72, 76, 80, 84, 88, 92, 96
               },
               100));
   ExampleRunner.eq(
       101, 2, new Mosquitoes().getMaximum(new int[] {0, -10}, new int[] {0, 100}, 1));
   ExampleRunner.eq(
       102, 2, new Mosquitoes().getMaximum(new int[] {1, -2}, new int[] {-100, 100}, 1));
   ExampleRunner.eq(
       103, 2, new Mosquitoes().getMaximum(new int[] {100, -100}, new int[] {0, 1}, 10));
   ExampleRunner.eq(
       104, 2, new Mosquitoes().getMaximum(new int[] {-10, 0}, new int[] {100, 0}, 1));
   ExampleRunner.eq(
       105,
       2,
       new Mosquitoes()
           .getMaximum(new int[] {1, -30, -60, 100, 90}, new int[] {-1, 2, -3, 4, -5}, 1));
   ExampleRunner.eq(
       106, 2, new Mosquitoes().getMaximum(new int[] {-100, 100}, new int[] {100, 99}, 1));
   ExampleRunner.eq(
       107, 3, new Mosquitoes().getMaximum(new int[] {0, 1, -1}, new int[] {0, -1, 1}, 10));
   ExampleRunner.eq(108, 2, new Mosquitoes().getMaximum(new int[] {0, 6}, new int[] {70, -70}, 1));
   ExampleRunner.eq(
       109,
       15,
       new Mosquitoes()
           .getMaximum(
               new int[] {
                 100, 100, -100, -100, 44, 55, 66, 77, -22, -33, -55, -66, -77, -11, -12, -34, -56,
                 -45, -23, 12, 45, 67, 89, 45, 34, 78, 54, 34, 88, 65, 45, -45, -45, -87
               },
               new int[] {
                 1, 100, 12, 13, 14, 15, 16, 17, 18, 19, -20, -21, -22, -23, -24, -25, 26, 27, 30,
                 40, 41, 42, 80, -81, -82, 82, -83, 60, 61, 62, -62, -63, -64, 65
               },
               30));
   ExampleRunner.eq(
       110, 2, new Mosquitoes().getMaximum(new int[] {100, 95}, new int[] {-100, -1}, 1));
   ExampleRunner.eq(
       111,
       5,
       new Mosquitoes()
           .getMaximum(new int[] {2, 0, 86, 12, 16, -32}, new int[] {1, 2, -40, -1, -2, 10}, 1));
   ExampleRunner.eq(
       112,
       17,
       new Mosquitoes()
           .getMaximum(
               new int[] {
                 60, 53, 63, 39, 7, 80, 86, 57, 31, 3, 66, 40, 31, 3, 57, 78, 53, 0, 23, 73, 71,
                 53, 25, 36, 37, 54, 47, 80, 71, 27, 71, 85, 73, 41, 97, 29, 85, 33, 83, 56, 60,
                 13, 27, 27, 20
               },
               new int[] {
                 41, 1, 36, 45, 2, 42, 3, 8, 40, 6, 25, 16, 26, 19, 48, 14, 30, 24, 10, 23, 7, 17,
                 21, 37, 18, 0, 32, 5, 4, 22, 12, 31, 35, 29, 44, 9, 46, 38, 39, 13, 47, 34, 28,
                 11, 27
               },
               12));
   ExampleRunner.eq(113, 2, new Mosquitoes().getMaximum(new int[] {-2, 2}, new int[] {-2, 2}, 3));
   ExampleRunner.eq(
       114, 3, new Mosquitoes().getMaximum(new int[] {-2, 0, 2}, new int[] {100, 0, -100}, 1));
   ExampleRunner.eq(
       115,
       7,
       new Mosquitoes()
           .getMaximum(
               new int[] {
                 1, -1, 1, 2, 3, 4, 5, 6, 7, 8, 9, 0, -9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19,
                 20, 21, 22, 23, 24, 25, 26, 27, 28, 29, 30, 31, 32, 33, 35, 36, 37, 38, 40, 41,
                 43, 45, 56, 78, 99, 100, -23
               },
               new int[] {
                 1, 2, 3, 4, -1, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, 21, 22,
                 23, 24, 25, 26, 27, 28, 29, 30, 31, 32, 33, 34, 45, 46, 47, 48, 49, 50, 52, 53,
                 54, 56, 57, 58, 59, 90, 92
               },
               2));
   ExampleRunner.eq(
       116,
       7,
       new Mosquitoes()
           .getMaximum(
               new int[] {
                 0, -1, 10, -11, 99, -99, 39, 1, -2, 11, -12, 98, -98, 38, 4, -3, 13, -16, 92, -93,
                 34, 6, -4, 15, -21, 95, -96, 37
               },
               new int[] {
                 1, -1, -3, 3, 47, -47, -80, 12, -12, -32, 32, 42, -42, -81, 13, -13, -33, 0, 15,
                 -52, -21, 2, 4, -2, -4, 6, -6, 8
               },
               3));
 }
 public static void main(String[] args) {
   ExampleRunner.eq(1, 2L, new MagicDiamonds().minimalTransfer(2L));
   ExampleRunner.eq(2, 1L, new MagicDiamonds().minimalTransfer(4294967297L));
   ExampleRunner.eq(3, 2L, new MagicDiamonds().minimalTransfer(2147483647L));
   ExampleRunner.eq(4, 1L, new MagicDiamonds().minimalTransfer(1L));
   ExampleRunner.eq(5, 1L, new MagicDiamonds().minimalTransfer(8566L));
   ExampleRunner.eq(6, 1L, new MagicDiamonds().minimalTransfer(6308L));
   ExampleRunner.eq(7, 1L, new MagicDiamonds().minimalTransfer(4081L));
   ExampleRunner.eq(8, 1L, new MagicDiamonds().minimalTransfer(5680L));
   ExampleRunner.eq(9, 1L, new MagicDiamonds().minimalTransfer(4427L));
   ExampleRunner.eq(10, 1L, new MagicDiamonds().minimalTransfer(2739L));
   ExampleRunner.eq(11, 1L, new MagicDiamonds().minimalTransfer(6181L));
   ExampleRunner.eq(12, 1L, new MagicDiamonds().minimalTransfer(6274L));
   ExampleRunner.eq(13, 1L, new MagicDiamonds().minimalTransfer(3601L));
   ExampleRunner.eq(14, 1L, new MagicDiamonds().minimalTransfer(7506L));
   ExampleRunner.eq(15, 2L, new MagicDiamonds().minimalTransfer(8951L));
   ExampleRunner.eq(16, 1L, new MagicDiamonds().minimalTransfer(5345L));
   ExampleRunner.eq(17, 1L, new MagicDiamonds().minimalTransfer(9621L));
   ExampleRunner.eq(18, 1L, new MagicDiamonds().minimalTransfer(9300L));
   ExampleRunner.eq(19, 2L, new MagicDiamonds().minimalTransfer(23L));
   ExampleRunner.eq(20, 1L, new MagicDiamonds().minimalTransfer(720L));
   ExampleRunner.eq(21, 1L, new MagicDiamonds().minimalTransfer(2151L));
   ExampleRunner.eq(22, 1L, new MagicDiamonds().minimalTransfer(7854L));
   ExampleRunner.eq(23, 2L, new MagicDiamonds().minimalTransfer(3607L));
   ExampleRunner.eq(24, 1L, new MagicDiamonds().minimalTransfer(1881L));
   ExampleRunner.eq(25, 1L, new MagicDiamonds().minimalTransfer(6076L));
   ExampleRunner.eq(26, 1L, new MagicDiamonds().minimalTransfer(9369L));
   ExampleRunner.eq(27, 2L, new MagicDiamonds().minimalTransfer(3853L));
   ExampleRunner.eq(28, 1L, new MagicDiamonds().minimalTransfer(8229L));
   ExampleRunner.eq(29, 1L, new MagicDiamonds().minimalTransfer(205L));
   ExampleRunner.eq(30, 1L, new MagicDiamonds().minimalTransfer(980L));
   ExampleRunner.eq(31, 1L, new MagicDiamonds().minimalTransfer(4197L));
   ExampleRunner.eq(32, 1L, new MagicDiamonds().minimalTransfer(1460L));
   ExampleRunner.eq(33, 2L, new MagicDiamonds().minimalTransfer(320020303L));
   ExampleRunner.eq(34, 1L, new MagicDiamonds().minimalTransfer(1021932001L));
   ExampleRunner.eq(35, 1L, new MagicDiamonds().minimalTransfer(1804873438L));
   ExampleRunner.eq(36, 1L, new MagicDiamonds().minimalTransfer(625102087L));
   ExampleRunner.eq(37, 1L, new MagicDiamonds().minimalTransfer(298989654L));
   ExampleRunner.eq(38, 1L, new MagicDiamonds().minimalTransfer(713692516L));
   ExampleRunner.eq(39, 1L, new MagicDiamonds().minimalTransfer(2019257625L));
   ExampleRunner.eq(40, 1L, new MagicDiamonds().minimalTransfer(1567124116L));
   ExampleRunner.eq(41, 1L, new MagicDiamonds().minimalTransfer(196044214L));
   ExampleRunner.eq(42, 1L, new MagicDiamonds().minimalTransfer(436143805L));
   ExampleRunner.eq(43, 1L, new MagicDiamonds().minimalTransfer(1906602942L));
   ExampleRunner.eq(44, 1L, new MagicDiamonds().minimalTransfer(1651588877L));
   ExampleRunner.eq(45, 1L, new MagicDiamonds().minimalTransfer(1477002708L));
   ExampleRunner.eq(46, 1L, new MagicDiamonds().minimalTransfer(1117874276L));
   ExampleRunner.eq(47, 1L, new MagicDiamonds().minimalTransfer(378147332L));
   ExampleRunner.eq(48, 1L, new MagicDiamonds().minimalTransfer(557741133L));
   ExampleRunner.eq(49, 1L, new MagicDiamonds().minimalTransfer(668154454L));
   ExampleRunner.eq(50, 1L, new MagicDiamonds().minimalTransfer(570251827L));
   ExampleRunner.eq(51, 1L, new MagicDiamonds().minimalTransfer(1039736738L));
   ExampleRunner.eq(52, 1L, new MagicDiamonds().minimalTransfer(2099585234L));
   ExampleRunner.eq(53, 1L, new MagicDiamonds().minimalTransfer(1981093541L));
   ExampleRunner.eq(54, 1L, new MagicDiamonds().minimalTransfer(1884363755L));
   ExampleRunner.eq(55, 1L, new MagicDiamonds().minimalTransfer(1865560917L));
   ExampleRunner.eq(56, 1L, new MagicDiamonds().minimalTransfer(745615932L));
   ExampleRunner.eq(57, 1L, new MagicDiamonds().minimalTransfer(1214865010L));
   ExampleRunner.eq(58, 1L, new MagicDiamonds().minimalTransfer(1695760303L));
   ExampleRunner.eq(59, 1L, new MagicDiamonds().minimalTransfer(1246390622L));
   ExampleRunner.eq(60, 1L, new MagicDiamonds().minimalTransfer(1692493778L));
   ExampleRunner.eq(61, 1L, new MagicDiamonds().minimalTransfer(1065227310L));
   ExampleRunner.eq(62, 1L, new MagicDiamonds().minimalTransfer(1265265799L));
   ExampleRunner.eq(63, 1L, new MagicDiamonds().minimalTransfer(1084963329L));
   ExampleRunner.eq(64, 1L, new MagicDiamonds().minimalTransfer(1478843645L));
   ExampleRunner.eq(65, 1L, new MagicDiamonds().minimalTransfer(2006456208L));
   ExampleRunner.eq(66, 1L, new MagicDiamonds().minimalTransfer(1722953950L));
   ExampleRunner.eq(67, 1L, new MagicDiamonds().minimalTransfer(496132103L));
   ExampleRunner.eq(68, 1L, new MagicDiamonds().minimalTransfer(6562762L));
   ExampleRunner.eq(69, 1L, new MagicDiamonds().minimalTransfer(957223956L));
   ExampleRunner.eq(70, 1L, new MagicDiamonds().minimalTransfer(654140677L));
   ExampleRunner.eq(71, 1L, new MagicDiamonds().minimalTransfer(1586450237L));
   ExampleRunner.eq(72, 1L, new MagicDiamonds().minimalTransfer(1018720108L));
   ExampleRunner.eq(73, 1L, new MagicDiamonds().minimalTransfer(2026536822L));
   ExampleRunner.eq(74, 1L, new MagicDiamonds().minimalTransfer(764222894L));
   ExampleRunner.eq(75, 1L, new MagicDiamonds().minimalTransfer(1544043251L));
   ExampleRunner.eq(76, 1L, new MagicDiamonds().minimalTransfer(1034964664L));
   ExampleRunner.eq(77, 1L, new MagicDiamonds().minimalTransfer(684533819L));
   ExampleRunner.eq(78, 2L, new MagicDiamonds().minimalTransfer(559623793L));
   ExampleRunner.eq(79, 1L, new MagicDiamonds().minimalTransfer(1102523518L));
   ExampleRunner.eq(80, 1L, new MagicDiamonds().minimalTransfer(1103984296L));
   ExampleRunner.eq(81, 1L, new MagicDiamonds().minimalTransfer(1487426600L));
   ExampleRunner.eq(82, 1L, new MagicDiamonds().minimalTransfer(1402158154L));
   ExampleRunner.eq(83, 1L, new MagicDiamonds().minimalTransfer(1000000000000L));
   ExampleRunner.eq(84, 3L, new MagicDiamonds().minimalTransfer(3L));
   ExampleRunner.eq(85, 1L, new MagicDiamonds().minimalTransfer(1L));
   ExampleRunner.eq(86, 1L, new MagicDiamonds().minimalTransfer(4L));
   ExampleRunner.eq(87, 2L, new MagicDiamonds().minimalTransfer(5L));
   ExampleRunner.eq(88, 1L, new MagicDiamonds().minimalTransfer(6L));
   ExampleRunner.eq(89, 2L, new MagicDiamonds().minimalTransfer(7L));
   ExampleRunner.eq(90, 1L, new MagicDiamonds().minimalTransfer(8L));
   ExampleRunner.eq(91, 1L, new MagicDiamonds().minimalTransfer(9L));
   ExampleRunner.eq(92, 1L, new MagicDiamonds().minimalTransfer(10L));
   ExampleRunner.eq(93, 1L, new MagicDiamonds().minimalTransfer(1000000000000L));
   ExampleRunner.eq(94, 1L, new MagicDiamonds().minimalTransfer(999999999997L));
   ExampleRunner.eq(95, 2L, new MagicDiamonds().minimalTransfer(999999999989L));
   ExampleRunner.eq(96, 2L, new MagicDiamonds().minimalTransfer(22222223L));
   ExampleRunner.eq(97, 1L, new MagicDiamonds().minimalTransfer(524524524524L));
   ExampleRunner.eq(98, 2L, new MagicDiamonds().minimalTransfer(524524524521L));
   ExampleRunner.eq(99, 2L, new MagicDiamonds().minimalTransfer(51432121451L));
   ExampleRunner.eq(100, 1L, new MagicDiamonds().minimalTransfer(25L));
   ExampleRunner.eq(101, 2L, new MagicDiamonds().minimalTransfer(11L));
   ExampleRunner.eq(102, 2L, new MagicDiamonds().minimalTransfer(999999000001L));
   ExampleRunner.eq(103, 1L, new MagicDiamonds().minimalTransfer(66L));
   ExampleRunner.eq(104, 1L, new MagicDiamonds().minimalTransfer(16L));
   ExampleRunner.eq(105, 1L, new MagicDiamonds().minimalTransfer(49L));
   ExampleRunner.eq(106, 2L, new MagicDiamonds().minimalTransfer(100000000019L));
   ExampleRunner.eq(107, 2L, new MagicDiamonds().minimalTransfer(982451653L));
   ExampleRunner.eq(108, 2L, new MagicDiamonds().minimalTransfer(31L));
   ExampleRunner.eq(109, 1L, new MagicDiamonds().minimalTransfer(424248523252L));
   ExampleRunner.eq(110, 1L, new MagicDiamonds().minimalTransfer(27L));
   ExampleRunner.eq(111, 1L, new MagicDiamonds().minimalTransfer(999966000289L));
   ExampleRunner.eq(112, 1L, new MagicDiamonds().minimalTransfer(10010602793L));
   ExampleRunner.eq(113, 1L, new MagicDiamonds().minimalTransfer(97969L));
   ExampleRunner.eq(114, 1L, new MagicDiamonds().minimalTransfer(1000000000L));
   ExampleRunner.eq(115, 2L, new MagicDiamonds().minimalTransfer(13L));
   ExampleRunner.eq(116, 2L, new MagicDiamonds().minimalTransfer(1000000007L));
 }