03ab2ccbb3c596f4b569ea29a1708c2f35c9615f61d50e8706d35be5ad7589e2

.gitattributes

@@ -139,3 +139,6 @@ house_robber_iv/meta.json filter=lfs diff=lfs merge=lfs -text
 increment_submatrices_by_one/meta.json filter=lfs diff=lfs merge=lfs -text
 intervals_between_identical_elements/meta.json filter=lfs diff=lfs merge=lfs -text
 k_th_nearest_obstacle_queries/haskell_tests/Main.hs filter=lfs diff=lfs merge=lfs -text
+k_th_nearest_obstacle_queries/meta.json filter=lfs diff=lfs merge=lfs -text
+largest_combination_with_bitwise_and_greater_than_zero/meta.json filter=lfs diff=lfs merge=lfs -text
+largest_element_in_an_array_after_merge_operations/meta.json filter=lfs diff=lfs merge=lfs -text

k_th_nearest_obstacle_queries/java_tests/Main.java

@@ -0,0 +1,21 @@
+
+import static org.junit.jupiter.api.Assertions.*;
+import org.junit.jupiter.api.Test;
+import java.util.List;
+import java.util.Arrays;
+import java.util.ArrayList;
+public class Main {
+    //Program start
+    
+    //Program end
+
+    @Test
+public void test1() {
+    assertEquals(new ArrayList<>(Arrays.asList(-1,7,5,3)), resultsArray(new ArrayList<>(Arrays.asList(new ArrayList<>(Arrays.asList(1,2)),new ArrayList<>(Arrays.asList(3,4)),new ArrayList<>(Arrays.asList(2,3)),new ArrayList<>(Arrays.asList(-3,0)))), 2));
+}
+@Test
+public void test2() {
+    assertEquals(new ArrayList<>(Arrays.asList(10,8,6)), resultsArray(new ArrayList<>(Arrays.asList(new ArrayList<>(Arrays.asList(5,5)),new ArrayList<>(Arrays.asList(4,4)),new ArrayList<>(Arrays.asList(3,3)))), 1));
+}
+
+}

k_th_nearest_obstacle_queries/meta.json

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:422dd72288fae67c9e7b4276c59761432319db784ec24aaf79f7c1e8bb467e09
+size 27808393

keep_multiplying_found_values_by_two/haskell_tests/Main.hs

@@ -0,0 +1,24 @@
+
+module Main where
+import Test.HUnit
+
+--Program start
+
+--Program end
+
+-- Test cases
+
+test1 :: Test
+test1 = TestCase (assertEqual "for (findFinalValue [5,3,6,1,12] 3)," 24 (findFinalValue [5,3,6,1,12] 3))
+
+test2 :: Test
+test2 = TestCase (assertEqual "for (findFinalValue [2,7,9] 4)," 4 (findFinalValue [2,7,9] 4))
+
+
+-- Grouping test cases
+tests :: Test
+tests = TestList [TestLabel "Test1" test1]
+
+-- Running the tests
+main :: IO Counts
+main = runTestTT tests

keep_multiplying_found_values_by_two/java_tests/Main.java

@@ -0,0 +1,21 @@
+
+import static org.junit.jupiter.api.Assertions.*;
+import org.junit.jupiter.api.Test;
+import java.util.List;
+import java.util.Arrays;
+import java.util.ArrayList;
+public class Main {
+    //Program start
+    
+    //Program end
+
+    @Test
+public void test1() {
+    assertEquals(24, findFinalValue(new ArrayList<>(Arrays.asList(5,3,6,1,12)), 3));
+}
+@Test
+public void test2() {
+    assertEquals(4, findFinalValue(new ArrayList<>(Arrays.asList(2,7,9)), 4));
+}
+
+}

keep_multiplying_found_values_by_two/ocaml_tests/main.ml

@@ -0,0 +1,26 @@
+
+module Main = struct
+    open OUnit2
+
+    (* Program start *)
+
+    (* Program end *)
+
+    (* Test cases *)
+    
+let test1 _ = assert_equal 24 (findFinalValue [5;3;6;1;12] 3)
+
+let test2 _ = assert_equal 4 (findFinalValue [2;7;9] 4)
+
+
+    (* Grouping test cases *)
+    let suite = "Test Suite for findFinalValue" >::: [
+        
+  "test1" >:: test1;
+  "test2" >:: test2;
+    ]
+
+
+    (* Running the tests *)
+    let () = run_test_tt_main suite
+end

keep_multiplying_found_values_by_two/scala_tests/MySuite.scala

@@ -0,0 +1,12 @@
+
+class MySuite extends munit.FunSuite {
+  
+  test("test1") {
+    assertEquals(Main.findFinalValue(List(5,3,6,1,12),3), 24)
+  }
+
+  test("test2") {
+    assertEquals(Main.findFinalValue(List(2,7,9),4), 4)
+  }
+
+}

kth_smallest_amount_with_single_denomination_combination/haskell_tests/Main.hs

@@ -0,0 +1,45 @@
+
+module Main where
+import Test.HUnit
+
+--Program start
+
+--Program end
+
+-- Test cases
+
+test1 :: Test
+test1 = TestCase (assertEqual "for (findKthSmallest [3,6,9] 3)," 9 (findKthSmallest [3,6,9] 3))
+
+test2 :: Test
+test2 = TestCase (assertEqual "for (findKthSmallest [5,2] 7)," 12 (findKthSmallest [5,2] 7))
+
+test3 :: Test
+test3 = TestCase (assertEqual "for (findKthSmallest [22, 19, 23, 7, 21, 4, 18] 179515623)," 394779506 (findKthSmallest [22, 19, 23, 7, 21, 4, 18] 179515623))
+
+test4 :: Test
+test4 = TestCase (assertEqual "for (findKthSmallest [4, 13, 25, 21, 2, 19, 5, 22, 6, 10, 3, 9, 7, 23, 18] 456523631)," 564441242 (findKthSmallest [4, 13, 25, 21, 2, 19, 5, 22, 6, 10, 3, 9, 7, 23, 18] 456523631))
+
+test5 :: Test
+test5 = TestCase (assertEqual "for (findKthSmallest [21, 18, 11, 24, 2, 13, 15, 8, 12, 3, 19] 60303763)," 82045731 (findKthSmallest [21, 18, 11, 24, 2, 13, 15, 8, 12, 3, 19] 60303763))
+
+test6 :: Test
+test6 = TestCase (assertEqual "for (findKthSmallest [24, 4, 12, 19, 21, 18, 17, 11, 5, 20, 9, 15, 23, 14, 22] 1736682371)," 2819188176 (findKthSmallest [24, 4, 12, 19, 21, 18, 17, 11, 5, 20, 9, 15, 23, 14, 22] 1736682371))
+
+test7 :: Test
+test7 = TestCase (assertEqual "for (findKthSmallest [9, 12, 7, 23, 8] 992400036)," 2577038805 (findKthSmallest [9, 12, 7, 23, 8] 992400036))
+
+test8 :: Test
+test8 = TestCase (assertEqual "for (findKthSmallest [21] 1900534776)," 39911230296 (findKthSmallest [21] 1900534776))
+
+test9 :: Test
+test9 = TestCase (assertEqual "for (findKthSmallest [14, 4, 11, 20, 17, 3, 8, 13, 2] 1300066508)," 1764635218 (findKthSmallest [14, 4, 11, 20, 17, 3, 8, 13, 2] 1300066508))
+
+
+-- Grouping test cases
+tests :: Test
+tests = TestList [TestLabel "Test1" test1, TestLabel "Test2" test2, TestLabel "Test3" test3, TestLabel "Test4" test4, TestLabel "Test5" test5, TestLabel "Test6" test6, TestLabel "Test7" test7, TestLabel "Test8" test8, TestLabel "Test9" test9]
+
+-- Running the tests
+main :: IO Counts
+main = runTestTT tests

kth_smallest_amount_with_single_denomination_combination/java_tests/Main.java

@@ -0,0 +1,21 @@
+
+import static org.junit.jupiter.api.Assertions.*;
+import org.junit.jupiter.api.Test;
+import java.util.List;
+import java.util.Arrays;
+import java.util.ArrayList;
+public class Main {
+    //Program start
+    
+    //Program end
+
+    @Test
+public void test1() {
+    assertEquals(9, findKthSmallest(new ArrayList<>(Arrays.asList(3,6,9)), 3));
+}
+@Test
+public void test2() {
+    assertEquals(12, findKthSmallest(new ArrayList<>(Arrays.asList(5,2)), 7));
+}
+
+}

kth_smallest_amount_with_single_denomination_combination/meta.json

