diff --git a/CHANGELOG.md b/CHANGELOG.md
index f062c17..e2c99cd 100644
--- a/CHANGELOG.md
+++ b/CHANGELOG.md
@@ -1,3 +1,8 @@
+## version 2.19.1
+
+- 区域调试参数,等到使用的时候才生成
+- 部分题目配置调试区后还是无法调试问题
+
 ## version 2.18.1
 
 - 增加周赛场次信息展示
diff --git a/README.md b/README.md
index b3f9a67..70661a1 100644
--- a/README.md
+++ b/README.md
@@ -84,7 +84,6 @@
    // @lcpr-div-debug-arg-start
    // funName= alternateDigitSum
    // paramTypes= ["number"]
-   // returnType= number
    // @lcpr-div-debug-arg-end
    ```
 2. diy 参数说明
@@ -120,9 +119,6 @@
       - 类型说明:数组
     - "TreeNode"
       - 类型说明:树节点
-- returnType:函数的返回值
-
-  - 可填入内容同 paramTypes
 
 <!-- ## TODO 看到一些可能会用得上的功能
 
diff --git a/package-lock.json b/package-lock.json
index 7147e8b..aa99914 100644
--- a/package-lock.json
+++ b/package-lock.json
@@ -1,12 +1,12 @@
 {
     "name": "vscode-leetcode-problem-rating",
-    "version": "2.14.2",
+    "version": "2.18.1",
     "lockfileVersion": 2,
     "requires": true,
     "packages": {
         "": {
             "name": "vscode-leetcode-problem-rating",
-            "version": "2.14.2",
+            "version": "2.18.1",
             "license": "MIT",
             "dependencies": {
                 "ansi-styles": "3.2.1",
diff --git a/package.json b/package.json
index fd17b0d..52e81ce 100644
--- a/package.json
+++ b/package.json
@@ -2,7 +2,7 @@
     "name": "vscode-leetcode-problem-rating",
     "displayName": "LeetCode",
     "description": "%main.description%",
-    "version": "2.18.1",
+    "version": "2.19.1",
     "author": "ccagml",
     "publisher": "ccagml",
     "license": "MIT",
@@ -1018,7 +1018,8 @@
                             "case",
                             "allcase",
                             "test",
-                            "solution"
+                            "solution",
+                            "debug"
                         ],
                         "scope": "application",
                         "items": {
@@ -1030,7 +1031,8 @@
                                 "solution",
                                 "description",
                                 "case",
-                                "allcase"
+                                "allcase",
+                                "debug"
                             ],
                             "enumDescriptions": [
                                 "%main.contributes.configuration.properties.leetcode-problem-rating.editor.shortcuts.items.enumDescriptions.0%",
@@ -1039,7 +1041,8 @@
                                 "%main.contributes.configuration.properties.leetcode-problem-rating.editor.shortcuts.items.enumDescriptions.3%",
                                 "%main.contributes.configuration.properties.leetcode-problem-rating.editor.shortcuts.items.enumDescriptions.4%",
                                 "%main.contributes.configuration.properties.leetcode-problem-rating.editor.shortcuts.items.enumDescriptions.5%",
-                                "%main.contributes.configuration.properties.leetcode-problem-rating.editor.shortcuts.items.enumDescriptions.6%"
+                                "%main.contributes.configuration.properties.leetcode-problem-rating.editor.shortcuts.items.enumDescriptions.6%",
+                                "%main.contributes.configuration.properties.leetcode-problem-rating.editor.shortcuts.items.enumDescriptions.7%"
                             ]
                         },
                         "description": "%main.contributes.configuration.properties.leetcode-problem-rating.editor.shortcuts.description%"
diff --git a/package.nls.json b/package.nls.json
index 7e92505..f019dac 100644
--- a/package.nls.json
+++ b/package.nls.json
@@ -79,7 +79,8 @@
         "Show the top voted solution for the current problem.",
         "Show the problem description page.",
         "Test default case",
-        "Test all default case"
+        "Test all default case",
+        "Debug case"
     ],
     "main.contributes.configuration.properties.leetcode-problem-rating.enableSideMode.description": "Determine whether to group all webview pages into the second editor column when solving problems.",
     "main.contributes.configuration.properties.leetcode-problem-rating.nodePath.description": "The Node.js executable path. for example, C:\\Program Files\\nodejs\\node.exe",
diff --git a/package.nls.zh-cn.json b/package.nls.zh-cn.json
index 7c5f804..0186908 100644
--- a/package.nls.zh-cn.json
+++ b/package.nls.zh-cn.json
@@ -73,13 +73,14 @@
     "main.contributes.configuration.properties.leetcode-problem-rating.enableStatusBar.description": "是否显示状态栏。",
     "main.contributes.configuration.properties.leetcode-problem-rating.editor.shortcuts.description": "自定义编辑器中的快捷方式。",
     "main.contributes.configuration.properties.leetcode-problem-rating.editor.shortcuts.items.enumDescriptions": [
-        "Submit your answer to LeetCode.",
-        "Test your answer with customized test cases.",
-        "Star or unstar the current problem.",
-        "Show the top voted solution for the current problem.",
-        "Show the problem description page.",
-        "Test default case",
-        "Test all default case"
+        "提交题解",
+        "提交测试",
+        "题目标心",
+        "获取题解",
+        "显示题目简介",
+        "提交默认测试",
+        "提交所有测试",
+        "本地调试"
     ],
     "main.contributes.configuration.properties.leetcode-problem-rating.enableSideMode.description": "解决问题时确定是否将所有webview页面分组到第二个编辑器列中。",
     "main.contributes.configuration.properties.leetcode-problem-rating.nodePath.description": "Node.js 可执行文件路径。 例如:C:\\Program Files\\nodejs\\node.exe",
diff --git a/resources/data.json b/resources/data.json
index c8cecbf..df6451e 100644
--- a/resources/data.json
+++ b/resources/data.json
@@ -87,6 +87,17 @@
         "ContestID_en": "Biweekly Contest 58",
         "ContestID_zh": "第 58 场双周赛"
     },
+    {
+        "Rating": 2681.7054310332,
+        "ID": 2573,
+        "Title": "Find the String with LCP",
+        "TitleZH": "找出对应 LCP 矩阵的字符串",
+        "TitleSlug": "find-the-string-with-lcp",
+        "ContestSlug": "weekly-contest-333",
+        "ProblemIndex": "Q4",
+        "ContestID_en": "Weekly Contest 333",
+        "ContestID_zh": "第 333 场周赛"
+    },
     {
         "Rating": 2666.668150845,
         "ID": 1397,
@@ -736,6 +747,28 @@
         "ContestID_en": "Weekly Contest 101",
         "ContestID_zh": "第 101 场周赛"
     },
+    {
+        "Rating": 2432.713399111,
+        "ID": 2552,
+        "Title": "Count Increasing Quadruplets",
+        "TitleZH": "统计上升四元组",
+        "TitleSlug": "count-increasing-quadruplets",
+        "ContestSlug": "weekly-contest-330",
+        "ProblemIndex": "Q4",
+        "ContestID_en": "Weekly Contest 330",
+        "ContestID_zh": "第 330 场周赛"
+    },
+    {
+        "Rating": 2432.4146343542,
+        "ID": 2565,
+        "Title": "Subsequence With the Minimum Score",
+        "TitleZH": "最少得分子序列",
+        "TitleSlug": "subsequence-with-the-minimum-score",
+        "ContestSlug": "weekly-contest-332",
+        "ProblemIndex": "Q4",
+        "ContestID_en": "Weekly Contest 332",
+        "ContestID_zh": "第 332 场周赛"
+    },
     {
         "Rating": 2429.6705422448,
         "ID": 782,
@@ -791,6 +824,17 @@
         "ContestID_en": "Weekly Contest 256",
         "ContestID_zh": "第 256 场周赛"
     },
+    {
+        "Rating": 2419.5791089724,
+        "ID": 2572,
+        "Title": "Count the Number of Square-Free Subsets",
+        "TitleZH": "无平方子集计数",
+        "TitleSlug": "count-the-number-of-square-free-subsets",
+        "ContestSlug": "weekly-contest-333",
+        "ProblemIndex": "Q3",
+        "ContestID_en": "Weekly Contest 333",
+        "ContestID_zh": "第 333 场周赛"
+    },
     {
         "Rating": 2418.5742747632,
         "ID": 1203,
@@ -879,6 +923,17 @@
         "ContestID_en": "Weekly Contest 328",
         "ContestID_zh": "第 328 场周赛"
     },
+    {
+        "Rating": 2397.8728428256,
+        "ID": 2569,
+        "Title": "Handling Sum Queries After Update",
+        "TitleZH": "更新数组后处理求和查询",
+        "TitleSlug": "handling-sum-queries-after-update",
+        "ContestSlug": "biweekly-contest-98",
+        "ProblemIndex": "Q4",
+        "ContestID_en": "Biweekly Contest 98",
+        "ContestID_zh": "第 98 场双周赛"
+    },
     {
         "Rating": 2396.6267778669,
         "ID": 808,
@@ -967,6 +1022,17 @@
         "ContestID_en": "Weekly Contest 198",
         "ContestID_zh": "第 198 场周赛"
     },
+    {
+        "Rating": 2381.625583289,
+        "ID": 2577,
+        "Title": "Minimum Time to Visit a Cell In a Grid",
+        "TitleZH": "在网格图中访问一个格子的最少时间",
+        "TitleSlug": "minimum-time-to-visit-a-cell-in-a-grid",
+        "ContestSlug": "weekly-contest-334",
+        "ProblemIndex": "Q4",
+        "ContestID_en": "Weekly Contest 334",
+        "ContestID_zh": "第 334 场周赛"
+    },
     {
         "Rating": 2381.6019709166,
         "ID": 2468,
@@ -1044,6 +1110,17 @@
         "ContestID_en": "Weekly Contest 238",
         "ContestID_zh": "第 238 场周赛"
     },
+    {
+        "Rating": 2368.6674771307,
+        "ID": 2556,
+        "Title": "Disconnect Path in a Binary Matrix by at Most One Flip",
+        "TitleZH": "二进制矩阵中翻转最多一次使路径不连通",
+        "TitleSlug": "disconnect-path-in-a-binary-matrix-by-at-most-one-flip",
+        "ContestSlug": "biweekly-contest-97",
+        "ProblemIndex": "Q4",
+        "ContestID_en": "Biweekly Contest 97",
+        "ContestID_zh": "第 97 场双周赛"
+    },
     {
         "Rating": 2366.7099607655,
         "ID": 1183,
@@ -1781,6 +1858,17 @@
         "ContestID_en": "Weekly Contest 293",
         "ContestID_zh": "第 293 场周赛"
     },
+    {
+        "Rating": 2221.793185714,
+        "ID": 2561,
+        "Title": "Rearranging Fruits",
+        "TitleZH": "重排水果",
+        "TitleSlug": "rearranging-fruits",
+        "ContestSlug": "weekly-contest-331",
+        "ProblemIndex": "Q4",
+        "ContestID_en": "Weekly Contest 331",
+        "ContestID_zh": "第 331 场周赛"
+    },
     {
         "Rating": 2221.7336557442,
         "ID": 1542,
@@ -2793,6 +2881,28 @@
         "ContestID_en": "Biweekly Contest 38",
         "ContestID_zh": "第 38 场双周赛"
     },
+    {
+        "Rating": 2081.1880297942,
+        "ID": 2560,
+        "Title": "House Robber IV",
+        "TitleZH": "打家劫舍 IV",
+        "TitleSlug": "house-robber-iv",
+        "ContestSlug": "weekly-contest-331",
+        "ProblemIndex": "Q3",
+        "ContestID_en": "Weekly Contest 331",
+        "ContestID_zh": "第 331 场周赛"
+    },
+    {
+        "Rating": 2080.7845644831,
+        "ID": 2555,
+        "Title": "Maximize Win From Two Segments",
+        "TitleZH": "两个线段获得的最多奖品",
+        "TitleSlug": "maximize-win-from-two-segments",
+        "ContestSlug": "biweekly-contest-97",
+        "ProblemIndex": "Q3",
+        "ContestID_en": "Biweekly Contest 97",
+        "ContestID_zh": "第 97 场双周赛"
+    },
     {
         "Rating": 2080.0425875741,
         "ID": 1718,
@@ -3167,6 +3277,17 @@
         "ContestID_en": "Weekly Contest 202",
         "ContestID_zh": "第 202 场周赛"
     },
+    {
+        "Rating": 2042.4005521254,
+        "ID": 2551,
+        "Title": "Put Marbles in Bags",
+        "TitleZH": "将珠子放入背包中",
+        "TitleSlug": "put-marbles-in-bags",
+        "ContestSlug": "weekly-contest-330",
+        "ProblemIndex": "Q3",
+        "ContestID_en": "Weekly Contest 330",
+        "ContestID_zh": "第 330 场周赛"
+    },
     {
         "Rating": 2040.5621123027,
         "ID": 1751,
@@ -4058,6 +4179,17 @@
         "ContestID_en": "Weekly Contest 308",
         "ContestID_zh": "第 308 场周赛"
     },
+    {
+        "Rating": 1959.2696201953,
+        "ID": 2564,
+        "Title": "Substring XOR Queries",
+        "TitleZH": "子字符串异或查询",
+        "TitleSlug": "substring-xor-queries",
+        "ContestSlug": "weekly-contest-332",
+        "ProblemIndex": "Q3",
+        "ContestID_en": "Weekly Contest 332",
+        "ContestID_zh": "第 332 场周赛"
+    },
     {
         "Rating": 1956.7059585934,
         "ID": 1463,
@@ -5290,6 +5422,17 @@
         "ContestID_en": "Weekly Contest 184",
         "ContestID_zh": "第 184 场周赛"
     },
+    {
+        "Rating": 1843.2383664194,
+        "ID": 2576,
+        "Title": "Find the Maximum Number of Marked Indices",
+        "TitleZH": "求出最多标记下标",
+        "TitleSlug": "find-the-maximum-number-of-marked-indices",
+        "ContestSlug": "weekly-contest-334",
+        "ProblemIndex": "Q3",
+        "ContestID_en": "Weekly Contest 334",
+        "ContestID_zh": "第 334 场周赛"
+    },
     {
         "Rating": 1841.4067816266,
         "ID": 2013,
@@ -6324,6 +6467,17 @@
         "ContestID_en": "Weekly Contest 252",
         "ContestID_zh": "第 252 场周赛"
     },
+    {
+        "Rating": 1754.1710323358,
+        "ID": 2568,
+        "Title": "Minimum Impossible OR",
+        "TitleZH": "最小无法得到的或值",
+        "TitleSlug": "minimum-impossible-or",
+        "ContestSlug": "biweekly-contest-98",
+        "ProblemIndex": "Q3",
+        "ContestID_en": "Biweekly Contest 98",
+        "ContestID_zh": "第 98 场双周赛"
+    },
     {
         "Rating": 1753.9062487685,
         "ID": 1216,
@@ -6720,6 +6874,17 @@
         "ContestID_en": "Biweekly Contest 9",
         "ContestID_zh": "第 9 场双周赛"
     },
+    {
+        "Rating": 1720.7470612766,
+        "ID": 2563,
+        "Title": "Count the Number of Fair Pairs",
+        "TitleZH": "统计公平数对的数目",
+        "TitleSlug": "count-the-number-of-fair-pairs",
+        "ContestSlug": "weekly-contest-332",
+        "ProblemIndex": "Q2",
+        "ContestID_en": "Weekly Contest 332",
+        "ContestID_zh": "第 332 场周赛"
+    },
     {
         "Rating": 1719.945199874,
         "ID": 1239,
@@ -7556,6 +7721,17 @@
         "ContestID_en": "Weekly Contest 91",
         "ContestID_zh": "第 91 场周赛"
     },
+    {
+        "Rating": 1662.7075394144,
+        "ID": 2550,
+        "Title": "Count Collisions of Monkeys on a Polygon",
+        "TitleZH": "猴子碰撞的方法数",
+        "TitleSlug": "count-collisions-of-monkeys-on-a-polygon",
+        "ContestSlug": "weekly-contest-330",
+        "ProblemIndex": "Q2",
+        "ContestID_en": "Weekly Contest 330",
+        "ContestID_zh": "第 330 场周赛"
+    },
     {
         "Rating": 1662.6673692545,
         "ID": 2170,
@@ -7765,6 +7941,17 @@
         "ContestID_en": "Weekly Contest 326",
         "ContestID_zh": "第 326 场周赛"
     },
+    {
+        "Rating": 1649.2000410344,
+        "ID": 2571,
+        "Title": "Minimum Operations to Reduce an Integer to 0",
+        "TitleZH": "将整数减少到零需要的最少操作数",
+        "TitleSlug": "minimum-operations-to-reduce-an-integer-to-0",
+        "ContestSlug": "weekly-contest-333",
+        "ProblemIndex": "Q2",
+        "ContestID_en": "Weekly Contest 333",
+        "ContestID_zh": "第 333 场周赛"
+    },
     {
         "Rating": 1648.3540381514,
         "ID": 2423,
@@ -8282,6 +8469,17 @@
         "ContestID_en": "Biweekly Contest 89",
         "ContestID_zh": "第 89 场双周赛"
     },
+    {
+        "Rating": 1608.577875807,
+        "ID": 2567,
+        "Title": "Minimum Score by Changing Two Elements",
+        "TitleZH": "修改两个元素的最小分数",
+        "TitleSlug": "minimum-score-by-changing-two-elements",
+        "ContestSlug": "biweekly-contest-98",
+        "ProblemIndex": "Q2",
+        "ContestID_en": "Biweekly Contest 98",
+        "ContestID_zh": "第 98 场双周赛"
+    },
     {
         "Rating": 1607.80608595,
         "ID": 962,
@@ -9162,6 +9360,17 @@
         "ContestID_en": "Weekly Contest 156",
         "ContestID_zh": "第 156 场周赛"
     },
+    {
+        "Rating": 1541.3741526845,
+        "ID": 2575,
+        "Title": "Find the Divisibility Array of a String",
+        "TitleZH": "找出字符串的可整除数组",
+        "TitleSlug": "find-the-divisibility-array-of-a-string",
+        "ContestSlug": "weekly-contest-334",
+        "ProblemIndex": "Q2",
+        "ContestID_en": "Weekly Contest 334",
+        "ContestID_zh": "第 334 场周赛"
+    },
     {
         "Rating": 1541.348438509,
         "ID": 1007,
@@ -10625,6 +10834,17 @@
         "ContestID_en": "Weekly Contest 132",
         "ContestID_zh": "第 132 场周赛"
     },
+    {
+        "Rating": 1435.0179887342,
+        "ID": 2559,
+        "Title": "Count Vowel Strings in Ranges",
+        "TitleZH": "统计范围内的元音字符串数",
+        "TitleSlug": "count-vowel-strings-in-ranges",
+        "ContestSlug": "weekly-contest-331",
+        "ProblemIndex": "Q2",
+        "ContestID_en": "Weekly Contest 331",
+        "ContestID_zh": "第 331 场周赛"
+    },
     {
         "Rating": 1433.0795554833,
         "ID": 1535,
@@ -11296,6 +11516,17 @@
         "ContestID_en": "Weekly Contest 111",
         "ContestID_zh": "第 111 场周赛"
     },
+    {
+        "Rating": 1396.1044458638,
+        "ID": 2566,
+        "Title": "Maximum Difference by Remapping a Digit",
+        "TitleZH": "替换一个数字后的最大差值",
+        "TitleSlug": "maximum-difference-by-remapping-a-digit",
+        "ContestSlug": "biweekly-contest-98",
+        "ProblemIndex": "Q1",
+        "ContestID_en": "Biweekly Contest 98",
+        "ContestID_zh": "第 98 场双周赛"
+    },
     {
         "Rating": 1395.5132479177,
         "ID": 1668,
@@ -12451,6 +12682,17 @@
         "ContestID_en": "Weekly Contest 234",
         "ContestID_zh": "第 234 场周赛"
     },
+    {
+        "Rating": 1333.2008827592,
+        "ID": 2554,
+        "Title": "Maximum Number of Integers to Choose From a Range I",
+        "TitleZH": "从一个范围内选择最多整数 I",
+        "TitleSlug": "maximum-number-of-integers-to-choose-from-a-range-i",
+        "ContestSlug": "biweekly-contest-97",
+        "ProblemIndex": "Q2",
+        "ContestID_en": "Biweekly Contest 97",
+        "ContestID_zh": "第 97 场双周赛"
+    },
     {
         "Rating": 1333.192050397,
         "ID": 2181,
@@ -13540,6 +13782,17 @@
         "ContestID_en": "Weekly Contest 211",
         "ContestID_zh": "第 211 场周赛"
     },
+    {
+        "Rating": 1281.0889272532,
+        "ID": 2570,
+        "Title": "Merge Two 2D Arrays by Summing Values",
+        "TitleZH": "合并两个二维数组 - 求和法",
+        "TitleSlug": "merge-two-2d-arrays-by-summing-values",
+        "ContestSlug": "weekly-contest-333",
+        "ProblemIndex": "Q1",
+        "ContestID_en": "Weekly Contest 333",
+        "ContestID_zh": "第 333 场周赛"
+    },
     {
         "Rating": 1280.2941647587,
         "ID": 1572,
@@ -13617,6 +13870,17 @@
         "ContestID_en": "Weekly Contest 171",
         "ContestID_zh": "第 171 场周赛"
     },
+    {
+        "Rating": 1276.7817742915,
+        "ID": 2558,
+        "Title": "Take Gifts From the Richest Pile",
+        "TitleZH": "从数量最多的堆取走礼物",
+        "TitleSlug": "take-gifts-from-the-richest-pile",
+        "ContestSlug": "weekly-contest-331",
+        "ProblemIndex": "Q1",
+        "ContestID_en": "Weekly Contest 331",
+        "ContestID_zh": "第 331 场周赛"
+    },
     {
         "Rating": 1275.6108152653,
         "ID": 2150,
@@ -13815,6 +14079,17 @@
         "ContestID_en": "Weekly Contest 81",
         "ContestID_zh": "第 81 场周赛"
     },
+    {
+        "Rating": 1265.8320564115,
+        "ID": 2549,
+        "Title": "Count Distinct Numbers on Board",
+        "TitleZH": "统计桌面上的不同数字",
+        "TitleSlug": "count-distinct-numbers-on-board",
+        "ContestSlug": "weekly-contest-330",
+        "ProblemIndex": "Q1",
+        "ContestID_en": "Weekly Contest 330",
+        "ContestID_zh": "第 330 场周赛"
+    },
     {
         "Rating": 1264.4836883082,
         "ID": 1736,
@@ -13925,6 +14200,17 @@
         "ContestID_en": "Weekly Contest 169",
         "ContestID_zh": "第 169 场周赛"
     },
+    {
+        "Rating": 1259.949137745,
+        "ID": 2562,
+        "Title": "Find the Array Concatenation Value",
+        "TitleZH": "找出数组的串联值",
+        "TitleSlug": "find-the-array-concatenation-value",
+        "ContestSlug": "weekly-contest-332",
+        "ProblemIndex": "Q1",
+        "ContestID_en": "Weekly Contest 332",
+        "ContestID_zh": "第 332 场周赛"
+    },
     {
         "Rating": 1259.5707438932,
         "ID": 1779,
@@ -14904,6 +15190,17 @@
         "ContestID_en": "Weekly Contest 239",
         "ContestID_zh": "第 239 场周赛"
     },
+    {
+        "Rating": 1216.612918849,
+        "ID": 2553,
+        "Title": "Separate the Digits in an Array",
+        "TitleZH": "分割数组中数字的数位",
+        "TitleSlug": "separate-the-digits-in-an-array",
+        "ContestSlug": "biweekly-contest-97",
+        "ProblemIndex": "Q1",
+        "ContestID_en": "Biweekly Contest 97",
+        "ContestID_zh": "第 97 场双周赛"
+    },
     {
         "Rating": 1215.7827321325,
         "ID": 2176,
@@ -15058,6 +15355,17 @@
         "ContestID_en": "Weekly Contest 231",
         "ContestID_zh": "第 231 场周赛"
     },
+    {
+        "Rating": 1206.0712568518,
+        "ID": 2574,
+        "Title": "Left and Right Sum Differences",
+        "TitleZH": "左右元素和的差值",
+        "TitleSlug": "left-and-right-sum-differences",
+        "ContestSlug": "weekly-contest-334",
+        "ProblemIndex": "Q1",
+        "ContestID_en": "Weekly Contest 334",
+        "ContestID_zh": "第 334 场周赛"
+    },
     {
         "Rating": 1205.6698455508,
         "ID": 1160,
diff --git a/resources/templates/codeonly.tpl b/resources/templates/codeonly.tpl
index 1c8ee25..1043500 100644
--- a/resources/templates/codeonly.tpl
+++ b/resources/templates/codeonly.tpl
@@ -9,11 +9,6 @@
 <%=code%>
 <%=comment.singleLine%> @lc code=end
 
-<%=comment.singleLine%> @lcpr-div-debug-arg-start
-<%=comment.singleLine%> funName=
-<%=comment.singleLine%> paramTypes= []
-<%=comment.singleLine%> returnType=
-<%=comment.singleLine%> @lcpr-div-debug-arg-end
 
 <% if(allCaseList && allCaseList.length > 0){ %>
 <%=comment.start%><% allCaseList.forEach(function(acase) { %>
diff --git a/resources/templates/detailed.tpl b/resources/templates/detailed.tpl
index 8d2cd66..7d8f1e3 100644
--- a/resources/templates/detailed.tpl
+++ b/resources/templates/detailed.tpl
@@ -21,11 +21,6 @@
 <%=code%>
 <%=comment.singleLine%> @lc code=end
 
-<%=comment.singleLine%> @lcpr-div-debug-arg-start
-<%=comment.singleLine%> funName=
-<%=comment.singleLine%> paramTypes= []
-<%=comment.singleLine%> returnType=
-<%=comment.singleLine%> @lcpr-div-debug-arg-end
 
 <% if(allCaseList && allCaseList.length > 0){ %>
 <%=comment.start%><% allCaseList.forEach(function(acase) { %>
diff --git a/src/controller/DebugController.ts b/src/controller/DebugController.ts
index 29e9a9a..479b012 100644
--- a/src/controller/DebugController.ts
+++ b/src/controller/DebugController.ts
@@ -7,7 +7,7 @@
  * Copyright (c) 2023 ccagml . All rights reserved
  */
 
-import { TextDocument, window, Range } from "vscode";
+import { TextDocument, window, Range, Position } from "vscode";
 import { getTextEditorFilePathByUri } from "../utils/SystemUtils";
 import * as fs from "fs";
 import { fileMeta, ProblemMeta, supportDebugLanguages } from "../utils/problemUtils";
@@ -17,6 +17,26 @@ import { debugArgDao } from "../dao/debugArgDao";
 
 import { IQuickItemEx } from "../model/Model";
 
+const singleLineFlag = {
+  bash: "#",
+  c: "//",
+  cpp: "//",
+  csharp: "//",
+  golang: "//",
+  java: "//",
+  javascript: "//",
+  kotlin: "//",
+  mysql: "--",
+  php: "//",
+  python: "#",
+  python3: "#",
+  ruby: "#",
+  rust: "//",
+  scala: "//",
+  swift: "//",
+  typescript: "//",
+};
+
 // 做杂活
 class DebugContorller {
   constructor() {}
@@ -31,6 +51,149 @@ class DebugContorller {
     return true;
   }
 
+  public async check_create_debug_area(meta: ProblemMeta | null, document: TextDocument) {
+    if (supportDebugLanguages.indexOf(meta?.lang || "") != -1) {
+      // 分析uri代码块
+      if (document != null) {
+        const fileContent: string = document.getText();
+        const debug_div_arg: RegExp = /@lcpr-div-debug-arg-start/;
+        if (!debug_div_arg.test(fileContent.toString())) {
+          // 弹一个生成配置区的选项
+          await this.create_diy_debug_arg(meta, document);
+        }
+      }
+    }
+  }
+
+  public try_get_array_type(obj) {
+    if (Array.isArray(obj)) {
+      if (Array.isArray(obj[0])) {
+        if (typeof obj[0][0] == "number") {
+          return "number[][]";
+        } else if (typeof obj[0][0] == "string") {
+          return "string[][]";
+        }
+      } else if (typeof obj[0] == "number") {
+        return "number[]";
+      } else if (typeof obj[0] == "string") {
+        return "string[]";
+      }
+    }
+    return "try_arg_error";
+  }
+
+  // 尝试获取diy的参数
+  public try_get_diy_param(ts: string) {
+    let debug_param: Array<any> = [];
+
+    ts = (ts || "").replace(/\r?\n/g, "\\n");
+    ts += "\\n";
+
+    let case_array: Array<string> = ts.split("\\n");
+
+    case_array.forEach((element) => {
+      if (element.length > 0) {
+        try {
+          let cur_param = JSON.parse(element);
+          if (typeof cur_param == "number") {
+            debug_param.push("number");
+          } else if (Array.isArray(cur_param)) {
+            debug_param.push(this.try_get_array_type(cur_param));
+          } else if (typeof cur_param == "string") {
+            debug_param.push(element.length == 1 ? "character" : "string");
+          } else {
+            debug_param = [];
+            return;
+          }
+        } catch (error) {
+          // 这里是字符串
+          debug_param.push(element.length == 1 ? "character" : "string");
+        }
+      }
+    });
+
+    // console.log("结果", debug_param);
+    return debug_param;
+  }
+
+  // 去除测试用例前的注释符号, 测试用例 可能有某些语言的注释符号, 例如 844题的#
+  public fix_lineContent(lineContent) {
+    let cut_pos = 0;
+    for (let left = 0; left < lineContent.length; left++) {
+      if (lineContent[left] == "#") {
+        continue;
+      }
+      if (lineContent[left] == "/" && lineContent[left + 1] == "/") {
+        left++;
+        continue;
+      }
+      if (lineContent[left] == "-" && lineContent[left + 1] == "-") {
+        left++;
+        continue;
+      }
+      if (lineContent[left] == " ") {
+        continue;
+      }
+      cut_pos = left;
+      break;
+    }
+    return lineContent.substring(cut_pos);
+  }
+
+  public get_one_case(document: TextDocument) {
+    let caseFlag = false;
+    let curCase = "";
+    for (let i: number = 0; i < document.lineCount; i++) {
+      const lineContent: string = document.lineAt(i).text;
+
+      if (caseFlag && lineContent.indexOf("@lcpr case=end") < 0) {
+        curCase += this.fix_lineContent(lineContent).replace(/\s+/g, "");
+      }
+      // 收集所有用例
+      if (lineContent.indexOf("@lcpr case=start") >= 0) {
+        caseFlag = true;
+      }
+
+      if (caseFlag && lineContent.indexOf("@lcpr case=end") >= 0) {
+        return curCase;
+      }
+    }
+    return curCase;
+  }
+
+  public async create_diy_debug_arg(meta: ProblemMeta | null, document: TextDocument) {
+    const name: string | undefined = await window.showInputBox({
+      prompt: "输入函数名",
+      title: "尝试生成区域调试参数",
+      ignoreFocusOut: true,
+    });
+
+    if (!(name && name.trim())) {
+      return;
+    }
+
+    let singleLine = singleLineFlag[meta?.lang || ""];
+    let div_debug_arg: any = [
+      `\n`,
+      `${singleLine} @lcpr-div-debug-arg-start`,
+      `${singleLine} funName=${name}`,
+      `${singleLine} paramTypes= ${JSON.stringify(this.try_get_diy_param(this.get_one_case(document)))}`,
+      `${singleLine} @lcpr-div-debug-arg-end`,
+      `\n`,
+    ];
+
+    for (let i: number = 0; i < document.lineCount; i++) {
+      const lineContent: string = document.lineAt(i).text;
+
+      if (lineContent.indexOf("@lc code=end") >= 0) {
+        const editor = window.activeTextEditor;
+        editor?.edit((edit) => {
+          edit.insert(new Position(i + 1, i + 1), div_debug_arg.join("\n"));
+        });
+      }
+    }
+  }
+
   public async startDebug(document: TextDocument, testcase?: string): Promise<void> {
     try {
       const filePath: string | undefined = await getTextEditorFilePathByUri(document.uri);
@@ -41,7 +204,9 @@ class DebugContorller {
       const meta: ProblemMeta | null = fileMeta(fileContent.toString());
 
       if (!this.canDebug(meta, document)) {
-        window.showErrorMessage("这题还不能debug,请尝试配置区域调试参数,麻烦提issuse");
+        // window.showErrorMessage("这题还不能debug,请尝试配置区域调试参数,麻烦提issuse");
+        // 判断生成测试区块
+        await this.check_create_debug_area(meta, document);
         return;
       }
       let result: any;
@@ -99,8 +264,10 @@ class DebugContorller {
     }
 
     const content: string = document.getText();
-    const matchResult: RegExpMatchArray | null = content.match(/@lc app=.* id=(.*) lang=(.*)/);
-    if (!matchResult || !matchResult[2]) {
+    const matchResult: RegExpMatchArray | null = content.match(
+      /@lc app=(.*) id=(.*|\w*|\W*|[\\u4e00-\\u9fa5]*) lang=(.*)/
+    );
+    if (!matchResult || !matchResult[3]) {
       return undefined;
     }
     // 搜集所有debug
@@ -132,11 +299,12 @@ class DebugContorller {
 
             edit.replace(new Range(i, equal_index + 1, i, last_index), JSON.stringify(cur_param_array));
           });
-        } else if (addType == "returnType" && lineContent.indexOf("returnType=") >= 0) {
-          window.activeTextEditor?.edit((edit) => {
-            edit.replace(new Range(i, equal_index + 1, i, last_index), choice.value);
-          });
         }
+        //  else if (addType == "returnType" && lineContent.indexOf("returnType=") >= 0) {
+        //   window.activeTextEditor?.edit((edit) => {
+        //     edit.replace(new Range(i, equal_index + 1, i, last_index), choice.value);
+        //   });
+        // }
       }
 
       // 收集所有用例
@@ -148,7 +316,9 @@ class DebugContorller {
   }
   public async resetDebugType(document: TextDocument, addType) {
     const content: string = document.getText();
-    const matchResult: RegExpMatchArray | null = content.match(/@lc app=.* id=(.*) lang=(.*)/);
+    const matchResult: RegExpMatchArray | null = content.match(
+      /@lc app=(.*) id=(.*|\w*|\W*|[\\u4e00-\\u9fa5]*) lang=(.*)/
+    );
     if (!matchResult || !matchResult[2]) {
       return undefined;
     }
@@ -170,11 +340,12 @@ class DebugContorller {
             let cur_param_array: any = [];
             edit.replace(new Range(i, equal_index + 1, i, last_index), JSON.stringify(cur_param_array));
           });
-        } else if (addType == "returnType" && lineContent.indexOf("returnType=") >= 0) {
-          window.activeTextEditor?.edit((edit) => {
-            edit.replace(new Range(i, equal_index + 1, i, last_index), "");
-          });
         }
+        //  else if (addType == "returnType" && lineContent.indexOf("returnType=") >= 0) {
+        //   window.activeTextEditor?.edit((edit) => {
+        //     edit.replace(new Range(i, equal_index + 1, i, last_index), "");
+        //   });
+        // }
       }
 
       // 收集所有用例
diff --git a/src/controller/TreeViewController.ts b/src/controller/TreeViewController.ts
index ea810df..dd18078 100644
--- a/src/controller/TreeViewController.ts
+++ b/src/controller/TreeViewController.ts
@@ -628,10 +628,10 @@ class TreeViewController implements Disposable {
 
   public async testapi(): Promise<void> {
     try {
-      let so = {};
-
-      const solution: string = JSON.stringify(so);
-      solutionService.show(solution);
+      // let so = {};
+      // const solution: string = JSON.stringify(so);
+      // solutionService.show(solution);
+      // debugContorller.try_get_diy_param();
     } catch (error) {
       logOutput.appendLine(error.toString());
       await promptForOpenOutputChannel("Failed to fetch today question. 请查看控制台信息~", OutPutType.error);
diff --git a/src/dao/debugArgDao.ts b/src/dao/debugArgDao.ts
index e6ca989..9bebc15 100644
--- a/src/dao/debugArgDao.ts
+++ b/src/dao/debugArgDao.ts
@@ -14,1371 +14,910 @@ class DebugArgDao {
     1: {
       funName: "twoSum",
       paramTypes: ["number[]", "number"],
-      returnType: "number[]",
-      testCase: "[2,7,11,15]\\n9",
     },
     2: {
       funName: "addTwoNumbers",
       paramTypes: ["ListNode", "ListNode"],
-      returnType: "ListNode",
-      testCase: "[2,4,3]\\n[5,6,4]",
     },
     3: {
       funName: "lengthOfLongestSubstring",
       paramTypes: ["string"],
-      returnType: "number",
-      testCase: '"abcabcbb"',
     },
     4: {
       funName: "findMedianSortedArrays",
       paramTypes: ["number[]", "number[]"],
-      returnType: "number",
-      testCase: "[1,3]\\n[2]",
     },
     5: {
       funName: "longestPalindrome",
       paramTypes: ["string"],
-      returnType: "string",
-      testCase: '"babad"',
     },
     6: {
       funName: "convert",
       paramTypes: ["string", "number"],
-      returnType: "string",
-      testCase: '"PAYPALISHIRING"\\n3',
     },
     7: {
       funName: "reverse",
       paramTypes: ["number"],
-      returnType: "number",
-      testCase: "123",
     },
     8: {
       funName: "myAtoi",
       paramTypes: ["string"],
-      returnType: "number",
-      testCase: '"42"',
     },
     9: {
       funName: "isPalindrome",
       paramTypes: ["number"],
-      returnType: "boolean",
-      testCase: "121",
     },
     10: {
       funName: "isMatch",
       paramTypes: ["string", "string"],
-      returnType: "boolean",
-      testCase: '"aa"\\n"a"',
     },
     11: {
       funName: "maxArea",
       paramTypes: ["number[]"],
-      returnType: "number",
-      testCase: "[1,8,6,2,5,4,8,3,7]",
     },
     12: {
       funName: "intToRoman",
       paramTypes: ["number"],
-      returnType: "string",
-      testCase: "3",
     },
     13: {
       funName: "romanToInt",
       paramTypes: ["string"],
-      returnType: "number",
-      testCase: '"III"',
     },
     14: {
       funName: "longestCommonPrefix",
       paramTypes: ["string[]"],
-      returnType: "string",
-      testCase: '["flower","flow","flight"]',
     },
     15: {
       funName: "threeSum",
       paramTypes: ["number[]"],
-      returnType: "number[][]",
-      testCase: "[-1,0,1,2,-1,-4]",
     },
     16: {
       funName: "threeSumClosest",
       paramTypes: ["number[]", "number"],
-      returnType: "number",
-      testCase: "[-1,2,1,-4]\\n1",
     },
     17: {
       funName: "letterCombinations",
       paramTypes: ["string"],
-      returnType: "string[]",
-      testCase: '"23"',
     },
     18: {
       funName: "fourSum",
       paramTypes: ["number[]", "number"],
-      returnType: "number[][]",
-      testCase: "[1,0,-1,0,-2,2]\\n0",
     },
     19: {
       funName: "removeNthFromEnd",
       paramTypes: ["ListNode", "number"],
-      returnType: "ListNode",
-      testCase: "[1,2,3,4,5]\\n2",
     },
     20: {
       funName: "isValid",
       paramTypes: ["string"],
-      returnType: "boolean",
-      testCase: '"()"',
     },
     21: {
       funName: "mergeTwoLists",
       paramTypes: ["ListNode", "ListNode"],
-      returnType: "ListNode",
-      testCase: "[1,2,4]\\n[1,3,4]",
     },
     22: {
       funName: "generateParenthesis",
       paramTypes: ["number"],
-      returnType: "string[]",
-      testCase: "3",
     },
     23: {
       funName: "mergeKLists",
       paramTypes: ["ListNode[]"],
-      returnType: "ListNode",
-      testCase: "[[1,4,5],[1,3,4],[2,6]]",
     },
     24: {
       funName: "swapPairs",
       paramTypes: ["ListNode"],
-      returnType: "ListNode",
-      testCase: "[1,2,3,4]",
     },
     25: {
       funName: "reverseKGroup",
       paramTypes: ["ListNode", "number"],
-      returnType: "ListNode",
-      testCase: "[1,2,3,4,5]\\n2",
     },
     26: {
       funName: "removeDuplicates",
       paramTypes: ["number[]"],
-      returnType: "number",
-      testCase: "[1,1,2]",
     },
     27: {
       funName: "removeElement",
       paramTypes: ["number[]", "number"],
-      returnType: "number",
-      testCase: "[3,2,2,3]\\n3",
     },
     28: {
       funName: "strStr",
       paramTypes: ["string", "string"],
-      returnType: "number",
-      testCase: '"hello"\\n"ll"',
     },
     29: {
       funName: "divide",
       paramTypes: ["number", "number"],
-      returnType: "number",
-      testCase: "10\\n3",
     },
     30: {
       funName: "findSubstring",
       paramTypes: ["string", "string[]"],
-      returnType: "number[]",
-      testCase: '"barfoothefoobarman"\\n["foo","bar"]',
     },
     31: {
       funName: "nextPermutation",
       paramTypes: ["number[]"],
-      returnType: "void",
-      testCase: "[1,2,3]",
     },
     32: {
       funName: "longestValidParentheses",
       paramTypes: ["string"],
-      returnType: "number",
-      testCase: '"(()"',
     },
     33: {
       funName: "search",
       paramTypes: ["number[]", "number"],
-      returnType: "number",
-      testCase: "[4,5,6,7,0,1,2]\\n0",
     },
     34: {
       funName: "searchRange",
       paramTypes: ["number[]", "number"],
-      returnType: "number[]",
-      testCase: "[5,7,7,8,8,10]\\n8",
     },
     35: {
       funName: "searchInsert",
       paramTypes: ["number[]", "number"],
-      returnType: "number",
-      testCase: "[1,3,5,6]\\n5",
     },
     36: {
       funName: "isValidSudoku",
       paramTypes: ["character[][]"],
-      returnType: "boolean",
-      testCase:
-        '[["5","3",".",".","7",".",".",".","."],["6",".",".","1","9","5",".",".","."],[".","9","8",".",".",".",".","6","."],["8",".",".",".","6",".",".",".","3"],["4",".",".","8",".","3",".",".","1"],["7",".",".",".","2",".",".",".","6"],[".","6",".",".",".",".","2","8","."],[".",".",".","4","1","9",".",".","5"],[".",".",".",".","8",".",".","7","9"]]',
     },
     37: {
       funName: "solveSudoku",
       paramTypes: ["character[][]"],
-      returnType: "void",
-      testCase:
-        '[["5","3",".",".","7",".",".",".","."],["6",".",".","1","9","5",".",".","."],[".","9","8",".",".",".",".","6","."],["8",".",".",".","6",".",".",".","3"],["4",".",".","8",".","3",".",".","1"],["7",".",".",".","2",".",".",".","6"],[".","6",".",".",".",".","2","8","."],[".",".",".","4","1","9",".",".","5"],[".",".",".",".","8",".",".","7","9"]]',
     },
     38: {
       funName: "countAndSay",
       paramTypes: ["number"],
-      returnType: "string",
-      testCase: "1",
     },
     39: {
       funName: "combinationSum",
       paramTypes: ["number[]", "number"],
-      returnType: "number[][]",
-      testCase: "[2,3,6,7]\\n7",
     },
     40: {
       funName: "combinationSum2",
       paramTypes: ["number[]", "number"],
-      returnType: "number[][]",
-      testCase: "[10,1,2,7,6,1,5]\\n8",
     },
     41: {
       funName: "firstMissingPositive",
       paramTypes: ["number[]"],
-      returnType: "number",
-      testCase: "[1,2,0]",
     },
     42: {
       funName: "trap",
       paramTypes: ["number[]"],
-      returnType: "number",
-      testCase: "[0,1,0,2,1,0,1,3,2,1,2,1]",
     },
     43: {
       funName: "multiply",
       paramTypes: ["string", "string"],
-      returnType: "string",
-      testCase: '"2"\\n"3"',
     },
     44: {
       funName: "isMatch",
       paramTypes: ["string", "string"],
-      returnType: "boolean",
-      testCase: '"aa"\\n"a"',
     },
     45: {
       funName: "jump",
       paramTypes: ["number[]"],
-      returnType: "number",
-      testCase: "[2,3,1,1,4]",
     },
     46: {
       funName: "permute",
       paramTypes: ["number[]"],
-      returnType: "number[][]",
-      testCase: "[1,2,3]",
     },
     47: {
       funName: "permuteUnique",
       paramTypes: ["number[]"],
-      returnType: "number[][]",
-      testCase: "[1,1,2]",
     },
     48: {
       funName: "rotate",
       paramTypes: ["number[][]"],
-      returnType: "void",
-      testCase: "[[1,2,3],[4,5,6],[7,8,9]]",
     },
     49: {
       funName: "groupAnagrams",
       paramTypes: ["string[]"],
-      returnType: "string[][]",
-      testCase: '["eat","tea","tan","ate","nat","bat"]',
     },
     50: {
       funName: "myPow",
       paramTypes: ["number", "number"],
-      returnType: "number",
-      testCase: "2.00000\\n10",
     },
     51: {
       funName: "solveNQueens",
       paramTypes: ["number"],
-      returnType: "string[][]",
-      testCase: "4",
     },
     52: {
       funName: "totalNQueens",
       paramTypes: ["number"],
-      returnType: "number",
-      testCase: "4",
     },
     53: {
       funName: "maxSubArray",
       paramTypes: ["number[]"],
-      returnType: "number",
-      testCase: "[-2,1,-3,4,-1,2,1,-5,4]",
     },
     54: {
       funName: "spiralOrder",
       paramTypes: ["number[][]"],
-      returnType: "number[]",
-      testCase: "[[1,2,3],[4,5,6],[7,8,9]]",
     },
     55: {
       funName: "canJump",
       paramTypes: ["number[]"],
-      returnType: "boolean",
-      testCase: "[2,3,1,1,4]",
     },
     56: {
       funName: "merge",
       paramTypes: ["number[][]"],
-      returnType: "number[][]",
-      testCase: "[[1,3],[2,6],[8,10],[15,18]]",
     },
     57: {
       funName: "insert",
       paramTypes: ["number[][]", "number[]"],
-      returnType: "number[][]",
-      testCase: "[[1,3],[6,9]]\\n[2,5]",
     },
     58: {
       funName: "lengthOfLastWord",
       paramTypes: ["string"],
-      returnType: "number",
-      testCase: '"Hello World"',
     },
     59: {
       funName: "generateMatrix",
       paramTypes: ["number"],
-      returnType: "number[][]",
-      testCase: "3",
     },
     60: {
       funName: "getPermutation",
       paramTypes: ["number", "number"],
-      returnType: "string",
-      testCase: "3\\n3",
     },
     61: {
       funName: "rotateRight",
       paramTypes: ["ListNode", "number"],
-      returnType: "ListNode",
-      testCase: "[1,2,3,4,5]\\n2",
     },
     62: {
       funName: "uniquePaths",
       paramTypes: ["number", "number"],
-      returnType: "number",
-      testCase: "3\\n2",
     },
     63: {
       funName: "uniquePathsWithObstacles",
       paramTypes: ["number[][]"],
-      returnType: "number",
-      testCase: "[[0,0,0],[0,1,0],[0,0,0]]",
     },
     64: {
       funName: "minPathSum",
       paramTypes: ["number[][]"],
-      returnType: "number",
-      testCase: "[[1,3,1],[1,5,1],[4,2,1]]",
     },
     65: {
       funName: "isNumber",
       paramTypes: ["string"],
-      returnType: "boolean",
-      testCase: '"0"',
     },
     66: {
       funName: "plusOne",
       paramTypes: ["number[]"],
-      returnType: "number[]",
-      testCase: "[1,2,3]",
     },
     67: {
       funName: "addBinary",
       paramTypes: ["string", "string"],
-      returnType: "string",
-      testCase: '"11"\\n"1"',
     },
     68: {
       funName: "fullJustify",
       paramTypes: ["string[]", "number"],
-      returnType: "string[]",
-      testCase: '["This", "is", "an", "example", "of", "text", "justification."]\\n16',
     },
     69: {
       funName: "mySqrt",
       paramTypes: ["number"],
-      returnType: "number",
-      testCase: "4",
     },
     70: {
       funName: "climbStairs",
       paramTypes: ["number"],
-      returnType: "number",
-      testCase: "2",
     },
     71: {
       funName: "simplifyPath",
       paramTypes: ["string"],
-      returnType: "string",
-      testCase: '"/home/"',
     },
     72: {
       funName: "minDistance",
       paramTypes: ["string", "string"],
-      returnType: "number",
-      testCase: '"horse"\\n"ros"',
     },
     73: {
       funName: "setZeroes",
       paramTypes: ["number[][]"],
-      returnType: "void",
-      testCase: "[[1,1,1],[1,0,1],[1,1,1]]",
     },
     74: {
       funName: "searchMatrix",
       paramTypes: ["number[][]", "number"],
-      returnType: "boolean",
-      testCase: "[[1,3,5,7],[10,11,16,20],[23,30,34,50]]\\n3",
     },
     75: {
       funName: "sortColors",
       paramTypes: ["number[]"],
-      returnType: "void",
-      testCase: "[2,0,2,1,1,0]",
     },
     76: {
       funName: "minWindow",
       paramTypes: ["string", "string"],
-      returnType: "string",
-      testCase: '"ADOBECODEBANC"\\n"ABC"',
     },
     77: {
       funName: "combine",
       paramTypes: ["number", "number"],
-      returnType: "number[][]",
-      testCase: "4\\n2",
     },
     78: {
       funName: "subsets",
       paramTypes: ["number[]"],
-      returnType: "number[][]",
-      testCase: "[1,2,3]",
     },
     79: {
       funName: "exist",
       paramTypes: ["character[][]", "string"],
-      returnType: "boolean",
-      testCase: '[["A","B","C","E"],["S","F","C","S"],["A","D","E","E"]]\\n"ABCCED"',
     },
     80: {
       funName: "removeDuplicates",
       paramTypes: ["number[]"],
-      returnType: "number",
-      testCase: "[1,1,1,2,2,3]",
     },
     81: {
       funName: "search",
       paramTypes: ["number[]", "number"],
-      returnType: "boolean",
-      testCase: "[2,5,6,0,0,1,2]\\n0",
     },
     82: {
       funName: "deleteDuplicates",
       paramTypes: ["ListNode"],
-      returnType: "ListNode",
-      testCase: "[1,2,3,3,4,4,5]",
     },
     83: {
       funName: "deleteDuplicates",
       paramTypes: ["ListNode"],
-      returnType: "ListNode",
-      testCase: "[1,1,2]",
     },
     84: {
       funName: "largestRectangleArea",
       paramTypes: ["number[]"],
-      returnType: "number",
-      testCase: "[2,1,5,6,2,3]",
     },
     85: {
       funName: "maximalRectangle",
       paramTypes: ["character[][]"],
-      returnType: "number",
-      testCase: '[["1","0","1","0","0"],["1","0","1","1","1"],["1","1","1","1","1"],["1","0","0","1","0"]]',
     },
     86: {
       funName: "partition",
       paramTypes: ["ListNode", "number"],
-      returnType: "ListNode",
-      testCase: "[1,4,3,2,5,2]\\n3",
     },
     87: {
       funName: "isScramble",
       paramTypes: ["string", "string"],
-      returnType: "boolean",
-      testCase: '"great"\\n"rgeat"',
     },
     88: {
       funName: "merge",
       paramTypes: ["number[]", "number", "number[]", "number"],
-      returnType: "void",
-      testCase: "[1,2,3,0,0,0]\\n3\\n[2,5,6]\\n3",
     },
     89: {
       funName: "grayCode",
       paramTypes: ["number"],
-      returnType: "number[]",
-      testCase: "2",
     },
     90: {
       funName: "subsetsWithDup",
       paramTypes: ["number[]"],
-      returnType: "number[][]",
-      testCase: "[1,2,2]",
     },
     91: {
       funName: "numDecodings",
       paramTypes: ["string"],
-      returnType: "number",
-      testCase: '"12"',
     },
     92: {
       funName: "reverseBetween",
       paramTypes: ["ListNode", "number", "number"],
-      returnType: "ListNode",
-      testCase: "[1,2,3,4,5]\\n2\\n4",
     },
     93: {
       funName: "restoreIpAddresses",
       paramTypes: ["string"],
-      returnType: "string[]",
-      testCase: '"25525511135"',
     },
     94: {
       funName: "inorderTraversal",
       paramTypes: ["TreeNode"],
-      returnType: "number[]",
-      testCase: "[1,null,2,3]",
     },
     95: {
       funName: "generateTrees",
       paramTypes: ["number"],
-      returnType: "TreeNode[]",
-      testCase: "3",
     },
     96: {
       funName: "numTrees",
       paramTypes: ["number"],
-      returnType: "number",
-      testCase: "3",
     },
     97: {
       funName: "isInterleave",
       paramTypes: ["string", "string", "string"],
-      returnType: "boolean",
-      testCase: '"aabcc"\\n"dbbca"\\n"aadbbcbcac"',
     },
     98: {
       funName: "isValidBST",
       paramTypes: ["TreeNode"],
-      returnType: "boolean",
-      testCase: "[2,1,3]",
     },
     99: {
       funName: "recoverTree",
       paramTypes: ["TreeNode"],
-      returnType: "void",
-      testCase: "[1,3,null,null,2]",
     },
     100: {
       funName: "isSameTree",
       paramTypes: ["TreeNode", "TreeNode"],
-      returnType: "boolean",
-      testCase: "[1,2,3]\\n[1,2,3]",
     },
     101: {
       funName: "isSymmetric",
       paramTypes: ["TreeNode"],
-      returnType: "boolean",
-      testCase: "[1,2,2,3,4,4,3]",
     },
     102: {
       funName: "levelOrder",
       paramTypes: ["TreeNode"],
-      returnType: "number[][]",
-      testCase: "[3,9,20,null,null,15,7]",
     },
     103: {
       funName: "zigzagLevelOrder",
       paramTypes: ["TreeNode"],
-      returnType: "number[][]",
-      testCase: "[3,9,20,null,null,15,7]",
     },
     104: {
       funName: "maxDepth",
       paramTypes: ["TreeNode"],
-      returnType: "number",
-      testCase: "[3,9,20,null,null,15,7]",
     },
     105: {
       funName: "buildTree",
       paramTypes: ["number[]", "number[]"],
-      returnType: "TreeNode",
-      testCase: "[3,9,20,15,7]\\n[9,3,15,20,7]",
     },
     106: {
       funName: "buildTree",
       paramTypes: ["number[]", "number[]"],
-      returnType: "TreeNode",
-      testCase: "[9,3,15,20,7]\\n[9,15,7,20,3]",
     },
     107: {
       funName: "levelOrderBottom",
       paramTypes: ["TreeNode"],
-      returnType: "number[][]",
-      testCase: "[3,9,20,null,null,15,7]",
     },
     108: {
       funName: "sortedArrayToBST",
       paramTypes: ["number[]"],
-      returnType: "TreeNode",
-      testCase: "[-10,-3,0,5,9]",
     },
     109: {
       funName: "sortedListToBST",
       paramTypes: ["ListNode"],
-      returnType: "TreeNode",
-      testCase: "[-10,-3,0,5,9]",
     },
     110: {
       funName: "isBalanced",
       paramTypes: ["TreeNode"],
-      returnType: "boolean",
-      testCase: "[3,9,20,null,null,15,7]",
     },
     111: {
       funName: "minDepth",
       paramTypes: ["TreeNode"],
-      returnType: "number",
-      testCase: "[3,9,20,null,null,15,7]",
     },
     112: {
       funName: "hasPathSum",
       paramTypes: ["TreeNode", "number"],
-      returnType: "boolean",
-      testCase: "[5,4,8,11,null,13,4,7,2,null,null,null,1]\\n22",
     },
     113: {
       funName: "pathSum",
       paramTypes: ["TreeNode", "number"],
-      returnType: "number[][]",
-      testCase: "[5,4,8,11,null,13,4,7,2,null,null,5,1]\\n22",
     },
     114: {
       funName: "flatten",
       paramTypes: ["TreeNode"],
-      returnType: "void",
-      testCase: "[1,2,5,3,4,null,6]",
     },
     115: {
       funName: "numDistinct",
       paramTypes: ["string", "string"],
-      returnType: "number",
-      testCase: '"rabbbit"\\n"rabbit"',
     },
     116: {
       funName: "connect",
       paramTypes: ["Node"],
-      returnType: "Node",
-      testCase: "[1,2,3,4,5,6,7]",
     },
     117: {
       funName: "connect",
       paramTypes: ["Node"],
-      returnType: "Node",
-      testCase: "[1,2,3,4,5,null,7]",
     },
     118: {
       funName: "generate",
       paramTypes: ["number"],
-      returnType: "number[][]",
-      testCase: "5",
     },
     119: {
       funName: "getRow",
       paramTypes: ["number"],
-      returnType: "number[]",
-      testCase: "3",
     },
     120: {
       funName: "minimumTotal",
       paramTypes: ["number[][]"],
-      returnType: "number",
-      testCase: "[[2],[3,4],[6,5,7],[4,1,8,3]]",
     },
     121: {
       funName: "maxProfit",
       paramTypes: ["number[]"],
-      returnType: "number",
-      testCase: "[7,1,5,3,6,4]",
     },
     122: {
       funName: "maxProfit",
       paramTypes: ["number[]"],
-      returnType: "number",
-      testCase: "[7,1,5,3,6,4]",
     },
     123: {
       funName: "maxProfit",
       paramTypes: ["number[]"],
-      returnType: "number",
-      testCase: "[3,3,5,0,0,3,1,4]",
     },
     124: {
       funName: "maxPathSum",
       paramTypes: ["TreeNode"],
-      returnType: "number",
-      testCase: "[1,2,3]",
     },
     125: {
       funName: "isPalindrome",
       paramTypes: ["string"],
-      returnType: "boolean",
-      testCase: '"A man, a plan, a canal: Panama"',
     },
     126: {
       funName: "findLadders",
       paramTypes: ["string", "string", "string[]"],
-      returnType: "string[][]",
-      testCase: '"hit"\\n"cog"\\n["hot","dot","dog","lot","log","cog"]',
     },
     127: {
       funName: "ladderLength",
       paramTypes: ["string", "string", "string[]"],
-      returnType: "number",
-      testCase: '"hit"\\n"cog"\\n["hot","dot","dog","lot","log","cog"]',
     },
     128: {
       funName: "longestConsecutive",
       paramTypes: ["number[]"],
-      returnType: "number",
-      testCase: "[100,4,200,1,3,2]",
     },
     129: {
       funName: "sumNumbers",
       paramTypes: ["TreeNode"],
-      returnType: "number",
-      testCase: "[1,2,3]",
     },
     130: {
       funName: "solve",
       paramTypes: ["character[][]"],
-      returnType: "void",
-      testCase: '[["X","X","X","X"],["X","O","O","X"],["X","X","O","X"],["X","O","X","X"]]',
     },
     131: {
       funName: "partition",
       paramTypes: ["string"],
-      returnType: "string[][]",
-      testCase: '"aab"',
     },
     132: {
       funName: "minCut",
       paramTypes: ["string"],
-      returnType: "number",
-      testCase: '"aab"',
     },
     133: {
       funName: "cloneGraph",
       paramTypes: ["Node"],
-      returnType: "Node",
-      testCase: "[[2,4],[1,3],[2,4],[1,3]]",
     },
     134: {
       funName: "canCompleteCircuit",
       paramTypes: ["number[]", "number[]"],
-      returnType: "number",
-      testCase: "[1,2,3,4,5]\\n[3,4,5,1,2]",
     },
     135: {
       funName: "candy",
       paramTypes: ["number[]"],
-      returnType: "number",
-      testCase: "[1,0,2]",
     },
     136: {
       funName: "singleNumber",
       paramTypes: ["number[]"],
-      returnType: "number",
-      testCase: "[2,2,1]",
     },
     137: {
       funName: "singleNumber",
       paramTypes: ["number[]"],
-      returnType: "number",
-      testCase: "[2,2,3,2]",
     },
     138: {
       funName: "copyRandomList",
       paramTypes: ["Node"],
-      returnType: "Node",
-      testCase: "[[7,null],[13,0],[11,4],[10,2],[1,0]]",
     },
     139: {
       funName: "wordBreak",
       paramTypes: ["string", "string[]"],
-      returnType: "boolean",
-      testCase: '"leetcode"\\n["leet","code"]',
     },
     140: {
       funName: "wordBreak",
       paramTypes: ["string", "string[]"],
-      returnType: "string[]",
-      testCase: '"catsanddog"\\n["cat","cats","and","sand","dog"]',
     },
     141: {
       funName: "hasCycle",
       paramTypes: ["ListNode"],
-      returnType: "boolean",
-      testCase: "[3,2,0,-4]\\n1",
     },
     142: {
       funName: "detectCycle",
       paramTypes: ["ListNode"],
-      returnType: "ListNode",
-      testCase: "[3,2,0,-4]\\n1",
     },
     143: {
       funName: "reorderList",
       paramTypes: ["ListNode"],
-      returnType: "void",
-      testCase: "[1,2,3,4]",
     },
     144: {
       funName: "preorderTraversal",
       paramTypes: ["TreeNode"],
-      returnType: "number[]",
-      testCase: "[1,null,2,3]",
     },
     145: {
       funName: "postorderTraversal",
       paramTypes: ["TreeNode"],
-      returnType: "number[]",
-      testCase: "[1,null,2,3]",
     },
     146: {
       funName: "LRUCache",
       paramTypes: ["number"],
-      returnType: "void",
-      testCase:
-        '["LRUCache","put","put","get","put","get","put","get","get","get"]\\n[[2],[1,1],[2,2],[1],[3,3],[2],[4,4],[1],[3],[4]]',
     },
     147: {
       funName: "insertionSortList",
       paramTypes: ["ListNode"],
-      returnType: "ListNode",
-      testCase: "[4,2,1,3]",
     },
     148: {
       funName: "sortList",
       paramTypes: ["ListNode"],
-      returnType: "ListNode",
-      testCase: "[4,2,1,3]",
     },
     149: {
       funName: "maxPoints",
       paramTypes: ["number[][]"],
-      returnType: "number",
-      testCase: "[[1,1],[2,2],[3,3]]",
     },
     150: {
       funName: "evalRPN",
       paramTypes: ["string[]"],
-      returnType: "number",
-      testCase: '["2","1","+","3","*"]',
     },
     151: {
       funName: "reverseWords",
       paramTypes: ["string"],
-      returnType: "string",
-      testCase: '"the sky is blue"',
     },
     152: {
       funName: "maxProduct",
       paramTypes: ["number[]"],
-      returnType: "number",
-      testCase: "[2,3,-2,4]",
     },
     153: {
       funName: "findMin",
       paramTypes: ["number[]"],
-      returnType: "number",
-      testCase: "[3,4,5,1,2]",
     },
     154: {
       funName: "findMin",
       paramTypes: ["number[]"],
-      returnType: "number",
-      testCase: "[1,3,5]",
     },
     155: {
       funName: "MinStack",
       paramTypes: [],
-      returnType: "void",
-      testCase: '["MinStack","push","push","push","getMin","pop","top","getMin"]\\n[[],[-2],[0],[-3],[],[],[],[]]',
     },
     160: {
       funName: "getIntersectionNode",
       paramTypes: ["ListNode", "ListNode"],
-      returnType: "ListNode",
-      testCase: "8\\n[4,1,8,4,5]\\n[5,0,1,8,4,5]\\n2\\n3",
     },
     162: {
       funName: "findPeakElement",
       paramTypes: ["number[]"],
-      returnType: "number",
-      testCase: "[1,2,3,1]",
     },
     164: {
       funName: "maximumGap",
       paramTypes: ["number[]"],
-      returnType: "number",
-      testCase: "[3,6,9,1]",
     },
     165: {
       funName: "compareVersion",
       paramTypes: ["string", "string"],
-      returnType: "number",
-      testCase: '"0.1"\\n"1.1"',
     },
     166: {
       funName: "fractionToDecimal",
       paramTypes: ["number", "number"],
-      returnType: "string",
-      testCase: "1\\n2",
     },
     167: {
       funName: "twoSum",
       paramTypes: ["number[]", "number"],
-      returnType: "number[]",
-      testCase: "[2,7,11,15]\\n9",
     },
     168: {
       funName: "convertToTitle",
       paramTypes: ["number"],
-      returnType: "string",
-      testCase: "1",
     },
     169: {
       funName: "majorityElement",
       paramTypes: ["number[]"],
-      returnType: "number",
-      testCase: "[3,2,3]",
     },
     171: {
       funName: "titleToNumber",
       paramTypes: ["string"],
-      returnType: "number",
-      testCase: '"A"',
     },
     172: {
       funName: "trailingZeroes",
       paramTypes: ["number"],
-      returnType: "number",
-      testCase: "3",
     },
     173: {
       funName: "BSTIterator",
       paramTypes: ["TreeNode"],
-      returnType: "void",
-      testCase:
-        '["BSTIterator","next","next","hasNext","next","hasNext","next","hasNext","next","hasNext"]\\n[[[7,3,15,null,null,9,20]],[null],[null],[null],[null],[null],[null],[null],[null],[null]]',
     },
     174: {
       funName: "calculateMinimumHP",
       paramTypes: ["number[][]"],
-      returnType: "number",
-      testCase: "[[-2,-3,3],[-5,-10,1],[10,30,-5]]",
     },
     179: {
       funName: "largestNumber",
       paramTypes: ["number[]"],
-      returnType: "string",
-      testCase: "[10,2]",
     },
     187: {
       funName: "findRepeatedDnaSequences",
       paramTypes: ["string"],
-      returnType: "string[]",
-      testCase: '"AAAAACCCCCAAAAACCCCCCAAAAAGGGTTT"',
     },
     188: {
       funName: "maxProfit",
       paramTypes: ["number", "number[]"],
-      returnType: "number",
-      testCase: "2\\n[2,4,1]",
     },
     189: {
       funName: "rotate",
       paramTypes: ["number[]", "number"],
-      returnType: "void",
-      testCase: "[1,2,3,4,5,6,7]\\n3",
     },
     190: {
       funName: "reverseBits",
       paramTypes: ["number"],
-      returnType: "number",
-      testCase: "00000010100101000001111010011100",
     },
     191: {
       funName: "hammingWeight",
       paramTypes: ["number"],
-      returnType: "number",
-      testCase: "00000000000000000000000000001011",
     },
     198: {
       funName: "rob",
       paramTypes: ["number[]"],
-      returnType: "number",
-      testCase: "[1,2,3,1]",
     },
     199: {
       funName: "rightSideView",
       paramTypes: ["TreeNode"],
-      returnType: "number[]",
-      testCase: "[1,2,3,null,5,null,4]",
     },
     200: {
       funName: "numIslands",
       paramTypes: ["character[][]"],
-      returnType: "number",
-      testCase: '[["1","1","1","1","0"],["1","1","0","1","0"],["1","1","0","0","0"],["0","0","0","0","0"]]',
     },
     201: {
       funName: "rangeBitwiseAnd",
       paramTypes: ["number", "number"],
-      returnType: "number",
-      testCase: "5\\n7",
     },
     202: {
       funName: "isHappy",
       paramTypes: ["number"],
-      returnType: "boolean",
-      testCase: "19",
     },
     203: {
       funName: "removeElements",
       paramTypes: ["ListNode", "number"],
-      returnType: "ListNode",
-      testCase: "[1,2,6,3,4,5,6]\\n6",
     },
     204: {
       funName: "countPrimes",
       paramTypes: ["number"],
-      returnType: "number",
-      testCase: "10",
     },
     205: {
       funName: "isIsomorphic",
       paramTypes: ["string", "string"],
-      returnType: "boolean",
-      testCase: '"egg"\\n"add"',
     },
     206: {
       funName: "reverseList",
       paramTypes: ["ListNode"],
-      returnType: "ListNode",
-      testCase: "[1,2,3,4,5]",
     },
     207: {
       funName: "canFinish",
       paramTypes: ["number", "number[][]"],
-      returnType: "boolean",
-      testCase: "2\\n[[1,0]]",
     },
     208: {
       funName: "Trie",
       paramTypes: [],
-      returnType: "void",
-      testCase:
-        '["Trie","insert","search","search","startsWith","insert","search"]\\n[[],["apple"],["apple"],["app"],["app"],["app"],["app"]]',
     },
     209: {
       funName: "minSubArrayLen",
       paramTypes: ["number", "number[]"],
-      returnType: "number",
-      testCase: "7\\n[2,3,1,2,4,3]",
     },
     210: {
       funName: "findOrder",
       paramTypes: ["number", "number[][]"],
-      returnType: "number[]",
-      testCase: "2\\n[[1,0]]",
     },
     211: {
       funName: "WordDictionary",
       paramTypes: [],
-      returnType: "void",
-      testCase:
-        '["WordDictionary","addWord","addWord","addWord","search","search","search","search"]\\n[[],["bad"],["dad"],["mad"],["pad"],["bad"],[".ad"],["b.."]]',
     },
     212: {
       funName: "findWords",
       paramTypes: ["character[][]", "string[]"],
-      returnType: "string[]",
-      testCase:
-        '[["o","a","a","n"],["e","t","a","e"],["i","h","k","r"],["i","f","l","v"]]\\n["oath","pea","eat","rain"]',
     },
     213: {
       funName: "rob",
       paramTypes: ["number[]"],
-      returnType: "number",
-      testCase: "[2,3,2]",
     },
     214: {
       funName: "shortestPalindrome",
       paramTypes: ["string"],
-      returnType: "string",
-      testCase: '"aacecaaa"',
     },
     215: {
       funName: "findKthLargest",
       paramTypes: ["number[]", "number"],
-      returnType: "number",
-      testCase: "[3,2,1,5,6,4]\\n2",
     },
     216: {
       funName: "combinationSum3",
       paramTypes: ["number", "number"],
-      returnType: "number[][]",
-      testCase: "3\\n7",
     },
     217: {
       funName: "containsDuplicate",
       paramTypes: ["number[]"],
-      returnType: "boolean",
-      testCase: "[1,2,3,1]",
     },
     218: {
       funName: "getSkyline",
       paramTypes: ["number[][]"],
-      returnType: "number[][]",
-      testCase: "[[2,9,10],[3,7,15],[5,12,12],[15,20,10],[19,24,8]]",
     },
     219: {
       funName: "containsNearbyDuplicate",
       paramTypes: ["number[]", "number"],
-      returnType: "boolean",
-      testCase: "[1,2,3,1]\\n3",
     },
     220: {
       funName: "containsNearbyAlmostDuplicate",
       paramTypes: ["number[]", "number", "number"],
-      returnType: "boolean",
-      testCase: "[1,2,3,1]\\n3\\n0",
     },
     221: {
       funName: "maximalSquare",
       paramTypes: ["character[][]"],
-      returnType: "number",
-      testCase: '[["1","0","1","0","0"],["1","0","1","1","1"],["1","1","1","1","1"],["1","0","0","1","0"]]',
     },
     222: {
       funName: "countNodes",
       paramTypes: ["TreeNode"],
-      returnType: "number",
-      testCase: "[1,2,3,4,5,6]",
     },
     223: {
       funName: "computeArea",
       paramTypes: ["number", "number", "number", "number", "number", "number", "number", "number"],
-      returnType: "number",
-      testCase: "-3\\n0\\n3\\n4\\n0\\n-1\\n9\\n2",
     },
     224: {
       funName: "calculate",
       paramTypes: ["string"],
-      returnType: "number",
-      testCase: '"1 + 1"',
     },
     225: {
       funName: "MyStack",
       paramTypes: [],
-      returnType: "void",
-      testCase: '["MyStack","push","push","top","pop","empty"]\\n[[],[1],[2],[],[],[]]',
     },
     226: {
       funName: "invertTree",
       paramTypes: ["TreeNode"],
-      returnType: "TreeNode",
-      testCase: "[4,2,7,1,3,6,9]",
     },
     227: {
       funName: "calculate",
       paramTypes: ["string"],
-      returnType: "number",
-      testCase: '"3+2*2"',
     },
     228: {
       funName: "summaryRanges",
       paramTypes: ["number[]"],
-      returnType: "string[]",
-      testCase: "[0,1,2,4,5,7]",
     },
     229: {
       funName: "majorityElement",
       paramTypes: ["number[]"],
-      returnType: "number[]",
-      testCase: "[3,2,3]",
     },
     230: {
       funName: "kthSmallest",
       paramTypes: ["TreeNode", "number"],
-      returnType: "number",
-      testCase: "[3,1,4,null,2]\\n1",
     },
     231: {
       funName: "isPowerOfTwo",
       paramTypes: ["number"],
-      returnType: "boolean",
-      testCase: "1",
     },
     232: {
       funName: "MyQueue",
       paramTypes: [],
-      returnType: "void",
-      testCase: '["MyQueue","push","push","peek","pop","empty"]\\n[[],[1],[2],[],[],[]]',
     },
     233: {
       funName: "countDigitOne",
       paramTypes: ["number"],
-      returnType: "number",
-      testCase: "13",
     },
     234: {
       funName: "isPalindrome",
       paramTypes: ["ListNode"],
-      returnType: "boolean",
-      testCase: "[1,2]",
     },
     235: {
       funName: "lowestCommonAncestor",
       paramTypes: ["TreeNode", "TreeNode", "TreeNode"],
-      returnType: "TreeNode",
-      testCase: "[6,2,8,0,4,7,9,null,null,3,5]\\n2\\n8",
     },
     236: {
       funName: "lowestCommonAncestor",
       paramTypes: ["TreeNode", "TreeNode", "TreeNode"],
-      returnType: "TreeNode",
-      testCase: "[3,5,1,6,2,0,8,null,null,7,4]\\n5\\n1",
     },
     237: {
       funName: "deleteNode",
       paramTypes: ["ListNode"],
-      returnType: "void",
-      testCase: "[4,5,1,9]\\n5",
     },
     238: {
       funName: "productExceptSelf",
       paramTypes: ["number[]"],
-      returnType: "number[]",
-      testCase: "[1,2,3,4]",
     },
     239: {
       funName: "maxSlidingWindow",
       paramTypes: ["number[]", "number"],
-      returnType: "number[]",
-      testCase: "[1,3,-1,-3,5,3,6,7]\\n3",
     },
     240: {
       funName: "searchMatrix",
       paramTypes: ["number[][]", "number"],
-      returnType: "boolean",
-      testCase: "[[1,4,7,11,15],[2,5,8,12,19],[3,6,9,16,22],[10,13,14,17,24],[18,21,23,26,30]]\\n5",
     },
     241: {
       funName: "diffWaysToCompute",
       paramTypes: ["string"],
-      returnType: "number[]",
-      testCase: '"2-1-1"',
     },
     242: {
       funName: "isAnagram",
       paramTypes: ["string", "string"],
-      returnType: "boolean",
-      testCase: '"anagram"\\n"nagaram"',
     },
     257: {
       funName: "binaryTreePaths",
       paramTypes: ["TreeNode"],
-      returnType: "string[]",
-      testCase: "[1,2,3,null,5]",
     },
     258: {
       funName: "addDigits",
       paramTypes: ["number"],
-      returnType: "number",
-      testCase: "38",
     },
     260: {
       funName: "singleNumber",
       paramTypes: ["number[]"],
-      returnType: "number[]",
-      testCase: "[1,2,1,3,2,5]",
     },
     263: {
       funName: "isUgly",
       paramTypes: ["number"],
-      returnType: "boolean",
-      testCase: "6",
     },
     264: {
       funName: "nthUglyNumber",
       paramTypes: ["number"],
-      returnType: "number",
-      testCase: "10",
     },
     268: {
       funName: "missingNumber",
       paramTypes: ["number[]"],
-      returnType: "number",
-      testCase: "[3,0,1]",
     },
     273: {
       funName: "numberToWords",
       paramTypes: ["number"],
-      returnType: "string",
-      testCase: "123",
     },
     274: {
       funName: "hIndex",
       paramTypes: ["number[]"],
-      returnType: "number",
-      testCase: "[3,0,6,1,5]",
     },
     275: {
       funName: "hIndex",
       paramTypes: ["number[]"],
-      returnType: "number",
-      testCase: "[0,1,3,5,6]",
     },
     278: {
       funName: "firstBadVersion",
@@ -1387,3947 +926,2619 @@ class DebugArgDao {
       },
       // changede from original
       paramTypes: ["number", "number"],
-      returnType: "function",
-      testCase: "5\\n4",
     },
     279: {
       funName: "numSquares",
       paramTypes: ["number"],
-      returnType: "number",
-      testCase: "12",
     },
     282: {
       funName: "addOperators",
       paramTypes: ["string", "number"],
-      returnType: "string[]",
-      testCase: '"123"\\n6',
     },
     283: {
       funName: "moveZeroes",
       paramTypes: ["number[]"],
-      returnType: "void",
-      testCase: "[0,1,0,3,12]",
     },
     287: {
       funName: "findDuplicate",
       paramTypes: ["number[]"],
-      returnType: "number",
-      testCase: "[1,3,4,2,2]",
     },
     289: {
       funName: "gameOfLife",
       paramTypes: ["number[][]"],
-      returnType: "void",
-      testCase: "[[0,1,0],[0,0,1],[1,1,1],[0,0,0]]",
     },
     290: {
       funName: "wordPattern",
       paramTypes: ["string", "string"],
-      returnType: "boolean",
-      testCase: '"abba"\\n"dog cat cat dog"',
     },
     292: {
       funName: "canWinNim",
       paramTypes: ["number"],
-      returnType: "boolean",
-      testCase: "4",
     },
     295: {
       funName: "MedianFinder",
       paramTypes: [],
-      returnType: "void",
-      testCase: '["MedianFinder","addNum","addNum","findMedian","addNum","findMedian"]\\n[[],[1],[2],[],[3],[]]',
     },
     297: {
       funName: "serialize",
       paramTypes: ["TreeNode"],
-      returnType: "string",
-      testCase: "[1,2,3,null,null,4,5]",
     },
     299: {
       funName: "getHint",
       paramTypes: ["string", "string"],
-      returnType: "string",
-      testCase: '"1807"\\n"7810"',
     },
     300: {
       funName: "lengthOfLIS",
       paramTypes: ["number[]"],
-      returnType: "number",
-      testCase: "[10,9,2,5,3,7,101,18]",
     },
     301: {
       funName: "removeInvalidParentheses",
       paramTypes: ["string"],
-      returnType: "string[]",
-      testCase: '"()())()"',
     },
     303: {
       funName: "NumArray",
       paramTypes: ["number[]"],
-      returnType: "void",
-      testCase: '["NumArray","sumRange","sumRange","sumRange"]\\n[[[-2,0,3,-5,2,-1]],[0,2],[2,5],[0,5]]',
     },
     304: {
       funName: "NumMatrix",
       paramTypes: ["number[][]"],
-      returnType: "void",
-      testCase:
-        '["NumMatrix","sumRegion","sumRegion","sumRegion"]\\n[[[[3,0,1,4,2],[5,6,3,2,1],[1,2,0,1,5],[4,1,0,1,7],[1,0,3,0,5]]],[2,1,4,3],[1,1,2,2],[1,2,2,4]]',
     },
     306: {
       funName: "isAdditiveNumber",
       paramTypes: ["string"],
-      returnType: "boolean",
-      testCase: '"112358"',
     },
     307: {
       funName: "NumArray",
       paramTypes: ["number[]"],
-      returnType: "void",
-      testCase: '["NumArray","sumRange","update","sumRange"]\\n[[[1,3,5]],[0,2],[1,2],[0,2]]',
     },
     309: {
       funName: "maxProfit",
       paramTypes: ["number[]"],
-      returnType: "number",
-      testCase: "[1,2,3,0,2]",
     },
     310: {
       funName: "findMinHeightTrees",
       paramTypes: ["number", "number[][]"],
-      returnType: "number[]",
-      testCase: "4\\n[[1,0],[1,2],[1,3]]",
     },
     312: {
       funName: "maxCoins",
       paramTypes: ["number[]"],
-      returnType: "number",
-      testCase: "[3,1,5,8]",
     },
     313: {
       funName: "nthSuperUglyNumber",
       paramTypes: ["number", "number[]"],
-      returnType: "number",
-      testCase: "12\\n[2,7,13,19]",
     },
     315: {
       funName: "countSmaller",
       paramTypes: ["number[]"],
-      returnType: "number[]",
-      testCase: "[5,2,6,1]",
     },
     316: {
       funName: "removeDuplicateLetters",
       paramTypes: ["string"],
-      returnType: "string",
-      testCase: '"bcabc"',
     },
     318: {
       funName: "maxProduct",
       paramTypes: ["string[]"],
-      returnType: "number",
-      testCase: '["abcw","baz","foo","bar","xtfn","abcdef"]',
     },
     319: {
       funName: "bulbSwitch",
       paramTypes: ["number"],
-      returnType: "number",
-      testCase: "3",
     },
     321: {
       funName: "maxNumber",
       paramTypes: ["number[]", "number[]", "number"],
-      returnType: "number[]",
-      testCase: "[3,4,6,5]\\n[9,1,2,5,8,3]\\n5",
     },
     322: {
       funName: "coinChange",
       paramTypes: ["number[]", "number"],
-      returnType: "number",
-      testCase: "[1,2,5]\\n11",
     },
     324: {
       funName: "wiggleSort",
       paramTypes: ["number[]"],
-      returnType: "void",
-      testCase: "[1,5,1,1,6,4]",
     },
     326: {
       funName: "isPowerOfThree",
       paramTypes: ["number"],
-      returnType: "boolean",
-      testCase: "27",
     },
     327: {
       funName: "countRangeSum",
       paramTypes: ["number[]", "number", "number"],
-      returnType: "number",
-      testCase: "[-2,5,-1]\\n-2\\n2",
     },
     328: {
       funName: "oddEvenList",
       paramTypes: ["ListNode"],
-      returnType: "ListNode",
-      testCase: "[1,2,3,4,5]",
     },
     329: {
       funName: "longestIncreasingPath",
       paramTypes: ["number[][]"],
-      returnType: "number",
-      testCase: "[[9,9,4],[6,6,8],[2,1,1]]",
     },
     330: {
       funName: "minPatches",
       paramTypes: ["number[]", "number"],
-      returnType: "number",
-      testCase: "[1,3]\\n6",
     },
     331: {
       funName: "isValidSerialization",
       paramTypes: ["string"],
-      returnType: "boolean",
-      testCase: '"9,3,4,#,#,1,#,#,2,#,6,#,#"',
     },
     332: {
       funName: "findItinerary",
       paramTypes: ["string[][]"],
-      returnType: "string[]",
-      testCase: '[["MUC","LHR"],["JFK","MUC"],["SFO","SJC"],["LHR","SFO"]]',
     },
     334: {
       funName: "increasingTriplet",
       paramTypes: ["number[]"],
-      returnType: "boolean",
-      testCase: "[1,2,3,4,5]",
     },
     335: {
       funName: "isSelfCrossing",
       paramTypes: ["number[]"],
-      returnType: "boolean",
-      testCase: "[2,1,1,2]",
     },
     336: {
       funName: "palindromePairs",
       paramTypes: ["string[]"],
-      returnType: "number[][]",
-      testCase: '["abcd","dcba","lls","s","sssll"]',
     },
     337: {
       funName: "rob",
       paramTypes: ["TreeNode"],
-      returnType: "number",
-      testCase: "[3,2,3,null,3,null,1]",
     },
     338: {
       funName: "countBits",
       paramTypes: ["number"],
-      returnType: "number[]",
-      testCase: "2",
     },
     341: {
       funName: "NestedIterator",
       paramTypes: ["NestedInteger[]"],
-      returnType: "void",
-      testCase: "[[1,1],2,[1,1]]",
     },
     342: {
       funName: "isPowerOfFour",
       paramTypes: ["number"],
-      returnType: "boolean",
-      testCase: "16",
     },
     343: {
       funName: "integerBreak",
       paramTypes: ["number"],
-      returnType: "number",
-      testCase: "2",
     },
     344: {
       funName: "reverseString",
       paramTypes: ["character[]"],
-      returnType: "void",
-      testCase: '["h","e","l","l","o"]',
     },
     345: {
       funName: "reverseVowels",
       paramTypes: ["string"],
-      returnType: "string",
-      testCase: '"hello"',
     },
     347: {
       funName: "topKFrequent",
       paramTypes: ["number[]", "number"],
-      returnType: "number[]",
-      testCase: "[1,1,1,2,2,3]\\n2",
     },
     349: {
       funName: "intersection",
       paramTypes: ["number[]", "number[]"],
-      returnType: "number[]",
-      testCase: "[1,2,2,1]\\n[2,2]",
     },
     350: {
       funName: "intersect",
       paramTypes: ["number[]", "number[]"],
-      returnType: "number[]",
-      testCase: "[1,2,2,1]\\n[2,2]",
     },
     352: {
       funName: "SummaryRanges",
       paramTypes: [],
-      returnType: "void",
-      testCase:
-        '["SummaryRanges","addNum","getIntervals","addNum","getIntervals","addNum","getIntervals","addNum","getIntervals","addNum","getIntervals"]\\n[[],[1],[],[3],[],[7],[],[2],[],[6],[]]',
     },
     354: {
       funName: "maxEnvelopes",
       paramTypes: ["number[][]"],
-      returnType: "number",
-      testCase: "[[5,4],[6,4],[6,7],[2,3]]",
     },
     355: {
       funName: "Twitter",
       paramTypes: [],
-      returnType: "void",
-      testCase:
-        '["Twitter","postTweet","getNewsFeed","follow","postTweet","getNewsFeed","unfollow","getNewsFeed"]\\n[[],[1,5],[1],[1,2],[2,6],[1],[1,2],[1]]',
     },
     357: {
       funName: "countNumbersWithUniqueDigits",
       paramTypes: ["number"],
-      returnType: "number",
-      testCase: "2",
     },
     363: {
       funName: "maxSumSubmatrix",
       paramTypes: ["number[][]", "number"],
-      returnType: "number",
-      testCase: "[[1,0,1],[0,-2,3]]\\n2",
     },
     365: {
       funName: "canMeasureWater",
       paramTypes: ["number", "number", "number"],
-      returnType: "boolean",
-      testCase: "3\\n5\\n4",
     },
     367: {
       funName: "isPerfectSquare",
       paramTypes: ["number"],
-      returnType: "boolean",
-      testCase: "16",
     },
     368: {
       funName: "largestDivisibleSubset",
       paramTypes: ["number[]"],
-      returnType: "number[]",
-      testCase: "[1,2,3]",
     },
     371: {
       funName: "getSum",
       paramTypes: ["number", "number"],
-      returnType: "number",
-      testCase: "1\\n2",
     },
     372: {
       funName: "superPow",
       paramTypes: ["number", "number[]"],
-      returnType: "number",
-      testCase: "2\\n[3]",
     },
     373: {
       funName: "kSmallestPairs",
       paramTypes: ["number[]", "number[]", "number"],
-      returnType: "number[][]",
-      testCase: "[1,7,11]\\n[2,4,6]\\n3",
     },
     375: {
       funName: "getMoneyAmount",
       paramTypes: ["number"],
-      returnType: "number",
-      testCase: "1",
     },
     376: {
       funName: "wiggleMaxLength",
       paramTypes: ["number[]"],
-      returnType: "number",
-      testCase: "[1,7,4,9,2,5]",
     },
     377: {
       funName: "combinationSum4",
       paramTypes: ["number[]", "number"],
-      returnType: "number",
-      testCase: "[1,2,3]\\n4",
     },
     378: {
       funName: "kthSmallest",
       paramTypes: ["number[][]", "number"],
-      returnType: "number",
-      testCase: "[[1,5,9],[10,11,13],[12,13,15]]\\n8",
     },
     380: {
       funName: "RandomizedSet",
       paramTypes: [],
-      returnType: "void",
-      testCase:
-        '["RandomizedSet","insert","remove","insert","getRandom","remove","insert","getRandom"]\\n[[],[1],[2],[2],[],[1],[2],[]]',
     },
     381: {
       funName: "RandomizedCollection",
       paramTypes: [],
-      returnType: "void",
-      testCase:
-        '["RandomizedCollection","insert","insert","insert","getRandom","remove","getRandom"]\\n[[],[1],[1],[2],[],[1],[]]',
     },
     382: {
       funName: "Solution",
       paramTypes: ["ListNode"],
-      returnType: "void",
-      testCase: '["Solution","getRandom"]\\n[[[1,2,3]],[]]',
     },
     383: {
       funName: "canConstruct",
       paramTypes: ["string", "string"],
-      returnType: "boolean",
-      testCase: '"a"\\n"b"',
     },
     384: {
       funName: "Solution",
       paramTypes: ["number[]"],
-      returnType: "void",
-      testCase: '["Solution","shuffle","reset","shuffle"]\\n[[[1,2,3]],[],[],[]]',
     },
     385: {
       funName: "deserialize",
       paramTypes: ["string"],
-      returnType: "NestedInteger",
-      testCase: '"324"',
     },
     386: {
       funName: "lexicalOrder",
       paramTypes: ["number"],
-      returnType: "number[]",
-      testCase: "13",
     },
     387: {
       funName: "firstUniqChar",
       paramTypes: ["string"],
-      returnType: "number",
-      testCase: '"leetcode"',
     },
     388: {
       funName: "lengthLongestPath",
       paramTypes: ["string"],
-      returnType: "number",
-      testCase: '"dir\\\\n\\\\tsubdir1\\\\n\\\\tsubdir2\\\\n\\\\t\\\\tfile.ext"',
     },
     389: {
       funName: "findTheDifference",
       paramTypes: ["string", "string"],
-      returnType: "character",
-      testCase: '"abcd"\\n"abcde"',
     },
     390: {
       funName: "lastRemaining",
       paramTypes: ["number"],
-      returnType: "number",
-      testCase: "9",
     },
     391: {
       funName: "isRectangleCover",
       paramTypes: ["number[][]"],
-      returnType: "boolean",
-      testCase: "[[1,1,3,3],[3,1,4,2],[3,2,4,4],[1,3,2,4],[2,3,3,4]]",
     },
     392: {
       funName: "isSubsequence",
       paramTypes: ["string", "string"],
-      returnType: "boolean",
-      testCase: '"abc"\\n"ahbgdc"',
     },
     393: {
       funName: "validUtf8",
       paramTypes: ["number[]"],
-      returnType: "boolean",
-      testCase: "[197,130,1]",
     },
     394: {
       funName: "decodeString",
       paramTypes: ["string"],
-      returnType: "string",
-      testCase: '"3[a]2[bc]"',
     },
     395: {
       funName: "longestSubstring",
       paramTypes: ["string", "number"],
-      returnType: "number",
-      testCase: '"aaabb"\\n3',
     },
     396: {
       funName: "maxRotateFunction",
       paramTypes: ["number[]"],
-      returnType: "number",
-      testCase: "[]",
     },
     397: {
       funName: "integerReplacement",
       paramTypes: ["number"],
-      returnType: "number",
-      testCase: "8",
     },
     398: {
       funName: "Solution",
       paramTypes: ["number[]"],
-      returnType: "void",
-      testCase: '["Solution","pick"]\\n[[[1,2,3,3,3]],[3]]',
     },
     399: {
       funName: "calcEquation",
       paramTypes: ["string[][]", "number[]", "string[][]"],
-      returnType: "number[]",
-      testCase: '[["a","b"],["b","c"]]\\n[2.0,3.0]\\n[["a","c"],["b","a"],["a","e"],["a","a"],["x","x"]]',
     },
     400: {
       funName: "findNthDigit",
       paramTypes: ["number"],
-      returnType: "number",
-      testCase: "3",
     },
     401: {
       funName: "readBinaryWatch",
       paramTypes: ["number"],
-      returnType: "string[]",
-      testCase: "0",
     },
     402: {
       funName: "removeKdigits",
       paramTypes: ["string", "number"],
-      returnType: "string",
-      testCase: '"1432219"\\n3',
     },
     403: {
       funName: "canCross",
       paramTypes: ["number[]"],
-      returnType: "boolean",
-      testCase: "[0,1,3,4,5,7,9,10,12]",
     },
     404: {
       funName: "sumOfLeftLeaves",
       paramTypes: ["TreeNode"],
-      returnType: "number",
-      testCase: "[3,9,20,null,null,15,7]",
     },
     405: {
       funName: "toHex",
       paramTypes: ["number"],
-      returnType: "string",
-      testCase: "26",
     },
     406: {
       funName: "reconstructQueue",
       paramTypes: ["number[][]"],
-      returnType: "number[][]",
-      testCase: "[[7,0],[4,4],[7,1],[5,0],[6,1],[5,2]]",
     },
     407: {
       funName: "trapRainWater",
       paramTypes: ["number[][]"],
-      returnType: "number",
-      testCase: "[[1,4,3,1,3,2],[3,2,1,3,2,4],[2,3,3,2,3,1]]",
     },
     409: {
       funName: "longestPalindrome",
       paramTypes: ["string"],
-      returnType: "number",
-      testCase: '"abccccdd"',
     },
     410: {
       funName: "splitArray",
       paramTypes: ["number[]", "number"],
-      returnType: "number",
-      testCase: "[7,2,5,10,8]\\n2",
     },
     412: {
       funName: "fizzBuzz",
       paramTypes: ["number"],
-      returnType: "string[]",
-      testCase: "1",
     },
     413: {
       funName: "numberOfArithmeticSlices",
       paramTypes: ["number[]"],
-      returnType: "number",
-      testCase: "[1,2,3,4]",
     },
     414: {
       funName: "thirdMax",
       paramTypes: ["number[]"],
-      returnType: "number",
-      testCase: "[3,2,1]",
     },
     415: {
       funName: "addStrings",
       paramTypes: ["string", "string"],
-      returnType: "string",
-      testCase: '"0"\\n"0"',
     },
     416: {
       funName: "canPartition",
       paramTypes: ["number[]"],
-      returnType: "boolean",
-      testCase: "[1,5,11,5]",
     },
     417: {
       funName: "pacificAtlantic",
       paramTypes: ["number[][]"],
-      returnType: "number[][]",
-      testCase: "[[1,2,2,3,5],[3,2,3,4,4],[2,4,5,3,1],[6,7,1,4,5],[5,1,1,2,4]]",
     },
     419: {
       funName: "countBattleships",
       paramTypes: ["character[][]"],
-      returnType: "number",
-      testCase: '[["X",".",".","X"],[".",".",".","X"],[".",".",".","X"]]',
     },
     420: {
       funName: "strongPasswordChecker",
       paramTypes: ["string"],
-      returnType: "number",
-      testCase: '""',
     },
     421: {
       funName: "findMaximumXOR",
       paramTypes: ["number[]"],
-      returnType: "number",
-      testCase: "[3,10,5,25,2,8]",
     },
     423: {
       funName: "originalDigits",
       paramTypes: ["string"],
-      returnType: "string",
-      testCase: '"owoztneoer"',
     },
     424: {
       funName: "characterReplacement",
       paramTypes: ["string", "number"],
-      returnType: "number",
-      testCase: '"ABAB"\\n2',
     },
     427: {
       funName: "construct",
       paramTypes: ["number[][]"],
-      returnType: "Node",
-      testCase: "[[0,1],[1,0]]",
     },
     429: {
       funName: "levelOrder",
       paramTypes: ["Node"],
-      returnType: "number[][]",
-      testCase: "[1,null,3,2,4,null,5,6]",
     },
     // TODO: parse parameters
     // 430: {
     //     funName: "flatten",
     //     paramTypes: ["Node"],
-    //     returnType: "Node",
-    //     testCase: "[1,2,3,4,5,6,null,null,null,7,8,9,10,null,null,11,12]",
+
+    //
     // },
     432: {
       funName: "AllOne",
       paramTypes: [],
-      returnType: "void",
-      testCase: '["AllOne","getMaxKey","getMinKey"]\\n[[],[],[]]',
     },
     433: {
       funName: "minMutation",
       paramTypes: ["string", "string", "string[]"],
-      returnType: "number",
-      testCase: '"AACCGGTT"\\n"AACCGGTA"\\n["AACCGGTA"]',
     },
     434: {
       funName: "countSegments",
       paramTypes: ["string"],
-      returnType: "number",
-      testCase: '"Hello, my name is John"',
     },
     435: {
       funName: "eraseOverlapIntervals",
       paramTypes: ["number[][]"],
-      returnType: "number",
-      testCase: "[[1,2]]",
     },
     436: {
       funName: "findRightInterval",
       paramTypes: ["number[][]"],
-      returnType: "number[]",
-      testCase: "[[1,2]]",
     },
     437: {
       funName: "pathSum",
       paramTypes: ["TreeNode", "number"],
-      returnType: "number",
-      testCase: "[10,5,-3,3,2,null,11,3,-2,null,1]\\n8",
     },
     438: {
       funName: "findAnagrams",
       paramTypes: ["string", "string"],
-      returnType: "number[]",
-      testCase: '"cbaebabacd"\\n"abc"',
     },
     440: {
       funName: "findKthNumber",
       paramTypes: ["number", "number"],
-      returnType: "number",
-      testCase: "13\\n2",
     },
     441: {
       funName: "arrangeCoins",
       paramTypes: ["number"],
-      returnType: "number",
-      testCase: "5",
     },
     442: {
       funName: "findDuplicates",
       paramTypes: ["number[]"],
-      returnType: "number[]",
-      testCase: "[4,3,2,7,8,2,3,1]",
     },
     443: {
       funName: "compress",
       paramTypes: ["character[]"],
-      returnType: "number",
-      testCase: '["a","a","b","b","c","c","c"]',
     },
     445: {
       funName: "addTwoNumbers",
       paramTypes: ["ListNode", "ListNode"],
-      returnType: "ListNode",
-      testCase: "[7,2,4,3]\\n[5,6,4]",
     },
     446: {
       funName: "numberOfArithmeticSlices",
       paramTypes: ["number[]"],
-      returnType: "number",
-      testCase: "[2,4,6,8,10]",
     },
     447: {
       funName: "numberOfBoomerangs",
       paramTypes: ["number[][]"],
-      returnType: "number",
-      testCase: "[[0,0],[1,0],[2,0]]",
     },
     448: {
       funName: "findDisappearedNumbers",
       paramTypes: ["number[]"],
-      returnType: "number[]",
-      testCase: "[4,3,2,7,8,2,3,1]",
     },
     449: {
       funName: "serialize",
       paramTypes: ["TreeNode"],
-      returnType: "string",
-      testCase: "[2,1,3]",
     },
     450: {
       funName: "deleteNode",
       paramTypes: ["TreeNode", "number"],
-      returnType: "TreeNode",
-      testCase: "[5,3,6,2,4,null,7]\\n3",
     },
     451: {
       funName: "frequencySort",
       paramTypes: ["string"],
-      returnType: "string",
-      testCase: '"tree"',
     },
     452: {
       funName: "findMinArrowShots",
       paramTypes: ["number[][]"],
-      returnType: "number",
-      testCase: "[[10,16],[2,8],[1,6],[7,12]]",
     },
     453: {
       funName: "minMoves",
       paramTypes: ["number[]"],
-      returnType: "number",
-      testCase: "[1,2,3]",
     },
     454: {
       funName: "fourSumCount",
       paramTypes: ["number[]", "number[]", "number[]", "number[]"],
-      returnType: "number",
-      testCase: "[1,2]\\n[-2,-1]\\n[-1,2]\\n[0,2]",
     },
     455: {
       funName: "findContentChildren",
       paramTypes: ["number[]", "number[]"],
-      returnType: "number",
-      testCase: "[1,2,3]\\n[1,1]",
     },
     456: {
       funName: "find132pattern",
       paramTypes: ["number[]"],
-      returnType: "boolean",
-      testCase: "[1,2,3,4]",
     },
     457: {
       funName: "circularArrayLoop",
       paramTypes: ["number[]"],
-      returnType: "boolean",
-      testCase: "[2,-1,1,2,2]",
     },
     458: {
       funName: "poorPigs",
       paramTypes: ["number", "number", "number"],
-      returnType: "number",
-      testCase: "1000\\n15\\n60",
     },
     459: {
       funName: "repeatedSubstringPattern",
       paramTypes: ["string"],
-      returnType: "boolean",
-      testCase: '"abab"',
     },
     460: {
       funName: "LFUCache",
       paramTypes: ["number"],
-      returnType: "void",
-      testCase:
-        '["LFUCache","put","put","get","put","get","get","put","get","get","get"]\\n[[2],[1,1],[2,2],[1],[3,3],[2],[3],[4,4],[1],[3],[4]]',
     },
     461: {
       funName: "hammingDistance",
       paramTypes: ["number", "number"],
-      returnType: "number",
-      testCase: "1\\n4",
     },
     462: {
       funName: "minMoves2",
       paramTypes: ["number[]"],
-      returnType: "number",
-      testCase: "[1,2,3]",
     },
     463: {
       funName: "islandPerimeter",
       paramTypes: ["number[][]"],
-      returnType: "number",
-      testCase: "[[0,1,0,0],[1,1,1,0],[0,1,0,0],[1,1,0,0]]",
     },
     464: {
       funName: "canIWin",
       paramTypes: ["number", "number"],
-      returnType: "boolean",
-      testCase: "10\\n11",
     },
     466: {
       funName: "getMaxRepetitions",
       paramTypes: ["string", "number", "string", "number"],
-      returnType: "number",
-      testCase: '"acb"\\n4\\n"ab"\\n2',
     },
     467: {
       funName: "findSubstringInWraproundString",
       paramTypes: ["string"],
-      returnType: "number",
-      testCase: '"a"',
     },
     468: {
       funName: "validIPAddress",
       paramTypes: ["string"],
-      returnType: "string",
-      testCase: '"172.16.254.1"',
     },
     470: {
       funName: "rand10",
       paramTypes: [],
-      returnType: "number",
-      testCase: "1",
     },
     472: {
       funName: "findAllConcatenatedWordsInADict",
       paramTypes: ["string[]"],
-      returnType: "string[]",
-      testCase: '["cat","cats","catsdogcats","dog","dogcatsdog","hippopotamuses","rat","ratcatdogcat"]',
     },
     473: {
       funName: "makesquare",
       paramTypes: ["number[]"],
-      returnType: "boolean",
-      testCase: "[1,1,2,2,2]",
     },
     474: {
       funName: "findMaxForm",
       paramTypes: ["string[]", "number", "number"],
-      returnType: "number",
-      testCase: '["10","0001","111001","1","0"]\\n5\\n3',
     },
     475: {
       funName: "findRadius",
       paramTypes: ["number[]", "number[]"],
-      returnType: "number",
-      testCase: "[1,2,3]\\n[2]",
     },
     476: {
       funName: "findComplement",
       paramTypes: ["number"],
-      returnType: "number",
-      testCase: "5",
     },
     477: {
       funName: "totalHammingDistance",
       paramTypes: ["number[]"],
-      returnType: "number",
-      testCase: "[4,14,2]",
     },
     478: {
       funName: "Solution",
       paramTypes: ["number", "number", "number"],
-      returnType: "void",
-      testCase: '["Solution", "randPoint", "randPoint", "randPoint"]\\n[[1.0, 0.0, 0.0], [], [], []]',
     },
     479: {
       funName: "largestPalindrome",
       paramTypes: ["number"],
-      returnType: "number",
-      testCase: "1",
     },
     480: {
       funName: "medianSlidingWindow",
       paramTypes: ["number[]", "number"],
-      returnType: "number[]",
-      testCase: "[1,3,-1,-3,5,3,6,7]\\n3",
     },
     481: {
       funName: "magicalString",
       paramTypes: ["number"],
-      returnType: "number",
-      testCase: "1",
     },
     482: {
       funName: "licenseKeyFormatting",
       paramTypes: ["string", "number"],
-      returnType: "string",
-      testCase: '"5F3Z-2e-9-w"\\n4',
     },
     483: {
       funName: "smallestGoodBase",
       paramTypes: ["string"],
-      returnType: "string",
-      testCase: '"13"',
     },
     485: {
       funName: "findMaxConsecutiveOnes",
       paramTypes: ["number[]"],
-      returnType: "number",
-      testCase: "[1,0,1,1,0,1]",
     },
     486: {
       funName: "PredictTheWinner",
       paramTypes: ["number[]"],
-      returnType: "boolean",
-      testCase: "[1,5,2]",
     },
     488: {
       funName: "findMinStep",
       paramTypes: ["string", "string"],
-      returnType: "number",
-      testCase: '"WRRBBW"\\n"RB"',
     },
     491: {
       funName: "findSubsequences",
       paramTypes: ["number[]"],
-      returnType: "number[][]",
-      testCase: "[4,6,7,7]",
     },
     492: {
       funName: "constructRectangle",
       paramTypes: ["number"],
-      returnType: "number[]",
-      testCase: "1",
     },
     493: {
       funName: "reversePairs",
       paramTypes: ["number[]"],
-      returnType: "number",
-      testCase: "[1,3,2,3,1]",
     },
     494: {
       funName: "findTargetSumWays",
       paramTypes: ["number[]", "number"],
-      returnType: "number",
-      testCase: "[1,1,1,1,1]\\n3",
     },
     495: {
       funName: "findPoisonedDuration",
       paramTypes: ["number[]", "number"],
-      returnType: "number",
-      testCase: "[1,4]\\n2",
     },
     496: {
       funName: "nextGreaterElement",
       paramTypes: ["number[]", "number[]"],
-      returnType: "number[]",
-      testCase: "[4,1,2]\\n[1,3,4,2]",
     },
     497: {
       funName: "Solution",
       paramTypes: ["number[][]"],
-      returnType: "void",
-      testCase: '["Solution", "pick", "pick", "pick"]\\n[[[[1, 1, 5, 5]]], [], [], []]',
     },
     498: {
       funName: "findDiagonalOrder",
       paramTypes: ["number[][]"],
-      returnType: "number[]",
-      testCase: "[[1,2,3],[4,5,6],[7,8,9]]",
     },
     500: {
       funName: "findWords",
       paramTypes: ["string[]"],
-      returnType: "string[]",
-      testCase: '["Hello","Alaska","Dad","Peace"]',
     },
     501: {
       funName: "findMode",
       paramTypes: ["TreeNode"],
-      returnType: "number[]",
-      testCase: "[1,null,2,2]",
     },
     502: {
       funName: "findMaximizedCapital",
       paramTypes: ["number", "number", "number[]", "number[]"],
-      returnType: "number",
-      testCase: "2\\n0\\n[1,2,3]\\n[0,1,1]",
     },
     503: {
       funName: "nextGreaterElements",
       paramTypes: ["number[]"],
-      returnType: "number[]",
-      testCase: "[1,2,1]",
     },
     504: {
       funName: "convertToBase7",
       paramTypes: ["number"],
-      returnType: "string",
-      testCase: "100",
     },
     506: {
       funName: "findRelativeRanks",
       paramTypes: ["number[]"],
-      returnType: "string[]",
-      testCase: "[5,4,3,2,1]",
     },
     507: {
       funName: "checkPerfectNumber",
       paramTypes: ["number"],
-      returnType: "boolean",
-      testCase: "28",
     },
     508: {
       funName: "findFrequentTreeSum",
       paramTypes: ["TreeNode"],
-      returnType: "number[]",
-      testCase: "[5,2,-3]",
     },
     509: {
       funName: "fib",
       paramTypes: ["number"],
-      returnType: "number",
-      testCase: "2",
     },
     513: {
       funName: "findBottomLeftValue",
       paramTypes: ["TreeNode"],
-      returnType: "number",
-      testCase: "[2,1,3]",
     },
     514: {
       funName: "findRotateSteps",
       paramTypes: ["string", "string"],
-      returnType: "number",
-      testCase: '"godding"\\n"gd"',
     },
     515: {
       funName: "largestValues",
       paramTypes: ["TreeNode"],
-      returnType: "number[]",
-      testCase: "[1,3,2,5,3,null,9]",
     },
     516: {
       funName: "longestPalindromeSubseq",
       paramTypes: ["string"],
-      returnType: "number",
-      testCase: '"bbbab"',
     },
     517: {
       funName: "findMinMoves",
       paramTypes: ["number[]"],
-      returnType: "number",
-      testCase: "[1,0,5]",
     },
     518: {
       funName: "change",
       paramTypes: ["number", "number[]"],
-      returnType: "number",
-      testCase: "5\\n[1,2,5]",
     },
     519: {
       funName: "Solution",
       paramTypes: ["number", "number"],
-      returnType: "void",
-      testCase: '["Solution", "flip", "flip", "flip", "flip"]\\n[[2, 2], [], [], [], []]',
     },
     520: {
       funName: "detectCapitalUse",
       paramTypes: ["string"],
-      returnType: "boolean",
-      testCase: '"USA"',
     },
     521: {
       funName: "findLUSlength",
       paramTypes: ["string", "string"],
-      returnType: "number",
-      testCase: '"aba"\\n"cdc"',
     },
     522: {
       funName: "findLUSlength",
       paramTypes: ["string[]"],
-      returnType: "number",
-      testCase: '["aba","cdc","eae"]',
     },
     523: {
       funName: "checkSubarraySum",
       paramTypes: ["number[]", "number"],
-      returnType: "boolean",
-      testCase: "[23,2,4,6,7]\\n6",
     },
     524: {
       funName: "findLongestWord",
       paramTypes: ["string", "string[]"],
-      returnType: "string",
-      testCase: '"abpcplea"\\n["ale","apple","monkey","plea"]',
     },
     525: {
       funName: "findMaxLength",
       paramTypes: ["number[]"],
-      returnType: "number",
-      testCase: "[0,1]",
     },
     526: {
       funName: "countArrangement",
       paramTypes: ["number"],
-      returnType: "number",
-      testCase: "2",
     },
     528: {
       funName: "Solution",
       paramTypes: ["number[]"],
-      returnType: "void",
-      testCase: '["Solution", "pickIndex"]\\n[[[1]], []]',
     },
     529: {
       funName: "updateBoard",
       paramTypes: ["character[][]", "number[]"],
-      returnType: "character[][]",
-      testCase: '[["E","E","E","E","E"],["E","E","M","E","E"],["E","E","E","E","E"],["E","E","E","E","E"]]\\n[3,0]',
     },
     530: {
       funName: "getMinimumDifference",
       paramTypes: ["TreeNode"],
-      returnType: "number",
-      testCase: "[1,null,3,2]",
     },
     532: {
       funName: "findPairs",
       paramTypes: ["number[]", "number"],
-      returnType: "number",
-      testCase: "[3,1,4,1,5]\\n2",
     },
     535: {
       funName: "encode",
       paramTypes: ["string"],
-      returnType: "string",
-      testCase: '"https://leetcode.com/problems/design-tinyurl"',
     },
     537: {
       funName: "complexNumberMultiply",
       paramTypes: ["string", "string"],
-      returnType: "string",
-      testCase: '"1+1i"\\n"1+1i"',
     },
     538: {
       funName: "convertBST",
       paramTypes: ["TreeNode"],
-      returnType: "TreeNode",
-      testCase: "[5,2,13]",
     },
     539: {
       funName: "findMinDifference",
       paramTypes: ["string[]"],
-      returnType: "number",
-      testCase: '["23:59","00:00"]',
     },
     540: {
       funName: "singleNonDuplicate",
       paramTypes: ["number[]"],
-      returnType: "number",
-      testCase: "[1,1,2,3,3,4,4,8,8]",
     },
     541: {
       funName: "reverseStr",
       paramTypes: ["string", "number"],
-      returnType: "string",
-      testCase: '"abcdefg"\\n2',
     },
     542: {
       funName: "updateMatrix",
       paramTypes: ["number[][]"],
-      returnType: "number[][]",
-      testCase: "[[0,0,0],[0,1,0],[0,0,0]]",
     },
     543: {
       funName: "diameterOfBinaryTree",
       paramTypes: ["TreeNode"],
-      returnType: "number",
-      testCase: "[1,2,3,4,5]",
     },
     546: {
       funName: "removeBoxes",
       paramTypes: ["number[]"],
-      returnType: "number",
-      testCase: "[1,3,2,2,2,3,4,3,1]",
     },
     547: {
       funName: "findCircleNum",
       paramTypes: ["number[][]"],
-      returnType: "number",
-      testCase: "[[1,1,0],[1,1,0],[0,0,1]]",
     },
     551: {
       funName: "checkRecord",
       paramTypes: ["string"],
-      returnType: "boolean",
-      testCase: '"PPALLP"',
     },
     552: {
       funName: "checkRecord",
       paramTypes: ["number"],
-      returnType: "number",
-      testCase: "1",
     },
     553: {
       funName: "optimalDivision",
       paramTypes: ["number[]"],
-      returnType: "string",
-      testCase: "[1000,100,10,2]",
     },
     554: {
       funName: "leastBricks",
       paramTypes: ["number[][]"],
-      returnType: "number",
-      testCase: "[[1,2,2,1],[3,1,2],[1,3,2],[2,4],[3,1,2],[1,3,1,1]]",
     },
     556: {
       funName: "nextGreaterElement",
       paramTypes: ["number"],
-      returnType: "number",
-      testCase: "12",
     },
     557: {
       funName: "reverseWords",
       paramTypes: ["string"],
-      returnType: "string",
-      testCase: '"Let\\',
     },
     // TODO: parse parameters
     // 558: {
     //     funName: "intersect",
     //     paramTypes: ["Node", "Node"],
-    //     returnType: "Node",
-    //     testCase:
-    //         "[[0,1],[1,1],[1,1],[1,0],[1,0]]\\n[[0,1],[1,1],[0,1],[1,1],[1,0],null,null,null,null,[1,0],[1,0],[1,1],[1,1]]",
+
+    //
+    //
     // },
     559: {
       funName: "maxDepth",
       paramTypes: ["Node"],
-      returnType: "number",
-      testCase: "[1,null,3,2,4,null,5,6]",
     },
     560: {
       funName: "subarraySum",
       paramTypes: ["number[]", "number"],
-      returnType: "number",
-      testCase: "[1,1,1]\\n2",
     },
     561: {
       funName: "arrayPairSum",
       paramTypes: ["number[]"],
-      returnType: "number",
-      testCase: "[1,4,3,2]",
     },
     563: {
       funName: "findTilt",
       paramTypes: ["TreeNode"],
-      returnType: "number",
-      testCase: "[1,2,3]",
     },
     564: {
       funName: "nearestPalindromic",
       paramTypes: ["string"],
-      returnType: "string",
-      testCase: '"1"',
     },
     565: {
       funName: "arrayNesting",
       paramTypes: ["number[]"],
-      returnType: "number",
-      testCase: "[5,4,0,3,1,6,2]",
     },
     566: {
       funName: "matrixReshape",
       paramTypes: ["number[][]", "number", "number"],
-      returnType: "number[][]",
-      testCase: "[[1,2],[3,4]]\\n1\\n4",
     },
     567: {
       funName: "checkInclusion",
       paramTypes: ["string", "string"],
-      returnType: "boolean",
-      testCase: '"ab"\\n"eidbaooo"',
     },
     572: {
       funName: "isSubtree",
       paramTypes: ["TreeNode", "TreeNode"],
-      returnType: "boolean",
-      testCase: "[3,4,5,1,2]\\n[4,1,2]",
     },
     575: {
       funName: "distributeCandies",
       paramTypes: ["number[]"],
-      returnType: "number",
-      testCase: "[1,1,2,2,3,3]",
     },
     576: {
       funName: "findPaths",
       paramTypes: ["number", "number", "number", "number", "number"],
-      returnType: "number",
-      testCase: "2\\n2\\n2\\n0\\n0",
     },
     581: {
       funName: "findUnsortedSubarray",
       paramTypes: ["number[]"],
-      returnType: "number",
-      testCase: "[2,6,4,8,10,9,15]",
     },
     583: {
       funName: "minDistance",
       paramTypes: ["string", "string"],
-      returnType: "number",
-      testCase: '"sea"\\n"eat"',
     },
     587: {
       funName: "outerTrees",
       paramTypes: ["number[][]"],
-      returnType: "number[][]",
-      testCase: "[[1,1],[2,2],[2,0],[2,4],[3,3],[4,2]]",
     },
     589: {
       funName: "preorder",
       paramTypes: ["Node"],
-      returnType: "number[]",
-      testCase: "[1,null,3,2,4,null,5,6]",
     },
     590: {
       funName: "postorder",
       paramTypes: ["Node"],
-      returnType: "number[]",
-      testCase: "[1,null,3,2,4,null,5,6]",
     },
     591: {
       funName: "isValid",
       paramTypes: ["string"],
-      returnType: "boolean",
-      testCase: '"<DIV>This is the first line <![CDATA[<div>]]></DIV>"',
     },
     592: {
       funName: "fractionAddition",
       paramTypes: ["string"],
-      returnType: "string",
-      testCase: '"-1/2+1/2"',
     },
     593: {
       funName: "validSquare",
       paramTypes: ["number[]", "number[]", "number[]", "number[]"],
-      returnType: "boolean",
-      testCase: "[0,0]\\n[1,1]\\n[1,0]\\n[0,1]",
     },
     594: {
       funName: "findLHS",
       paramTypes: ["number[]"],
-      returnType: "number",
-      testCase: "[1,3,2,2,5,2,3,7]",
     },
     598: {
       funName: "maxCount",
       paramTypes: ["number", "number", "number[][]"],
-      returnType: "number",
-      testCase: "3\\n3\\n[[2,2],[3,3]]",
     },
     599: {
       funName: "findRestaurant",
       paramTypes: ["string[]", "string[]"],
-      returnType: "string[]",
-      testCase:
-        '["Shogun","Tapioca Express","Burger King","KFC"]\\n["Piatti","The Grill at Torrey Pines","Hungry Hunter Steakhouse","Shogun"]',
     },
     600: {
       funName: "findIntegers",
       paramTypes: ["number"],
-      returnType: "number",
-      testCase: "1",
     },
     605: {
       funName: "canPlaceFlowers",
       paramTypes: ["number[]", "number"],
-      returnType: "boolean",
-      testCase: "[1,0,0,0,1]\\n1",
     },
     606: {
       funName: "tree2str",
       paramTypes: ["TreeNode"],
-      returnType: "string",
-      testCase: "[1,2,3,4]",
     },
     609: {
       funName: "findDuplicate",
       paramTypes: ["string[]"],
-      returnType: "string[][]",
-      testCase: '["root/a 1.txt(abcd) 2.txt(efgh)","root/c 3.txt(abcd)","root/c/d 4.txt(efgh)","root 4.txt(efgh)"]',
     },
     611: {
       funName: "triangleNumber",
       paramTypes: ["number[]"],
-      returnType: "number",
-      testCase: "[2,2,3,4]",
     },
     617: {
       funName: "mergeTrees",
       paramTypes: ["TreeNode", "TreeNode"],
-      returnType: "TreeNode",
-      testCase: "[1,3,2,5]\\n[2,1,3,null,4,null,7]",
     },
     621: {
       funName: "leastInterval",
       paramTypes: ["character[]", "number"],
-      returnType: "number",
-      testCase: '["A","A","A","B","B","B"]\\n2',
     },
     622: {
       funName: "MyCircularQueue",
       paramTypes: ["number"],
-      returnType: "void",
-      testCase:
-        '["MyCircularQueue","enQueue","enQueue","enQueue","enQueue","Rear","isFull","deQueue","enQueue","Rear"]\\n[[3],[1],[2],[3],[4],[],[],[],[4],[]]',
     },
     623: {
       funName: "addOneRow",
       paramTypes: ["TreeNode", "number", "number"],
-      returnType: "TreeNode",
-      testCase: "[4,2,6,3,1,5]\\n1\\n2",
     },
     628: {
       funName: "maximumProduct",
       paramTypes: ["number[]"],
-      returnType: "number",
-      testCase: "[1,2,3]",
     },
     629: {
       funName: "kInversePairs",
       paramTypes: ["number", "number"],
-      returnType: "number",
-      testCase: "3\\n0",
     },
     630: {
       funName: "scheduleCourse",
       paramTypes: ["number[][]"],
-      returnType: "number",
-      testCase: "[[100,200],[200,1300],[1000,1250],[2000,3200]]",
     },
     632: {
       funName: "smallestRange",
       paramTypes: ["number[][]"],
-      returnType: "number[]",
-      testCase: "[[4,10,15,24,26],[0,9,12,20],[5,18,22,30]]",
     },
     633: {
       funName: "judgeSquareSum",
       paramTypes: ["number"],
-      returnType: "boolean",
-      testCase: "5",
     },
     636: {
       funName: "exclusiveTime",
       paramTypes: ["number", "string[]"],
-      returnType: "number[]",
-      testCase: '2\\n["0:start:0","1:start:2","1:end:5","0:end:6"]',
     },
     637: {
       funName: "averageOfLevels",
       paramTypes: ["TreeNode"],
-      returnType: "number[]",
-      testCase: "[3,9,20,15,7]",
     },
     638: {
       funName: "shoppingOffers",
       paramTypes: ["number[]", "number[][]", "number[]"],
-      returnType: "number",
-      testCase: "[2,5]\\n[[3,0,5],[1,2,10]]\\n[3,2]",
     },
     639: {
       funName: "numDecodings",
       paramTypes: ["string"],
-      returnType: "number",
-      testCase: '"*"',
     },
     640: {
       funName: "solveEquation",
       paramTypes: ["string"],
-      returnType: "string",
-      testCase: '"x+5-3+x=6+x-2"',
     },
     641: {
       funName: "MyCircularDeque",
       paramTypes: ["number"],
-      returnType: "void",
-      testCase:
-        '["MyCircularDeque","insertLast","insertLast","insertFront","insertFront","getRear","isFull","deleteLast","insertFront","getFront"]\\n[[3],[1],[2],[3],[4],[],[],[],[4],[]]',
     },
     643: {
       funName: "findMaxAverage",
       paramTypes: ["number[]", "number"],
-      returnType: "number",
-      testCase: "[1,12,-5,-6,50,3]\\n4",
     },
     645: {
       funName: "findErrorNums",
       paramTypes: ["number[]"],
-      returnType: "number[]",
-      testCase: "[1,2,2,4]",
     },
     646: {
       funName: "findLongestChain",
       paramTypes: ["number[][]"],
-      returnType: "number",
-      testCase: "[[1,2], [2,3], [3,4]]",
     },
     647: {
       funName: "countSubstrings",
       paramTypes: ["string"],
-      returnType: "number",
-      testCase: '"abc"',
     },
     648: {
       funName: "replaceWords",
       paramTypes: ["string[]", "string"],
-      returnType: "string",
-      testCase: '["cat", "bat", "rat"]\\n"the cattle was rattled by the battery"',
     },
     649: {
       funName: "predictPartyVictory",
       paramTypes: ["string"],
-      returnType: "string",
-      testCase: '"RD"',
     },
     650: {
       funName: "minSteps",
       paramTypes: ["number"],
-      returnType: "number",
-      testCase: "3",
     },
     652: {
       funName: "findDuplicateSubtrees",
       paramTypes: ["TreeNode"],
-      returnType: "TreeNode[]",
-      testCase: "[1,2,3,4,null,2,4,null,null,4]",
     },
     653: {
       funName: "findTarget",
       paramTypes: ["TreeNode", "number"],
-      returnType: "boolean",
-      testCase: "[5,3,6,2,4,null,7]\\n9",
     },
     654: {
       funName: "constructMaximumBinaryTree",
       paramTypes: ["number[]"],
-      returnType: "TreeNode",
-      testCase: "[3,2,1,6,0,5]",
     },
     655: {
       funName: "printTree",
       paramTypes: ["TreeNode"],
-      returnType: "string[][]",
-      testCase: "[1,2]",
     },
     657: {
       funName: "judgeCircle",
       paramTypes: ["string"],
-      returnType: "boolean",
-      testCase: '"UD"',
     },
     658: {
       funName: "findClosestElements",
       paramTypes: ["number[]", "number", "number"],
-      returnType: "number[]",
-      testCase: "[1,2,3,4,5]\\n4\\n3",
     },
     659: {
       funName: "isPossible",
       paramTypes: ["number[]"],
-      returnType: "boolean",
-      testCase: "[1,2,3,3,4,5]",
     },
     661: {
       funName: "imageSmoother",
       paramTypes: ["number[][]"],
-      returnType: "number[][]",
-      testCase: "[[1,1,1],[1,0,1],[1,1,1]]",
     },
     662: {
       funName: "widthOfBinaryTree",
       paramTypes: ["TreeNode"],
-      returnType: "number",
-      testCase: "[1,3,2,5,3,null,9]",
     },
     664: {
       funName: "strangePrinter",
       paramTypes: ["string"],
-      returnType: "number",
-      testCase: '"aaabbb"',
     },
     665: {
       funName: "checkPossibility",
       paramTypes: ["number[]"],
-      returnType: "boolean",
-      testCase: "[4,2,3]",
     },
     667: {
       funName: "constructArray",
       paramTypes: ["number", "number"],
-      returnType: "number[]",
-      testCase: "3\\n2",
     },
     668: {
       funName: "findKthNumber",
       paramTypes: ["number", "number", "number"],
-      returnType: "number",
-      testCase: "3\\n3\\n5",
     },
     669: {
       funName: "trimBST",
       paramTypes: ["TreeNode", "number", "number"],
-      returnType: "TreeNode",
-      testCase: "[1,0,2]\\n1\\n2",
     },
     670: {
       funName: "maximumSwap",
       paramTypes: ["number"],
-      returnType: "number",
-      testCase: "2736",
     },
     671: {
       funName: "findSecondMinimumValue",
       paramTypes: ["TreeNode"],
-      returnType: "number",
-      testCase: "[2,2,5,null,null,5,7]",
     },
     672: {
       funName: "flipLights",
       paramTypes: ["number", "number"],
-      returnType: "number",
-      testCase: "1\\n1",
     },
     673: {
       funName: "findNumberOfLIS",
       paramTypes: ["number[]"],
-      returnType: "number",
-      testCase: "[1,3,5,4,7]",
     },
     674: {
       funName: "findLengthOfLCIS",
       paramTypes: ["number[]"],
-      returnType: "number",
-      testCase: "[1,3,5,4,7]",
     },
     675: {
       funName: "cutOffTree",
       paramTypes: ["number[][]"],
-      returnType: "number",
-      testCase: "[[1,2,3],[0,0,4],[7,6,5]]",
     },
     676: {
       funName: "MagicDictionary",
       paramTypes: [],
-      returnType: "void",
-      testCase:
-        '["MagicDictionary", "buildDict", "search", "search", "search", "search"]\\n[[], [["hello","leetcode"]], ["hello"], ["hhllo"], ["hell"], ["leetcoded"]]',
     },
     677: {
       funName: "MapSum",
       paramTypes: [],
-      returnType: "void",
-      testCase: '["MapSum", "insert", "sum", "insert", "sum"]\\n[[], ["apple",3], ["ap"], ["app",2], ["ap"]]',
     },
     678: {
       funName: "checkValidString",
       paramTypes: ["string"],
-      returnType: "boolean",
-      testCase: '"()"',
     },
     679: {
       funName: "judgePoint24",
       paramTypes: ["number[]"],
-      returnType: "boolean",
-      testCase: "[4,1,8,7]",
     },
     680: {
       funName: "validPalindrome",
       paramTypes: ["string"],
-      returnType: "boolean",
-      testCase: '"aba"',
     },
     682: {
       funName: "calPoints",
       paramTypes: ["string[]"],
-      returnType: "number",
-      testCase: '["5","2","C","D","+"]',
     },
     684: {
       funName: "findRedundantConnection",
       paramTypes: ["number[][]"],
-      returnType: "number[]",
-      testCase: "[[1,2],[1,3],[2,3]]",
     },
     685: {
       funName: "findRedundantDirectedConnection",
       paramTypes: ["number[][]"],
-      returnType: "number[]",
-      testCase: "[[1,2],[1,3],[2,3]]",
     },
     686: {
       funName: "repeatedStringMatch",
       paramTypes: ["string", "string"],
-      returnType: "number",
-      testCase: '"abcd"\\n"cdabcdab"',
     },
     687: {
       funName: "longestUnivaluePath",
       paramTypes: ["TreeNode"],
-      returnType: "number",
-      testCase: "[5,4,5,1,1,5]",
     },
     688: {
       funName: "knightProbability",
       paramTypes: ["number", "number", "number", "number"],
-      returnType: "number",
-      testCase: "3\\n2\\n0\\n0",
     },
     689: {
       funName: "maxSumOfThreeSubarrays",
       paramTypes: ["number[]", "number"],
-      returnType: "number[]",
-      testCase: "[1,2,1,2,6,7,5,1]\\n2",
     },
     691: {
       funName: "minStickers",
       paramTypes: ["string[]", "string"],
-      returnType: "number",
-      testCase: '["with","example","science"]\\n"thehat"',
     },
     692: {
       funName: "topKFrequent",
       paramTypes: ["string[]", "number"],
-      returnType: "string[]",
-      testCase: '["i", "love", "leetcode", "i", "love", "coding"]\\n2',
     },
     693: {
       funName: "hasAlternatingBits",
       paramTypes: ["number"],
-      returnType: "boolean",
-      testCase: "5",
     },
     695: {
       funName: "maxAreaOfIsland",
       paramTypes: ["number[][]"],
-      returnType: "number",
-      testCase: "[[1,1,0,0,0],[1,1,0,0,0],[0,0,0,1,1],[0,0,0,1,1]]",
     },
     696: {
       funName: "countBinarySubstrings",
       paramTypes: ["string"],
-      returnType: "number",
-      testCase: '"00110"',
     },
     697: {
       funName: "findShortestSubArray",
       paramTypes: ["number[]"],
-      returnType: "number",
-      testCase: "[1,2,2,3,1]",
     },
     698: {
       funName: "canPartitionKSubsets",
       paramTypes: ["number[]", "number"],
-      returnType: "boolean",
-      testCase: "[4,3,2,3,5,2,1]\\n4",
     },
     699: {
       funName: "fallingSquares",
       paramTypes: ["number[][]"],
-      returnType: "number[]",
-      testCase: "[[1,2],[2,3],[6,1]]",
     },
     700: {
       funName: "searchBST",
       paramTypes: ["TreeNode", "number"],
-      returnType: "TreeNode",
-      testCase: "[4,2,7,1,3]\\n2",
     },
     701: {
       funName: "insertIntoBST",
       paramTypes: ["TreeNode", "number"],
-      returnType: "TreeNode",
-      testCase: "[4,2,7,1,3]\\n5",
     },
     703: {
       funName: "KthLargest",
       paramTypes: ["number", "number[]"],
-      returnType: "void",
-      testCase: '["KthLargest","add","add","add","add","add"]\\n[[3,[4,5,8,2]],[3],[5],[10],[9],[4]]',
     },
     704: {
       funName: "search",
       paramTypes: ["number[]", "number"],
-      returnType: "number",
-      testCase: "[-1,0,3,5,9,12]\\n9",
     },
     705: {
       funName: "MyHashSet",
       paramTypes: [],
-      returnType: "void",
-      testCase:
-        '["MyHashSet","add","add","contains","contains","add","contains","remove","contains"]\\n[[],[1],[2],[1],[3],[2],[2],[2],[2]]',
     },
     706: {
       funName: "MyHashMap",
       paramTypes: [],
-      returnType: "void",
-      testCase:
-        '["MyHashMap","put","put","get","get","put","get", "remove", "get"]\\n[[],[1,1],[2,2],[1],[3],[2,1],[2],[2],[2]]',
     },
     707: {
       funName: "MyLinkedList",
       paramTypes: [],
-      returnType: "void",
-      testCase:
-        '["MyLinkedList","addAtHead","addAtTail","addAtIndex","get","deleteAtIndex","get"]\\n[[],[1],[3],[1,2],[1],[1],[1]]',
     },
     709: {
       funName: "toLowerCase",
       paramTypes: ["string"],
-      returnType: "string",
-      testCase: '"Hello"',
     },
     710: {
       funName: "Solution",
       paramTypes: ["number", "number[]"],
-      returnType: "void",
-      testCase: '["Solution", "pick", "pick", "pick"]\\n[[1, []], [], [], []]',
     },
     712: {
       funName: "minimumDeleteSum",
       paramTypes: ["string", "string"],
-      returnType: "number",
-      testCase: '"sea"\\n"eat"',
     },
     713: {
       funName: "numSubarrayProductLessThanK",
       paramTypes: ["number[]", "number"],
-      returnType: "number",
-      testCase: "[10,5,2,6]\\n100",
     },
     714: {
       funName: "maxProfit",
       paramTypes: ["number[]", "number"],
-      returnType: "number",
-      testCase: "[1,3,2,8,4,9]\\n2",
     },
     715: {
       funName: "RangeModule",
       paramTypes: [],
-      returnType: "void",
-      testCase:
-        '["RangeModule","addRange","removeRange","queryRange","queryRange","queryRange"]\\n[[],[10,20],[14,16],[10,14],[13,15],[16,17]]',
     },
     717: {
       funName: "isOneBitCharacter",
       paramTypes: ["number[]"],
-      returnType: "boolean",
-      testCase: "[1,0,0]",
     },
     718: {
       funName: "findLength",
       paramTypes: ["number[]", "number[]"],
-      returnType: "number",
-      testCase: "[1,2,3,2,1]\\n[3,2,1,4,7]",
     },
     719: {
       funName: "smallestDistancePair",
       paramTypes: ["number[]", "number"],
-      returnType: "number",
-      testCase: "[1,3,1]\\n1",
     },
     720: {
       funName: "longestWord",
       paramTypes: ["string[]"],
-      returnType: "string",
-      testCase: '["w","wo","wor","worl","world"]',
     },
     721: {
       funName: "accountsMerge",
       paramTypes: ["string[][]"],
-      returnType: "string[][]",
-      testCase:
-        '[["John","johnsmith@mail.com","john_newyork@mail.com"],["John","johnsmith@mail.com","john00@mail.com"],["Mary","mary@mail.com"],["John","johnnybravo@mail.com"]]',
     },
     722: {
       funName: "removeComments",
       paramTypes: ["string[]"],
-      returnType: "string[]",
-      testCase:
-        '["/*Test program */", "int main()", "{ ", "  // variable declaration ", "int a, b, c;", "/* This is a test", "   multiline  ", "   comment for ", "   testing */", "a = b + c;", "}"]',
     },
     724: {
       funName: "pivotIndex",
       paramTypes: ["number[]"],
-      returnType: "number",
-      testCase: "[1,7,3,6,5,6]",
     },
     725: {
       funName: "splitListToParts",
       paramTypes: ["ListNode", "number"],
-      returnType: "ListNode[]",
-      testCase: "[1,2,3,4]\\n5",
     },
     726: {
       funName: "countOfAtoms",
       paramTypes: ["string"],
-      returnType: "string",
-      testCase: '"H2O"',
     },
     728: {
       funName: "selfDividingNumbers",
       paramTypes: ["number", "number"],
-      returnType: "number[]",
-      testCase: "1\\n22",
     },
     729: {
       funName: "MyCalendar",
       paramTypes: [],
-      returnType: "void",
-      testCase: '["MyCalendar","book","book","book"]\\n[[],[10,20],[15,25],[20,30]]',
     },
     730: {
       funName: "countPalindromicSubsequences",
       paramTypes: ["string"],
-      returnType: "number",
-      testCase: '"bccb"',
     },
     731: {
       funName: "MyCalendarTwo",
       paramTypes: [],
-      returnType: "void",
-      testCase:
-        '["MyCalendarTwo","book","book","book","book","book","book"]\\n[[],[10,20],[50,60],[10,40],[5,15],[5,10],[25,55]]',
     },
     732: {
       funName: "MyCalendarThree",
       paramTypes: [],
-      returnType: "void",
-      testCase:
-        '["MyCalendarThree","book","book","book","book","book","book"]\\n[[],[10,20],[50,60],[10,40],[5,15],[5,10],[25,55]]',
     },
     733: {
       funName: "floodFill",
       paramTypes: ["number[][]", "number", "number", "number"],
-      returnType: "number[][]",
-      testCase: "[[1,1,1],[1,1,0],[1,0,1]]\\n1\\n1\\n2",
     },
     735: {
       funName: "asteroidCollision",
       paramTypes: ["number[]"],
-      returnType: "number[]",
-      testCase: "[5,10,-5]",
     },
     736: {
       funName: "evaluate",
       paramTypes: ["string"],
-      returnType: "number",
-      testCase: '"(add 1 2)"',
     },
     738: {
       funName: "monotoneIncreasingDigits",
       paramTypes: ["number"],
-      returnType: "number",
-      testCase: "10",
     },
     739: {
       funName: "dailyTemperatures",
       paramTypes: ["number[]"],
-      returnType: "number[]",
-      testCase: "[73,74,75,71,69,72,76,73]",
     },
     740: {
       funName: "deleteAndEarn",
       paramTypes: ["number[]"],
-      returnType: "number",
-      testCase: "[3,4,2]",
     },
     741: {
       funName: "cherryPickup",
       paramTypes: ["number[][]"],
-      returnType: "number",
-      testCase: "[[0,1,-1],[1,0,-1],[1,1,1]]",
     },
     743: {
       funName: "networkDelayTime",
       paramTypes: ["number[][]", "number", "number"],
-      returnType: "number",
-      testCase: "[[2,1,1],[2,3,1],[3,4,1]]\\n4\\n2",
     },
     744: {
       funName: "nextGreatestLetter",
       paramTypes: ["character[]", "character"],
-      returnType: "character",
-      testCase: '["c","f","j"]\\n"a"',
     },
     745: {
       funName: "WordFilter",
       paramTypes: ["string[]"],
-      returnType: "void",
-      testCase: '["WordFilter","f"]\\n[[["apple"]],["a","e"]]',
     },
     746: {
       funName: "minCostClimbingStairs",
       paramTypes: ["number[]"],
-      returnType: "number",
-      testCase: "[0,0,0,0]",
     },
     747: {
       funName: "dominantIndex",
       paramTypes: ["number[]"],
-      returnType: "number",
-      testCase: "[0,0,0,1]",
     },
     748: {
       funName: "shortestCompletingWord",
       paramTypes: ["string", "string[]"],
-      returnType: "string",
-      testCase: '"1s3 PSt"\\n["step","steps","stripe","stepple"]',
     },
     749: {
       funName: "containVirus",
       paramTypes: ["number[][]"],
-      returnType: "number",
-      testCase: "[[0,1,0,0,0,0,0,1],[0,1,0,0,0,0,0,1],[0,0,0,0,0,0,0,1],[0,0,0,0,0,0,0,0]]",
     },
     752: {
       funName: "openLock",
       paramTypes: ["string[]", "string"],
-      returnType: "number",
-      testCase: '["0201","0101","0102","1212","2002"]\\n"0202"',
     },
     753: {
       funName: "crackSafe",
       paramTypes: ["number", "number"],
-      returnType: "string",
-      testCase: "1\\n1",
     },
     754: {
       funName: "reachNumber",
       paramTypes: ["number"],
-      returnType: "number",
-      testCase: "1",
     },
     756: {
       funName: "pyramidTransition",
       paramTypes: ["string", "string[]"],
-      returnType: "boolean",
-      testCase: '"ABC"\\n["ABD","BCE","DEF","FFF"]',
     },
     757: {
       funName: "intersectionSizeTwo",
       paramTypes: ["number[][]"],
-      returnType: "number",
-      testCase: "[[1,3],[1,4],[2,5],[3,5]]",
     },
     761: {
       funName: "makeLargestSpecial",
       paramTypes: ["string"],
-      returnType: "string",
-      testCase: '"11011000"',
     },
     762: {
       funName: "countPrimeSetBits",
       paramTypes: ["number", "number"],
-      returnType: "number",
-      testCase: "842\\n888",
     },
     763: {
       funName: "partitionLabels",
       paramTypes: ["string"],
-      returnType: "number[]",
-      testCase: '"ababcbacadefegdehijhklij"',
     },
     764: {
       funName: "orderOfLargestPlusSign",
       paramTypes: ["number", "number[][]"],
-      returnType: "number",
-      testCase: "5\\n[[4,2]]",
     },
     765: {
       funName: "minSwapsCouples",
       paramTypes: ["number[]"],
-      returnType: "number",
-      testCase: "[0,2,1,3]",
     },
     766: {
       funName: "isToeplitzMatrix",
       paramTypes: ["number[][]"],
-      returnType: "boolean",
-      testCase: "[[1,2,3,4],[5,1,2,3],[9,5,1,2]]",
     },
     767: {
       funName: "reorganizeString",
       paramTypes: ["string"],
-      returnType: "string",
-      testCase: '"aab"',
     },
     768: {
       funName: "maxChunksToSorted",
       paramTypes: ["number[]"],
-      returnType: "number",
-      testCase: "[5,4,3,2,1]",
     },
     769: {
       funName: "maxChunksToSorted",
       paramTypes: ["number[]"],
-      returnType: "number",
-      testCase: "[4,3,2,1,0]",
     },
     770: {
       funName: "basicCalculatorIV",
       paramTypes: ["string", "string[]", "number[]"],
-      returnType: "string[]",
-      testCase: '"e + 8 - a + 5"\\n["e"]\\n[1]',
     },
     771: {
       funName: "numJewelsInStones",
       paramTypes: ["string", "string"],
-      returnType: "number",
-      testCase: '"aA"\\n"aAAbbbb"',
     },
     773: {
       funName: "slidingPuzzle",
       paramTypes: ["number[][]"],
-      returnType: "number",
-      testCase: "[[1,2,3],[4,0,5]]",
     },
     775: {
       funName: "isIdealPermutation",
       paramTypes: ["number[]"],
-      returnType: "boolean",
-      testCase: "[0]",
     },
     777: {
       funName: "canTransform",
       paramTypes: ["string", "string"],
-      returnType: "boolean",
-      testCase: '"X"\\n"L"',
     },
     778: {
       funName: "swimInWater",
       paramTypes: ["number[][]"],
-      returnType: "number",
-      testCase: "[[0,2],[1,3]]",
     },
     779: {
       funName: "kthGrammar",
       paramTypes: ["number", "number"],
-      returnType: "number",
-      testCase: "1\\n1",
     },
     780: {
       funName: "reachingPoints",
       paramTypes: ["number", "number", "number", "number"],
-      returnType: "boolean",
-      testCase: "9\\n5\\n12\\n8",
     },
     781: {
       funName: "numRabbits",
       paramTypes: ["number[]"],
-      returnType: "number",
-      testCase: "[1,0,1,0,0]",
     },
     782: {
       funName: "movesToChessboard",
       paramTypes: ["number[][]"],
-      returnType: "number",
-      testCase: "[[0,1,1,0],[0,1,1,0],[1,0,0,1],[1,0,0,1]]",
     },
     783: {
       funName: "minDiffInBST",
       paramTypes: ["TreeNode"],
-      returnType: "number",
-      testCase: "[4,2,6,1,3,null,null]",
     },
     784: {
       funName: "letterCasePermutation",
       paramTypes: ["string"],
-      returnType: "string[]",
-      testCase: '"a1b2"',
     },
     785: {
       funName: "isBipartite",
       paramTypes: ["number[][]"],
-      returnType: "boolean",
-      testCase: "[[1,3],[0,2],[1,3],[0,2]]",
     },
     786: {
       funName: "kthSmallestPrimeFraction",
       paramTypes: ["number[]", "number"],
-      returnType: "number[]",
-      testCase: "[1,2,3,5]\\n3",
     },
     787: {
       funName: "findCheapestPrice",
       paramTypes: ["number", "number[][]", "number", "number", "number"],
-      returnType: "number",
-      testCase: "3\\n[[0,1,100],[1,2,100],[0,2,500]]\\n0\\n2\\n1",
     },
     788: {
       funName: "rotatedDigits",
       paramTypes: ["number"],
-      returnType: "number",
-      testCase: "10",
     },
     789: {
       funName: "escapeGhosts",
       paramTypes: ["number[][]", "number[]"],
-      returnType: "boolean",
-      testCase: "[[1,0],[0,3]]\\n[0,1]",
     },
     790: {
       funName: "numTilings",
       paramTypes: ["number"],
-      returnType: "number",
-      testCase: "3",
     },
     791: {
       funName: "customSortString",
       paramTypes: ["string", "string"],
-      returnType: "string",
-      testCase: '"cba"\\n"abcd"',
     },
     792: {
       funName: "numMatchingSubseq",
       paramTypes: ["string", "string[]"],
-      returnType: "number",
-      testCase: '"abcde"\\n["a","bb","acd","ace"]',
     },
     793: {
       funName: "preimageSizeFZF",
       paramTypes: ["number"],
-      returnType: "number",
-      testCase: "0",
     },
     794: {
       funName: "validTicTacToe",
       paramTypes: ["string[]"],
-      returnType: "boolean",
-      testCase: '["O  ","   ","   "]',
     },
     795: {
       funName: "numSubarrayBoundedMax",
       paramTypes: ["number[]", "number", "number"],
-      returnType: "number",
-      testCase: "[2,1,4,3]\\n2\\n3",
     },
     796: {
       funName: "rotateString",
       paramTypes: ["string", "string"],
-      returnType: "boolean",
-      testCase: '"abcde"\\n"cdeab"',
     },
     797: {
       funName: "allPathsSourceTarget",
       paramTypes: ["number[][]"],
-      returnType: "number[][]",
-      testCase: "[[1,2],[3],[3],[]]",
     },
     798: {
       funName: "bestRotation",
       paramTypes: ["number[]"],
-      returnType: "number",
-      testCase: "[2,3,1,4,0]",
     },
     799: {
       funName: "champagneTower",
       paramTypes: ["number", "number", "number"],
-      returnType: "number",
-      testCase: "1\\n1\\n1",
     },
     801: {
       funName: "minSwap",
       paramTypes: ["number[]", "number[]"],
-      returnType: "number",
-      testCase: "[1,3,5,4]\\n[1,2,3,7]",
     },
     802: {
       funName: "eventualSafeNodes",
       paramTypes: ["number[][]"],
-      returnType: "number[]",
-      testCase: "[[1,2],[2,3],[5],[0],[5],[],[]]",
     },
     803: {
       funName: "hitBricks",
       paramTypes: ["number[][]", "number[][]"],
-      returnType: "number[]",
-      testCase: "[[1,0,0,0],[1,1,1,0]]\\n[[1,0]]",
     },
     804: {
       funName: "uniqueMorseRepresentations",
       paramTypes: ["string[]"],
-      returnType: "number",
-      testCase: '["gin", "zen", "gig", "msg"]',
     },
     805: {
       funName: "splitArraySameAverage",
       paramTypes: ["number[]"],
-      returnType: "boolean",
-      testCase: "[1,2,3,4,5,6,7,8]",
     },
     806: {
       funName: "numberOfLines",
       paramTypes: ["number[]", "string"],
-      returnType: "number[]",
-      testCase:
-        '[10,10,10,10,10,10,10,10,10,10,10,10,10,10,10,10,10,10,10,10,10,10,10,10,10,10]\\n"abcdefghijklmnopqrstuvwxyz"',
     },
     807: {
       funName: "maxIncreaseKeepingSkyline",
       paramTypes: ["number[][]"],
-      returnType: "number",
-      testCase: "[[3,0,8,4],[2,4,5,7],[9,2,6,3],[0,3,1,0]]",
     },
     808: {
       funName: "soupServings",
       paramTypes: ["number"],
-      returnType: "number",
-      testCase: "50",
     },
     809: {
       funName: "expressiveWords",
       paramTypes: ["string", "string[]"],
-      returnType: "number",
-      testCase: '"heeellooo"\\n["hello", "hi", "helo"]',
     },
     810: {
       funName: "xorGame",
       paramTypes: ["number[]"],
-      returnType: "boolean",
-      testCase: "[1,1,2]",
     },
     811: {
       funName: "subdomainVisits",
       paramTypes: ["string[]"],
-      returnType: "string[]",
-      testCase: '["9001 discuss.leetcode.com"]',
     },
     812: {
       funName: "largestTriangleArea",
       paramTypes: ["number[][]"],
-      returnType: "number",
-      testCase: "[[0,0],[0,1],[1,0],[0,2],[2,0]]",
     },
     813: {
       funName: "largestSumOfAverages",
       paramTypes: ["number[]", "number"],
-      returnType: "number",
-      testCase: "[9,1,2,3,9]\\n3",
     },
     814: {
       funName: "pruneTree",
       paramTypes: ["TreeNode"],
-      returnType: "TreeNode",
-      testCase: "[1,null,0,0,1]",
     },
     815: {
       funName: "numBusesToDestination",
       paramTypes: ["number[][]", "number", "number"],
-      returnType: "number",
-      testCase: "[[1,2,7],[3,6,7]]\\n1\\n6",
     },
     816: {
       funName: "ambiguousCoordinates",
       paramTypes: ["string"],
-      returnType: "string[]",
-      testCase: '"(123)"',
     },
     817: {
       funName: "numComponents",
       paramTypes: ["ListNode", "number[]"],
-      returnType: "number",
-      testCase: "[0,1,2,3]\\n[0,1,3]",
     },
     818: {
       funName: "racecar",
       paramTypes: ["number"],
-      returnType: "number",
-      testCase: "3",
     },
     819: {
       funName: "mostCommonWord",
       paramTypes: ["string", "string[]"],
-      returnType: "string",
-      testCase: '"Bob hit a ball, the hit BALL flew far after it was hit."\\n["hit"]',
     },
     820: {
       funName: "minimumLengthEncoding",
       paramTypes: ["string[]"],
-      returnType: "number",
-      testCase: '["time", "me", "bell"]',
     },
     821: {
       funName: "shortestToChar",
       paramTypes: ["string", "character"],
-      returnType: "number[]",
-      testCase: '"loveleetcode"\\n"e"',
     },
     822: {
       funName: "flipgame",
       paramTypes: ["number[]", "number[]"],
-      returnType: "number",
-      testCase: "[1,2,4,4,7]\\n[1,3,4,1,3]",
     },
     823: {
       funName: "numFactoredBinaryTrees",
       paramTypes: ["number[]"],
-      returnType: "number",
-      testCase: "[2,4]",
     },
     824: {
       funName: "toGoatLatin",
       paramTypes: ["string"],
-      returnType: "string",
-      testCase: '"I speak Goat Latin"',
     },
     825: {
       funName: "numFriendRequests",
       paramTypes: ["number[]"],
-      returnType: "number",
-      testCase: "[16,16]",
     },
     826: {
       funName: "maxProfitAssignment",
       paramTypes: ["number[]", "number[]", "number[]"],
-      returnType: "number",
-      testCase: "[2,4,6,8,10]\\n[10,20,30,40,50]\\n[4,5,6,7]",
     },
     827: {
       funName: "largestIsland",
       paramTypes: ["number[][]"],
-      returnType: "number",
-      testCase: "[[1,0],[0,1]]",
     },
     828: {
       funName: "uniqueLetterString",
       paramTypes: ["string"],
-      returnType: "number",
-      testCase: '"ABC"',
     },
     829: {
       funName: "consecutiveNumbersSum",
       paramTypes: ["number"],
-      returnType: "number",
-      testCase: "5",
     },
     830: {
       funName: "largeGroupPositions",
       paramTypes: ["string"],
-      returnType: "number[][]",
-      testCase: '"abbxxxxzzy"',
     },
     831: {
       funName: "maskPII",
       paramTypes: ["string"],
-      returnType: "string",
-      testCase: '"LeetCode@LeetCode.com"',
     },
     832: {
       funName: "flipAndInvertImage",
       paramTypes: ["number[][]"],
-      returnType: "number[][]",
-      testCase: "[[1,1,0],[1,0,1],[0,0,0]]",
     },
     833: {
       funName: "findReplaceString",
       paramTypes: ["string", "number[]", "string[]", "string[]"],
-      returnType: "string",
-      testCase: '"abcd"\\n[0, 2]\\n["a", "cd"]\\n["eee", "ffff"]',
     },
     834: {
       funName: "sumOfDistancesInTree",
       paramTypes: ["number", "number[][]"],
-      returnType: "number[]",
-      testCase: "6\\n[[0,1],[0,2],[2,3],[2,4],[2,5]]",
     },
     835: {
       funName: "largestOverlap",
       paramTypes: ["number[][]", "number[][]"],
-      returnType: "number",
-      testCase: "[[1,1,0],[0,1,0],[0,1,0]]\\n[[0,0,0],[0,1,1],[0,0,1]]",
     },
     836: {
       funName: "isRectangleOverlap",
       paramTypes: ["number[]", "number[]"],
-      returnType: "boolean",
-      testCase: "[0,0,2,2]\\n[1,1,3,3]",
     },
     837: {
       funName: "new21Game",
       paramTypes: ["number", "number", "number"],
-      returnType: "number",
-      testCase: "10\\n1\\n10",
     },
     838: {
       funName: "pushDominoes",
       paramTypes: ["string"],
-      returnType: "string",
-      testCase: '".L.R...LR..L.."',
     },
     839: {
       funName: "numSimilarGroups",
       paramTypes: ["string[]"],
-      returnType: "number",
-      testCase: '["tars","rats","arts","star"]',
     },
     840: {
       funName: "numMagicSquaresInside",
       paramTypes: ["number[][]"],
-      returnType: "number",
-      testCase: "[[4,3,8,4],[9,5,1,9],[2,7,6,2]]",
     },
     841: {
       funName: "canVisitAllRooms",
       paramTypes: ["number[][]"],
-      returnType: "boolean",
-      testCase: "[[1],[2],[3],[]]",
     },
     842: {
       funName: "splitIntoFibonacci",
       paramTypes: ["string"],
-      returnType: "number[]",
-      testCase: '"123456579"',
     },
     843: {
       funName: "findSecretWord",
       // changede from original
       paramTypes: ["string", "string[]", "number"],
-      returnType: "void",
-      testCase: '"acckzz"\\n["acckzz","ccbazz","eiowzz","abcczz"]\\n10',
     },
     844: {
       funName: "backspaceCompare",
       paramTypes: ["string", "string"],
-      returnType: "boolean",
-      testCase: '"ab#c"\\n"ad#c"',
     },
     845: {
       funName: "longestMountain",
       paramTypes: ["number[]"],
-      returnType: "number",
-      testCase: "[2,1,4,7,3,2,5]",
     },
     846: {
       funName: "isNStraightHand",
       paramTypes: ["number[]", "number"],
-      returnType: "boolean",
-      testCase: "[1,2,3,6,2,3,4,7,8]\\n3",
     },
     847: {
       funName: "shortestPathLength",
       paramTypes: ["number[][]"],
-      returnType: "number",
-      testCase: "[[1,2,3],[0],[0],[0]]",
     },
     848: {
       funName: "shiftingLetters",
       paramTypes: ["string", "number[]"],
-      returnType: "string",
-      testCase: '"abc"\\n[3,5,9]',
     },
     849: {
       funName: "maxDistToClosest",
       paramTypes: ["number[]"],
-      returnType: "number",
-      testCase: "[1,0,0,0,1,0,1]",
     },
     850: {
       funName: "rectangleArea",
       paramTypes: ["number[][]"],
-      returnType: "number",
-      testCase: "[[0,0,2,2],[1,0,2,3],[1,0,3,1]]",
     },
     851: {
       funName: "loudAndRich",
       paramTypes: ["number[][]", "number[]"],
-      returnType: "number[]",
-      testCase: "[[1,0],[2,1],[3,1],[3,7],[4,3],[5,3],[6,3]]\\n[3,2,5,4,6,1,7,0]",
     },
     852: {
       funName: "peakIndexInMountainArray",
       paramTypes: ["number[]"],
-      returnType: "number",
-      testCase: "[0,1,0]",
     },
     853: {
       funName: "carFleet",
       paramTypes: ["number", "number[]", "number[]"],
-      returnType: "number",
-      testCase: "12\\n[10,8,0,5,3]\\n[2,4,1,1,3]",
     },
     854: {
       funName: "kSimilarity",
       paramTypes: ["string", "string"],
-      returnType: "number",
-      testCase: '"ab"\\n"ba"',
     },
     855: {
       funName: "ExamRoom",
       paramTypes: ["number"],
-      returnType: "void",
-      testCase: '["ExamRoom","seat","seat","seat","seat","leave","seat"]\\n[[10],[],[],[],[],[4],[]]',
     },
     856: {
       funName: "scoreOfParentheses",
       paramTypes: ["string"],
-      returnType: "number",
-      testCase: '"()"',
     },
     857: {
       funName: "mincostToHireWorkers",
       paramTypes: ["number[]", "number[]", "number"],
-      returnType: "number",
-      testCase: "[10,20,5]\\n[70,50,30]\\n2",
     },
     858: {
       funName: "mirrorReflection",
       paramTypes: ["number", "number"],
-      returnType: "number",
-      testCase: "2\\n1",
     },
     859: {
       funName: "buddyStrings",
       paramTypes: ["string", "string"],
-      returnType: "boolean",
-      testCase: '"ab"\\n"ba"',
     },
     860: {
       funName: "lemonadeChange",
       paramTypes: ["number[]"],
-      returnType: "boolean",
-      testCase: "[5,5,5,10,20]",
     },
     861: {
       funName: "matrixScore",
       paramTypes: ["number[][]"],
-      returnType: "number",
-      testCase: "[[0,0,1,1],[1,0,1,0],[1,1,0,0]]",
     },
     862: {
       funName: "shortestSubarray",
       paramTypes: ["number[]", "number"],
-      returnType: "number",
-      testCase: "[1]\\n1",
     },
     863: {
       funName: "distanceK",
       paramTypes: ["TreeNode", "TreeNode", "number"],
-      returnType: "number[]",
-      testCase: "[3,5,1,6,2,0,8,null,null,7,4]\\n5\\n2",
     },
     864: {
       funName: "shortestPathAllKeys",
       paramTypes: ["string[]"],
-      returnType: "number",
-      testCase: '["@.a.#","###.#","b.A.B"]',
     },
     865: {
       funName: "subtreeWithAllDeepest",
       paramTypes: ["TreeNode"],
-      returnType: "TreeNode",
-      testCase: "[3,5,1,6,2,0,8,null,null,7,4]",
     },
     866: {
       funName: "primePalindrome",
       paramTypes: ["number"],
-      returnType: "number",
-      testCase: "6",
     },
     867: {
       funName: "transpose",
       paramTypes: ["number[][]"],
-      returnType: "number[][]",
-      testCase: "[[1,2,3],[4,5,6],[7,8,9]]",
     },
     868: {
       funName: "binaryGap",
       paramTypes: ["number"],
-      returnType: "number",
-      testCase: "22",
     },
     869: {
       funName: "reorderedPowerOf2",
       paramTypes: ["number"],
-      returnType: "boolean",
-      testCase: "1",
     },
     870: {
       funName: "advantageCount",
       paramTypes: ["number[]", "number[]"],
-      returnType: "number[]",
-      testCase: "[2,7,11,15]\\n[1,10,4,11]",
     },
     871: {
       funName: "minRefuelStops",
       paramTypes: ["number", "number", "number[][]"],
-      returnType: "number",
-      testCase: "1\\n1\\n[]",
     },
     872: {
       funName: "leafSimilar",
       paramTypes: ["TreeNode", "TreeNode"],
-      returnType: "boolean",
-      testCase: "[3,5,1,6,2,9,8,null,null,7,4]\\n[3,5,1,6,7,4,2,null,null,null,null,null,null,9,8]",
     },
     873: {
       funName: "lenLongestFibSubseq",
       paramTypes: ["number[]"],
-      returnType: "number",
-      testCase: "[1,2,3,4,5,6,7,8]",
     },
     874: {
       funName: "robotSim",
       paramTypes: ["number[]", "number[][]"],
-      returnType: "number",
-      testCase: "[4,-1,3]\\n[]",
     },
     875: {
       funName: "minEatingSpeed",
       paramTypes: ["number[]", "number"],
-      returnType: "number",
-      testCase: "[3,6,7,11]\\n8",
     },
     876: {
       funName: "middleNode",
       paramTypes: ["ListNode"],
-      returnType: "ListNode",
-      testCase: "[1,2,3,4,5]",
     },
     877: {
       funName: "stoneGame",
       paramTypes: ["number[]"],
-      returnType: "boolean",
-      testCase: "[5,3,4,5]",
     },
     878: {
       funName: "nthMagicalNumber",
       paramTypes: ["number", "number", "number"],
-      returnType: "number",
-      testCase: "1\\n2\\n3",
     },
     879: {
       funName: "profitableSchemes",
       paramTypes: ["number", "number", "number[]", "number[]"],
-      returnType: "number",
-      testCase: "5\\n3\\n[2,2]\\n[2,3]",
     },
     880: {
       funName: "decodeAtIndex",
       paramTypes: ["string", "number"],
-      returnType: "string",
-      testCase: '"leet2code3"\\n10',
     },
     881: {
       funName: "numRescueBoats",
       paramTypes: ["number[]", "number"],
-      returnType: "number",
-      testCase: "[1,2]\\n3",
     },
     882: {
       funName: "reachableNodes",
       paramTypes: ["number[][]", "number", "number"],
-      returnType: "number",
-      testCase: "[[0,1,10],[0,2,1],[1,2,2]]\\n6\\n3",
     },
     883: {
       funName: "projectionArea",
       paramTypes: ["number[][]"],
-      returnType: "number",
-      testCase: "[[2]]",
     },
     884: {
       funName: "uncommonFromSentences",
       paramTypes: ["string", "string"],
-      returnType: "string[]",
-      testCase: '"this apple is sweet"\\n"this apple is sour"',
     },
     885: {
       funName: "spiralMatrixIII",
       paramTypes: ["number", "number", "number", "number"],
-      returnType: "number[][]",
-      testCase: "1\\n4\\n0\\n0",
     },
     886: {
       funName: "possibleBipartition",
       paramTypes: ["number", "number[][]"],
-      returnType: "boolean",
-      testCase: "4\\n[[1,2],[1,3],[2,4]]",
     },
     887: {
       funName: "superEggDrop",
       paramTypes: ["number", "number"],
-      returnType: "number",
-      testCase: "1\\n2",
     },
     888: {
       funName: "fairCandySwap",
       paramTypes: ["number[]", "number[]"],
-      returnType: "number[]",
-      testCase: "[1,1]\\n[2,2]",
     },
     889: {
       funName: "constructFromPrePost",
       paramTypes: ["number[]", "number[]"],
-      returnType: "TreeNode",
-      testCase: "[1,2,4,5,3,6,7]\\n[4,5,2,6,7,3,1]",
     },
     890: {
       funName: "findAndReplacePattern",
       paramTypes: ["string[]", "string"],
-      returnType: "string[]",
-      testCase: '["abc","deq","mee","aqq","dkd","ccc"]\\n"abb"',
     },
     891: {
       funName: "sumSubseqWidths",
       paramTypes: ["number[]"],
-      returnType: "number",
-      testCase: "[2,1,3]",
     },
     892: {
       funName: "surfaceArea",
       paramTypes: ["number[][]"],
-      returnType: "number",
-      testCase: "[[2]]",
     },
     893: {
       funName: "numSpecialEquivGroups",
       paramTypes: ["string[]"],
-      returnType: "number",
-      testCase: '["abcd","cdab","cbad","xyzz","zzxy","zzyx"]',
     },
     894: {
       funName: "allPossibleFBT",
       paramTypes: ["number"],
-      returnType: "TreeNode[]",
-      testCase: "7",
     },
     895: {
       funName: "FreqStack",
       paramTypes: [],
-      returnType: "void",
-      testCase:
-        '["FreqStack","push","push","push","push","push","push","pop","pop","pop","pop"]\\n[[],[5],[7],[5],[7],[4],[5],[],[],[],[]]',
     },
     896: {
       funName: "isMonotonic",
       paramTypes: ["number[]"],
-      returnType: "boolean",
-      testCase: "[1,2,2,3]",
     },
     897: {
       funName: "increasingBST",
       paramTypes: ["TreeNode"],
-      returnType: "TreeNode",
-      testCase: "[5,3,6,2,4,null,8,1,null,null,null,7,9]",
     },
     898: {
       funName: "subarrayBitwiseORs",
       paramTypes: ["number[]"],
-      returnType: "number",
-      testCase: "[0]",
     },
     899: {
       funName: "orderlyQueue",
       paramTypes: ["string", "number"],
-      returnType: "string",
-      testCase: '"cba"\\n1',
     },
     900: {
       funName: "RLEIterator",
       paramTypes: ["number[]"],
-      returnType: "void",
-      testCase: '["RLEIterator","next","next","next","next"]\\n[[[3,8,0,9,2,5]],[2],[1],[1],[2]]',
     },
     901: {
       funName: "StockSpanner",
       paramTypes: [],
-      returnType: "void",
-      testCase:
-        '["StockSpanner","next","next","next","next","next","next","next"]\\n[[],[100],[80],[60],[70],[60],[75],[85]]',
     },
     902: {
       funName: "atMostNGivenDigitSet",
       paramTypes: ["string[]", "number"],
-      returnType: "number",
-      testCase: '["1","3","5","7"]\\n100',
     },
     903: {
       funName: "numPermsDISequence",
       paramTypes: ["string"],
-      returnType: "number",
-      testCase: '"DID"',
     },
     904: {
       funName: "totalFruit",
       paramTypes: ["number[]"],
-      returnType: "number",
-      testCase: "[1,2,1]",
     },
     905: {
       funName: "sortArrayByParity",
       paramTypes: ["number[]"],
-      returnType: "number[]",
-      testCase: "[3,1,2,4]",
     },
     906: {
       funName: "superpalindromesInRange",
       paramTypes: ["string", "string"],
-      returnType: "number",
-      testCase: '"4"\\n"1000"',
     },
     907: {
       funName: "sumSubarrayMins",
       paramTypes: ["number[]"],
-      returnType: "number",
-      testCase: "[3,1,2,4]",
     },
     908: {
       funName: "smallestRangeI",
       paramTypes: ["number[]", "number"],
-      returnType: "number",
-      testCase: "[1]\\n0",
     },
     909: {
       funName: "snakesAndLadders",
       paramTypes: ["number[][]"],
-      returnType: "number",
-      testCase:
-        "[[-1,-1,-1,-1,-1,-1],[-1,-1,-1,-1,-1,-1],[-1,-1,-1,-1,-1,-1],[-1,35,-1,-1,13,-1],[-1,-1,-1,-1,-1,-1],[-1,15,-1,-1,-1,-1]]",
     },
     910: {
       funName: "smallestRangeII",
       paramTypes: ["number[]", "number"],
-      returnType: "number",
-      testCase: "[1]\\n0",
     },
     911: {
       funName: "TopVotedCandidate",
       paramTypes: ["number[]", "number[]"],
-      returnType: "void",
-      testCase:
-        '["TopVotedCandidate","q","q","q","q","q","q"]\\n[[[0,1,1,0,0,1,0],[0,5,10,15,20,25,30]],[3],[12],[25],[15],[24],[8]]',
     },
     912: {
       funName: "sortArray",
       paramTypes: ["number[]"],
-      returnType: "number[]",
-      testCase: "[5,2,3,1]",
     },
     913: {
       funName: "catMouseGame",
       paramTypes: ["number[][]"],
-      returnType: "number",
-      testCase: "[[2,5],[3],[0,4,5],[1,4,5],[2,3],[0,2,3]]",
     },
     914: {
       funName: "hasGroupsSizeX",
       paramTypes: ["number[]"],
-      returnType: "boolean",
-      testCase: "[1,2,3,4,4,3,2,1]",
     },
     915: {
       funName: "partitionDisjoint",
       paramTypes: ["number[]"],
-      returnType: "number",
-      testCase: "[5,0,3,8,6]",
     },
     916: {
       funName: "wordSubsets",
       paramTypes: ["string[]", "string[]"],
-      returnType: "string[]",
-      testCase: '["amazon","apple","facebook","google","leetcode"]\\n["e","o"]',
     },
     917: {
       funName: "reverseOnlyLetters",
       paramTypes: ["string"],
-      returnType: "string",
-      testCase: '"ab-cd"',
     },
     918: {
       funName: "maxSubarraySumCircular",
       paramTypes: ["number[]"],
-      returnType: "number",
-      testCase: "[1,-2,3,-2]",
     },
     919: {
       funName: "CBTInserter",
       paramTypes: ["TreeNode"],
-      returnType: "void",
-      testCase: '["CBTInserter","insert","get_root"]\\n[[[1]],[2],[]]',
     },
     920: {
       funName: "numMusicPlaylists",
       paramTypes: ["number", "number", "number"],
-      returnType: "number",
-      testCase: "3\\n3\\n1",
     },
     921: {
       funName: "minAddToMakeValid",
       paramTypes: ["string"],
-      returnType: "number",
-      testCase: '"())"',
     },
     922: {
       funName: "sortArrayByParityII",
       paramTypes: ["number[]"],
-      returnType: "number[]",
-      testCase: "[4,2,5,7]",
     },
     923: {
       funName: "threeSumMulti",
       paramTypes: ["number[]", "number"],
-      returnType: "number",
-      testCase: "[1,1,2,2,3,3,4,4,5,5]\\n8",
     },
     924: {
       funName: "minMalwareSpread",
       paramTypes: ["number[][]", "number[]"],
-      returnType: "number",
-      testCase: "[[1,1,0],[1,1,0],[0,0,1]]\\n[0,1]",
     },
     925: {
       funName: "isLongPressedName",
       paramTypes: ["string", "string"],
-      returnType: "boolean",
-      testCase: '"alex"\\n"aaleex"',
     },
     926: {
       funName: "minFlipsMonoIncr",
       paramTypes: ["string"],
-      returnType: "number",
-      testCase: '"00110"',
     },
     927: {
       funName: "threeEqualParts",
       paramTypes: ["number[]"],
-      returnType: "number[]",
-      testCase: "[1,0,1,0,1]",
     },
     928: {
       funName: "minMalwareSpread",
       paramTypes: ["number[][]", "number[]"],
-      returnType: "number",
-      testCase: "[[1,1,0],[1,1,0],[0,0,1]]\\n[0,1]",
     },
     929: {
       funName: "numUniqueEmails",
       paramTypes: ["string[]"],
-      returnType: "number",
-      testCase: '["test.email+alex@leetcode.com","test.e.mail+bob.cathy@leetcode.com","testemail+david@lee.tcode.com"]',
     },
     930: {
       funName: "numSubarraysWithSum",
       paramTypes: ["number[]", "number"],
-      returnType: "number",
-      testCase: "[1,0,1,0,1]\\n2",
     },
     931: {
       funName: "minFallingPathSum",
       paramTypes: ["number[][]"],
-      returnType: "number",
-      testCase: "[[1,2,3],[4,5,6],[7,8,9]]",
     },
     932: {
       funName: "beautifulArray",
       paramTypes: ["number"],
-      returnType: "number[]",
-      testCase: "4",
     },
     933: {
       funName: "RecentCounter",
       paramTypes: [],
-      returnType: "void",
-      testCase: '["RecentCounter","ping","ping","ping","ping"]\\n[[],[1],[100],[3001],[3002]]',
     },
     934: {
       funName: "shortestBridge",
       paramTypes: ["number[][]"],
-      returnType: "number",
-      testCase: "[[0,1],[1,0]]",
     },
     935: {
       funName: "knightDialer",
       paramTypes: ["number"],
-      returnType: "number",
-      testCase: "1",
     },
     936: {
       funName: "movesToStamp",
       paramTypes: ["string", "string"],
-      returnType: "number[]",
-      testCase: '"abc"\\n"ababc"',
     },
     937: {
       funName: "reorderLogFiles",
       paramTypes: ["string[]"],
-      returnType: "string[]",
-      testCase: '["dig1 8 1 5 1","let1 art can","dig2 3 6","let2 own kit dig","let3 art zero"]',
     },
     938: {
       funName: "rangeSumBST",
       paramTypes: ["TreeNode", "number", "number"],
-      returnType: "number",
-      testCase: "[10,5,15,3,7,null,18]\\n7\\n15",
     },
     939: {
       funName: "minAreaRect",
       paramTypes: ["number[][]"],
-      returnType: "number",
-      testCase: "[[1,1],[1,3],[3,1],[3,3],[2,2]]",
     },
     940: {
       funName: "distinctSubseqII",
       paramTypes: ["string"],
-      returnType: "number",
-      testCase: '"abc"',
     },
     941: {
       funName: "validMountainArray",
       paramTypes: ["number[]"],
-      returnType: "boolean",
-      testCase: "[2,1]",
     },
     942: {
       funName: "diStringMatch",
       paramTypes: ["string"],
-      returnType: "number[]",
-      testCase: '"IDID"',
     },
     943: {
       funName: "shortestSuperstring",
       paramTypes: ["string[]"],
-      returnType: "string",
-      testCase: '["alex","loves","leetcode"]',
     },
     944: {
       funName: "minDeletionSize",
       paramTypes: ["string[]"],
-      returnType: "number",
-      testCase: '["cba","daf","ghi"]',
     },
     945: {
       funName: "minIncrementForUnique",
       paramTypes: ["number[]"],
-      returnType: "number",
-      testCase: "[1,2,2]",
     },
     946: {
       funName: "validateStackSequences",
       paramTypes: ["number[]", "number[]"],
-      returnType: "boolean",
-      testCase: "[1,2,3,4,5]\\n[4,5,3,2,1]",
     },
     947: {
       funName: "removeStones",
       paramTypes: ["number[][]"],
-      returnType: "number",
-      testCase: "[[0,0],[0,1],[1,0],[1,2],[2,1],[2,2]]",
     },
     948: {
       funName: "bagOfTokensScore",
       paramTypes: ["number[]", "number"],
-      returnType: "number",
-      testCase: "[100]\\n50",
     },
     949: {
       funName: "largestTimeFromDigits",
       paramTypes: ["number[]"],
-      returnType: "string",
-      testCase: "[1,2,3,4]",
     },
     950: {
       funName: "deckRevealedIncreasing",
       paramTypes: ["number[]"],
-      returnType: "number[]",
-      testCase: "[17,13,11,2,3,5,7]",
     },
     951: {
       funName: "flipEquiv",
       paramTypes: ["TreeNode", "TreeNode"],
-      returnType: "boolean",
-      testCase: "[1,2,3,4,5,6,null,null,null,7,8]\\n[1,3,2,null,6,4,5,null,null,null,null,8,7]",
     },
     952: {
       funName: "largestComponentSize",
       paramTypes: ["number[]"],
-      returnType: "number",
-      testCase: "[4,6,15,35]",
     },
     953: {
       funName: "isAlienSorted",
       paramTypes: ["string[]", "string"],
-      returnType: "boolean",
-      testCase: '["hello","leetcode"]\\n"hlabcdefgijkmnopqrstuvwxyz"',
     },
     954: {
       funName: "canReorderDoubled",
       paramTypes: ["number[]"],
-      returnType: "boolean",
-      testCase: "[3,1,3,6]",
     },
     955: {
       funName: "minDeletionSize",
       paramTypes: ["string[]"],
-      returnType: "number",
-      testCase: '["ca","bb","ac"]',
     },
     956: {
       funName: "tallestBillboard",
       paramTypes: ["number[]"],
-      returnType: "number",
-      testCase: "[1,2,3,6]",
     },
     957: {
       funName: "prisonAfterNDays",
       paramTypes: ["number[]", "number"],
-      returnType: "number[]",
-      testCase: "[0,1,0,1,1,0,0,1]\\n7",
     },
     958: {
       funName: "isCompleteTree",
       paramTypes: ["TreeNode"],
-      returnType: "boolean",
-      testCase: "[1,2,3,4,5,6]",
     },
     959: {
       funName: "regionsBySlashes",
       paramTypes: ["string[]"],
-      returnType: "number",
-      testCase: '[" /","/ "]',
     },
     960: {
       funName: "minDeletionSize",
       paramTypes: ["string[]"],
-      returnType: "number",
-      testCase: '["babca","bbazb"]',
     },
     961: {
       funName: "repeatedNTimes",
       paramTypes: ["number[]"],
-      returnType: "number",
-      testCase: "[1,2,3,3]",
     },
     962: {
       funName: "maxWidthRamp",
       paramTypes: ["number[]"],
-      returnType: "number",
-      testCase: "[6,0,8,2,1,5]",
     },
     963: {
       funName: "minAreaFreeRect",
       paramTypes: ["number[][]"],
-      returnType: "number",
-      testCase: "[[1,2],[2,1],[1,0],[0,1]]",
     },
     964: {
       funName: "leastOpsExpressTarget",
       paramTypes: ["number", "number"],
-      returnType: "number",
-      testCase: "3\\n19",
     },
     965: {
       funName: "isUnivalTree",
       paramTypes: ["TreeNode"],
-      returnType: "boolean",
-      testCase: "[1,1,1,1,1,null,1]",
     },
     966: {
       funName: "spellchecker",
       paramTypes: ["string[]", "string[]"],
-      returnType: "string[]",
-      testCase:
-        '["KiTe","kite","hare","Hare"]\\n["kite","Kite","KiTe","Hare","HARE","Hear","hear","keti","keet","keto"]',
     },
     967: {
       funName: "numsSameConsecDiff",
       paramTypes: ["number", "number"],
-      returnType: "number[]",
-      testCase: "3\\n7",
     },
     968: {
       funName: "minCameraCover",
       paramTypes: ["TreeNode"],
-      returnType: "number",
-      testCase: "[0,0,null,0,0]",
     },
     969: {
       funName: "pancakeSort",
       paramTypes: ["number[]"],
-      returnType: "number[]",
-      testCase: "[3,2,4,1]",
     },
     970: {
       funName: "powerfulIntegers",
       paramTypes: ["number", "number", "number"],
-      returnType: "number[]",
-      testCase: "2\\n3\\n10",
     },
     971: {
       funName: "flipMatchVoyage",
       paramTypes: ["TreeNode", "number[]"],
-      returnType: "number[]",
-      testCase: "[1,2]\\n[2,1]",
     },
     972: {
       funName: "isRationalEqual",
       paramTypes: ["string", "string"],
-      returnType: "boolean",
-      testCase: '"0.(52)"\\n"0.5(25)"',
     },
     973: {
       funName: "kClosest",
       paramTypes: ["number[][]", "number"],
-      returnType: "number[][]",
-      testCase: "[[1,3],[-2,2]]\\n1",
     },
     974: {
       funName: "subarraysDivByK",
       paramTypes: ["number[]", "number"],
-      returnType: "number",
-      testCase: "[4,5,0,-2,-3,1]\\n5",
     },
     975: {
       funName: "oddEvenJumps",
       paramTypes: ["number[]"],
-      returnType: "number",
-      testCase: "[10,13,12,14,15]",
     },
     976: {
       funName: "largestPerimeter",
       paramTypes: ["number[]"],
-      returnType: "number",
-      testCase: "[2,1,2]",
     },
     977: {
       funName: "sortedSquares",
       paramTypes: ["number[]"],
-      returnType: "number[]",
-      testCase: "[-4,-1,0,3,10]",
     },
     978: {
       funName: "maxTurbulenceSize",
       paramTypes: ["number[]"],
-      returnType: "number",
-      testCase: "[9,4,2,10,7,8,8,1,9]",
     },
     979: {
       funName: "distributeCoins",
       paramTypes: ["TreeNode"],
-      returnType: "number",
-      testCase: "[3,0,0]",
     },
     980: {
       funName: "uniquePathsIII",
       paramTypes: ["number[][]"],
-      returnType: "number",
-      testCase: "[[1,0,0,0],[0,0,0,0],[0,0,2,-1]]",
     },
     981: {
       funName: "TimeMap",
       paramTypes: [],
-      returnType: "void",
-      testCase:
-        '["TimeMap","set","get","get","set","get","get"]\\n[[],["foo","bar",1],["foo",1],["foo",3],["foo","bar2",4],["foo",4],["foo",5]]',
     },
     982: {
       funName: "countTriplets",
       paramTypes: ["number[]"],
-      returnType: "number",
-      testCase: "[2,1,3]",
     },
     983: {
       funName: "mincostTickets",
       paramTypes: ["number[]", "number[]"],
-      returnType: "number",
-      testCase: "[1,4,6,7,8,20]\\n[2,7,15]",
     },
     984: {
       funName: "strWithout3a3b",
       paramTypes: ["number", "number"],
-      returnType: "string",
-      testCase: "1\\n2",
     },
     985: {
       funName: "sumEvenAfterQueries",
       paramTypes: ["number[]", "number[][]"],
-      returnType: "number[]",
-      testCase: "[1,2,3,4]\\n[[1,0],[-3,1],[-4,0],[2,3]]",
     },
     986: {
       funName: "intervalIntersection",
       paramTypes: ["number[][]", "number[][]"],
-      returnType: "number[][]",
-      testCase: "[[0,2],[5,10],[13,23],[24,25]]\\n[[1,5],[8,12],[15,24],[25,26]]",
     },
     987: {
       funName: "verticalTraversal",
       paramTypes: ["TreeNode"],
-      returnType: "number[][]",
-      testCase: "[3,9,20,null,null,15,7]",
     },
     988: {
       funName: "smallestFromLeaf",
       paramTypes: ["TreeNode"],
-      returnType: "string",
-      testCase: "[0,1,2,3,4,3,4]",
     },
     989: {
       funName: "addToArrayForm",
       paramTypes: ["number[]", "number"],
-      returnType: "number[]",
-      testCase: "[1,2,0,0]\\n34",
     },
     990: {
       funName: "equationsPossible",
       paramTypes: ["string[]"],
-      returnType: "boolean",
-      testCase: '["a==b","b!=a"]',
     },
     991: {
       funName: "brokenCalc",
       paramTypes: ["number", "number"],
-      returnType: "number",
-      testCase: "2\\n3",
     },
     992: {
       funName: "subarraysWithKDistinct",
       paramTypes: ["number[]", "number"],
-      returnType: "number",
-      testCase: "[1,2,1,2,3]\\n2",
     },
     993: {
       funName: "isCousins",
       paramTypes: ["TreeNode", "number", "number"],
-      returnType: "boolean",
-      testCase: "[1,2,3,4]\\n4\\n3",
     },
     994: {
       funName: "orangesRotting",
       paramTypes: ["number[][]"],
-      returnType: "number",
-      testCase: "[[2,1,1],[1,1,0],[0,1,1]]",
     },
     995: {
       funName: "minKBitFlips",
       paramTypes: ["number[]", "number"],
-      returnType: "number",
-      testCase: "[0,1,0]\\n1",
     },
     996: {
       funName: "numSquarefulPerms",
       paramTypes: ["number[]"],
-      returnType: "number",
-      testCase: "[1,17,8]",
     },
     997: {
       funName: "findJudge",
       paramTypes: ["number", "number[][]"],
-      returnType: "number",
-      testCase: "2\\n[[1,2]]",
     },
     998: {
       funName: "insertIntoMaxTree",
       paramTypes: ["TreeNode", "number"],
-      returnType: "TreeNode",
-      testCase: "[4,1,3,null,null,2]\\n5",
     },
     999: {
       funName: "numRookCaptures",
       paramTypes: ["character[][]"],
-      returnType: "number",
-      testCase:
-        '[[".",".",".",".",".",".",".","."],[".",".",".","p",".",".",".","."],[".",".",".","R",".",".",".","p"],[".",".",".",".",".",".",".","."],[".",".",".",".",".",".",".","."],[".",".",".","p",".",".",".","."],[".",".",".",".",".",".",".","."],[".",".",".",".",".",".",".","."]]',
     },
     1000: {
       funName: "mergeStones",
       paramTypes: ["number[]", "number"],
-      returnType: "number",
-      testCase: "[3,2,4,1]\\n2",
     },
     1001: {
       funName: "gridIllumination",
       paramTypes: ["number", "number[][]", "number[][]"],
-      returnType: "number[]",
-      testCase: "5\\n[[0,0],[4,4]]\\n[[1,1],[1,0]]",
     },
     1002: {
       funName: "commonChars",
       paramTypes: ["string[]"],
-      returnType: "string[]",
-      testCase: '["bella","label","roller"]',
     },
     1003: {
       funName: "isValid",
       paramTypes: ["string"],
-      returnType: "boolean",
-      testCase: '"aabcbc"',
     },
     1004: {
       funName: "longestOnes",
       paramTypes: ["number[]", "number"],
-      returnType: "number",
-      testCase: "[1,1,1,0,0,0,1,1,1,1,0]\\n2",
     },
     1005: {
       funName: "largestSumAfterKNegations",
       paramTypes: ["number[]", "number"],
-      returnType: "number",
-      testCase: "[4,2,3]\\n1",
     },
     1006: {
       funName: "clumsy",
       paramTypes: ["number"],
-      returnType: "number",
-      testCase: "4",
     },
     1007: {
       funName: "minDominoRotations",
       paramTypes: ["number[]", "number[]"],
-      returnType: "number",
-      testCase: "[2,1,2,4,2,2]\\n[5,2,6,2,3,2]",
     },
     1008: {
       funName: "bstFromPreorder",
       paramTypes: ["number[]"],
-      returnType: "TreeNode",
-      testCase: "[8,5,1,7,10,12]",
     },
     1009: {
       funName: "bitwiseComplement",
       paramTypes: ["number"],
-      returnType: "number",
-      testCase: "5",
     },
     1010: {
       funName: "numPairsDivisibleBy60",
       paramTypes: ["number[]"],
-      returnType: "number",
-      testCase: "[30,20,150,100,40]",
     },
     1011: {
       funName: "shipWithinDays",
       paramTypes: ["number[]", "number"],
-      returnType: "number",
-      testCase: "[1,2,3,4,5,6,7,8,9,10]\\n5",
     },
     1012: {
       funName: "numDupDigitsAtMostN",
       paramTypes: ["number"],
-      returnType: "number",
-      testCase: "20",
     },
     1013: {
       funName: "canThreePartsEqualSum",
       paramTypes: ["number[]"],
-      returnType: "boolean",
-      testCase: "[0,2,1,-6,6,-7,9,1,2,0,1]",
     },
     1014: {
       funName: "maxScoreSightseeingPair",
       paramTypes: ["number[]"],
-      returnType: "number",
-      testCase: "[8,1,5,2,6]",
     },
     1015: {
       funName: "smallestRepunitDivByK",
       paramTypes: ["number"],
-      returnType: "number",
-      testCase: "1",
     },
     1016: {
       funName: "queryString",
       paramTypes: ["string", "number"],
-      returnType: "boolean",
-      testCase: '"0110"\\n3',
     },
     1017: {
       funName: "baseNeg2",
       paramTypes: ["number"],
-      returnType: "string",
-      testCase: "2",
     },
     1018: {
       funName: "prefixesDivBy5",
       paramTypes: ["number[]"],
-      returnType: "boolean[]",
-      testCase: "[0,1,1]",
     },
     1019: {
       funName: "nextLargerNodes",
       paramTypes: ["ListNode"],
-      returnType: "number[]",
-      testCase: "[2,1,5]",
     },
     1020: {
       funName: "numEnclaves",
       paramTypes: ["number[][]"],
-      returnType: "number",
-      testCase: "[[0,0,0,0],[1,0,1,0],[0,1,1,0],[0,0,0,0]]",
     },
     1021: {
       funName: "removeOuterParentheses",
       paramTypes: ["string"],
-      returnType: "string",
-      testCase: '"(()())(())"',
     },
     1022: {
       funName: "sumRootToLeaf",
       paramTypes: ["TreeNode"],
-      returnType: "number",
-      testCase: "[1,0,1,0,1,0,1]",
     },
     1023: {
       funName: "camelMatch",
       paramTypes: ["string[]", "string"],
-      returnType: "boolean[]",
-      testCase: '["FooBar","FooBarTest","FootBall","FrameBuffer","ForceFeedBack"]\\n"FB"',
     },
     1024: {
       funName: "videoStitching",
       paramTypes: ["number[][]", "number"],
-      returnType: "number",
-      testCase: "[[0,2],[4,6],[8,10],[1,9],[1,5],[5,9]]\\n10",
     },
     1025: {
       funName: "divisorGame",
       paramTypes: ["number"],
-      returnType: "boolean",
-      testCase: "2",
     },
     1026: {
       funName: "maxAncestorDiff",
       paramTypes: ["TreeNode"],
-      returnType: "number",
-      testCase: "[8,3,10,1,6,null,14,null,null,4,7,13]",
     },
     1027: {
       funName: "longestArithSeqLength",
       paramTypes: ["number[]"],
-      returnType: "number",
-      testCase: "[3,6,9,12]",
     },
     1028: {
       funName: "recoverFromPreorder",
       paramTypes: ["string"],
-      returnType: "TreeNode",
-      testCase: '"1-2--3--4-5--6--7"',
     },
     1029: {
       funName: "twoCitySchedCost",
       paramTypes: ["number[][]"],
-      returnType: "number",
-      testCase: "[[10,20],[30,200],[400,50],[30,20]]",
     },
     1030: {
       funName: "allCellsDistOrder",
       paramTypes: ["number", "number", "number", "number"],
-      returnType: "number[][]",
-      testCase: "1\\n2\\n0\\n0",
     },
     1031: {
       funName: "maxSumTwoNoOverlap",
       paramTypes: ["number[]", "number", "number"],
-      returnType: "number",
-      testCase: "[0,6,5,2,2,5,1,9,4]\\n1\\n2",
     },
     1032: {
       funName: "StreamChecker",
       paramTypes: ["string[]"],
-      returnType: "void",
-      testCase:
-        '["StreamChecker","query","query","query","query","query","query","query","query","query","query","query","query"]\\n[[["cd","f","kl"]],["a"],["b"],["c"],["d"],["e"],["f"],["g"],["h"],["i"],["j"],["k"],["l"]]',
     },
     1033: {
       funName: "numMovesStones",
       paramTypes: ["number", "number", "number"],
-      returnType: "number[]",
-      testCase: "1\\n2\\n5",
     },
     1034: {
       funName: "colorBorder",
       paramTypes: ["number[][]", "number", "number", "number"],
-      returnType: "number[][]",
-      testCase: "[[1,1],[1,2]]\\n0\\n0\\n3",
     },
     1035: {
       funName: "maxUncrossedLines",
       paramTypes: ["number[]", "number[]"],
-      returnType: "number",
-      testCase: "[1,4,2]\\n[1,2,4]",
     },
     1036: {
       funName: "isEscapePossible",
       paramTypes: ["number[][]", "number[]", "number[]"],
-      returnType: "boolean",
-      testCase: "[[0,1],[1,0]]\\n[0,0]\\n[0,2]",
     },
     1037: {
       funName: "isBoomerang",
       paramTypes: ["number[][]"],
-      returnType: "boolean",
-      testCase: "[[1,1],[2,3],[3,2]]",
     },
     1038: {
       funName: "bstToGst",
       paramTypes: ["TreeNode"],
-      returnType: "TreeNode",
-      testCase: "[4,1,6,0,2,5,7,null,null,null,3,null,null,null,8]",
     },
     1039: {
       funName: "minScoreTriangulation",
       paramTypes: ["number[]"],
-      returnType: "number",
-      testCase: "[1,2,3]",
     },
     1040: {
       funName: "numMovesStonesII",
       paramTypes: ["number[]"],
-      returnType: "number[]",
-      testCase: "[7,4,9]",
     },
     1041: {
       funName: "isRobotBounded",
       paramTypes: ["string"],
-      returnType: "boolean",
-      testCase: '"GGLLGG"',
     },
     1042: {
       funName: "gardenNoAdj",
       paramTypes: ["number", "number[][]"],
-      returnType: "number[]",
-      testCase: "3\\n[[1,2],[2,3],[3,1]]",
     },
     1043: {
       funName: "maxSumAfterPartitioning",
       paramTypes: ["number[]", "number"],
-      returnType: "number",
-      testCase: "[1,15,7,9,2,5,10]\\n3",
     },
     1044: {
       funName: "longestDupSubstring",
       paramTypes: ["string"],
-      returnType: "string",
-      testCase: '"banana"',
     },
     1046: {
       funName: "lastStoneWeight",
       paramTypes: ["number[]"],
-      returnType: "number",
-      testCase: "[2,7,4,1,8,1]",
     },
     1047: {
       funName: "removeDuplicates",
       paramTypes: ["string"],
-      returnType: "string",
-      testCase: '"abbaca"',
     },
     1048: {
       funName: "longestStrChain",
       paramTypes: ["string[]"],
-      returnType: "number",
-      testCase: '["a","b","ba","bca","bda","bdca"]',
     },
     1049: {
       funName: "lastStoneWeightII",
       paramTypes: ["number[]"],
-      returnType: "number",
-      testCase: "[2,7,4,1,8,1]",
     },
     1051: {
       funName: "heightChecker",
       paramTypes: ["number[]"],
-      returnType: "number",
-      testCase: "[1,1,4,2,1,3]",
     },
     1052: {
       funName: "maxSatisfied",
       paramTypes: ["number[]", "number[]", "number"],
-      returnType: "number",
-      testCase: "[1,0,1,2,1,1,7,5]\\n[0,1,0,1,0,1,0,1]\\n3",
     },
     1053: {
       funName: "prevPermOpt1",
       paramTypes: ["number[]"],
-      returnType: "number[]",
-      testCase: "[3,2,1]",
     },
     1054: {
       funName: "rearrangeBarcodes",
       paramTypes: ["number[]"],
-      returnType: "number[]",
-      testCase: "[1,1,1,2,2,2]",
     },
     1071: {
       funName: "gcdOfStrings",
       paramTypes: ["string", "string"],
-      returnType: "string",
-      testCase: '"ABCABC"\\n"ABC"',
     },
     1072: {
       funName: "maxEqualRowsAfterFlips",
       paramTypes: ["number[][]"],
-      returnType: "number",
-      testCase: "[[0,1],[1,1]]",
     },
     1073: {
       funName: "addNegabinary",
       paramTypes: ["number[]", "number[]"],
-      returnType: "number[]",
-      testCase: "[1,1,1,1,1]\\n[1,0,1]",
     },
     1074: {
       funName: "numSubmatrixSumTarget",
       paramTypes: ["number[][]", "number"],
-      returnType: "number",
-      testCase: "[[0,1,0],[1,1,1],[0,1,0]]\\n0",
     },
     1078: {
       funName: "findOcurrences",
       paramTypes: ["string", "string", "string"],
-      returnType: "string[]",
-      testCase: '"alice is a good girl she is a good student"\\n"a"\\n"good"',
     },
     1079: {
       funName: "numTilePossibilities",
       paramTypes: ["string"],
-      returnType: "number",
-      testCase: '"AAB"',
     },
     1080: {
       funName: "sufficientSubset",
       paramTypes: ["TreeNode", "number"],
-      returnType: "TreeNode",
-      testCase: "[1,2,3,4,-99,-99,7,8,9,-99,-99,12,13,-99,14]\\n1",
     },
     1081: {
       funName: "smallestSubsequence",
       paramTypes: ["string"],
-      returnType: "string",
-      testCase: '"cdadabcc"',
     },
     1089: {
       funName: "duplicateZeros",
       paramTypes: ["number[]"],
-      returnType: "void",
-      testCase: "[1,0,2,3,0,4,5,0]",
     },
     1090: {
       funName: "largestValsFromLabels",
       paramTypes: ["number[]", "number[]", "number", "number"],
-      returnType: "number",
-      testCase: "[5,4,3,2,1]\\n[1,1,2,2,3]\\n3\\n1",
     },
     1091: {
       funName: "shortestPathBinaryMatrix",
       paramTypes: ["number[][]"],
-      returnType: "number",
-      testCase: "[[0,1],[1,0]]",
     },
     1092: {
       funName: "shortestCommonSupersequence",
       paramTypes: ["string", "string"],
-      returnType: "string",
-      testCase: '"abac"\\n"cab"',
     },
     1093: {
       funName: "sampleStats",
       paramTypes: ["number[]"],
-      returnType: "number[]",
-      testCase:
-        "[0,1,3,4,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0]",
     },
     1094: {
       funName: "carPooling",
       paramTypes: ["number[][]", "number"],
-      returnType: "boolean",
-      testCase: "[[2,1,5],[3,3,7]]\\n4",
     },
     1095: {
       funName: "findInMountainArray",
       // change the order of paramTypes
       paramTypes: ["MountainArray", "number"],
-      returnType: "number",
-      testCase: "[1,2,3,4,5,3,1]\\n3",
     },
     1096: {
       funName: "braceExpansionII",
       paramTypes: ["string"],
-      returnType: "string[]",
-      testCase: '"{a,b}{c,{d,e}}"',
     },
     1103: {
       funName: "distributeCandies",
       paramTypes: ["number", "number"],
-      returnType: "number[]",
-      testCase: "7\\n4",
     },
     1104: {
       funName: "pathInZigZagTree",
       paramTypes: ["number"],
-      returnType: "number[]",
-      testCase: "14",
     },
     1105: {
       funName: "minHeightShelves",
       paramTypes: ["number[][]", "number"],
-      returnType: "number",
-      testCase: "[[1,1],[2,3],[2,3],[1,1],[1,1],[1,1],[1,2]]\\n4",
     },
     1106: {
       funName: "parseBoolExpr",
       paramTypes: ["string"],
-      returnType: "boolean",
-      testCase: '"!(f)"',
     },
   };
 
@@ -5391,9 +3602,9 @@ class DebugArgDao {
         }
         // funName: string;
         // paramTypes: string[];
-        // returnType: string;
+
         // testCase?: string;
-        if (start_collect_arg && file_arg["funName"] && file_arg["paramTypes"] && file_arg["returnType"]) {
+        if (start_collect_arg && file_arg["funName"] && file_arg["paramTypes"]) {
           file_arg["paramTypes"] = JSON.parse(file_arg["paramTypes"]);
           return file_arg as IProblemType;
         } else {
diff --git a/src/debugex/debugCpp.ts b/src/debugex/debugCpp.ts
index c468b18..323ef4b 100644
--- a/src/debugex/debugCpp.ts
+++ b/src/debugex/debugCpp.ts
@@ -267,7 +267,7 @@ class DebugCpp extends DebugBase {
       testString.replace(/\\"/g, '\\\\"'),
       problemType.funName,
       problemType.paramTypes.join(","),
-      problemType.returnType,
+      problemType.returnType || "",
       meta.id,
       port.toString(),
     ];
@@ -279,7 +279,6 @@ class DebugCpp extends DebugBase {
         name: debugSessionName,
         // logging: { engineLogging: true, trace: true, traceResponse: true },
         args,
-
       })
     );
 
diff --git a/src/service/DebugService.ts b/src/service/DebugService.ts
index c43b028..45cd682 100644
--- a/src/service/DebugService.ts
+++ b/src/service/DebugService.ts
@@ -113,7 +113,7 @@ class DebugService {
       testString,
       problemType.funName,
       problemType.paramTypes.join(","),
-      problemType.returnType,
+      problemType.returnType || "",
       meta.id,
       (this.server.address() as net.AddressInfo).port.toString(),
     ];
diff --git a/src/service/FileButtonService.ts b/src/service/FileButtonService.ts
index fae53e9..33d1e23 100644
--- a/src/service/FileButtonService.ts
+++ b/src/service/FileButtonService.ts
@@ -104,13 +104,15 @@ export class FileButtonService implements vscode.CodeLensProvider {
     }
 
     if (supportDebugLanguages.indexOf(nodeLang) != -1) {
-      temp_result.push(
-        new vscode.CodeLens(range, {
-          title: "debug",
-          command: "lcpr.simpleDebug",
-          arguments: [document],
-        })
-      );
+      if (shortcuts.indexOf("debug") >= 0) {
+        temp_result.push(
+          new vscode.CodeLens(range, {
+            title: "debug",
+            command: "lcpr.simpleDebug",
+            arguments: [document],
+          })
+        );
+      }
     }
 
     return temp_result;
@@ -124,24 +126,33 @@ export class FileButtonService implements vscode.CodeLensProvider {
 
     const temp_result: vscode.CodeLens[] = [];
 
-    temp_result.push(
-      new vscode.CodeLens(range, {
-        title: "case",
-        command: "lcpr.tesCaseArea",
-        arguments: [document.uri, testCase],
-      })
-    );
+    const shortcuts: string[] = getEditorShortcuts();
+    if (!shortcuts) {
+      return temp_result;
+    }
 
-    if (supportDebugLanguages.indexOf(nodeLang) != -1) {
+    if (shortcuts.indexOf("case") >= 0) {
       temp_result.push(
         new vscode.CodeLens(range, {
-          title: "debug",
-          command: "lcpr.simpleDebug",
-          arguments: [document, testCase],
+          title: "case",
+          command: "lcpr.tesCaseArea",
+          arguments: [document.uri, testCase],
         })
       );
     }
 
+    if (supportDebugLanguages.indexOf(nodeLang) != -1) {
+      if (shortcuts.indexOf("debug") >= 0) {
+        temp_result.push(
+          new vscode.CodeLens(range, {
+            title: "debug",
+            command: "lcpr.simpleDebug",
+            arguments: [document, testCase],
+          })
+        );
+      }
+    }
+
     return temp_result;
   }
 
@@ -216,56 +227,63 @@ export class FileButtonService implements vscode.CodeLensProvider {
     const temp_result: vscode.CodeLens[] = [];
 
     // paramTypes= []
-    // returnType=
 
     if (lineContent.indexOf("paramTypes=") >= 0) {
-      temp_result.push(
-        new vscode.CodeLens(range, {
-          title: "addParam",
-          command: "lcpr.addDebugType",
-          arguments: [document, "paramTypes"],
-        })
-      );
-      temp_result.push(
-        new vscode.CodeLens(range, {
-          title: "resetParam",
-          command: "lcpr.resetDebugType",
-          arguments: [document, "paramTypes"],
-        })
-      );
+      const shortcuts: string[] = getEditorShortcuts();
+      if (!shortcuts) {
+        return temp_result;
+      }
+      if (shortcuts.indexOf("debug") >= 0) {
+        temp_result.push(
+          new vscode.CodeLens(range, {
+            title: "addParam",
+            command: "lcpr.addDebugType",
+            arguments: [document, "paramTypes"],
+          })
+        );
+        temp_result.push(
+          new vscode.CodeLens(range, {
+            title: "resetParam",
+            command: "lcpr.resetDebugType",
+            arguments: [document, "paramTypes"],
+          })
+        );
+      }
     }
 
-    if (lineContent.indexOf("returnType=") >= 0) {
-      temp_result.push(
-        new vscode.CodeLens(range, {
-          title: "addReturn",
-          command: "lcpr.addDebugType",
-          arguments: [document, "returnType"],
-        })
-      );
-      temp_result.push(
-        new vscode.CodeLens(range, {
-          title: "resetReturn",
-          command: "lcpr.resetDebugType",
-          arguments: [document, "returnType"],
-        })
-      );
-    }
+    // if (lineContent.indexOf("returnType=") >= 0) {
+    //   temp_result.push(
+    //     new vscode.CodeLens(range, {
+    //       title: "addReturn",
+    //       command: "lcpr.addDebugType",
+    //       arguments: [document, "returnType"],
+    //     })
+    //   );
+    //   temp_result.push(
+    //     new vscode.CodeLens(range, {
+    //       title: "resetReturn",
+    //       command: "lcpr.resetDebugType",
+    //       arguments: [document, "returnType"],
+    //     })
+    //   );
+    // }
     return temp_result;
   }
 
   public provideCodeLenses(document: vscode.TextDocument): vscode.ProviderResult<vscode.CodeLens[]> {
     const content: string = document.getText();
-    const matchResult: RegExpMatchArray | null = content.match(/@lc app=.* id=(.*) lang=(.*)/);
+    const matchResult: RegExpMatchArray | null = content.match(
+      /@lc app=(.*) id=(.*|\w*|\W*|[\\u4e00-\\u9fa5]*) lang=(.*)/
+    );
     if (!matchResult) {
       return undefined;
     }
-    const nodeId: string | undefined = matchResult[1];
+    const nodeId: string | undefined = matchResult[2];
     let node: NodeModel | undefined;
     if (nodeId) {
       node = treeViewController.getNodeById(nodeId);
     }
-    let nodeLang: string | undefined = matchResult[2];
+    let nodeLang: string | undefined = matchResult[3];
 
     const codeLens: vscode.CodeLens[] = [];
     let caseFlag: boolean = false;
diff --git a/src/service/RemarkService.ts b/src/service/RemarkService.ts
index fce1311..159e543 100644
--- a/src/service/RemarkService.ts
+++ b/src/service/RemarkService.ts
@@ -22,12 +22,14 @@ class RemarkService implements Disposable {
 
   getQidByDocument(document: TextDocument) {
     const content: string = document.getText();
-    const matchResult: RegExpMatchArray | null = content.match(/@lc app=.* id=(.*) lang=.*/);
+    const matchResult: RegExpMatchArray | null = content.match(
+      /@lc app=(.*) id=(.*|\w*|\W*|[\\u4e00-\\u9fa5]*) lang=(.*)/
+    );
     let result: Map<string, string> = new Map<string, string>();
     if (!matchResult) {
       return result;
     }
-    const fid: string | undefined = matchResult[1];
+    const fid: string | undefined = matchResult[2];
     let qid: string | undefined = treeViewController.getQidByFid(fid);
     result["fid"] = fid;
     if (qid != undefined) {
@@ -49,8 +51,10 @@ class RemarkService implements Disposable {
 
   public async includeTemplates(document: TextDocument) {
     const content: string = document.getText();
-    const matchResult: RegExpMatchArray | null = content.match(/@lc app=.* id=(.*) lang=(.*)/);
-    if (!matchResult || !matchResult[2]) {
+    const matchResult: RegExpMatchArray | null = content.match(
+      /@lc app=(.*) id=(.*|\w*|\W*|[\\u4e00-\\u9fa5]*) lang=(.*)/
+    );
+    if (!matchResult || !matchResult[3]) {
       return undefined;
     }
     for (let i: number = 0; i < document.lineCount; i++) {
@@ -59,7 +63,7 @@ class RemarkService implements Disposable {
       if (lineContent.indexOf("@lc code=start") >= 0) {
         const editor = window.activeTextEditor;
         editor?.edit((edit) => {
-          edit.insert(new Position(i - 1, i - 1), getIncludeTemplate(matchResult[2]));
+          edit.insert(new Position(i - 1, i - 1), getIncludeTemplate(matchResult[3]));
         });
       }
     }
diff --git a/src/utils/ConfigUtils.ts b/src/utils/ConfigUtils.ts
index 5a07dc9..d481952 100644
--- a/src/utils/ConfigUtils.ts
+++ b/src/utils/ConfigUtils.ts
@@ -92,7 +92,14 @@ export function getWorkspaceFolder(): string {
 
 // 快捷操作
 export function getEditorShortcuts(): string[] {
-  return getVsCodeConfig().get<string[]>("editor.shortcuts", ["submit", "case", "allcase", "test", "solution"]);
+  return getVsCodeConfig().get<string[]>("editor.shortcuts", [
+    "submit",
+    "case",
+    "allcase",
+    "test",
+    "solution",
+    "debug",
+  ]);
 }
 
 export function isStarShortcut(): boolean {
diff --git a/src/utils/problemUtils.ts b/src/utils/problemUtils.ts
index 49abc02..ec1981c 100644
--- a/src/utils/problemUtils.ts
+++ b/src/utils/problemUtils.ts
@@ -4,8 +4,6 @@ import * as vscode from "vscode";
 
 import { useWsl, isWindows, usingCmd } from "./SystemUtils";
 
-const fileMateReg: RegExp = /@lc\s+(?:[\s\S]*?)\s+id=(\d+)\s+lang=([\S]+)/;
-
 const beforeStubReg: RegExp = /@lcpr-before-debug-begin([\s\S]*?)@lcpr-before-debug-end/;
 const afterStubReg: RegExp = /@lcpr-after-debug-begin([\s\S]*?)@lcpr-after-debug-end/;
 
@@ -101,11 +99,11 @@ export function genFileExt(language: string): string {
 }
 
 export function fileMeta(content: string): ProblemMeta | null {
-  const result: RegExpExecArray | null = fileMateReg.exec(content);
+  const result: RegExpExecArray | null = /@lc app=(.*) id=(.*|\w*|\W*|[\\u4e00-\\u9fa5]*) lang=(.*)/.exec(content);
   if (result != null) {
     return {
-      id: result[1],
-      lang: result[2],
+      id: result[2],
+      lang: result[3],
     };
   }
   return null;