@@ -0,0 +1,187 @@
+{
+    "id": 3375,
+    "name": "kth_smallest_amount_with_single_denomination_combination",
+    "difficulty": "Hard",
+    "link": "https://leetcode.com/problems/kth-smallest-amount-with-single-denomination-combination/",
+    "date": "2024-04-07 00:00:00",
+    "task_description": "You are given an integer array `coins` representing coins of different denominations and an integer `k`. You have an infinite number of coins of each denomination. However, you are **not allowed** to combine coins of different denominations. Return the `kth` **smallest** amount that can be made using these coins. **Example 1:** **Input:** coins = [3,6,9], k = 3 **Output:** 9 **Explanation:** The given coins can make the following amounts: Coin 3 produces multiples of 3: 3, 6, 9, 12, 15, etc. Coin 6 produces multiples of 6: 6, 12, 18, 24, etc. Coin 9 produces multiples of 9: 9, 18, 27, 36, etc. All of the coins combined produce: 3, 6, **9**, 12, 15, etc. **Example 2:** **Input:** coins = [5,2], k = 7 **Output:** 12 **Explanation:** The given coins can make the following amounts: Coin 5 produces multiples of 5: 5, 10, 15, 20, etc. Coin 2 produces multiples of 2: 2, 4, 6, 8, 10, 12, etc. All of the coins combined produce: 2, 4, 5, 6, 8, 10, **12**, 14, 15, etc. **Constraints:** `1 <= coins.length <= 15` `1 <= coins[i] <= 25` `1 <= k <= 2 * 109` `coins` contains pairwise distinct integers.",
+    "public_test_cases": [
+        {
+            "label": "Example 1",
+            "input": "coins = [3,6,9], k = 3",
+            "output": "9 "
+        },
+        {
+            "label": "Example 2",
+            "input": "coins = [5,2], k = 7",
+            "output": "12 "
+        }
+    ],
+    "private_test_cases": [
+        {
+            "input": [
+                [
+                    22,
+                    19,
+                    23,
+                    7,
+                    21,
+                    4,
+                    18
+                ],
+                179515623
+            ],
+            "output": 394779506
+        },
+        {
+            "input": [
+                [
+                    4,
+                    13,
+                    25,
+                    21,
+                    2,
+                    19,
+                    5,
+                    22,
+                    6,
+                    10,
+                    3,
+                    9,
+                    7,
+                    23,
+                    18
+                ],
+                456523631
+            ],
+            "output": 564441242
+        },
+        {
+            "input": [
+                [
+                    21,
+                    18,
+                    11,
+                    24,
+                    2,
+                    13,
+                    15,
+                    8,
+                    12,
+                    3,
+                    19
+                ],
+                60303763
+            ],
+            "output": 82045731
+        },
+        {
+            "input": [
+                [
+                    24,
+                    4,
+                    12,
+                    19,
+                    21,
+                    18,
+                    17,
+                    11,
+                    5,
+                    20,
+                    9,
+                    15,
+                    23,
+                    14,
+                    22
+                ],
+                1736682371
+            ],
+            "output": 2819188176
+        },
+        {
+            "input": [
+                [
+                    9,
+                    12,
+                    7,
+                    23,
+                    8
+                ],
+                992400036
+            ],
+            "output": 2577038805
+        },
+        {
+            "input": [
+                [
+                    21
+                ],
+                1900534776
+            ],
+            "output": 39911230296
+        },
+        {
+            "input": [
+                [
+                    14,
+                    4,
+                    11,
+                    20,
+                    17,
+                    3,
+                    8,
+                    13,
+                    2
+                ],
+                1300066508
+            ],
+            "output": 1764635218
+        },
+        {
+            "input": [
+                [
+                    3,
+                    14,
+                    15,
+                    23,
+                    4,
+                    10,
+                    17,
+                    7,
+                    24
+                ],
+                493157103
+            ],
+            "output": 770681166
+        },
+        {
+            "input": [
+                [
+                    5,
+                    8,
+                    15,
+                    10,
+                    25,
+                    22,
+                    12
+                ],
+                99895996
+            ],
+            "output": 279370155
+        },
+        {
+            "input": [
+                [
+                    5
+                ],
+                180705975
+            ],
+            "output": 903529875
+        }
+    ],
+    "haskell_template": "findKthSmallest :: [Int] -> Int -> Int\nfindKthSmallest coins k ",
+    "ocaml_template": "let findKthSmallest (coins: int list) (k: int) : int =  ",
+    "scala_template": "def findKthSmallest(coins: List[Int],k: Int): Int = { \n    \n}",
+    "java_template": "class Solution {\n    public long findKthSmallest(int[] coins, int k) {\n        \n    }\n}",
+    "python_template": "class Solution(object):\n    def findKthSmallest(self, coins, k):\n        \"\"\"\n        :type coins: List[int]\n        :type k: int\n        :rtype: int\n        \"\"\"\n        "
+}

kth_smallest_amount_with_single_denomination_combination/ocaml_tests/main.ml

@@ -0,0 +1,50 @@
+
+module Main = struct
+    open OUnit2
+
+    (* Program start *)
+
+    (* Program end *)
+
+    (* Test cases *)
+    
+let test1 _ = assert_equal 9 (findKthSmallest [3;6;9] 3)
+
+let test2 _ = assert_equal 12 (findKthSmallest [5;2] 7)
+
+let test3 _ = assert_equal 394779506 (findKthSmallest [22; 19; 23; 7; 21; 4; 18] 179515623)
+
+let test4 _ = assert_equal 564441242 (findKthSmallest [4; 13; 25; 21; 2; 19; 5; 22; 6; 10; 3; 9; 7; 23; 18] 456523631)
+
+let test5 _ = assert_equal 82045731 (findKthSmallest [21; 18; 11; 24; 2; 13; 15; 8; 12; 3; 19] 60303763)
+
+let test6 _ = assert_equal 2819188176 (findKthSmallest [24; 4; 12; 19; 21; 18; 17; 11; 5; 20; 9; 15; 23; 14; 22] 1736682371)
+
+let test7 _ = assert_equal 2577038805 (findKthSmallest [9; 12; 7; 23; 8] 992400036)
+
+let test8 _ = assert_equal 39911230296 (findKthSmallest [21] 1900534776)
+
+let test9 _ = assert_equal 1764635218 (findKthSmallest [14; 4; 11; 20; 17; 3; 8; 13; 2] 1300066508)
+
+let test10 _ = assert_equal 770681166 (findKthSmallest [3; 14; 15; 23; 4; 10; 17; 7; 24] 493157103)
+
+
+    (* Grouping test cases *)
+    let suite = "Test Suite for findKthSmallest" >::: [
+        
+  "test1" >:: test1;
+  "test2" >:: test2;
+  "test3" >:: test3;
+  "test4" >:: test4;
+  "test5" >:: test5;
+  "test6" >:: test6;
+  "test7" >:: test7;
+  "test8" >:: test8;
+  "test9" >:: test9;
+  "test10" >:: test10;
+    ]
+
+
+    (* Running the tests *)
+    let () = run_test_tt_main suite
+end

kth_smallest_amount_with_single_denomination_combination/scala_tests/MySuite.scala

@@ -0,0 +1,44 @@
+
+class MySuite extends munit.FunSuite {
+  
+  test("test1") {
+    assertEquals(Main.findKthSmallest(List(3,6,9),3), 9)
+  }
+
+  test("test2") {
+    assertEquals(Main.findKthSmallest(List(5,2),7), 12)
+  }
+
+  test("test3") {
+    assertEquals(Main.findKthSmallest(List(22, 19, 23, 7, 21, 4, 18),179515623), 394779506)
+  }
+
+  test("test4") {
+    assertEquals(Main.findKthSmallest(List(4, 13, 25, 21, 2, 19, 5, 22, 6, 10, 3, 9, 7, 23, 18),456523631), 564441242)
+  }
+
+  test("test5") {
+    assertEquals(Main.findKthSmallest(List(21, 18, 11, 24, 2, 13, 15, 8, 12, 3, 19),60303763), 82045731)
+  }
+
+  test("test6") {
+    assertEquals(Main.findKthSmallest(List(24, 4, 12, 19, 21, 18, 17, 11, 5, 20, 9, 15, 23, 14, 22),1736682371), BigInt("2819188176"))
+  }
+
+  test("test7") {
+    assertEquals(Main.findKthSmallest(List(9, 12, 7, 23, 8),992400036), BigInt("2577038805"))
+  }
+
+  test("test8") {
+    assertEquals(Main.findKthSmallest(List(21),1900534776), BigInt("39911230296"))
+  }
+
+  test("test9") {
+    assertEquals(Main.findKthSmallest(List(14, 4, 11, 20, 17, 3, 8, 13, 2),1300066508), 1764635218)
+  }
+
+  test("test10") {
+    assertEquals(Main.findKthSmallest(List(3, 14, 15, 23, 4, 10, 17, 7, 24),493157103), 770681166)
+  }
+
+}

largest_3_same_digit_number_in_string/haskell_tests/Main.hs

@@ -0,0 +1,27 @@
+
+module Main where
+import Test.HUnit
+
+--Program start
+
+--Program end
+
+-- Test cases
+
+test1 :: Test
+test1 = TestCase (assertEqual "for (largestGoodInteger \"6 777 133339 \")," "777" (largestGoodInteger "6 777 133339"))
+
+test2 :: Test
+test2 = TestCase (assertEqual "for (largestGoodInteger \"23 000 19 \")," "000" (largestGoodInteger "23 000 19"))
+
+test3 :: Test
+test3 = TestCase (assertEqual "for (largestGoodInteger \"42352338 \")," "" (largestGoodInteger "42352338"))
+
+
+-- Grouping test cases
+tests :: Test
+tests = TestList [TestLabel "Test1" test1, TestLabel "Test2" test2]
+
+-- Running the tests
+main :: IO Counts
+main = runTestTT tests

largest_3_same_digit_number_in_string/java_tests/Main.java

@@ -0,0 +1,25 @@
+
+import static org.junit.jupiter.api.Assertions.*;
+import org.junit.jupiter.api.Test;
+import java.util.List;
+import java.util.Arrays;
+import java.util.ArrayList;
+public class Main {
+    //Program start
+    
+    //Program end
+
+    @Test
+public void test1() {
+    assertEquals("6 777 133339", largestGoodInteger("6 777 133339"));
+}
+@Test
+public void test2() {
+    assertEquals("23 000 19", largestGoodInteger("23 000 19"));
+}
+@Test
+public void test3() {
+    assertEquals("42352338", largestGoodInteger("42352338"));
+}
+
+}

largest_3_same_digit_number_in_string/meta.json

@@ -0,0 +1,72 @@
+{
+    "id": 2346,
+    "name": "largest_3_same_digit_number_in_string",
+    "difficulty": "Easy",
+    "link": "https://leetcode.com/problems/largest-3-same-digit-number-in-string/",
+    "date": "1651363200000",
+    "task_description": "You are given a string `num` representing a large integer. An integer is **good** if it meets the following conditions: It is a **substring** of `num` with length `3`. It consists of only one unique digit. Return _the **maximum good **integer as a **string** or an empty string _`\"\"`_ if no such integer exists_. Note: A **substring** is a contiguous sequence of characters within a string. There may be **leading zeroes** in `num` or a good integer. **Example 1:** ``` **Input:** num = \"6**777**133339\" **Output:** \"777\" **Explanation:** There are two distinct good integers: \"777\" and \"333\". \"777\" is the largest, so we return \"777\". ``` **Example 2:** ``` **Input:** num = \"23**000**19\" **Output:** \"000\" **Explanation:** \"000\" is the only good integer. ``` **Example 3:** ``` **Input:** num = \"42352338\" **Output:** \"\" **Explanation:** No substring of length 3 consists of only one unique digit. Therefore, there are no good integers. ``` **Constraints:** `3 <= num.length <= 1000` `num` only consists of digits.",
+    "public_test_cases": [
+        {
+            "label": "Example 1",
+            "input": "num = \"6 777 133339\"",
+            "output": "\"777\" "
+        },
+        {
+            "label": "Example 2",
+            "input": "num = \"23 000 19\"",
+            "output": "\"000\" "
+        },
+        {
+            "label": "Example 3",
+            "input": "num = \"42352338\"",
+            "output": "\"\" "
+        }
+    ],
+    "private_test_cases": [
+        {
+            "input": "10848558887451529562399824892249063295573302687714867726247825433478151593337015096112051310847176327315141750783505626390086820407142390143245980885287222547268009922288777421999646781790623902395690852955261930974507683651781052764181531519406441588049860448279820190326072303401308854006875409945113367931462657349059435994309403688692483386511557263512248119174669415680021146134368168641485458863809062016363211760308798332797013996524554539119951980156840185313585280974915529699426546397375719595837896905261529054565778111577698713553780623651880170767949347530394813704341638",
+            "output": "999"
+        },
+        {
+            "input": "47426887255841422940727384852730590925752629600461180972805741763417704395379701210464218806703804072608752847941624061081658686280785200554805253619349685885942473902642709150888213438209447899894695762278301896326216623576645899005329681998611857335207020091684599884375447207140846748585060448073488871336378667426183006251333530352645026079207079820085188588225338629872770617352545578100593172982482968114648138595773007135325437308180554918312316885129706463065683580270278214127636296513925573704533193724048330356471280986019273010628214900294417125830680531377939952202615423688744012249155193863324220542775405412695545033719536175067598",
+            "output": "888"
+        },
+        {
+            "input": "738048384163579046383583833585912061948169810763177715912952198244475182441915240510976498436468260847762946176312085113761419723199738383317650905495713028734366898353750356501857264217487816791462260304703996646548589984109946029889087074038837401879926731522053424082740552484458556141012986908489664361034712674798183682358121322422727327775867082605111873434076280759183034541099684312367252818106017173713189962367426025799925273962404207651562189536961238750014240495266902618014127358110",
+            "output": "999"
+        },
+        {
+            "input": "20209784743196939784503944352089875700757627790781375962866866897339998345279606032590560921191153900901217428584457899591916460620332246009942800379661594647183473452387479278",
+            "output": "999"
+        },
+        {
+            "input": "5548411556853590416728324497574743015738062966157881918587275799498324254891201497937916087812096852463024601053540406806014368947907700213158922587772111582606976647591232449570189253693801976582802678787871592640766663151224166469861611051645946723863666620586842480784895086975849009496917114341012115611574410200760492269029887282845090751641664131834193490342560824893101621115484103030906658884933319211841797040599649151593415819890038165746674486932597067412598642726350922112753967970479449354460410399642921789698638403523272017435958293407514573868403682632134909546250734669056158526269736151210092915267407485144474174648124028098994591181856301661714408984341484382249893726323167469163608227536254186333361296577399543594732138365012586708407952133229323240176647215489372222648254470081490670569912768094801133377396885230518233709570493860745619332564152012171202667306890633847",
+            "output": "888"
+        },
+        {
+            "input": "558525214095448955075293446516741317848899534263253659714969548538738896733587016157594097166156961465068886993616599233235575574253106995756424997751023279574655895299604787669434430530006232982727869806217550043060031283000485437785611173056520932958592543020874993056623503627914716866740549037015273784660398273336309731368846714406153875804705165867472496302049541597901054592319961085200123720743229473369900345481168420681958520154188010844049730046362087710601569818455449533216053633240277062901686347717518799557090381335773315864913595606650763016396816130021049818084514266021140810691169199426856648221714310905439742373487964511096693923320932883427943953528346180391862832239992394318766928921213132255018702404961490512070768896288605312098100187510316946786850302260956581916503053769258372468287640849019088767045065299883312331560866766978438026276010235268705298714763336461678270700044688044003565498076558337307885125128995792440009567308781585222016993605548158659339",
+            "output": "999"
+        },
+        {
+            "input": "7029428553518057506087288381487004528774546027105731217319980930568153760239755254772763611258652044522879026884683174253528954935951924484478059289938763129895022785439420687113132718393277231777614081060012540902746326704193450214686259678250262851492006776095673921170023997649457212121734252152627660806578130862885626190793550563162744431620498857462015960496611632",
+            "output": "777"
+        },
+        {
+            "input": "4902847507944205784467343917307446625649954161420242735051679920785132253773660918691653055989260793055207678807054119888813957105913335159277604331712018553437799924689478182041481071606774575296428378536353903946866248258335665780194100675057743725989345525729226449619032570030072293099228681280030896534120669216535295233011330709920943739779679238568815078735099645380852756656994093598712184309843557743341128799774197778332014399991434246439692465833415668027964663378426500733234336131086158741292124106803012897761155320813977887077054757282048240592974899562094707461088031625946412261991141201914584379238169650853034705104313004191342093594533966262243356985107328289571005772800507513647042060399148943317657784840471533287314680052360139786671772862796245336631159214389698775846585291187816582504783139767628347596575393589169856443961988168385579030247114186306753223282344943495738596849347457715787371991483550275393599644744460745184919328185476626",
+            "output": "999"
+        },
+        {
+            "input": "4365758523152195793307564181162714472668301306525818573644014370240915474969378280181940401695283",
+            "output": ""
+        },
+        {
+            "input": "56751877305078539977603477691615457057182065594309404668558405080994224124818937407320253425653684924596773282542500377439669321234068503948396228776002741129116604083751237347680099661746407568875925195",
+            "output": ""
+        }
+    ],
+    "haskell_template": "largestGoodInteger :: String -> String\nlargestGoodInteger num ",
+    "ocaml_template": "let largestGoodInteger (num: string) : string =  ",
+    "scala_template": "def largestGoodInteger(num: String): String = { \n    \n}",
+    "java_template": "public static String largestGoodInteger(String num) {\n\n}",
+    "python_template": "class Solution(object):\n    def largestGoodInteger(self, num):\n        \"\"\"\n        :type num: str\n        :rtype: str\n        \"\"\"\n        "
+}

largest_3_same_digit_number_in_string/ocaml_tests/main.ml

@@ -0,0 +1,29 @@
+
+module Main = struct
+    open OUnit2
+
+    (* Program start *)
+
+    (* Program end *)
+
+    (* Test cases *)
+    
+let test1 _ = assert_equal "777" (largestGoodInteger "6 777 133339")
+
+let test2 _ = assert_equal "000" (largestGoodInteger "23 000 19")
+
+let test3 _ = assert_equal "" (largestGoodInteger "42352338")
+
+
+    (* Grouping test cases *)
+    let suite = "Test Suite for largestGoodInteger" >::: [
+        
+  "test1" >:: test1;
+  "test2" >:: test2;
+  "test3" >:: test3;
+    ]
+
+
+    (* Running the tests *)
+    let () = run_test_tt_main suite
+end

largest_3_same_digit_number_in_string/scala_tests/MySuite.scala

@@ -0,0 +1,16 @@
+
+class MySuite extends munit.FunSuite {
+  
+  test("test1") {
+    assertEquals(Main.largestGoodInteger("6 777 133339"), "777")
+  }
+
+  test("test2") {
+    assertEquals(Main.largestGoodInteger("23 000 19"), "000")
+  }
+
+  test("test3") {
+    assertEquals(Main.largestGoodInteger("42352338"), "")
+  }
+
+}

largest_combination_with_bitwise_and_greater_than_zero/haskell_tests/Main.hs

@@ -0,0 +1,24 @@
+
+module Main where
+import Test.HUnit
+
+--Program start
+
+--Program end
+
+-- Test cases
+
+test1 :: Test
+test1 = TestCase (assertEqual "for (largestCombination [16,17,71,62,12,24,14])," 4 (largestCombination [16,17,71,62,12,24,14]))
+
+test2 :: Test
+test2 = TestCase (assertEqual "for (largestCombination [8,8])," 2 (largestCombination [8,8]))
+
+
+-- Grouping test cases
+tests :: Test
+tests = TestList [TestLabel "Test1" test1]
+
+-- Running the tests
+main :: IO Counts
+main = runTestTT tests

largest_combination_with_bitwise_and_greater_than_zero/java_tests/Main.java

@@ -0,0 +1,21 @@
+
+import static org.junit.jupiter.api.Assertions.*;
+import org.junit.jupiter.api.Test;
+import java.util.List;
+import java.util.Arrays;
+import java.util.ArrayList;
+public class Main {
+    //Program start
+    
+    //Program end
+
+    @Test
+public void test1() {
+    assertEquals(4, largestCombination(new ArrayList<>(Arrays.asList(16,17,71,62,12,24,14))));
+}
+@Test
+public void test2() {
+    assertEquals(2, largestCombination(new ArrayList<>(Arrays.asList(8,8))));
+}
+
+}

largest_combination_with_bitwise_and_greater_than_zero/meta.json

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:a47424c4e558ee0cfe7ac2e1597a85243d9a290566c36d9e69c82cd57b964c34
+size 13314049

largest_combination_with_bitwise_and_greater_than_zero/ocaml_tests/main.ml

@@ -0,0 +1,26 @@
+
+module Main = struct
+    open OUnit2
+
+    (* Program start *)
+
+    (* Program end *)
+
+    (* Test cases *)
+    
+let test1 _ = assert_equal 4 (largestCombination [16;17;71;62;12;24;14])
+
+let test2 _ = assert_equal 2 (largestCombination [8;8])
+
+
+    (* Grouping test cases *)
+    let suite = "Test Suite for largestCombination" >::: [
+        
+  "test1" >:: test1;
+  "test2" >:: test2;
+    ]
+
+
+    (* Running the tests *)
+    let () = run_test_tt_main suite
+end

largest_combination_with_bitwise_and_greater_than_zero/scala_tests/MySuite.scala

@@ -0,0 +1,12 @@
+
+class MySuite extends munit.FunSuite {
+  
+  test("test1") {
+    assertEquals(Main.largestCombination(List(16,17,71,62,12,24,14)), 4)
+  }
+
+  test("test2") {
+    assertEquals(Main.largestCombination(List(8,8)), 2)
+  }
+
+}

largest_element_in_an_array_after_merge_operations/haskell_tests/Main.hs

@@ -0,0 +1,24 @@
+
+module Main where
+import Test.HUnit
+
+--Program start
+
+--Program end
+
+-- Test cases
+
+test1 :: Test
+test1 = TestCase (assertEqual "for (maxArrayValue [2,3,7,9,3])," 21 (maxArrayValue [2,3,7,9,3]))
+
+test2 :: Test
+test2 = TestCase (assertEqual "for (maxArrayValue [5,3,3])," 11 (maxArrayValue [5,3,3]))
+
+
+-- Grouping test cases
+tests :: Test
+tests = TestList [TestLabel "Test1" test1]
+
+-- Running the tests
+main :: IO Counts
+main = runTestTT tests

largest_element_in_an_array_after_merge_operations/java_tests/Main.java

@@ -0,0 +1,21 @@
+
+import static org.junit.jupiter.api.Assertions.*;
+import org.junit.jupiter.api.Test;
+import java.util.List;
+import java.util.Arrays;
+import java.util.ArrayList;
+public class Main {
+    //Program start
+    
+    //Program end
+
+    @Test
+public void test1() {
+    assertEquals(21, maxArrayValue(new ArrayList<>(Arrays.asList(2,3,7,9,3))));
+}
+@Test
+public void test2() {
+    assertEquals(11, maxArrayValue(new ArrayList<>(Arrays.asList(5,3,3))));
+}
+
+}

largest_element_in_an_array_after_merge_operations/meta.json

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:a757cb94940e419204880ce987b8afb53d1637ebc9cc808bba6a7493551e405d
+size 12382820

largest_element_in_an_array_after_merge_operations/ocaml_tests/main.ml

@@ -0,0 +1,26 @@
+
+module Main = struct
+    open OUnit2
+
+    (* Program start *)
+
+    (* Program end *)
+
+    (* Test cases *)
+    
+let test1 _ = assert_equal 21 (maxArrayValue [2;3;7;9;3])
+
+let test2 _ = assert_equal 11 (maxArrayValue [5;3;3])
+
+
+    (* Grouping test cases *)
+    let suite = "Test Suite for maxArrayValue" >::: [
+        
+  "test1" >:: test1;
+  "test2" >:: test2;
+    ]
+
+
+    (* Running the tests *)
+    let () = run_test_tt_main suite
+end

largest_element_in_an_array_after_merge_operations/scala_tests/MySuite.scala

@@ -0,0 +1,12 @@
+
+class MySuite extends munit.FunSuite {
+  
+  test("test1") {
+    assertEquals(Main.maxArrayValue(List(2,3,7,9,3)), 21)
+  }
+
+  test("test2") {
+    assertEquals(Main.maxArrayValue(List(5,3,3)), 11)
+  }
+
+}

largest_local_values_in_a_matrix/haskell_tests/Main.hs

@@ -0,0 +1,24 @@
+
+module Main where
+import Test.HUnit
+
+--Program start
+
+--Program end
+
+-- Test cases
+
+test1 :: Test
+test1 = TestCase (assertEqual "for (largestLocal [[9,9,8,1],[5,6,2,6],[8,2,6,4],[6,2,2,2]])," [[9,9],[8,6]] (largestLocal [[9,9,8,1],[5,6,2,6],[8,2,6,4],[6,2,2,2]]))
+
+test2 :: Test
+test2 = TestCase (assertEqual "for (largestLocal [[1,1,1,1,1],[1,1,1,1,1],[1,1,2,1,1],[1,1,1,1,1],[1,1,1,1,1]])," [[2,2,2],[2,2,2],[2,2,2]] (largestLocal [[1,1,1,1,1],[1,1,1,1,1],[1,1,2,1,1],[1,1,1,1,1],[1,1,1,1,1]]))
+
+
+-- Grouping test cases
+tests :: Test
+tests = TestList [TestLabel "Test1" test1]
+
+-- Running the tests
+main :: IO Counts
+main = runTestTT tests

largest_local_values_in_a_matrix/java_tests/Main.java

@@ -0,0 +1,21 @@
+
+import static org.junit.jupiter.api.Assertions.*;
+import org.junit.jupiter.api.Test;
+import java.util.List;
+import java.util.Arrays;
+import java.util.ArrayList;
+public class Main {
+    //Program start
+    
+    //Program end
+
+    @Test
+public void test1() {
+    assertEquals(new ArrayList<>(Arrays.asList(new ArrayList<>(Arrays.asList(9,9)),new ArrayList<>(Arrays.asList(8,6)))), largestLocal(new ArrayList<>(Arrays.asList(new ArrayList<>(Arrays.asList(9,9,8,1)),new ArrayList<>(Arrays.asList(5,6,2,6)),new ArrayList<>(Arrays.asList(8,2,6,4)),new ArrayList<>(Arrays.asList(6,2,2,2))))));
+}
+@Test
+public void test2() {
+    assertEquals(new ArrayList<>(Arrays.asList(new ArrayList<>(Arrays.asList(2,2,2)),new ArrayList<>(Arrays.asList(2,2,2)),new ArrayList<>(Arrays.asList(2,2,2)))), largestLocal(new ArrayList<>(Arrays.asList(new ArrayList<>(Arrays.asList(1,1,1,1,1)),new ArrayList<>(Arrays.asList(1,1,1,1,1)),new ArrayList<>(Arrays.asList(1,1,2,1,1)),new ArrayList<>(Arrays.asList(1,1,1,1,1)),new ArrayList<>(Arrays.asList(1,1,1,1,1))))));
+}
+
+}

largest_local_values_in_a_matrix/ocaml_tests/main.ml

@@ -0,0 +1,26 @@
+
+module Main = struct
+    open OUnit2
+
+    (* Program start *)
+
+    (* Program end *)
+
+    (* Test cases *)
+    
+let test1 _ = assert_equal [[9;9];[8;6]] (largestLocal [[9;9;8;1];[5;6;2;6];[8;2;6;4];[6;2;2;2]])
+
+let test2 _ = assert_equal [[2;2;2];[2;2;2];[2;2;2]] (largestLocal [[1;1;1;1;1];[1;1;1;1;1];[1;1;2;1;1];[1;1;1;1;1];[1;1;1;1;1]])
+
+
+    (* Grouping test cases *)
+    let suite = "Test Suite for largestLocal" >::: [
+        
+  "test1" >:: test1;
+  "test2" >:: test2;
+    ]
+
+
+    (* Running the tests *)
+    let () = run_test_tt_main suite
+end

largest_local_values_in_a_matrix/scala_tests/MySuite.scala

@@ -0,0 +1,12 @@
+
+class MySuite extends munit.FunSuite {
+  
+  test("test1") {
+    assertEquals(Main.largestLocal(List(List(9,9,8,1),List(5,6,2,6),List(8,2,6,4),List(6,2,2,2))), List(List(9,9),List(8,6)))
+  }
+
+  test("test2") {
+    assertEquals(Main.largestLocal(List(List(1,1,1,1,1),List(1,1,1,1,1),List(1,1,2,1,1),List(1,1,1,1,1),List(1,1,1,1,1))), List(List(2,2,2),List(2,2,2),List(2,2,2)))
+  }
+
+}

largest_palindromic_number/haskell_tests/Main.hs

@@ -0,0 +1,24 @@
+
+module Main where
+import Test.HUnit
+
+--Program start
+
+--Program end
+
+-- Test cases
+
+test1 :: Test
+test1 = TestCase (assertEqual "for (largestPalindromic \"444947137 \")," "7449447" (largestPalindromic "444947137"))
+
+test2 :: Test
+test2 = TestCase (assertEqual "for (largestPalindromic \"00009 \")," "9" (largestPalindromic "00009"))
+
+
+-- Grouping test cases
+tests :: Test
+tests = TestList [TestLabel "Test1" test1]
+
+-- Running the tests
+main :: IO Counts
+main = runTestTT tests

largest_palindromic_number/java_tests/Main.java

@@ -0,0 +1,21 @@
+
+import static org.junit.jupiter.api.Assertions.*;
+import org.junit.jupiter.api.Test;
+import java.util.List;
+import java.util.Arrays;
+import java.util.ArrayList;
+public class Main {
+    //Program start
+    
+    //Program end
+
+    @Test
+public void test1() {
+    assertEquals("444947137", largestPalindromic("444947137"));
+}
+@Test
+public void test2() {
+    assertEquals("00009", largestPalindromic("00009"));
+}
+
+}

largest_palindromic_number/meta.json

@@ -0,0 +1,67 @@
+{
+    "id": 2475,
+    "name": "largest_palindromic_number",
+    "difficulty": "Medium",
+    "link": "https://leetcode.com/problems/largest-palindromic-number/",
+    "date": "1660435200000",
+    "task_description": "You are given a string `num` consisting of digits only. Return _the **largest palindromic** integer (in the form of a string) that can be formed using digits taken from _`num`. It should not contain **leading zeroes**. **Notes:** You do **not** need to use all the digits of `num`, but you must use **at least** one digit. The digits can be reordered. **Example 1:** ``` **Input:** num = \"444947137\" **Output:** \"7449447\" **Explanation:** Use the digits \"4449477\" from \"**44494****7**13**7**\" to form the palindromic integer \"7449447\". It can be shown that \"7449447\" is the largest palindromic integer that can be formed. ``` **Example 2:** ``` **Input:** num = \"00009\" **Output:** \"9\" **Explanation:** It can be shown that \"9\" is the largest palindromic integer that can be formed. Note that the integer returned should not contain leading zeroes. ``` **Constraints:** `1 <= num.length <= 105` `num` consists of digits.",
+    "public_test_cases": [
+        {
+            "label": "Example 1",
+            "input": "num = \"444947137\"",
+            "output": "\"7449447\" "
+        },
+        {
+            "label": "Example 2",
+            "input": "num = \"00009\"",
+            "output": "\"9\" "
+        }
+    ],
+    "private_test_cases": [
+        {
+            "input": "4574357",
+            "output": "7543457"
+        },
+        {
+            "input": "323771360305980",
+            "output": "733090337"
+        },
+        {
+            "input": "915977436646661402578806504359626452933532890394320262788748102836284924152437266070747858033901879",
+            "output": "99998888877777666666555544444333332222221100000900000112222223333344444555566666677777888889999"
+        },
+        {
+            "input": "8288073188005753773764289343236297261209139278936329",
+            "output": "9998887776654333322221008001222233334566777888999"
+        },
+        {
+            "input": "76460896679381678729518210215426903546870637252450074473722681197470990848740583",
+            "output": "999888877777766665554444332222111000090000111222233444455566667777778888999"
+        },
+        {
+            "input": "640561031312180076174196658564620",
+            "output": "87666543211100900111234566678"
+        },
+        {
+            "input": "38286509445513",
+            "output": "854393458"
+        },
+        {
+            "input": "18796610610152728699956907327526994501042085030356183882245317618431649159",
+            "output": "999988877666655554433322211111000090000111112223334455556666778889999"
+        },
+        {
+            "input": "9249031911327257978608320605506328216552099502171897527492664374199557948938161464101809914867350",
+            "output": "99999998888777766665555544443332222211111100000700000111111222223334444555556666777788889999999"
+        },
+        {
+            "input": "958186096215117931164019189995544089530747635649857600585949137997186954099326185909122",
+            "output": "9999999998888777666655555444332211111100005000011111122334445555566667778888999999999"
+        }
+    ],
+    "haskell_template": "largestPalindromic :: String -> String\nlargestPalindromic num ",
+    "ocaml_template": "let largestPalindromic (num: string) : string =  ",
+    "scala_template": "def largestPalindromic(num: String): String = { \n    \n}",
+    "java_template": "public static String largestPalindromic(String num) {\n\n}",
+    "python_template": "class Solution(object):\n    def largestPalindromic(self, num):\n        \"\"\"\n        :type num: str\n        :rtype: str\n        \"\"\"\n        "
+}

largest_palindromic_number/ocaml_tests/main.ml

@@ -0,0 +1,26 @@
+
+module Main = struct
+    open OUnit2
+
+    (* Program start *)
+
+    (* Program end *)
+
+    (* Test cases *)
+    
+let test1 _ = assert_equal "7449447" (largestPalindromic "444947137")
+
+let test2 _ = assert_equal "9" (largestPalindromic "00009")
+
+
+    (* Grouping test cases *)
+    let suite = "Test Suite for largestPalindromic" >::: [
+        
+  "test1" >:: test1;
+  "test2" >:: test2;
+    ]
+
+
+    (* Running the tests *)
+    let () = run_test_tt_main suite
+end

largest_palindromic_number/scala_tests/MySuite.scala

@@ -0,0 +1,12 @@
+
+class MySuite extends munit.FunSuite {
+  
+  test("test1") {
+    assertEquals(Main.largestPalindromic("444947137"), "7449447")
+  }
+
+  test("test2") {
+    assertEquals(Main.largestPalindromic("00009"), "9")
+  }
+
+}

largest_positive_integer_that_exists_with_its_negative/haskell_tests/Main.hs

@@ -0,0 +1,27 @@
+
+module Main where
+import Test.HUnit
+
+--Program start
+
+--Program end
+
+-- Test cases
+
+test1 :: Test
+test1 = TestCase (assertEqual "for (findMaxK [-1,2,-3,3])," 3 (findMaxK [-1,2,-3,3]))
+
+test2 :: Test
+test2 = TestCase (assertEqual "for (findMaxK [-1,10,6,7,-7,1])," 7 (findMaxK [-1,10,6,7,-7,1]))
+
+test3 :: Test
+test3 = TestCase (assertEqual "for (findMaxK [-10,8,6,7,-2,-3])," (-1) (findMaxK [-10,8,6,7,-2,-3]))
+
+
+-- Grouping test cases
+tests :: Test
+tests = TestList [TestLabel "Test1" test1, TestLabel "Test2" test2]
+
+-- Running the tests
+main :: IO Counts
+main = runTestTT tests

largest_positive_integer_that_exists_with_its_negative/java_tests/Main.java

@@ -0,0 +1,25 @@
+
+import static org.junit.jupiter.api.Assertions.*;
+import org.junit.jupiter.api.Test;
+import java.util.List;
+import java.util.Arrays;
+import java.util.ArrayList;
+public class Main {
+    //Program start
+    
+    //Program end
+
+    @Test
+public void test1() {
+    assertEquals(3, findMaxK(new ArrayList<>(Arrays.asList(-1,2,-3,3))));
+}
+@Test
+public void test2() {
+    assertEquals(7, findMaxK(new ArrayList<>(Arrays.asList(-1,10,6,7,-7,1))));
+}
+@Test
+public void test3() {
+    assertEquals(-1, findMaxK(new ArrayList<>(Arrays.asList(-10,8,6,7,-2,-3))));
+}
+
+}

largest_positive_integer_that_exists_with_its_negative/meta.json

@@ -0,0 +1,2758 @@
+{
+    "id": 2524,
+    "name": "largest_positive_integer_that_exists_with_its_negative",
+    "difficulty": "Easy",
+    "link": "https://leetcode.com/problems/largest-positive-integer-that-exists-with-its-negative/",
+    "date": "1665273600000",
+    "task_description": "Given an integer array `nums` that **does not contain** any zeros, find **the largest positive** integer `k` such that `-k` also exists in the array. Return _the positive integer _`k`. If there is no such integer, return `-1`. **Example 1:** ``` **Input:** nums = [-1,2,-3,3] **Output:** 3 **Explanation:** 3 is the only valid k we can find in the array. ``` **Example 2:** ``` **Input:** nums = [-1,10,6,7,-7,1] **Output:** 7 **Explanation:** Both 1 and 7 have their corresponding negative values in the array. 7 has a larger value. ``` **Example 3:** ``` **Input:** nums = [-10,8,6,7,-2,-3] **Output:** -1 **Explanation:** There is no a single valid k, we return -1. ``` **Constraints:** `1 <= nums.length <= 1000` `-1000 <= nums[i] <= 1000` `nums[i] != 0`",
+    "public_test_cases": [
+        {
+            "label": "Example 1",
+            "input": "nums = [-1,2,-3,3]",
+            "output": "3 "
+        },
+        {
+            "label": "Example 2",
+            "input": "nums = [-1,10,6,7,-7,1]",
+            "output": "7 "
+        },
+        {
+            "label": "Example 3",
+            "input": "nums = [-10,8,6,7,-2,-3]",
+            "output": "-1 "
+        }
+    ],
+    "private_test_cases": [
+        {
+            "input": [
+                514,
+                -503,
+                -498,
+                -492,
+                21,
+                535,
+                538,
+                27,
+                540,
+                -995,
+                -483,
+                544,
+                33,
+                -990,
+                41,
+                47,
+                559,
+                -976,
+                -974,
+                -460,
+                566,
+                -450,
+                -442,
+                584,
+                -439,
+                -428,
+                599,
+                -935,
+                -422,
+                -931,
+                -417,
+                97,
+                -920,
+                -403,
+                -914,
+                -398,
+                115,
+                -395,
+                -907,
+                -393,
+                123,
+                -899,
+                641,
+                -894,
+                136,
+                -888,
+                -886,
+                -884,
+                656,
+                657,
+                658,
+                -368,
+                -878,
+                149,
+                662,
+                -365,
+                -876,
+                -875,
+                -362,
+                -871,
+                -868,
+                -867,
+                -865,
+                161,
+                -862,
+                167,
+                -343,
+                170,
+                -341,
+                -852,
+                174,
+                688,
+                -847,
+                178,
+                691,
+                -841,
+                -837,
+                700,
+                -324,
+                -832,
+                -318,
+                711,
+                200,
+                199,
+                -312,
+                719,
+                211,
+                -301,
+                213,
+                -299,
+                728,
+                733,
+                -290,
+                223,
+                -288,
+                -796,
+                741,
+                -794,
+                -790,
+                747,
+                750,
+                -266,
+                -774,
+                763,
+                -258,
+                258,
+                -763,
+                774,
+                266,
+                -750,
+                -747,
+                790,
+                794,
+                -741,
+                796,
+                288,
+                -223,
+                290,
+                -733,
+                -728,
+                299,
+                -213,
+                301,
+                -211,
+                -719,
+                312,
+                -200,
+                -711,
+                -199,
+                318,
+                832,
+                324,
+                837,
+                -700,
+                841,
+                -691,
+                -178,
+                847,
+                -688,
+                -174,
+                852,
+                341,
+                -170,
+                343,
+                -167,
+                862,
+                -161,
+                865,
+                867,
+                868,
+                871,
+                362,
+                875,
+                876,
+                365,
+                878,
+                -662,
+                368,
+                -149,
+                -658,
+                -657,
+                884,
+                -656,
+                886,
+                888,
+                -136,
+                894,
+                -641,
+                899,
+                -123,
+                393,
+                395,
+                907,
+                -115,
+                398,
+                914,
+                403,
+                920,
+                -97,
+                417,
+                931,
+                422,
+                935,
+                -599,
+                428,
+                439,
+                -584,
+                442,
+                450,
+                -566,
+                460,
+                974,
+                976,
+                -47,
+                -559,
+                -41,
+                990,
+                -33,
+                -544,
+                995,
+                483,
+                -540,
+                -27,
+                -538,
+                -535,
+                -21,
+                492,
+                498,
+                503,
+                -514
+            ],
+            "output": 995
+        },
+        {
+            "input": [
+                130,
+                389,
+                -121,
+                910,
+                274,
+                -494,
+                406,
+                154,
+                -228,
+                417,
+                674,
+                -351,
+                -979,
+                817,
+                -334,
+                -588,
+                -716,
+                -456,
+                574,
+                -574,
+                456,
+                588,
+                716,
+                334,
+                -817,
+                979,
+                -674,
+                351,
+                -417,
+                228,
+                -154,
+                -406,
+                494,
+                -274,
+                -910,
+                121,
+                -389,
+                -130
+            ],
+            "output": 979
+        },
+        {
+            "input": [
+                5,
+                8,
+                9,
+                10,
+                11,
+                15,
+                21,
+                24,
+                26,
+                29,
+                30,
+                32,
+                34,
+                38,
+                44,
+                47,
+                50,
+                52,
+                60,
+                64,
+                67,
+                69,
+                74,
+                75,
+                78,
+                80,
+                82,
+                84,
+                88,
+                89,
+                103,
+                106,
+                107,
+                108,
+                109,
+                114,
+                118,
+                121,
+                122,
+                125,
+                126,
+                127,
+                132,
+                133,
+                140,
+                142,
+                147,
+                149,
+                151,
+                152,
+                161,
+                166,
+                169,
+                176,
+                184,
+                191,
+                192,
+                195,
+                196,
+                204,
+                206,
+                211,
+                213,
+                214,
+                218,
+                219,
+                220,
+                223,
+                227,
+                229,
+                231,
+                233,
+                235,
+                241,
+                242,
+                249,
+                251,
+                254,
+                258,
+                259,
+                260,
+                261,
+                262,
+                265,
+                266,
+                268,
+                270,
+                275,
+                277,
+                278,
+                280,
+                284,
+                286,
+                287,
+                289,
+                291,
+                293,
+                296,
+                297,
+                302,
+                304,
+                305,
+                308,
+                310,
+                311,
+                312,
+                317,
+                322,
+                328,
+                329,
+                332,
+                338,
+                341,
+                342,
+                344,
+                345,
+                349,
+                353,
+                364,
+                365,
+                368,
+                369,
+                373,
+                377,
+                378,
+                382,
+                385,
+                387,
+                389,
+                393,
+                394,
+                396,
+                398,
+                399,
+                400,
+                401,
+                405,
+                408,
+                411,
+                412,
+                413,
+                417,
+                422,
+                425,
+                427,
+                428,
+                432,
+                433,
+                436,
+                438,
+                440,
+                442,
+                446,
+                448,
+                452,
+                455,
+                456,
+                457,
+                460,
+                464,
+                466,
+                468,
+                469,
+                470,
+                475,
+                479,
+                482,
+                484,
+                486,
+                491,
+                497,
+                498,
+                501,
+                505,
+                510,
+                511,
+                515,
+                517,
+                518,
+                523,
+                524,
+                527,
+                531,
+                532,
+                544,
+                549,
+                552,
+                553,
+                555,
+                556,
+                557,
+                558,
+                561,
+                565,
+                573,
+                576,
+                578,
+                581,
+                582,
+                583,
+                587,
+                589,
+                590,
+                594,
+                596,
+                597,
+                599,
+                601,
+                602,
+                604,
+                608,
+                610,
+                611,
+                615,
+                619,
+                623,
+                625,
+                629,
+                630,
+                632,
+                633,
+                636,
+                639,
+                641,
+                643,
+                645,
+                646,
+                649,
+                652,
+                654,
+                662,
+                666,
+                667,
+                668,
+                670,
+                678,
+                679,
+                681,
+                682,
+                683,
+                687,
+                693,
+                696,
+                697,
+                703,
+                704,
+                707,
+                708,
+                709,
+                711,
+                718,
+                722,
+                723,
+                726,
+                727,
+                730,
+                733,
+                738,
+                740,
+                742,
+                744,
+                745,
+                747,
+                750,
+                751,
+                752,
+                755,
+                756,
+                758,
+                759,
+                761,
+                762,
+                766,
+                768,
+                769,
+                775,
+                776,
+                777,
+                780,
+                781,
+                786,
+                788,
+                792,
+                795,
+                796,
+                799,
+                800,
+                802,
+                804,
+                808,
+                813,
+                817,
+                819,
+                826,
+                829,
+                834,
+                837,
+                845,
+                851,
+                852,
+                858,
+                863,
+                864,
+                865,
+                870,
+                871,
+                876,
+                878,
+                880,
+                885,
+                886,
+                887,
+                889,
+                891,
+                892,
+                896,
+                897,
+                898,
+                902,
+                909,
+                910,
+                914,
+                917,
+                919,
+                924,
+                926,
+                928,
+                934,
+                939,
+                943,
+                945,
+                948,
+                951,
+                953,
+                955,
+                956,
+                957,
+                959,
+                960,
+                961,
+                966,
+                971,
+                973,
+                976,
+                977,
+                978,
+                981,
+                983,
+                986,
+                990,
+                991,
+                994,
+                995,
+                999,
+                -999,
+                -995,
+                -994,
+                -991,
+                -990,
+                -986,
+                -983,
+                -981,
+                -978,
+                -977,
+                -976,
+                -973,
+                -971,
+                -966,
+                -961,
+                -960,
+                -959,
+                -957,
+                -956,
+                -955,
+                -953,
+                -951,
+                -948,
+                -945,
+                -943,
+                -939,
+                -934,
+                -928,
+                -926,
+                -924,
+                -919,
+                -917,
+                -914,
+                -910,
+                -909,
+                -902,
+                -898,
+                -897,
+                -896,
+                -892,
+                -891,
+                -889,
+                -887,
+                -886,
+                -885,
+                -880,
+                -878,
+                -876,
+                -871,
+                -870,
+                -865,
+                -864,
+                -863,
+                -858,
+                -852,
+                -851,
+                -845,
+                -837,
+                -834,
+                -829,
+                -826,
+                -819,
+                -817,
+                -813,
+                -808,
+                -804,
+                -802,
+                -800,
+                -799,
+                -796,
+                -795,
+                -792,
+                -788,
+                -786,
+                -781,
+                -780,
+                -777,
+                -776,
+                -775,
+                -769,
+                -768,
+                -766,
+                -762,
+                -761,
+                -759,
+                -758,
+                -756,
+                -755,
+                -752,
+                -751,
+                -750,
+                -747,
+                -745,
+                -744,
+                -742,
+                -740,
+                -738,
+                -733,
+                -730,
+                -727,
+                -726,
+                -723,
+                -722,
+                -718,
+                -711,
+                -709,
+                -708,
+                -707,
+                -704,
+                -703,
+                -697,
+                -696,
+                -693,
+                -687,
+                -683,
+                -682,
+                -681,
+                -679,
+                -678,
+                -670,
+                -668,
+                -667,
+                -666,
+                -662,
+                -654,
+                -652,
+                -649,
+                -646,
+                -645,
+                -643,
+                -641,
+                -639,
+                -636,
+                -633,
+                -632,
+                -630,
+                -629,
+                -625,
+                -623,
+                -619,
+                -615,
+                -611,
+                -610,
+                -608,
+                -604,
+                -602,
+                -601,
+                -599,
+                -597,
+                -596,
+                -594,
+                -590,
+                -589,
+                -587,
+                -583,
+                -582,
+                -581,
+                -578,
+                -576,
+                -573,
+                -565,
+                -561,
+                -558,
+                -557,
+                -556,
+                -555,
+                -553,
+                -552,
+                -549,
+                -544,
+                -532,
+                -531,
+                -527,
+                -524,
+                -523,
+                -518,
+                -517,
+                -515,
+                -511,
+                -510,
+                -505,
+                -501,
+                -498,
+                -497,
+                -491,
+                -486,
+                -484,
+                -482,
+                -479,
+                -475,
+                -470,
+                -469,
+                -468,
+                -466,
+                -464,
+                -460,
+                -457,
+                -456,
+                -455,
+                -452,
+                -448,
+                -446,
+                -442,
+                -440,
+                -438,
+                -436,
+                -433,
+                -432,
+                -428,
+                -427,
+                -425,
+                -422,
+                -417,
+                -413,
+                -412,
+                -411,
+                -408,
+                -405,
+                -401,
+                -400,
+                -399,
+                -398,
+                -396,
+                -394,
+                -393,
+                -389,
+                -387,
+                -385,
+                -382,
+                -378,
+                -377,
+                -373,
+                -369,
+                -368,
+                -365,
+                -364,
+                -353,
+                -349,
+                -345,
+                -344,
+                -342,
+                -341,
+                -338,
+                -332,
+                -329,
+                -328,
+                -322,
+                -317,
+                -312,
+                -311,
+                -310,
+                -308,
+                -305,
+                -304,
+                -302,
+                -297,
+                -296,
+                -293,
+                -291,
+                -289,
+                -287,
+                -286,
+                -284,
+                -280,
+                -278,
+                -277,
+                -275,
+                -270,
+                -268,
+                -266,
+                -265,
+                -262,
+                -261,
+                -260,
+                -259,
+                -258,
+                -254,
+                -251,
+                -249,
+                -242,
+                -241,
+                -235,
+                -233,
+                -231,
+                -229,
+                -227,
+                -223,
+                -220,
+                -219,
+                -218,
+                -214,
+                -213,
+                -211,
+                -206,
+                -204,
+                -196,
+                -195,
+                -192,
+                -191,
+                -184,
+                -176,
+                -169,
+                -166,
+                -161,
+                -152,
+                -151,
+                -149,
+                -147,
+                -142,
+                -140,
+                -133,
+                -132,
+                -127,
+                -126,
+                -125,
+                -122,
+                -121,
+                -118,
+                -114,
+                -109,
+                -108,
+                -107,
+                -106,
+                -103,
+                -89,
+                -88,
+                -84,
+                -82,
+                -80,
+                -78,
+                -75,
+                -74,
+                -69,
+                -67,
+                -64,
+                -60,
+                -52,
+                -50,
+                -47,
+                -44,
+                -38,
+                -34,
+                -32,
+                -30,
+                -29,
+                -26,
+                -24,
+                -21,
+                -15,
+                -11,
+                -10,
+                -9,
+                -8,
+                -5
+            ],
+            "output": 999
+        },
+        {
+            "input": [
+                -508,
+                5,
+                -762,
+                775,
+                -248,
+                522,
+                -234,
+                31,
+                -992,
+                289,
+                804,
+                -220,
+                -729,
+                -468,
+                45,
+                558,
+                52,
+                -203,
+                -970,
+                -967,
+                315,
+                -709,
+                573,
+                -448,
+                577,
+                67,
+                71,
+                842,
+                75,
+                844,
+                -944,
+                337,
+                849,
+                -938,
+                -674,
+                607,
+                -927,
+                -924,
+                871,
+                872,
+                617,
+                -141,
+                630,
+                -394,
+                -643,
+                383,
+                -383,
+                643,
+                394,
+                -630,
+                141,
+                -617,
+                -872,
+                -871,
+                924,
+                927,
+                -607,
+                674,
+                938,
+                -337,
+                944,
+                -849,
+                -844,
+                -75,
+                -842,
+                -71,
+                -67,
+                -577,
+                448,
+                -573,
+                709,
+                -315,
+                967,
+                970,
+                203,
+                -52,
+                -558,
+                -45,
+                468,
+                729,
+                220,
+                -804,
+                -289,
+                992,
+                -31,
+                234,
+                -522,
+                248,
+                -775,
+                762,
+                -5,
+                508
+            ],
+            "output": 992
+        },
+        {
+            "input": [
+                3,
+                6,
+                -506,
+                -505,
+                523,
+                526,
+                18,
+                -494,
+                537,
+                -486,
+                29,
+                -989,
+                -475,
+                -979,
+                49,
+                -975,
+                566,
+                55,
+                576,
+                -954,
+                71,
+                585,
+                -438,
+                -434,
+                -945,
+                -430,
+                -927,
+                -409,
+                -918,
+                620,
+                -402,
+                632,
+                -904,
+                -901,
+                130,
+                -879,
+                -367,
+                659,
+                150,
+                151,
+                -872,
+                665,
+                -871,
+                -357,
+                668,
+                -862,
+                -346,
+                682,
+                170,
+                172,
+                -337,
+                -335,
+                -328,
+                -838,
+                -837,
+                -830,
+                -312,
+                -822,
+                -307,
+                -306,
+                720,
+                210,
+                -298,
+                728,
+                222,
+                735,
+                -289,
+                -287,
+                738,
+                739,
+                -286,
+                -283,
+                -792,
+                746,
+                235,
+                -790,
+                749,
+                -272,
+                753,
+                -782,
+                758,
+                253,
+                -771,
+                771,
+                -253,
+                -758,
+                782,
+                -753,
+                272,
+                -749,
+                -235,
+                790,
+                -746,
+                792,
+                283,
+                -739,
+                286,
+                287,
+                -738,
+                289,
+                -735,
+                -222,
+                -728,
+                298,
+                -210,
+                -720,
+                306,
+                307,
+                822,
+                312,
+                830,
+                837,
+                838,
+                328,
+                335,
+                337,
+                -172,
+                -682,
+                -170,
+                346,
+                862,
+                -668,
+                357,
+                871,
+                872,
+                -665,
+                -151,
+                -150,
+                -659,
+                879,
+                367,
+                -130,
+                901,
+                904,
+                -632,
+                402,
+                -620,
+                918,
+                409,
+                927,
+                430,
+                945,
+                434,
+                438,
+                -585,
+                -71,
+                954,
+                -576,
+                -55,
+                -566,
+                975,
+                -49,
+                979,
+                475,
+                989,
+                -6,
+                -29,
+                486,
+                -537,
+                494,
+                -18,
+                -526,
+                -523,
+                505,
+                506,
+                -3
+            ],
+            "output": 989
+        },
+        {
+            "input": [
+                1,
+                4,
+                5,
+                6,
+                11,
+                14,
+                16,
+                20,
+                24,
+                -998,
+                30,
+                32,
+                -990,
+                37,
+                38,
+                40,
+                -984,
+                -981,
+                47,
+                -977,
+                52,
+                53,
+                54,
+                55,
+                -971,
+                -967,
+                60,
+                -964,
+                -961,
+                -960,
+                -958,
+                -957,
+                69,
+                -953,
+                -951,
+                74,
+                76,
+                -948,
+                -941,
+                -939,
+                -938,
+                88,
+                -934,
+                -931,
+                94,
+                97,
+                98,
+                -927,
+                100,
+                -926,
+                -924,
+                -922,
+                105,
+                106,
+                -916,
+                113,
+                114,
+                -909,
+                116,
+                -904,
+                121,
+                123,
+                -900,
+                -899,
+                -896,
+                129,
+                132,
+                133,
+                -890,
+                138,
+                139,
+                -883,
+                146,
+                147,
+                -878,
+                151,
+                152,
+                -873,
+                -872,
+                -870,
+                -871,
+                157,
+                -867,
+                159,
+                -866,
+                -864,
+                -860,
+                165,
+                -858,
+                -856,
+                -854,
+                -852,
+                -850,
+                179,
+                180,
+                -845,
+                -841,
+                -838,
+                192,
+                193,
+                -832,
+                -830,
+                196,
+                -819,
+                206,
+                -817,
+                209,
+                -813,
+                -812,
+                214,
+                216,
+                217,
+                -805,
+                -803,
+                225,
+                228,
+                231,
+                -793,
+                -792,
+                -791,
+                -789,
+                -788,
+                240,
+                241,
+                -783,
+                244,
+                -780,
+                -779,
+                248,
+                252,
+                -769,
+                -761,
+                -760,
+                269,
+                273,
+                278,
+                -746,
+                -743,
+                282,
+                283,
+                -741,
+                287,
+                -736,
+                289,
+                292,
+                293,
+                -731,
+                -730,
+                300,
+                -722,
+                305,
+                -718,
+                307,
+                -714,
+                316,
+                322,
+                -700,
+                -696,
+                -695,
+                -693,
+                334,
+                335,
+                337,
+                -687,
+                -686,
+                341,
+                344,
+                -680,
+                347,
+                348,
+                -674,
+                351,
+                -673,
+                353,
+                354,
+                -671,
+                356,
+                -668,
+                -666,
+                359,
+                -661,
+                366,
+                -658,
+                368,
+                369,
+                -657,
+                -655,
+                -654,
+                -652,
+                -651,
+                376,
+                379,
+                -643,
+                -642,
+                383,
+                385,
+                -639,
+                387,
+                -634,
+                391,
+                -633,
+                -631,
+                -629,
+                396,
+                397,
+                399,
+                402,
+                -621,
+                -620,
+                -618,
+                408,
+                -612,
+                -609,
+                417,
+                -607,
+                420,
+                422,
+                427,
+                -597,
+                -594,
+                -592,
+                435,
+                437,
+                441,
+                -583,
+                -582,
+                446,
+                447,
+                448,
+                -576,
+                450,
+                451,
+                452,
+                -574,
+                -570,
+                455,
+                -569,
+                460,
+                -562,
+                464,
+                465,
+                -549,
+                477,
+                479,
+                480,
+                -539,
+                -538,
+                487,
+                489,
+                490,
+                -531,
+                494,
+                -530,
+                496,
+                -529,
+                -527,
+                501,
+                504,
+                510,
+                -510,
+                -504,
+                -501,
+                527,
+                -496,
+                529,
+                530,
+                531,
+                -494,
+                -490,
+                -489,
+                -487,
+                538,
+                539,
+                -480,
+                -479,
+                -477,
+                549,
+                -465,
+                -464,
+                562,
+                -460,
+                569,
+                570,
+                -455,
+                -452,
+                -451,
+                574,
+                -450,
+                576,
+                -448,
+                -447,
+                -446,
+                582,
+                583,
+                -441,
+                -437,
+                -435,
+                592,
+                594,
+                597,
+                -427,
+                -422,
+                -420,
+                607,
+                -417,
+                609,
+                612,
+                -408,
+                618,
+                620,
+                621,
+                -402,
+                -399,
+                -397,
+                -396,
+                629,
+                631,
+                633,
+                634,
+                -391,
+                -387,
+                639,
+                -385,
+                -383,
+                642,
+                643,
+                -379,
+                -376,
+                651,
+                652,
+                654,
+                655,
+                -369,
+                657,
+                658,
+                -368,
+                -366,
+                661,
+                -359,
+                666,
+                668,
+                -356,
+                -354,
+                671,
+                -353,
+                673,
+                674,
+                -351,
+                -348,
+                -347,
+                680,
+                -344,
+                -341,
+                686,
+                687,
+                -337,
+                -335,
+                -334,
+                693,
+                695,
+                696,
+                700,
+                -322,
+                -316,
+                714,
+                -307,
+                718,
+                -305,
+                722,
+                -300,
+                730,
+                731,
+                -292,
+                -293,
+                -289,
+                736,
+                -287,
+                741,
+                -283,
+                743,
+                -282,
+                746,
+                -278,
+                -273,
+                -269,
+                760,
+                761,
+                769,
+                -252,
+                -248,
+                779,
+                780,
+                -244,
+                783,
+                -241,
+                -240,
+                788,
+                789,
+                791,
+                792,
+                793,
+                -231,
+                -228,
+                -225,
+                803,
+                805,
+                -217,
+                -216,
+                -214,
+                812,
+                813,
+                -209,
+                817,
+                -206,
+                819,
+                -196,
+                830,
+                -193,
+                832,
+                -192,
+                838,
+                841,
+                -180,
+                845,
+                -179,
+                850,
+                852,
+                854,
+                856,
+                858,
+                -165,
+                860,
+                864,
+                -159,
+                866,
+                867,
+                -157,
+                870,
+                871,
+                872,
+                873,
+                -152,
+                -151,
+                -147,
+                878,
+                -146,
+                883,
+                -139,
+                -138,
+                890,
+                -133,
+                -132,
+                -129,
+                896,
+                899,
+                900,
+                -123,
+                -121,
+                904,
+                -116,
+                909,
+                -114,
+                -113,
+                916,
+                -106,
+                -105,
+                922,
+                924,
+                -100,
+                926,
+                927,
+                -98,
+                -97,
+                -94,
+                931,
+                934,
+                -88,
+                938,
+                939,
+                941,
+                948,
+                -76,
+                -74,
+                951,
+                953,
+                -69,
+                957,
+                958,
+                960,
+                961,
+                964,
+                -60,
+                967,
+                -55,
+                -54,
+                971,
+                -53,
+                -52,
+                977,
+                -47,
+                981,
+                984,
+                -40,
+                -38,
+                -37,
+                990,
+                -32,
+                -30,
+                998,
+                -24,
+                -20,
+                -16,
+                -14,
+                -11,
+                -6,
+                -5,
+                -4,
+                -1
+            ],
+            "output": 998
+        },
+        {
+            "input": [
+                8,
+                10,
+                11,
+                16,
+                21,
+                28,
+                -989,
+                -988,
+                40,
+                44,
+                -979,
+                54,
+                -970,
+                57,
+                -963,
+                63,
+                65,
+                -952,
+                -951,
+                74,
+                -950,
+                -949,
+                -946,
+                81,
+                82,
+                -940,
+                85,
+                97,
+                -927,
+                103,
+                105,
+                107,
+                -917,
+                112,
+                -907,
+                -905,
+                -904,
+                123,
+                -897,
+                134,
+                -890,
+                136,
+                -888,
+                -883,
+                -880,
+                -879,
+                151,
+                -864,
+                -863,
+                -862,
+                163,
+                -861,
+                -857,
+                -855,
+                170,
+                171,
+                -852,
+                -850,
+                -848,
+                -847,
+                179,
+                -845,
+                -844,
+                -840,
+                185,
+                -839,
+                187,
+                194,
+                198,
+                199,
+                -826,
+                -824,
+                202,
+                -813,
+                213,
+                220,
+                222,
+                -802,
+                -801,
+                226,
+                -793,
+                242,
+                -778,
+                -777,
+                -774,
+                -768,
+                261,
+                -762,
+                263,
+                264,
+                265,
+                280,
+                -741,
+                284,
+                288,
+                290,
+                -734,
+                -731,
+                295,
+                303,
+                306,
+                -715,
+                318,
+                324,
+                325,
+                -700,
+                -694,
+                -689,
+                -685,
+                340,
+                344,
+                345,
+                -676,
+                354,
+                356,
+                357,
+                -664,
+                363,
+                -658,
+                370,
+                373,
+                375,
+                -648,
+                -645,
+                380,
+                381,
+                -644,
+                383,
+                384,
+                387,
+                389,
+                390,
+                -635,
+                394,
+                -629,
+                397,
+                398,
+                -627,
+                401,
+                -618,
+                -616,
+                410,
+                411,
+                -611,
+                -607,
+                422,
+                -599,
+                427,
+                -586,
+                439,
+                451,
+                453,
+                454,
+                457,
+                465,
+                -559,
+                471,
+                -552,
+                473,
+                -550,
+                -547,
+                479,
+                -541,
+                484,
+                -540,
+                489,
+                490,
+                491,
+                -532,
+                493,
+                497,
+                498,
+                500,
+                511,
+                -513,
+                513,
+                -511,
+                -500,
+                -498,
+                -497,
+                -493,
+                532,
+                -491,
+                -490,
+                -489,
+                540,
+                541,
+                -484,
+                -479,
+                547,
+                550,
+                -473,
+                552,
+                -471,
+                559,
+                -465,
+                -457,
+                -454,
+                -453,
+                -451,
+                -439,
+                586,
+                -427,
+                599,
+                -422,
+                607,
+                611,
+                -411,
+                -410,
+                616,
+                618,
+                -401,
+                -398,
+                627,
+                -397,
+                629,
+                -394,
+                -390,
+                635,
+                -389,
+                -387,
+                -384,
+                -383,
+                -381,
+                644,
+                645,
+                -380,
+                648,
+                -375,
+                -373,
+                -370,
+                658,
+                -363,
+                664,
+                -357,
+                -356,
+                -354,
+                676,
+                -345,
+                -344,
+                -340,
+                685,
+                689,
+                694,
+                -325,
+                700,
+                -324,
+                -318,
+                715,
+                -306,
+                -303,
+                -295,
+                731,
+                734,
+                -290,
+                -288,
+                -284,
+                741,
+                -280,
+                -265,
+                -264,
+                -263,
+                762,
+                -261,
+                768,
+                774,
+                777,
+                778,
+                -242,
+                793,
+                -226,
+                801,
+                802,
+                -222,
+                -220,
+                -213,
+                813,
+                -202,
+                824,
+                -199,
+                826,
+                -198,
+                -194,
+                -187,
+                839,
+                840,
+                -185,
+                844,
+                845,
+                -179,
+                847,
+                848,
+                850,
+                852,
+                -171,
+                -170,
+                855,
+                857,
+                861,
+                862,
+                863,
+                864,
+                -163,
+                -151,
+                879,
+                880,
+                883,
+                888,
+                -136,
+                890,
+                -134,
+                897,
+                -123,
+                904,
+                905,
+                907,
+                -112,
+                917,
+                -107,
+                -105,
+                -103,
+                927,
+                -97,
+                -85,
+                940,
+                -82,
+                -81,
+                946,
+                949,
+                950,
+                951,
+                952,
+                -74,
+                -65,
+                -63,
+                963,
+                -57,
+                970,
+                -54,
+                979,
+                -44,
+                -40,
+                988,
+                989,
+                -28,
+                -21,
+                -16,
+                -11,
+                -10,
+                -8
+            ],
+            "output": 989
+        },
+        {
+            "input": [
+                4,
+                7,
+                10,
+                14,
+                28,
+                30,
+                -993,
+                -988,
+                -987,
+                -985,
+                40,
+                -984,
+                44,
+                46,
+                -977,
+                53,
+                55,
+                -968,
+                61,
+                -962,
+                -960,
+                -957,
+                73,
+                -942,
+                83,
+                87,
+                89,
+                90,
+                -933,
+                -930,
+                95,
+                -928,
+                -920,
+                -919,
+                -917,
+                109,
+                -912,
+                113,
+                115,
+                116,
+                -907,
+                120,
+                121,
+                -903,
+                123,
+                126,
+                -888,
+                -887,
+                143,
+                146,
+                149,
+                -873,
+                152,
+                -870,
+                -868,
+                -866,
+                -863,
+                -862,
+                169,
+                -855,
+                171,
+                172,
+                175,
+                179,
+                -840,
+                -839,
+                -837,
+                188,
+                -836,
+                196,
+                -825,
+                202,
+                -821,
+                -815,
+                224,
+                -798,
+                231,
+                233,
+                -788,
+                -785,
+                240,
+                241,
+                -784,
+                -783,
+                248,
+                -774,
+                252,
+                253,
+                254,
+                -772,
+                265,
+                266,
+                -753,
+                279,
+                280,
+                281,
+                284,
+                291,
+                -732,
+                294,
+                -730,
+                299,
+                300,
+                -724,
+                303,
+                308,
+                310,
+                -714,
+                316,
+                -704,
+                321,
+                322,
+                -700,
+                332,
+                -689,
+                -685,
+                342,
+                344,
+                350,
+                -674,
+                -672,
+                354,
+                358,
+                -662,
+                365,
+                -658,
+                -657,
+                369,
+                -654,
+                376,
+                -647,
+                378,
+                -645,
+                382,
+                384,
+                385,
+                -640,
+                387,
+                -638,
+                -636,
+                391,
+                396,
+                400,
+                401,
+                -623,
+                403,
+                -621,
+                407,
+                413,
+                -605,
+                -604,
+                423,
+                -600,
+                426,
+                427,
+                -589,
+                -587,
+                -584,
+                442,
+                -579,
+                -578,
+                -573,
+                -565,
+                462,
+                466,
+                468,
+                -556,
+                -554,
+                471,
+                473,
+                -551,
+                -550,
+                -548,
+                477,
+                483,
+                -540,
+                491,
+                -531,
+                495,
+                496,
+                -528,
+                500,
+                -524,
+                508,
+                -515,
+                -514,
+                514,
+                515,
+                -508,
+                524,
+                -500,
+                528,
+                -496,
+                -495,
+                531,
+                -491,
+                540,
+                -483,
+                -477,
+                548,
+                550,
+                551,
+                -473,
+                -471,
+                554,
+                556,
+                -468,
+                -466,
+                -462,
+                565,
+                573,
+                578,
+                579,
+                -442,
+                584,
+                587,
+                589,
+                -427,
+                -426,
+                600,
+                -423,
+                604,
+                605,
+                -413,
+                -407,
+                621,
+                -403,
+                623,
+                -401,
+                -400,
+                -396,
+                -391,
+                636,
+                -387,
+                638,
+                -385,
+                640,
+                -384,
+                -382,
+                645,
+                -378,
+                647,
+                -376,
+                654,
+                -369,
+                657,
+                658,
+                -365,
+                662,
+                -358,
+                -354,
+                672,
+                674,
+                -350,
+                -344,
+                -342,
+                685,
+                689,
+                -332,
+                700,
+                -322,
+                -321,
+                704,
+                -316,
+                714,
+                -310,
+                -308,
+                -303,
+                724,
+                -300,
+                -299,
+                730,
+                -294,
+                732,
+                -291,
+                -284,
+                -281,
+                -280,
+                -279,
+                753,
+                -266,
+                -265,
+                -254,
+                -253,
+                772,
+                -252,
+                774,
+                -248,
+                783,
+                784,
+                785,
+                -240,
+                -241,
+                788,
+                -233,
+                -231,
+                798,
+                -224,
+                815,
+                821,
+                -202,
+                825,
+                -196,
+                836,
+                837,
+                -188,
+                839,
+                840,
+                -179,
+                -175,
+                -172,
+                -171,
+                855,
+                -169,
+                862,
+                863,
+                866,
+                868,
+                870,
+                -152,
+                873,
+                -149,
+                -146,
+                -143,
+                887,
+                888,
+                -126,
+                -123,
+                903,
+                -121,
+                -120,
+                907,
+                -116,
+                -115,
+                -113,
+                912,
+                -109,
+                917,
+                919,
+                920,
+                928,
+                -95,
+                930,
+                933,
+                -90,
+                -89,
+                -87,
+                -83,
+                942,
+                -73,
+                957,
+                960,
+                962,
+                -61,
+                968,
+                -55,
+                -53,
+                977,
+                -46,
+                -44,
+                984,
+                985,
+                -40,
+                987,
+                988,
+                993,
+                -30,
+                -28,
+                -14,
+                -10,
+                -7,
+                -4
+            ],
+            "output": 993
+        },
+        {
+            "input": [
+                516,
+                -764,
+                11,
+                15,
+                530,
+                -231,
+                -484,
+                -736,
+                36,
+                295,
+                -982,
+                557,
+                815,
+                563,
+                55,
+                823,
+                825,
+                -969,
+                -455,
+                -196,
+                323,
+                581,
+                330,
+                335,
+                -431,
+                -687,
+                339,
+                595,
+                -937,
+                856,
+                602,
+                -165,
+                93,
+                869,
+                -409,
+                618,
+                -662,
+                -146,
+                -655,
+                -398,
+                893,
+                -893,
+                398,
+                655,
+                146,
+                662,
+                -618,
+                409,
+                -869,
+                -93,
+                165,
+                -602,
+                -856,
+                937,
+                -339,
+                -595,
+                431,
+                687,
+                -335,
+                -330,
+                -581,
+                -323,
+                196,
+                455,
+                -825,
+                969,
+                -55,
+                -823,
+                -563,
+                -815,
+                -557,
+                982,
+                -295,
+                -36,
+                -516,
+                736,
+                484,
+                231,
+                -530,
+                -15,
+                -11,
+                764
+            ],
+            "output": 982
+        },
+        {
+            "input": [
+                771,
+                517,
+                262,
+                522,
+                -500,
+                -499,
+                -497,
+                784,
+                275,
+                276,
+                532,
+                -489,
+                -487,
+                -231,
+                -229,
+                806,
+                -986,
+                553,
+                298,
+                43,
+                -213,
+                -979,
+                -723,
+                -209,
+                563,
+                52,
+                -716,
+                -968,
+                -711,
+                -197,
+                -707,
+                -451,
+                -960,
+                833,
+                834,
+                322,
+                -446,
+                -190,
+                585,
+                329,
+                75,
+                -431,
+                595,
+                339,
+                -173,
+                343,
+                856,
+                -425,
+                346,
+                -167,
+                -169,
+                -931,
+                354,
+                611,
+                -158,
+                -155,
+                614,
+                871,
+                -666,
+                364,
+                -147,
+                -659,
+                -145,
+                112,
+                -916,
+                -140,
+                119,
+                -649,
+                -902,
+                894,
+                -894,
+                902,
+                649,
+                -119,
+                140,
+                -112,
+                145,
+                147,
+                659,
+                916,
+                -364,
+                -871,
+                666,
+                155,
+                -614,
+                -611,
+                158,
+                -354,
+                931,
+                -346,
+                167,
+                -856,
+                425,
+                169,
+                -343,
+                173,
+                -595,
+                431,
+                -339,
+                -75,
+                -585,
+                -329,
+                446,
+                190,
+                960,
+                -834,
+                -833,
+                707,
+                451,
+                197,
+                -322,
+                711,
+                968,
+                716,
+                -52,
+                -563,
+                209,
+                979,
+                723,
+                213,
+                -43,
+                -298,
+                -553,
+                986,
+                -806,
+                229,
+                487,
+                231,
+                489,
+                -276,
+                -532,
+                -275,
+                -784,
+                497,
+                499,
+                500,
+                -522,
+                -262,
+                -517,
+                -771
+            ],
+            "output": 986
+        }
+    ],
+    "haskell_template": "findMaxK :: [Int] -> Int\nfindMaxK nums ",
+    "ocaml_template": "let findMaxK (nums: int list) : int =  ",
+    "scala_template": "def findMaxK(nums: List[Int]): Int = { \n    \n}",
+    "java_template": "public static int findMaxK(List<Integer> nums) {\n\n}",
+    "python_template": "class Solution(object):\n    def findMaxK(self, nums):\n        \"\"\"\n        :type nums: List[int]\n        :rtype: int\n        \"\"\"\n        "
+}