diff --git a/TEST_FORMAT.md b/TEST_FORMAT.md
index d9787ee5..5da92022 100644
--- a/TEST_FORMAT.md
+++ b/TEST_FORMAT.md
@@ -12,6 +12,11 @@ Each problem has one test file located at `tests/<range>/<id>. <title>/manifest.
 entry:
   id: <int>
   title: <string>
+  params:
+    arg1:
+      type: <schema>
+    arg2:
+      type: <schema>
   call:
     cpp: "..."
     rust: "..."
@@ -62,23 +67,99 @@ tests:
 entry:
   id: 1
   title: "two-sum"
+  params:
+    nums:
+      type: array
+      items:
+        type: int
+    target:
+      type: int
   call:
-    rust: "Solution::two_sum(vec![{nums}], {target})"
-    cpp: "Solution().twoSum(lv(vector<int>{ {nums} }), {target})"
-    python3: "Solution().twoSum([{nums}], {target})"
-    java: "new Solution().twoSum(new int[] { {nums} }, {target})"
-    csharp: "new Solution().TwoSum(new int[]{ {nums} }, {target})"
-    go: "twoSum([]int{ {nums} }, {target})"
-    typescript: "twoSum([{nums}], {target})"
+    rust: "Solution::two_sum({nums}, {target})"
+    cpp: "Solution().twoSum({nums}, {target})"
+    python3: "Solution().twoSum({nums}, {target})"
+    java: "new Solution().twoSum({nums}, {target})"
+    csharp: "new Solution().TwoSum({nums}, {target})"
+    go: "twoSum({nums}, {target})"
+    typescript: "twoSum({nums}, {target})"
     # ... other languages
 ```
 
-`call` templates use `{param_name}` placeholders. At runtime, placeholders are replaced with the actual values of the test case inputs by their name.
-
 **Supported languages:** `cpp`, `rust`, `python3`, `python2`, `ruby`, `java`, `csharp`, `kotlin`, `go`, `dart`, `swift`, `typescript`
 
 ---
 
+### `entry.params`
+
+`entry.params` is the type schema for solution arguments. It tells the runtime how to materialize values from test data before evaluating `call`.
+
+Use plain placeholders in `call`:
+
+```yaml
+call:
+  python3: "Solution().twoSum({nums}, {target})"
+  java: "new Solution().twoSum({nums}, {target})"
+```
+
+The runtime uses `params` to decide what `{nums}` and `{target}` mean.
+
+#### Supported param types
+
+- scalar types: `int`, `long`, `float`, `double`, `bool`, `string`, `char`
+- structural types: `array`, `list_node`, `tree_node`
+
+#### Examples
+
+Scalar:
+
+```yaml
+params:
+  target:
+    type: int
+```
+
+1D array:
+
+```yaml
+params:
+  nums:
+    type: array
+    items:
+      type: int
+```
+
+2D matrix:
+
+```yaml
+params:
+  matrix:
+    type: array
+    items:
+      type: array
+      items:
+        type: char
+```
+
+Linked list:
+
+```yaml
+params:
+  l1:
+    type: list_node
+  l2:
+    type: list_node
+```
+
+Binary tree:
+
+```yaml
+params:
+  root:
+    type: tree_node
+```
+
+---
+
 ## `judge`
 
 ```yaml
@@ -114,17 +195,10 @@ Used when a test case has no `out` field. The oracle runs the checker on the sol
 ```yaml
 oracle:
   python3:
-    call: "Checker().twoSum([{nums}], {target}, {result})"
+    call: "Checker().twoSum(nums, target, {result})"
     checker: |
-      import json
-      from typing import List
-
       class Checker:
-          def twoSum(self, nums: List[int], target: int, result: str) -> bool:
-              try:
-                  indices = json.loads(result)
-              except:
-                  return False
+          def twoSum(self, nums: List[int], target: int, result: Any) -> bool:
               if not isinstance(indices, list) or len(indices) != 2:
                   return False
               i, j = indices
@@ -133,7 +207,7 @@ oracle:
               return nums[i] + nums[j] == target
 ```
 
-`call` receives the same input placeholders as the solution call, plus `{result}` which is the solution's output as a string.
+In `oracle.python3.call`, input arguments should be plain Python names such as `nums`, `target`, `matrix`, `root`. `{result}` remains the special placeholder for the solution output.
 
 `checker` must be a full source file. The call expression must return a `bool`.
 
@@ -155,7 +229,7 @@ A list of test cases. Test cases differ along two independent axes:
   judge: # optional - overrides the top-level judge
     type: "ignore_order"
   call: # optional - overrides the top-level entry.call for this case only
-    python3: "Solution().twoSum([{nums}], {target})"
+    python3: "Solution().twoSum({nums}, {target})"
   seed: 111 # optional - overrides the suite-level seed for generated inputs
   in:
     nums: [2, 7, 11, 15] # static value
@@ -437,7 +511,7 @@ in:
       - [false, true]
 ```
 
-For `call`, use the same syntax principle for 2D as for 1D: keep the usual language wrapper and only increase dimensionality (`int[] -> int[][]`, `[]int -> [][]int`, `intArrayOf(...) -> arrayOf(intArrayOf(...))`).
+For `call`, keep using plain placeholders such as `{matrix}`. Typed runtimes materialize values from `entry.params`.
 
 ---
 
@@ -447,19 +521,26 @@ For `call`, use the same syntax principle for 2D as for 1D: keep the usual langu
 entry:
   id: 1
   title: "two-sum"
+  params:
+    nums:
+      type: array
+      items:
+        type: int
+    target:
+      type: int
   call:
-    cpp: "Solution().twoSum(lv(vector<int>{ {nums} }), {target})"
-    rust: "Solution::two_sum(vec![{nums}], {target})"
-    python3: "Solution().twoSum([{nums}], {target})"
-    python2: "Solution().twoSum([{nums}], {target})"
-    ruby: "two_sum([{nums}], {target})"
-    java: "new Solution().twoSum(new int[] { {nums} }, {target})"
-    csharp: "new Solution().TwoSum(new int[]{ {nums} }, {target})"
-    kotlin: "Solution().twoSum(intArrayOf({nums}), {target})"
-    go: "twoSum([]int{ {nums} }, {target})"
-    dart: "Solution().twoSum([{nums}], {target})"
-    swift: "Solution().twoSum([{nums}], {target})"
-    typescript: "twoSum([{nums}], {target})"
+    cpp: "Solution().twoSum({nums}, {target})"
+    rust: "Solution::two_sum({nums}, {target})"
+    python3: "Solution().twoSum({nums}, {target})"
+    python2: "Solution().twoSum({nums}, {target})"
+    ruby: "two_sum({nums}, {target})"
+    java: "new Solution().twoSum({nums}, {target})"
+    csharp: "new Solution().TwoSum({nums}, {target})"
+    kotlin: "Solution().twoSum({nums}, {target})"
+    go: "twoSum({nums}, {target})"
+    dart: "Solution().twoSum({nums}, {target})"
+    swift: "Solution().twoSum({nums}, {target})"
+    typescript: "twoSum({nums}, {target})"
 
 judge:
   type: "ignore_order"
@@ -472,7 +553,7 @@ limits:
 
 oracle:
   python3:
-    call: "Checker().twoSum([{nums}], {target}, {result})"
+    call: "Checker().twoSum(nums, target, {result})"
     checker: |
       import json
       from typing import List
@@ -542,19 +623,24 @@ Each runtime provides helpers to convert between plain integer arrays and `ListN
 entry:
   id: 2
   title: "add-two-numbers"
+  params:
+    l1:
+      type: list_node
+    l2:
+      type: list_node
   call:
-    cpp: "listNodeToArray(Solution().addTwoNumbers(toListNode(lv(vector<int>{ {l1} })), toListNode(lv(vector<int>{ {l2} }))))"
-    rust: "ListNode::list_node_to_array(Solution::add_two_numbers(ListNode::to_list_node(vec![{l1}]), ListNode::to_list_node(vec![{l2}])))"
-    python3: "list_node_to_array(Solution().addTwoNumbers(to_list_node([{l1}]), to_list_node([{l2}])))"
-    python2: "list_node_to_array(Solution().addTwoNumbers(to_list_node([{l1}]), to_list_node([{l2}])))"
-    kotlin: "listNodeToArray(Solution().addTwoNumbers(toListNode(intArrayOf({l1})), toListNode(intArrayOf({l2}))))"
-    java: "ListNode.listNodeToArray(new Solution().addTwoNumbers(ListNode.toListNode(new int[]{ {l1} }), ListNode.toListNode(new int[]{ {l2} })))"
-    csharp: "ListNode.ListNodeToArray(new Solution().AddTwoNumbers(ListNode.ToListNode(new int[]{ {l1} }), ListNode.ToListNode(new int[]{ {l2} })))"
-    go: "listNodeToArray(addTwoNumbers(toListNode([]int{ {l1} }), toListNode([]int{ {l2} })))"
-    dart: "list_node_to_array(Solution().addTwoNumbers(to_list_node([{l1}]), to_list_node([{l2}])))"
-    swift: "list_node_to_array(Solution().addTwoNumbers(to_list_node([{l1}]), to_list_node([{l2}])))"
-    ruby: "list_node_to_array(add_two_numbers(to_list_node([{l1}]), to_list_node([{l2}])))"
-    typescript: "listNodeToArray(addTwoNumbers(toListNode([{l1}]), toListNode([{l2}])))"
+    cpp: "listNodeToArray(Solution().addTwoNumbers({l1}, {l2}))"
+    rust: "ListNode::list_node_to_array(Solution::add_two_numbers({l1}, {l2}))"
+    python3: "list_node_to_array(Solution().addTwoNumbers({l1}, {l2}))"
+    python2: "list_node_to_array(Solution().addTwoNumbers({l1}, {l2}))"
+    kotlin: "listNodeToArray(Solution().addTwoNumbers({l1}, {l2}))"
+    java: "ListNode.listNodeToArray(new Solution().addTwoNumbers({l1}, {l2}))"
+    csharp: "ListNode.ListNodeToArray(new Solution().AddTwoNumbers({l1}, {l2}))"
+    go: "listNodeToArray(addTwoNumbers({l1}, {l2}))"
+    dart: "list_node_to_array(Solution().addTwoNumbers({l1}, {l2}))"
+    swift: "list_node_to_array(Solution().addTwoNumbers({l1}, {l2}))"
+    ruby: "list_node_to_array(add_two_numbers({l1}, {l2}))"
+    typescript: "listNodeToArray(addTwoNumbers({l1}, {l2}))"
 
 tests:
   - name: "ex1"
@@ -591,19 +677,22 @@ Trees are represented as arrays in LeetCode standard level-order format. `null`
 entry:
   id: 104
   title: "maximum-depth-of-binary-tree"
+  params:
+    root:
+      type: tree_node
   call:
-    cpp: "Solution().maxDepth(toTreeNode(lv(vector<optional<int>>{ {root} })))"
-    rust: "Solution::max_depth(TreeNode::to_tree_node(vec![{root}]))"
-    python3: "Solution().maxDepth(to_tree_node([{root}]))"
-    python2: "Solution().maxDepth(to_tree_node([{root}]))"
-    ruby: "Solution.new.max_depth(to_tree_node([{root}]))"
-    java: "new Solution().maxDepth(TreeNode.toTreeNode(new Integer[]{ {root} }))"
-    csharp: "new Solution().MaxDepth(TreeNode.ToTreeNode(new int?[]{ {root} }))"
-    kotlin: "Solution().maxDepth(toTreeNode(arrayOf({root})))"
-    go: "maxDepth(toTreeNode([]interface{}{ {root} }))"
-    dart: "Solution().maxDepth(to_tree_node([{root}]))"
-    swift: "Solution().maxDepth(to_tree_node([{root}]))"
-    typescript: "maxDepth(toTreeNode([{root}]))"
+    cpp: "Solution().maxDepth({root})"
+    rust: "Solution::max_depth({root})"
+    python3: "Solution().maxDepth({root})"
+    python2: "Solution().maxDepth({root})"
+    ruby: "Solution.new.max_depth({root})"
+    java: "new Solution().maxDepth({root})"
+    csharp: "new Solution().MaxDepth({root})"
+    kotlin: "Solution().maxDepth({root})"
+    go: "maxDepth({root})"
+    dart: "Solution().maxDepth({root})"
+    swift: "Solution().maxDepth({root})"
+    typescript: "maxDepth({root})"
 
 tests:
   - name: "ex1"
@@ -623,19 +712,22 @@ When the solution returns a `TreeNode` (e.g. _Invert Binary Tree_), wrap the res
 entry:
   id: 226
   title: "invert-binary-tree"
+  params:
+    root:
+      type: tree_node
   call:
-    cpp: "treeNodeToArray(Solution().invertTree(toTreeNode(lv(vector<optional<int>>{ {root} }))))"
-    rust: "TreeNode::tree_node_to_array(Solution::invert_tree(TreeNode::to_tree_node(vec![{root}])))"
-    python3: "tree_node_to_array(Solution().invertTree(to_tree_node([{root}])))"
-    python2: "tree_node_to_array(Solution().invertTree(to_tree_node([{root}])))"
-    ruby: "tree_node_to_array(invert_tree(to_tree_node([{root}])))"
-    java: "TreeNode.treeNodeToArray(new Solution().invertTree(TreeNode.toTreeNode(new Integer[]{ {root} })))"
-    csharp: "TreeNode.TreeNodeToArray(new Solution().InvertTree(TreeNode.ToTreeNode(new int?[]{ {root} })))"
-    kotlin: "treeNodeToArray(Solution().invertTree(toTreeNode(arrayOf({root}))))"
-    go: "treeNodeToArray(invertTree(toTreeNode([]interface{}{ {root} })))"
-    dart: "tree_node_to_array(Solution().invertTree(to_tree_node([{root}])))"
-    swift: "tree_node_to_array(Solution().invertTree(to_tree_node([{root}])))"
-    typescript: "treeNodeToArray(invertTree(toTreeNode([{root}])))"
+    cpp: "treeNodeToArray(Solution().invertTree({root}))"
+    rust: "TreeNode::tree_node_to_array(Solution::invert_tree({root}))"
+    python3: "tree_node_to_array(Solution().invertTree({root}))"
+    python2: "tree_node_to_array(Solution().invertTree({root}))"
+    ruby: "tree_node_to_array(invert_tree({root}))"
+    java: "TreeNode.treeNodeToArray(new Solution().invertTree({root}))"
+    csharp: "TreeNode.TreeNodeToArray(new Solution().InvertTree({root}))"
+    kotlin: "treeNodeToArray(Solution().invertTree({root}))"
+    go: "treeNodeToArray(invertTree({root}))"
+    dart: "tree_node_to_array(Solution().invertTree({root}))"
+    swift: "tree_node_to_array(Solution().invertTree({root}))"
+    typescript: "treeNodeToArray(invertTree({root}))"
 
 tests:
   - name: "ex1"
diff --git a/core/Core/Executor/Class.hs b/core/Core/Executor/Class.hs
index ac8a8db4..ea23563b 100644
--- a/core/Core/Executor/Class.hs
+++ b/core/Core/Executor/Class.hs
@@ -6,9 +6,16 @@ module Core.Executor.Class where
 import Core.Types (Language)
 import Data.Text (Text)
 
+data ExecFile = ExecFile
+  { fileName :: Text,
+    fileContent :: Text
+  }
+  deriving (Show)
+
 data ExecRequest = ExecRequest
   { language :: Language,
     content :: Text,
+    files :: [ExecFile],
     runTimeout :: Maybe Int,
     runMemoryLimit :: Maybe Int
   }
diff --git a/core/Core/Executor/Piston.hs b/core/Core/Executor/Piston.hs
index 09aadc29..184c905e 100644
--- a/core/Core/Executor/Piston.hs
+++ b/core/Core/Executor/Piston.hs
@@ -24,6 +24,7 @@ data PistonExecuteRequest = PistonExecuteRequest
   { pistonRequestLanguage :: Language,
     pistonRequestVersion :: T.Text,
     pistonRequestContent :: T.Text,
+    pistonRequestFiles :: [E.ExecFile],
     pistonRequestRunTimeout :: Maybe Int,
     pistonRequestRunMemoryLimit :: Maybe Int
   }
@@ -98,6 +99,7 @@ instance E.CodeExecutor PistonExecutor where
                 { pistonRequestLanguage = E.language request,
                   pistonRequestVersion = v,
                   pistonRequestContent = E.content request,
+                  pistonRequestFiles = E.files request,
                   pistonRequestRunTimeout = E.runTimeout request,
                   pistonRequestRunMemoryLimit = E.runMemoryLimit request
                 }
@@ -145,7 +147,15 @@ instance ToJSON PistonExecuteRequest where
     object
       [ "language" .= pistonRequestLanguage req,
         "version" .= pistonRequestVersion req,
-        "files" .= [object ["content" .= pistonRequestContent req]],
+        "files"
+          .= ( [object ["content" .= pistonRequestContent req]]
+                 ++ [ object
+                        [ "name" .= E.fileName extraFile,
+                          "content" .= E.fileContent extraFile
+                        ]
+                    | extraFile <- pistonRequestFiles req
+                    ]
+             ),
         "run_timeout" .= pistonRequestRunTimeout req,
         "run_memory_limit" .= pistonRequestRunMemoryLimit req
       ]
diff --git a/core/Core/Generator/Splitmix.hs b/core/Core/Generator/Splitmix.hs
index 2f21e265..b090c435 100644
--- a/core/Core/Generator/Splitmix.hs
+++ b/core/Core/Generator/Splitmix.hs
@@ -139,7 +139,7 @@ generateArr (GenArr False _ l (GenFloatInfo (GenFloatConst constVal)) _) _ gen =
    in (formattedString, gen')
 generateArr (GenArr True _ _ (GenFloatInfo (GenFloatConst constVal)) _) _ gen =
   (T.pack (show constVal), gen)
-generateArr (GenArr False sortedVals l (GenCharInfo i) _) _ gen =
+generateArr (GenArr False sortedVals l (GenCharInfo i) _) lang gen =
   let (v, gen') = generateIntegral l gen
       len = read (T.unpack v) :: Int
       (chars, gen'') =
@@ -150,18 +150,18 @@ generateArr (GenArr False sortedVals l (GenCharInfo i) _) _ gen =
           )
           ([], gen')
           [1 .. len]
-      result = T.intercalate ", " (map T.singleton (applySorted sortedVals (reverse chars)))
+      result = T.intercalate ", " (map (renderGeneratedCharElem lang) (applySorted sortedVals (reverse chars)))
    in (result, gen'')
-generateArr (GenArr True sortedVals l (GenCharInfo (GenCharVariety alphabet)) _) _ gen =
+generateArr (GenArr True sortedVals l (GenCharInfo (GenCharVariety alphabet)) _) lang gen =
   let vec = V.fromList (T.unpack alphabet)
       (v, gen') = generateIntegral l gen
       len = min (read (T.unpack v) :: Int) (V.length vec)
       (shuffled, gen'') = fisherYates vec gen'
       chars = applySorted sortedVals (V.toList (V.take len shuffled))
-      result = T.intercalate ", " (map T.singleton chars)
+      result = T.intercalate ", " (map (renderGeneratedCharElem lang) chars)
    in (result, gen'')
-generateArr (GenArr True _ _ (GenCharInfo (GenCharConst c)) _) _ gen =
-  (T.singleton c, gen)
+generateArr (GenArr True _ _ (GenCharInfo (GenCharConst c)) _) lang gen =
+  (renderGeneratedCharElem lang c, gen)
 generateArr (GenArr False sortedVals l (GenStrInfo val) _) _ gen =
   let (v, gen') = generateIntegral l gen
       len = read (T.unpack v) :: Int
diff --git a/core/Core/Judge/Exact.hs b/core/Core/Judge/Exact.hs
index 0e166ede..786ce3ee 100644
--- a/core/Core/Judge/Exact.hs
+++ b/core/Core/Judge/Exact.hs
@@ -3,13 +3,31 @@
 module Core.Judge.Exact where
 
 import Core.Judge.Class
+import Data.Aeson (Value (..), decode)
+import Data.Aeson qualified as Aeson
+import Data.ByteString.Lazy.Char8 qualified as BS
+import Data.Text qualified as T
 
 data Exact = Exact
 
 instance Judge Exact where
   judge _ expected actual =
-    if expected == actual
-      then
-        Pass
-      else
-        Fail ("Expected: " <> expected <> " Got: " <> actual)
+    case compareJson expected actual of
+      Just True -> Pass
+      _ -> case (expected == actual, compareString expected actual) of
+        (True, _) -> Pass
+        (_, Just True) -> Pass
+        _ -> Fail ("Expected: " <> expected <> " Got: " <> actual)
+
+compareJson :: T.Text -> T.Text -> Maybe Bool
+compareJson expected actual =
+  case (decode (BS.pack (T.unpack expected)) :: Maybe Value, decode (BS.pack (T.unpack actual)) :: Maybe Value) of
+    (Just e, Just a) -> Just (e == a)
+    _ -> Nothing
+
+compareString :: T.Text -> T.Text -> Maybe Bool
+compareString expected actual =
+  case (decode (BS.pack (T.unpack expected)) :: Maybe Value, decode (BS.pack (T.unpack actual)) :: Maybe Value) of
+    (Nothing, Just (Aeson.String s)) -> Just (expected == s)
+    (Just (Aeson.String s), Nothing) -> Just (actual == s)
+    _ -> Nothing
diff --git a/core/Core/Test/Runner.hs b/core/Core/Test/Runner.hs
index 50fa600e..6e6d4767 100644
--- a/core/Core/Test/Runner.hs
+++ b/core/Core/Test/Runner.hs
@@ -13,12 +13,17 @@ import Core.Judge.IgnoreOrder qualified as ITypes
 import Core.Test.Converter (toGenInfo)
 import Core.Test.Types qualified as Types
 import Core.Types
+import Data.Aeson (Value (..), decodeStrictText, encode, object, (.=))
+import Data.Aeson.Key qualified as K
+import Data.ByteString.Lazy qualified as BL
 import Data.Either (fromRight)
 import Data.List qualified
 import Data.Map qualified as M
 import Data.Maybe (fromJust, fromMaybe)
 import Data.Text (Text)
 import Data.Text qualified as T
+import Data.Text.Encoding qualified as TE
+import Data.Vector qualified as V
 
 data TestResult = Pass Int | WA (Maybe Text) Text Text | TLE Text | RE Text Text | Internal Text deriving (Show, Eq)
 
@@ -28,6 +33,8 @@ data PreparedCase = PreparedCase
   { pcIdx :: Int,
     pcJudge :: AnyJudge,
     pcExpected :: Maybe Text,
+    pcPrelude :: [Text],
+    pcJsonInputs :: M.Map Text Value,
     pcMainCall :: Text,
     pcOracleCall :: Maybe Text
   }
@@ -91,23 +98,20 @@ prepareCase gen batch sSeed suite idx test =
       splitIn (var, Types.InCase c) (cs, ks, gs) = ((var, c) : cs, ks, gs)
       splitIn (var, Types.InGenerated gd) (cs, ks, gs) = (cs, ks, (var, gd) : gs)
       splitIn (var, Types.InConst d) (cs, ks, gs) = (cs, (var, d) : ks, gs)
+      entryParams =
+        case Types.teParams (Types.tsEntry suite) of
+          Just params -> params
+          Nothing -> error "entry.params is required"
       generateField renderLang (var, gData) =
         let gInfo = toGenInfo gData
             genData = GenData seed gInfo renderLang
-         in (var, generate gen genData)
-      genResults = map (generateField lang) inGens
+            rendered = generate gen genData
+         in ( var,
+              if renderLang == Python3
+                then wrapOracleGenerated (fromJust (M.lookup var entryParams)) rendered
+                else rendered
+            )
       oracleGenResults = map (generateField Python3) inGens
-      constResults =
-        map
-          ( \(var, d) ->
-              let rendered = renderConst lang d
-                  prepared =
-                    if expectsRustOptionList lang callStr var
-                      then wrapRustOptionList rendered
-                      else rendered
-               in (var, prepared)
-          )
-          inConsts
       oracleConstResults = map (\(var, d) -> (var, renderConst Python3 d)) inConsts
       callStr = case Types.tcCall test of
         Just call -> fromJust (M.lookup lang call)
@@ -123,7 +127,9 @@ prepareCase gen batch sSeed suite idx test =
               )
               afterConst
               cases
-      mainCall = buildCall lang callStr genResults constResults inCases
+      mainCall = foldl (\acc (var, _) -> T.replace ("{" <> var <> "}") (jsonVarName idx var) acc) callStr (M.toList entryParams)
+      jsonInputs = buildJsonInputs gen seed entryParams test
+      prelude = buildParamPrelude lang idx entryParams
       oracleCall =
         case Types.tcOut test of
           Just _ -> Nothing
@@ -138,6 +144,8 @@ prepareCase gen batch sSeed suite idx test =
           pcExpected = case Types.tcOut test of
             Just (Types.OutCase expected) -> Just expected
             Nothing -> Nothing,
+          pcPrelude = prelude,
+          pcJsonInputs = jsonInputs,
           pcMainCall = mainCall,
           pcOracleCall = oracleCall
         }
@@ -156,6 +164,7 @@ runMainBatch exec batch suite cases = do
       ( C.ExecRequest
           { C.language = sbLang batch,
             C.content = buildMainProgram batch cases,
+            C.files = buildMainFiles cases,
             C.runTimeout = Just batchTimeoutMs,
             C.runMemoryLimit = Just (Types.tlMemoryMb (Types.tsLimits suite))
           }
@@ -185,6 +194,7 @@ runOracleBatch exec _ batch suite cases mainOutputs =
           ( C.ExecRequest
               { C.language = Python3,
                 C.content = oracleProgram,
+                C.files = buildMainFiles cases,
                 C.runTimeout = Just batchTimeoutMs,
                 C.runMemoryLimit = Nothing
               }
@@ -225,32 +235,55 @@ buildMainProgram :: SolutionBatch -> [PreparedCase] -> Text
 buildMainProgram batch cases =
   buildProgramTemplate (sbLang batch) (entryMain batch) (solution batch) (utilities batch) snippets
   where
-    snippets = map (\pc -> buildMainSnippet (sbLang batch) (pcIdx pc) (pcMainCall pc)) cases
+    snippets = map (\pc -> buildMainSnippet (sbLang batch) (pcIdx pc) (pcPrelude pc) (pcMainCall pc)) cases
 
 buildOracleProgram :: SolutionBatch -> Types.TestOracleEntry -> [PreparedCase] -> M.Map Int MainCaseOutput -> Text
 buildOracleProgram batch oracleSolution cases mainOutputs =
   T.unlines $
-    [ "import datetime as _dt",
+    [ "import sys",
+      "import time as _time",
+      "import math",
+      "import heapq",
+      "import bisect",
+      "import itertools",
+      "import collections",
+      "import json",
+      "import datetime as _dt",
       "from dataclasses import is_dataclass, asdict",
       "from typing import *",
+      "from functools import *",
+      "from collections import *",
+      "from heapq import *",
+      "from bisect import *",
       python3Utilities batch,
       "",
+      "with open(\"test.json\", \"r\", encoding=\"utf-8\") as _f:",
+      "    _TEST_ = json.load(_f)",
+      "",
       Types.checker oracleSolution
     ]
       ++ map buildSnippet cases
   where
     buildSnippet pc =
       let resultLiteral =
-            case M.lookup (pcIdx pc) mainOutputs of
-              Just out -> T.pack (show (T.unpack (T.strip (mcoResult out))))
-              Nothing -> "\"\""
+            "json.loads("
+              <> T.pack (show (T.unpack (mcoResult (fromJust (M.lookup (pcIdx pc) mainOutputs)))))
+              <> ")"
           callExpr =
             T.replace "{result}" resultLiteral $
               fromJust (pcOracleCall pc)
        in T.unlines
-            [ "print(" <> T.pack (show (T.unpack (marker (pcIdx pc)))) <> ")",
-              "print(to_json(" <> callExpr <> "))"
-            ]
+            ( ["_case_" <> suffix <> " = _TEST_[" <> T.pack (show (show (pcIdx pc))) <> "]"]
+                ++ map (renderOracleBinding suffix) (M.keys (pcJsonInputs pc))
+                ++ [ "print(" <> T.pack (show (T.unpack (marker (pcIdx pc)))) <> ")",
+                     "print(to_json(" <> callExpr <> "))"
+                   ]
+            )
+      where
+        suffix = T.pack (show (pcIdx pc))
+
+    renderOracleBinding suffix var =
+      var <> " = _case_" <> suffix <> "[" <> T.pack (show (T.unpack var)) <> "][\"val\"]"
 
 buildProgramTemplate :: Language -> Text -> Text -> Text -> [Text] -> Text
 buildProgramTemplate lang template rawSolution runtimeUtilities snippets =
@@ -266,114 +299,136 @@ buildProgramTemplate lang template rawSolution runtimeUtilities snippets =
       withRuntime = T.replace "${UTILITIES}" runtimeUtilities withCall
    in T.replace "${SOLUTION}" userSolution withRuntime
 
-buildMainSnippet :: Language -> Int -> Text -> Text
-buildMainSnippet lang idx callExpr =
+buildMainSnippet :: Language -> Int -> [Text] -> Text -> Text
+buildMainSnippet lang idx prelude callExpr =
   case lang of
     Python3 -> pythonSnippet
     Python2 -> pythonSnippet
     Go ->
       T.unlines
-        [ "fmt.Println(" <> quotedMarker <> ")",
-          "cur" <> suffix <> " := time.Now().UnixNano() / 1_000_000",
-          "a" <> suffix <> " := " <> callExpr,
-          "now" <> suffix <> " := time.Now().UnixNano() / 1_000_000",
-          "fmt.Println(now" <> suffix <> " - cur" <> suffix <> ")",
-          "fmt.Println(toJson(a" <> suffix <> "))"
-        ]
+        ( ["fmt.Println(" <> quotedMarker <> ")"]
+            ++ prelude
+            ++ [ "cur" <> suffix <> " := time.Now().UnixNano() / 1_000_000",
+                 "a" <> suffix <> " := " <> callExpr,
+                 "now" <> suffix <> " := time.Now().UnixNano() / 1_000_000",
+                 "fmt.Println(now" <> suffix <> " - cur" <> suffix <> ")",
+                 "fmt.Println(toJson(a" <> suffix <> "))"
+               ]
+        )
     TypeScript ->
       T.unlines
-        [ "console.log(" <> quotedMarker <> ");",
-          "const _start" <> suffix <> " = Date.now();",
-          "const _a" <> suffix <> " = " <> callExpr <> ";",
-          "const _end" <> suffix <> " = Date.now();",
-          "console.log(String(_end" <> suffix <> " - _start" <> suffix <> "));",
-          "console.log(toJson(_a" <> suffix <> "));"
-        ]
+        ( ["console.log(" <> quotedMarker <> ");"]
+            ++ prelude
+            ++ [ "const _start" <> suffix <> " = Date.now();",
+                 "const _a" <> suffix <> " = " <> callExpr <> ";",
+                 "const _end" <> suffix <> " = Date.now();",
+                 "console.log(String(_end" <> suffix <> " - _start" <> suffix <> "));",
+                 "console.log(toJson(_a" <> suffix <> "));"
+               ]
+        )
     Dart ->
       T.unlines
-        [ "print(" <> quotedMarker <> ");",
-          "final start" <> suffix <> " = Stopwatch()..start();",
-          "final a" <> suffix <> " = " <> callExpr <> ";",
-          "start" <> suffix <> ".stop();",
-          "print(start" <> suffix <> ".elapsedMilliseconds);",
-          "print(toJson(a" <> suffix <> "));"
-        ]
+        ( ["print(" <> quotedMarker <> ");"]
+            ++ prelude
+            ++ [ "final start" <> suffix <> " = Stopwatch()..start();",
+                 "final a" <> suffix <> " = " <> callExpr <> ";",
+                 "start" <> suffix <> ".stop();",
+                 "print(start" <> suffix <> ".elapsedMilliseconds);",
+                 "print(toJson(a" <> suffix <> "));"
+               ]
+        )
     Cpp ->
       T.unlines
-        [ "cout << " <> quotedMarker <> " << \"\\n\";",
-          "auto start" <> suffix <> " = chrono::steady_clock::now();",
-          "auto a" <> suffix <> " = " <> callExpr <> ";",
-          "auto end" <> suffix <> " = chrono::steady_clock::now();",
-          "cout << chrono::duration_cast<chrono::milliseconds>(end" <> suffix <> " - start" <> suffix <> ").count() << \"\\n\";",
-          "cout << toJson(a" <> suffix <> ") << \"\\n\";"
-        ]
+        ( ["cout << " <> quotedMarker <> " << \"\\n\";"]
+            ++ prelude
+            ++ [ "auto start" <> suffix <> " = chrono::steady_clock::now();",
+                 "auto a" <> suffix <> " = " <> callExpr <> ";",
+                 "auto end" <> suffix <> " = chrono::steady_clock::now();",
+                 "cout << chrono::duration_cast<chrono::milliseconds>(end" <> suffix <> " - start" <> suffix <> ").count() << \"\\n\";",
+                 "cout << toJson(a" <> suffix <> ") << \"\\n\";"
+               ]
+        )
     CSharp ->
       T.unlines
-        [ "Console.WriteLine(" <> quotedMarker <> ");",
-          "var sw" <> suffix <> " = Stopwatch.StartNew();",
-          "var a" <> suffix <> " = " <> callExpr <> ";",
-          "sw" <> suffix <> ".Stop();",
-          "Console.WriteLine(sw" <> suffix <> ".ElapsedMilliseconds);",
-          "Console.WriteLine(ToJson(a" <> suffix <> "));"
-        ]
+        ( ["Console.WriteLine(" <> quotedMarker <> ");"]
+            ++ prelude
+            ++ [ "var sw" <> suffix <> " = Stopwatch.StartNew();",
+                 "var a" <> suffix <> " = " <> callExpr <> ";",
+                 "sw" <> suffix <> ".Stop();",
+                 "Console.WriteLine(sw" <> suffix <> ".ElapsedMilliseconds);",
+                 "Console.WriteLine(ToJson(a" <> suffix <> "));"
+               ]
+        )
     Java ->
       T.unlines
-        [ "System.out.println(" <> quotedMarker <> ");",
-          "long cur" <> suffix <> " = System.currentTimeMillis();",
-          "var a" <> suffix <> " = " <> callExpr <> ";",
-          "long now" <> suffix <> " = System.currentTimeMillis();",
-          "System.out.println(now" <> suffix <> " - cur" <> suffix <> ");",
-          "System.out.println(Json.toJson(a" <> suffix <> "));"
-        ]
+        ( ["System.out.println(" <> quotedMarker <> ");"]
+            ++ prelude
+            ++ [ "long cur" <> suffix <> " = System.currentTimeMillis();",
+                 "var a" <> suffix <> " = " <> callExpr <> ";",
+                 "long now" <> suffix <> " = System.currentTimeMillis();",
+                 "System.out.println(now" <> suffix <> " - cur" <> suffix <> ");",
+                 "System.out.println(Json.toJson(a" <> suffix <> "));"
+               ]
+        )
     Kotlin ->
       T.unlines
-        [ "println(" <> quotedMarker <> ")",
-          "val cur" <> suffix <> " = System.currentTimeMillis()",
-          "val a" <> suffix <> " = " <> callExpr,
-          "val now" <> suffix <> " = System.currentTimeMillis()",
-          "println(now" <> suffix <> " - cur" <> suffix <> ")",
-          "println(Json.toJson(a" <> suffix <> "))"
-        ]
+        ( ["println(" <> quotedMarker <> ")"]
+            ++ prelude
+            ++ [ "val cur" <> suffix <> " = System.currentTimeMillis()",
+                 "val a" <> suffix <> " = " <> callExpr,
+                 "val now" <> suffix <> " = System.currentTimeMillis()",
+                 "println(now" <> suffix <> " - cur" <> suffix <> ")",
+                 "println(Json.toJson(a" <> suffix <> "))"
+               ]
+        )
     Rust ->
       T.unlines
-        [ "println!(\"" <> marker idx <> "\");",
-          "let start" <> suffix <> " = Instant::now();",
-          "let result" <> suffix <> " = " <> callExpr <> ";",
-          "let duration" <> suffix <> " = start" <> suffix <> ".elapsed();",
-          "println!(\"{}\", duration" <> suffix <> ".as_millis());",
-          "println!(\"{}\", to_json(&result" <> suffix <> "));"
-        ]
+        ( ["println!(\"" <> marker idx <> "\");"]
+            ++ prelude
+            ++ [ "let start" <> suffix <> " = Instant::now();",
+                 "let result" <> suffix <> " = " <> callExpr <> ";",
+                 "let duration" <> suffix <> " = start" <> suffix <> ".elapsed();",
+                 "println!(\"{}\", duration" <> suffix <> ".as_millis());",
+                 "println!(\"{}\", to_json(&result" <> suffix <> "));"
+               ]
+        )
     Ruby ->
       T.unlines
-        [ "puts " <> quotedMarker,
-          "start" <> suffix <> " = (Time.now.to_f * 1000).to_i",
-          "a" <> suffix <> " = " <> callExpr,
-          "finish" <> suffix <> " = (Time.now.to_f * 1000).to_i",
-          "puts(finish" <> suffix <> " - start" <> suffix <> ")",
-          "puts to_json(a" <> suffix <> ")"
-        ]
+        ( ["puts " <> quotedMarker]
+            ++ prelude
+            ++ [ "start" <> suffix <> " = (Time.now.to_f * 1000).to_i",
+                 "a" <> suffix <> " = " <> callExpr,
+                 "finish" <> suffix <> " = (Time.now.to_f * 1000).to_i",
+                 "puts(finish" <> suffix <> " - start" <> suffix <> ")",
+                 "puts to_json(a" <> suffix <> ")"
+               ]
+        )
     Swift ->
       T.unlines
-        [ "print(" <> quotedMarker <> ")",
-          "let start" <> suffix <> " = Int(Date().timeIntervalSince1970 * 1000)",
-          "let result" <> suffix <> " = " <> callExpr,
-          "let end" <> suffix <> " = Int(Date().timeIntervalSince1970 * 1000)",
-          "print(end" <> suffix <> " - start" <> suffix <> ")",
-          "print(toJson(result" <> suffix <> "))"
-        ]
+        ( ["print(" <> quotedMarker <> ")"]
+            ++ prelude
+            ++ [ "let start" <> suffix <> " = Int(Date().timeIntervalSince1970 * 1000)",
+                 "let result" <> suffix <> " = " <> callExpr,
+                 "let end" <> suffix <> " = Int(Date().timeIntervalSince1970 * 1000)",
+                 "print(end" <> suffix <> " - start" <> suffix <> ")",
+                 "print(toJson(result" <> suffix <> "))"
+               ]
+        )
     Default -> error "Unsupported"
   where
     suffix = T.pack (show idx)
     quotedMarker = T.pack (show (T.unpack (marker idx)))
     pythonSnippet =
       T.unlines
-        [ "print(" <> quotedMarker <> ")",
-          "_start_" <> suffix <> " = int(" <> pythonTimeExpr <> " * 1000)",
-          "_a_" <> suffix <> " = " <> callExpr,
-          "_end_" <> suffix <> " = int(" <> pythonTimeExpr <> " * 1000)",
-          "print(_end_" <> suffix <> " - _start_" <> suffix <> ")",
-          "print(to_json(_a_" <> suffix <> "))"
-        ]
+        ( ["print(" <> quotedMarker <> ")"]
+            ++ prelude
+            ++ [ "_start_" <> suffix <> " = int(" <> pythonTimeExpr <> " * 1000)",
+                 "_a_" <> suffix <> " = " <> callExpr,
+                 "_end_" <> suffix <> " = int(" <> pythonTimeExpr <> " * 1000)",
+                 "print(_end_" <> suffix <> " - _start_" <> suffix <> ")",
+                 "print(to_json(_a_" <> suffix <> "))"
+               ]
+        )
     pythonTimeExpr =
       case lang of
         Python2 -> "_time.time()"
@@ -438,6 +493,657 @@ marker idx = "SOL_CASE_" <> T.pack (show idx)
 batchTimeoutMs :: Int
 batchTimeoutMs = 15000
 
+buildMainStdin :: [PreparedCase] -> Maybe Text
+buildMainStdin cases =
+  let payload =
+        object
+          [ K.fromText (T.pack (show (pcIdx pc)))
+              .= object
+                [ K.fromText name .= object ["val" .= val]
+                | (name, val) <- M.toList (pcJsonInputs pc)
+                ]
+          | pc <- cases
+          ]
+   in Just (TE.decodeUtf8 (BL.toStrict (encode payload)))
+
+buildMainFiles :: [PreparedCase] -> [C.ExecFile]
+buildMainFiles cases =
+  case buildMainStdin cases of
+    Just payload -> [C.ExecFile "test.json" payload]
+    Nothing -> []
+
+buildJsonInputs :: (Generator g) => g -> Int -> M.Map Text Types.TestParams -> Types.TestCase -> M.Map Text Value
+buildJsonInputs gen seed params test =
+  M.fromList
+    [ (var, inputToJson gen seed schema inputData)
+    | (var, inputData) <- Types.tcIn test,
+      let schema = fromJust (M.lookup var params)
+    ]
+
+inputToJson :: (Generator g) => g -> Int -> Types.TestParams -> Types.TestCaseInData -> Value
+inputToJson _ _ schema (Types.InCase t) =
+  case Types.tpaType schema of
+    Types.TPTString -> String t
+    Types.TPTChar -> String t
+    _ -> textToJsonValue t
+inputToJson _ _ _ (Types.InConst d) = generatedInDataToJson d
+inputToJson gen seed schema (Types.InGenerated gd) = generatedInputToJson gen seed schema gd
+
+generatedInputToJson :: (Generator g) => g -> Int -> Types.TestParams -> Types.GeneratedInData -> Value
+generatedInputToJson gen seed schema gd =
+  let rendered = generate gen (GenData seed (toGenInfo gd) Python3)
+   in parseGeneratedRendered schema rendered
+
+parseGeneratedRendered :: Types.TestParams -> Text -> Value
+parseGeneratedRendered schema rendered =
+  case Types.tpaType schema of
+    Types.TPTInt -> textToJsonValue rendered
+    Types.TPTLong -> textToJsonValue rendered
+    Types.TPTDouble -> textToJsonValue rendered
+    Types.TPTFloat -> textToJsonValue rendered
+    Types.TPTBool ->
+      case rendered of
+        "True" -> Bool True
+        "False" -> Bool False
+        _ -> error "Unsupported generated bool value"
+    Types.TPTString -> jsonStringValue rendered
+    Types.TPTChar -> jsonStringValue rendered
+    Types.TPTArray ->
+      case Types.tpaItems schema of
+        Just items@(Types.TestParams Types.TPTChar _) ->
+          Array $ V.fromList $ map (parseGeneratedRendered items) (splitTopLevelItems rendered)
+        Just items@(Types.TestParams Types.TPTArray _) ->
+          Array $
+            V.fromList $
+              map
+                (parseGeneratedRendered items . stripOuterBrackets)
+                (splitTopLevelItems rendered)
+        _ -> textToJsonValue ("[" <> rendered <> "]")
+    Types.TPTListNode -> textToJsonValue ("[" <> rendered <> "]")
+    Types.TPTTreeNode -> textToJsonValue ("[" <> rendered <> "]")
+
+splitTopLevelItems :: Text -> [Text]
+splitTopLevelItems raw = go 0 T.empty [] (T.unpack raw)
+  where
+    go _ current acc [] =
+      let item = T.strip current
+       in reverse (if T.null item then acc else item : acc)
+    go depth current acc (c : cs)
+      | c == '[' = go (depth + 1) (T.snoc current c) acc cs
+      | c == ']' = go (depth - 1) (T.snoc current c) acc cs
+      | c == ',' && depth == 0 =
+          let item = T.strip current
+              acc' = if T.null item then acc else item : acc
+           in go depth T.empty acc' cs
+      | otherwise = go depth (T.snoc current c) acc cs
+
+stripOuterBrackets :: Text -> Text
+stripOuterBrackets t =
+  let s = T.strip t
+   in fromMaybe s $ do
+        rest <- T.stripPrefix "[" s
+        inner <- T.stripSuffix "]" rest
+        pure (T.strip inner)
+
+jsonStringValue :: Text -> Value
+jsonStringValue raw =
+  case decodeStrictText raw of
+    Just (String s) -> String s
+    _ -> String raw
+
+jsonVarName :: Int -> Text -> Text
+jsonVarName idx var = "_" <> var <> "_" <> T.pack (show idx)
+
+jsonAccessorJava :: Int -> Text -> Text
+jsonAccessorJava idx name = "_TEST_.get(\"" <> T.pack (show idx) <> "\").get(\"" <> name <> "\").val"
+
+jsonAccessorCpp :: Int -> Text -> Text
+jsonAccessorCpp idx name = "_TEST_DATA_[\"" <> T.pack (show idx) <> "\"][\"" <> name <> "\"].val"
+
+jsonAccessorCSharp :: Int -> Text -> Text
+jsonAccessorCSharp idx name = "_TestVal(\"" <> T.pack (show idx) <> "\", \"" <> name <> "\")"
+
+jsonAccessorPython :: Int -> Text -> Text
+jsonAccessorPython idx name = "_test_val(\"" <> T.pack (show idx) <> "\", \"" <> name <> "\")"
+
+jsonAccessorRuby :: Int -> Text -> Text
+jsonAccessorRuby idx name = "_test_val(\"" <> T.pack (show idx) <> "\", \"" <> name <> "\")"
+
+jsonAccessorGo :: Int -> Text -> Text
+jsonAccessorGo idx name = "testVal(\"" <> T.pack (show idx) <> "\", \"" <> name <> "\")"
+
+jsonAccessorTypeScript :: Int -> Text -> Text
+jsonAccessorTypeScript idx name = "testVal(\"" <> T.pack (show idx) <> "\", \"" <> name <> "\")"
+
+jsonAccessorDart :: Int -> Text -> Text
+jsonAccessorDart idx name = "testVal(\"" <> T.pack (show idx) <> "\", \"" <> name <> "\")"
+
+jsonAccessorSwift :: Int -> Text -> Text
+jsonAccessorSwift idx name = "testVal(\"" <> T.pack (show idx) <> "\", \"" <> name <> "\")"
+
+jsonAccessorRust :: Int -> Text -> Text
+jsonAccessorRust idx name = "_TEST_.get(\"" <> T.pack (show idx) <> "\").unwrap().get(\"" <> name <> "\").unwrap().val.clone()"
+
+jsonAccessorKotlin :: Int -> Text -> Text
+jsonAccessorKotlin idx name = "testVal(\"" <> T.pack (show idx) <> "\", \"" <> name <> "\")"
+
+buildParamPrelude :: Language -> Int -> M.Map Text Types.TestParams -> [Text]
+buildParamPrelude lang idx params = map (\(name, p) -> renderParamDecl lang idx name p) (M.toList params)
+
+renderParamDecl :: Language -> Int -> Text -> Types.TestParams -> Text
+renderParamDecl Java idx name params = renderJavaDecl (jsonVarName idx name) (jsonAccessorJava idx name) params
+renderParamDecl Cpp idx name params = renderCppDecl (jsonVarName idx name) (jsonAccessorCpp idx name) params
+renderParamDecl CSharp idx name params = renderCSharpDecl (jsonVarName idx name) (jsonAccessorCSharp idx name) params
+renderParamDecl Python3 idx name params = renderPythonDecl (jsonVarName idx name) (jsonAccessorPython idx name) params
+renderParamDecl Python2 idx name params = renderPythonDecl (jsonVarName idx name) (jsonAccessorPython idx name) params
+renderParamDecl Ruby idx name params = renderRubyDecl (jsonVarName idx name) (jsonAccessorRuby idx name) params
+renderParamDecl Go idx name params = renderGoDecl (jsonVarName idx name) (jsonAccessorGo idx name) params
+renderParamDecl TypeScript idx name params = renderTypeScriptDecl (jsonVarName idx name) (jsonAccessorTypeScript idx name) params
+renderParamDecl Dart idx name params = renderDartDecl (jsonVarName idx name) (jsonAccessorDart idx name) params
+renderParamDecl Swift idx name params = renderSwiftDecl (jsonVarName idx name) (jsonAccessorSwift idx name) params
+renderParamDecl Rust idx name params = renderRustDecl (jsonVarName idx name) (jsonAccessorRust idx name) params
+renderParamDecl Kotlin idx name params = renderKotlinDecl (jsonVarName idx name) (jsonAccessorKotlin idx name) params
+renderParamDecl _ _ _ _ = error "Unsupported language for json params"
+
+renderJavaDecl :: Text -> Text -> Types.TestParams -> Text
+renderJavaDecl name accessor params = javaType params <> " " <> name <> " = " <> javaExpr accessor params <> ";"
+
+javaType :: Types.TestParams -> Text
+javaType (Types.TestParams Types.TPTInt _) = "int"
+javaType (Types.TestParams Types.TPTLong _) = "long"
+javaType (Types.TestParams Types.TPTDouble _) = "double"
+javaType (Types.TestParams Types.TPTFloat _) = "float"
+javaType (Types.TestParams Types.TPTString _) = "String"
+javaType (Types.TestParams Types.TPTChar _) = "char"
+javaType (Types.TestParams Types.TPTBool _) = "boolean"
+javaType (Types.TestParams Types.TPTArray (Just items)) = javaType items <> "[]"
+javaType (Types.TestParams Types.TPTListNode _) = "ListNode"
+javaType (Types.TestParams Types.TPTTreeNode _) = "TreeNode"
+javaType _ = error "Unsupported java param type"
+
+javaExpr :: Text -> Types.TestParams -> Text
+javaExpr accessor (Types.TestParams Types.TPTInt _) = "Json.toInt(" <> accessor <> ")"
+javaExpr accessor (Types.TestParams Types.TPTLong _) = "Json.toLong(" <> accessor <> ")"
+javaExpr accessor (Types.TestParams Types.TPTDouble _) = "Json.toDouble(" <> accessor <> ")"
+javaExpr accessor (Types.TestParams Types.TPTFloat _) = "Json.toFloat(" <> accessor <> ")"
+javaExpr accessor (Types.TestParams Types.TPTString _) = "Json.toStringValue(" <> accessor <> ")"
+javaExpr accessor (Types.TestParams Types.TPTChar _) = "Json.toChar(" <> accessor <> ")"
+javaExpr accessor (Types.TestParams Types.TPTBool _) = "Json.toBool(" <> accessor <> ")"
+javaExpr accessor (Types.TestParams Types.TPTArray (Just items)) =
+  case Types.tpaType items of
+    Types.TPTInt -> "Json.toIntArray(" <> accessor <> ")"
+    Types.TPTLong -> "Json.toLongArray(" <> accessor <> ")"
+    Types.TPTDouble -> "Json.toDoubleArray(" <> accessor <> ")"
+    Types.TPTFloat -> "Json.toFloatArray(" <> accessor <> ")"
+    Types.TPTString -> "Json.toStringArray(" <> accessor <> ")"
+    Types.TPTChar -> "Json.toCharArray(" <> accessor <> ")"
+    Types.TPTBool -> "Json.toBoolArray(" <> accessor <> ")"
+    Types.TPTArray ->
+      case fmap Types.tpaType (Types.tpaItems items) of
+        Just Types.TPTInt -> "Json.toIntMatrix(" <> accessor <> ")"
+        Just Types.TPTLong -> "Json.toLongMatrix(" <> accessor <> ")"
+        Just Types.TPTDouble -> "Json.toDoubleMatrix(" <> accessor <> ")"
+        Just Types.TPTFloat -> "Json.toFloatMatrix(" <> accessor <> ")"
+        Just Types.TPTString -> "Json.toStringMatrix(" <> accessor <> ")"
+        Just Types.TPTChar -> "Json.toCharMatrix(" <> accessor <> ")"
+        Just Types.TPTBool -> "Json.toBoolMatrix(" <> accessor <> ")"
+        _ -> error "Unsupported java nested array type"
+    _ -> error "Unsupported java array item type"
+javaExpr accessor (Types.TestParams Types.TPTListNode _) = "ListNode.toListNode(Json.toIntArray(" <> accessor <> "))"
+javaExpr accessor (Types.TestParams Types.TPTTreeNode _) = "TreeNode.toTreeNode(Json.toIntegerArray(" <> accessor <> "))"
+javaExpr _ _ = error "Unsupported java param type"
+
+renderCppDecl :: Text -> Text -> Types.TestParams -> Text
+renderCppDecl name accessor params = cppType params <> " " <> name <> " = " <> cppExpr accessor params <> ";"
+
+cppType :: Types.TestParams -> Text
+cppType (Types.TestParams Types.TPTInt _) = "int"
+cppType (Types.TestParams Types.TPTLong _) = "long long"
+cppType (Types.TestParams Types.TPTDouble _) = "double"
+cppType (Types.TestParams Types.TPTFloat _) = "float"
+cppType (Types.TestParams Types.TPTString _) = "string"
+cppType (Types.TestParams Types.TPTChar _) = "char"
+cppType (Types.TestParams Types.TPTBool _) = "bool"
+cppType (Types.TestParams Types.TPTArray (Just items)) = "vector<" <> cppInnerType items <> ">"
+cppType (Types.TestParams Types.TPTListNode _) = "ListNode*"
+cppType (Types.TestParams Types.TPTTreeNode _) = "TreeNode*"
+cppType _ = error "Unsupported cpp param type"
+
+cppInnerType :: Types.TestParams -> Text
+cppInnerType (Types.TestParams Types.TPTInt _) = "int"
+cppInnerType (Types.TestParams Types.TPTLong _) = "long long"
+cppInnerType (Types.TestParams Types.TPTDouble _) = "double"
+cppInnerType (Types.TestParams Types.TPTFloat _) = "float"
+cppInnerType (Types.TestParams Types.TPTString _) = "string"
+cppInnerType (Types.TestParams Types.TPTChar _) = "char"
+cppInnerType (Types.TestParams Types.TPTBool _) = "bool"
+cppInnerType (Types.TestParams Types.TPTArray (Just items)) = "vector<" <> cppInnerType items <> ">"
+cppInnerType _ = error "Unsupported cpp inner type"
+
+cppExpr :: Text -> Types.TestParams -> Text
+cppExpr accessor (Types.TestParams Types.TPTInt _) = "jsonToInt(" <> accessor <> ")"
+cppExpr accessor (Types.TestParams Types.TPTLong _) = "jsonToLong(" <> accessor <> ")"
+cppExpr accessor (Types.TestParams Types.TPTDouble _) = "jsonToDouble(" <> accessor <> ")"
+cppExpr accessor (Types.TestParams Types.TPTFloat _) = "jsonToFloat(" <> accessor <> ")"
+cppExpr accessor (Types.TestParams Types.TPTString _) = "jsonToString(" <> accessor <> ")"
+cppExpr accessor (Types.TestParams Types.TPTChar _) = "jsonToChar(" <> accessor <> ")"
+cppExpr accessor (Types.TestParams Types.TPTBool _) = "jsonToBool(" <> accessor <> ")"
+cppExpr accessor (Types.TestParams Types.TPTArray (Just items)) =
+  case Types.tpaType items of
+    Types.TPTInt -> "jsonToIntArray(" <> accessor <> ")"
+    Types.TPTLong -> "jsonToLongArray(" <> accessor <> ")"
+    Types.TPTDouble -> "jsonToDoubleArray(" <> accessor <> ")"
+    Types.TPTFloat -> "jsonToFloatArray(" <> accessor <> ")"
+    Types.TPTString -> "jsonToStringArray(" <> accessor <> ")"
+    Types.TPTBool -> "jsonToBoolArray(" <> accessor <> ")"
+    Types.TPTChar -> "jsonToCharArray(" <> accessor <> ")"
+    Types.TPTArray ->
+      case fmap Types.tpaType (Types.tpaItems items) of
+        Just Types.TPTInt -> "jsonToIntMatrix(" <> accessor <> ")"
+        Just Types.TPTLong -> "jsonToLongMatrix(" <> accessor <> ")"
+        Just Types.TPTDouble -> "jsonToDoubleMatrix(" <> accessor <> ")"
+        Just Types.TPTFloat -> "jsonToFloatMatrix(" <> accessor <> ")"
+        Just Types.TPTString -> "jsonToStringMatrix(" <> accessor <> ")"
+        Just Types.TPTBool -> "jsonToBoolMatrix(" <> accessor <> ")"
+        Just Types.TPTChar -> "jsonToCharMatrix(" <> accessor <> ")"
+        _ -> error "Unsupported cpp nested array type"
+    _ -> error "Unsupported cpp array item type"
+cppExpr accessor (Types.TestParams Types.TPTListNode _) = "toListNode(jsonToIntArray(" <> accessor <> "))"
+cppExpr accessor (Types.TestParams Types.TPTTreeNode _) = "toTreeNode(jsonToOptionalIntArray(" <> accessor <> "))"
+cppExpr _ _ = error "Unsupported cpp param type"
+
+renderCSharpDecl :: Text -> Text -> Types.TestParams -> Text
+renderCSharpDecl name accessor params = csharpType params <> " " <> name <> " = " <> csharpExpr accessor params <> ";"
+
+csharpType :: Types.TestParams -> Text
+csharpType (Types.TestParams Types.TPTInt _) = "int"
+csharpType (Types.TestParams Types.TPTLong _) = "long"
+csharpType (Types.TestParams Types.TPTDouble _) = "double"
+csharpType (Types.TestParams Types.TPTFloat _) = "float"
+csharpType (Types.TestParams Types.TPTString _) = "string"
+csharpType (Types.TestParams Types.TPTChar _) = "char"
+csharpType (Types.TestParams Types.TPTBool _) = "bool"
+csharpType (Types.TestParams Types.TPTArray (Just items)) = csharpType items <> "[]"
+csharpType (Types.TestParams Types.TPTListNode _) = "ListNode"
+csharpType (Types.TestParams Types.TPTTreeNode _) = "TreeNode"
+csharpType _ = error "Unsupported csharp param type"
+
+csharpExpr :: Text -> Types.TestParams -> Text
+csharpExpr accessor (Types.TestParams Types.TPTInt _) = "ToInt(" <> accessor <> ")"
+csharpExpr accessor (Types.TestParams Types.TPTLong _) = "ToLong(" <> accessor <> ")"
+csharpExpr accessor (Types.TestParams Types.TPTDouble _) = "ToDouble(" <> accessor <> ")"
+csharpExpr accessor (Types.TestParams Types.TPTFloat _) = "ToFloat(" <> accessor <> ")"
+csharpExpr accessor (Types.TestParams Types.TPTString _) = "ToStringValue(" <> accessor <> ")"
+csharpExpr accessor (Types.TestParams Types.TPTChar _) = "ToChar(" <> accessor <> ")"
+csharpExpr accessor (Types.TestParams Types.TPTBool _) = "ToBool(" <> accessor <> ")"
+csharpExpr accessor (Types.TestParams Types.TPTArray (Just items)) =
+  case Types.tpaType items of
+    Types.TPTInt -> "ToIntArray(" <> accessor <> ")"
+    Types.TPTLong -> "ToLongArray(" <> accessor <> ")"
+    Types.TPTDouble -> "ToDoubleArray(" <> accessor <> ")"
+    Types.TPTFloat -> "ToFloatArray(" <> accessor <> ")"
+    Types.TPTString -> "ToStringArray(" <> accessor <> ")"
+    Types.TPTChar -> "ToCharArray(" <> accessor <> ")"
+    Types.TPTBool -> "ToBoolArray(" <> accessor <> ")"
+    Types.TPTArray ->
+      case fmap Types.tpaType (Types.tpaItems items) of
+        Just Types.TPTInt -> "ToIntMatrix(" <> accessor <> ")"
+        Just Types.TPTLong -> "ToLongMatrix(" <> accessor <> ")"
+        Just Types.TPTDouble -> "ToDoubleMatrix(" <> accessor <> ")"
+        Just Types.TPTFloat -> "ToFloatMatrix(" <> accessor <> ")"
+        Just Types.TPTString -> "ToStringMatrix(" <> accessor <> ")"
+        Just Types.TPTChar -> "ToCharMatrix(" <> accessor <> ")"
+        Just Types.TPTBool -> "ToBoolMatrix(" <> accessor <> ")"
+        _ -> error "Unsupported csharp nested array type"
+    _ -> error "Unsupported csharp array item type"
+csharpExpr accessor (Types.TestParams Types.TPTListNode _) = "ListNode.ToListNode(ToIntArray(" <> accessor <> "))"
+csharpExpr accessor (Types.TestParams Types.TPTTreeNode _) = "TreeNode.ToTreeNode(ToNullableIntArray(" <> accessor <> "))"
+csharpExpr _ _ = error "Unsupported csharp param type"
+
+renderPythonDecl :: Text -> Text -> Types.TestParams -> Text
+renderPythonDecl name accessor params = name <> " = " <> pythonExpr accessor params
+
+pythonExpr :: Text -> Types.TestParams -> Text
+pythonExpr accessor (Types.TestParams Types.TPTListNode _) = "to_list_node(" <> accessor <> ")"
+pythonExpr accessor (Types.TestParams Types.TPTTreeNode _) = "to_tree_node(" <> accessor <> ")"
+pythonExpr accessor _ = accessor
+
+renderRubyDecl :: Text -> Text -> Types.TestParams -> Text
+renderRubyDecl name accessor params = name <> " = " <> rubyExpr accessor params
+
+rubyExpr :: Text -> Types.TestParams -> Text
+rubyExpr accessor (Types.TestParams Types.TPTListNode _) = "to_list_node(" <> accessor <> ")"
+rubyExpr accessor (Types.TestParams Types.TPTTreeNode _) = "to_tree_node(" <> accessor <> ")"
+rubyExpr accessor _ = accessor
+
+renderGoDecl :: Text -> Text -> Types.TestParams -> Text
+renderGoDecl name accessor params = name <> " := " <> goExpr accessor params
+
+goExpr :: Text -> Types.TestParams -> Text
+goExpr accessor (Types.TestParams Types.TPTInt _) = "toInt(" <> accessor <> ")"
+goExpr accessor (Types.TestParams Types.TPTLong _) = "toLongValue(" <> accessor <> ")"
+goExpr accessor (Types.TestParams Types.TPTDouble _) = "toFloat64Value(" <> accessor <> ")"
+goExpr accessor (Types.TestParams Types.TPTFloat _) = "float32(toFloat64Value(" <> accessor <> "))"
+goExpr accessor (Types.TestParams Types.TPTString _) = "toStringValue(" <> accessor <> ")"
+goExpr accessor (Types.TestParams Types.TPTChar _) = "toByteValue(" <> accessor <> ")"
+goExpr accessor (Types.TestParams Types.TPTBool _) = "toBoolValue(" <> accessor <> ")"
+goExpr accessor (Types.TestParams Types.TPTArray (Just items)) =
+  case Types.tpaType items of
+    Types.TPTInt -> "toIntArrayValue(" <> accessor <> ")"
+    Types.TPTLong -> "toLongArrayValue(" <> accessor <> ")"
+    Types.TPTDouble -> "toDoubleArrayValue(" <> accessor <> ")"
+    Types.TPTFloat -> "toFloatArrayValue(" <> accessor <> ")"
+    Types.TPTString -> "toStringArrayValue(" <> accessor <> ")"
+    Types.TPTChar -> "toByteArrayValue(" <> accessor <> ")"
+    Types.TPTBool -> "toBoolArrayValue(" <> accessor <> ")"
+    Types.TPTArray ->
+      case fmap Types.tpaType (Types.tpaItems items) of
+        Just Types.TPTInt -> "toIntMatrixValue(" <> accessor <> ")"
+        Just Types.TPTLong -> "toLongMatrixValue(" <> accessor <> ")"
+        Just Types.TPTDouble -> "toDoubleMatrixValue(" <> accessor <> ")"
+        Just Types.TPTFloat -> "toFloatMatrixValue(" <> accessor <> ")"
+        Just Types.TPTString -> "toStringMatrixValue(" <> accessor <> ")"
+        Just Types.TPTChar -> "toByteMatrixValue(" <> accessor <> ")"
+        Just Types.TPTBool -> "toBoolMatrixValue(" <> accessor <> ")"
+        _ -> error "Unsupported go nested array type"
+    _ -> error "Unsupported go array item type"
+goExpr accessor (Types.TestParams Types.TPTListNode _) = "toListNode(toIntArrayValue(" <> accessor <> "))"
+goExpr accessor (Types.TestParams Types.TPTTreeNode _) = "toTreeNode(toInterfaceArrayValue(" <> accessor <> "))"
+goExpr _ _ = error "Unsupported go param type"
+
+renderTypeScriptDecl :: Text -> Text -> Types.TestParams -> Text
+renderTypeScriptDecl name accessor params = "const " <> name <> " = " <> typeScriptExpr accessor params <> ";"
+
+typeScriptExpr :: Text -> Types.TestParams -> Text
+typeScriptExpr accessor (Types.TestParams Types.TPTInt _) = "Number(" <> accessor <> ")"
+typeScriptExpr accessor (Types.TestParams Types.TPTLong _) = "Number(" <> accessor <> ")"
+typeScriptExpr accessor (Types.TestParams Types.TPTDouble _) = "Number(" <> accessor <> ")"
+typeScriptExpr accessor (Types.TestParams Types.TPTFloat _) = "Number(" <> accessor <> ")"
+typeScriptExpr accessor (Types.TestParams Types.TPTString _) = "String(" <> accessor <> ")"
+typeScriptExpr accessor (Types.TestParams Types.TPTChar _) = "String(" <> accessor <> ")"
+typeScriptExpr accessor (Types.TestParams Types.TPTBool _) = "Boolean(" <> accessor <> ")"
+typeScriptExpr accessor (Types.TestParams Types.TPTArray (Just items)) =
+  case Types.tpaType items of
+    Types.TPTInt -> accessor <> " as number[]"
+    Types.TPTLong -> accessor <> " as number[]"
+    Types.TPTDouble -> accessor <> " as number[]"
+    Types.TPTFloat -> accessor <> " as number[]"
+    Types.TPTString -> accessor <> " as string[]"
+    Types.TPTChar -> accessor <> " as string[]"
+    Types.TPTBool -> accessor <> " as boolean[]"
+    Types.TPTArray ->
+      case fmap Types.tpaType (Types.tpaItems items) of
+        Just Types.TPTInt -> accessor <> " as number[][]"
+        Just Types.TPTLong -> accessor <> " as number[][]"
+        Just Types.TPTDouble -> accessor <> " as number[][]"
+        Just Types.TPTFloat -> accessor <> " as number[][]"
+        Just Types.TPTString -> accessor <> " as string[][]"
+        Just Types.TPTChar -> accessor <> " as string[][]"
+        Just Types.TPTBool -> accessor <> " as boolean[][]"
+        _ -> error "Unsupported typescript nested array type"
+    _ -> error "Unsupported typescript array item type"
+typeScriptExpr accessor (Types.TestParams Types.TPTListNode _) = "toListNode(" <> accessor <> " as number[])"
+typeScriptExpr accessor (Types.TestParams Types.TPTTreeNode _) = "toTreeNode(" <> accessor <> " as (number | null)[])"
+typeScriptExpr _ _ = error "Unsupported typescript param type"
+
+renderDartDecl :: Text -> Text -> Types.TestParams -> Text
+renderDartDecl name accessor params = "final " <> name <> " = " <> dartExpr accessor params <> ";"
+
+dartExpr :: Text -> Types.TestParams -> Text
+dartExpr accessor (Types.TestParams Types.TPTInt _) = "toIntValue(" <> accessor <> ")"
+dartExpr accessor (Types.TestParams Types.TPTLong _) = "toIntValue(" <> accessor <> ")"
+dartExpr accessor (Types.TestParams Types.TPTDouble _) = "toDoubleValue(" <> accessor <> ")"
+dartExpr accessor (Types.TestParams Types.TPTFloat _) = "toDoubleValue(" <> accessor <> ").toDouble()"
+dartExpr accessor (Types.TestParams Types.TPTString _) = "toStringValue(" <> accessor <> ")"
+dartExpr accessor (Types.TestParams Types.TPTChar _) = "toStringValue(" <> accessor <> ")"
+dartExpr accessor (Types.TestParams Types.TPTBool _) = "toBoolValue(" <> accessor <> ")"
+dartExpr accessor (Types.TestParams Types.TPTArray (Just items)) =
+  case Types.tpaType items of
+    Types.TPTInt -> "toIntArrayValue(" <> accessor <> ")"
+    Types.TPTLong -> "toIntArrayValue(" <> accessor <> ")"
+    Types.TPTDouble -> "toDoubleArrayValue(" <> accessor <> ")"
+    Types.TPTFloat -> "toDoubleArrayValue(" <> accessor <> ")"
+    Types.TPTString -> "toStringArrayValue(" <> accessor <> ")"
+    Types.TPTChar -> "toStringArrayValue(" <> accessor <> ")"
+    Types.TPTBool -> "toBoolArrayValue(" <> accessor <> ")"
+    Types.TPTArray ->
+      case fmap Types.tpaType (Types.tpaItems items) of
+        Just Types.TPTInt -> "toIntMatrixValue(" <> accessor <> ")"
+        Just Types.TPTLong -> "toIntMatrixValue(" <> accessor <> ")"
+        Just Types.TPTDouble -> "toDoubleMatrixValue(" <> accessor <> ")"
+        Just Types.TPTFloat -> "toDoubleMatrixValue(" <> accessor <> ")"
+        Just Types.TPTString -> "toStringMatrixValue(" <> accessor <> ")"
+        Just Types.TPTChar -> "toStringMatrixValue(" <> accessor <> ")"
+        Just Types.TPTBool -> "toBoolMatrixValue(" <> accessor <> ")"
+        _ -> error "Unsupported dart nested array type"
+    _ -> error "Unsupported dart array item type"
+dartExpr accessor (Types.TestParams Types.TPTListNode _) = "to_list_node(toIntArrayValue(" <> accessor <> "))"
+dartExpr accessor (Types.TestParams Types.TPTTreeNode _) = "to_tree_node(toDynamicListValue(" <> accessor <> "))"
+dartExpr _ _ = error "Unsupported dart param type"
+
+renderSwiftDecl :: Text -> Text -> Types.TestParams -> Text
+renderSwiftDecl name accessor params = "let " <> name <> ": " <> swiftType params <> " = " <> swiftExpr accessor params
+
+swiftType :: Types.TestParams -> Text
+swiftType (Types.TestParams Types.TPTInt _) = "Int"
+swiftType (Types.TestParams Types.TPTLong _) = "Int"
+swiftType (Types.TestParams Types.TPTDouble _) = "Double"
+swiftType (Types.TestParams Types.TPTFloat _) = "Float"
+swiftType (Types.TestParams Types.TPTString _) = "String"
+swiftType (Types.TestParams Types.TPTChar _) = "Character"
+swiftType (Types.TestParams Types.TPTBool _) = "Bool"
+swiftType (Types.TestParams Types.TPTArray (Just items)) =
+  case Types.tpaType items of
+    Types.TPTInt -> "[Int]"
+    Types.TPTLong -> "[Int]"
+    Types.TPTDouble -> "[Double]"
+    Types.TPTFloat -> "[Float]"
+    Types.TPTString -> "[String]"
+    Types.TPTChar -> "[Character]"
+    Types.TPTBool -> "[Bool]"
+    Types.TPTArray ->
+      case fmap Types.tpaType (Types.tpaItems items) of
+        Just Types.TPTInt -> "[[Int]]"
+        Just Types.TPTLong -> "[[Int]]"
+        Just Types.TPTDouble -> "[[Double]]"
+        Just Types.TPTFloat -> "[[Float]]"
+        Just Types.TPTString -> "[[String]]"
+        Just Types.TPTChar -> "[[Character]]"
+        Just Types.TPTBool -> "[[Bool]]"
+        _ -> error "Unsupported swift nested array type"
+    _ -> error "Unsupported swift array item type"
+swiftType (Types.TestParams Types.TPTListNode _) = "ListNode?"
+swiftType (Types.TestParams Types.TPTTreeNode _) = "TreeNode?"
+swiftType _ = error "Unsupported swift param type"
+
+swiftExpr :: Text -> Types.TestParams -> Text
+swiftExpr accessor (Types.TestParams Types.TPTInt _) = "anyToInt(" <> accessor <> ")"
+swiftExpr accessor (Types.TestParams Types.TPTLong _) = "anyToInt(" <> accessor <> ")"
+swiftExpr accessor (Types.TestParams Types.TPTDouble _) = "anyToDouble(" <> accessor <> ")"
+swiftExpr accessor (Types.TestParams Types.TPTFloat _) = "anyToFloat(" <> accessor <> ")"
+swiftExpr accessor (Types.TestParams Types.TPTString _) = "anyToString(" <> accessor <> ")"
+swiftExpr accessor (Types.TestParams Types.TPTChar _) = "Character(anyToString(" <> accessor <> "))"
+swiftExpr accessor (Types.TestParams Types.TPTBool _) = "anyToBool(" <> accessor <> ")"
+swiftExpr accessor (Types.TestParams Types.TPTArray (Just items)) =
+  case Types.tpaType items of
+    Types.TPTInt -> "anyToIntArray(" <> accessor <> ")"
+    Types.TPTLong -> "anyToIntArray(" <> accessor <> ")"
+    Types.TPTDouble -> "anyToDoubleArray(" <> accessor <> ")"
+    Types.TPTFloat -> "anyToFloatArray(" <> accessor <> ")"
+    Types.TPTString -> "anyToStringArray(" <> accessor <> ")"
+    Types.TPTChar -> "anyToCharArray(" <> accessor <> ")"
+    Types.TPTBool -> "anyToBoolArray(" <> accessor <> ")"
+    Types.TPTArray ->
+      case fmap Types.tpaType (Types.tpaItems items) of
+        Just Types.TPTInt -> "anyToIntMatrix(" <> accessor <> ")"
+        Just Types.TPTLong -> "anyToIntMatrix(" <> accessor <> ")"
+        Just Types.TPTDouble -> "anyToDoubleMatrix(" <> accessor <> ")"
+        Just Types.TPTFloat -> "anyToFloatMatrix(" <> accessor <> ")"
+        Just Types.TPTString -> "anyToStringMatrix(" <> accessor <> ")"
+        Just Types.TPTChar -> "anyToCharMatrix(" <> accessor <> ")"
+        Just Types.TPTBool -> "anyToBoolMatrix(" <> accessor <> ")"
+        _ -> error "Unsupported swift nested array type"
+    _ -> error "Unsupported swift array item type"
+swiftExpr accessor (Types.TestParams Types.TPTListNode _) = "to_list_node(anyToIntArray(" <> accessor <> "))"
+swiftExpr accessor (Types.TestParams Types.TPTTreeNode _) = "to_tree_node(anyToOptionalIntArray(" <> accessor <> "))"
+swiftExpr _ _ = error "Unsupported swift param type"
+
+renderRustDecl :: Text -> Text -> Types.TestParams -> Text
+renderRustDecl name accessor params = "let " <> name <> ": " <> rustType params <> " = " <> rustExpr accessor params <> ";"
+
+rustType :: Types.TestParams -> Text
+rustType (Types.TestParams Types.TPTInt _) = "i32"
+rustType (Types.TestParams Types.TPTLong _) = "i64"
+rustType (Types.TestParams Types.TPTDouble _) = "f64"
+rustType (Types.TestParams Types.TPTFloat _) = "f32"
+rustType (Types.TestParams Types.TPTString _) = "String"
+rustType (Types.TestParams Types.TPTChar _) = "char"
+rustType (Types.TestParams Types.TPTBool _) = "bool"
+rustType (Types.TestParams Types.TPTArray (Just items)) =
+  case Types.tpaType items of
+    Types.TPTInt -> "Vec<i32>"
+    Types.TPTLong -> "Vec<i64>"
+    Types.TPTDouble -> "Vec<f64>"
+    Types.TPTFloat -> "Vec<f32>"
+    Types.TPTString -> "Vec<String>"
+    Types.TPTChar -> "Vec<char>"
+    Types.TPTBool -> "Vec<bool>"
+    Types.TPTArray ->
+      case fmap Types.tpaType (Types.tpaItems items) of
+        Just Types.TPTInt -> "Vec<Vec<i32>>"
+        Just Types.TPTLong -> "Vec<Vec<i64>>"
+        Just Types.TPTDouble -> "Vec<Vec<f64>>"
+        Just Types.TPTFloat -> "Vec<Vec<f32>>"
+        Just Types.TPTString -> "Vec<Vec<String>>"
+        Just Types.TPTChar -> "Vec<Vec<char>>"
+        Just Types.TPTBool -> "Vec<Vec<bool>>"
+        _ -> error "Unsupported rust nested array type"
+    _ -> error "Unsupported rust array item type"
+rustType (Types.TestParams Types.TPTListNode _) = "Option<Box<ListNode>>"
+rustType (Types.TestParams Types.TPTTreeNode _) = "Option<Rc<RefCell<TreeNode>>>"
+rustType _ = error "Unsupported rust param type"
+
+rustExpr :: Text -> Types.TestParams -> Text
+rustExpr accessor (Types.TestParams Types.TPTInt _) = "json_to_i32(&" <> accessor <> ")"
+rustExpr accessor (Types.TestParams Types.TPTLong _) = "json_to_i64(&" <> accessor <> ")"
+rustExpr accessor (Types.TestParams Types.TPTDouble _) = "json_to_f64(&" <> accessor <> ")"
+rustExpr accessor (Types.TestParams Types.TPTFloat _) = "json_to_f32(&" <> accessor <> ")"
+rustExpr accessor (Types.TestParams Types.TPTString _) = "json_to_string(&" <> accessor <> ")"
+rustExpr accessor (Types.TestParams Types.TPTChar _) = "json_to_char(&" <> accessor <> ")"
+rustExpr accessor (Types.TestParams Types.TPTBool _) = "json_to_bool(&" <> accessor <> ")"
+rustExpr accessor (Types.TestParams Types.TPTArray (Just items)) =
+  case Types.tpaType items of
+    Types.TPTInt -> "json_to_i32_array(&" <> accessor <> ")"
+    Types.TPTLong -> "json_to_i64_array(&" <> accessor <> ")"
+    Types.TPTDouble -> "json_to_f64_array(&" <> accessor <> ")"
+    Types.TPTFloat -> "json_to_f32_array(&" <> accessor <> ")"
+    Types.TPTString -> "json_to_string_array(&" <> accessor <> ")"
+    Types.TPTChar -> "json_to_char_array(&" <> accessor <> ")"
+    Types.TPTBool -> "json_to_bool_array(&" <> accessor <> ")"
+    Types.TPTArray ->
+      case fmap Types.tpaType (Types.tpaItems items) of
+        Just Types.TPTInt -> "json_to_i32_matrix(&" <> accessor <> ")"
+        Just Types.TPTLong -> "json_to_i64_matrix(&" <> accessor <> ")"
+        Just Types.TPTDouble -> "json_to_f64_matrix(&" <> accessor <> ")"
+        Just Types.TPTFloat -> "json_to_f32_matrix(&" <> accessor <> ")"
+        Just Types.TPTString -> "json_to_string_matrix(&" <> accessor <> ")"
+        Just Types.TPTChar -> "json_to_char_matrix(&" <> accessor <> ")"
+        Just Types.TPTBool -> "json_to_bool_matrix(&" <> accessor <> ")"
+        _ -> error "Unsupported rust nested array type"
+    _ -> error "Unsupported rust array item type"
+rustExpr accessor (Types.TestParams Types.TPTListNode _) = "ListNode::to_list_node(json_to_i32_array(&" <> accessor <> "))"
+rustExpr accessor (Types.TestParams Types.TPTTreeNode _) = "TreeNode::to_tree_node(json_to_optional_i32_array(&" <> accessor <> "))"
+rustExpr _ _ = error "Unsupported rust param type"
+
+renderKotlinDecl :: Text -> Text -> Types.TestParams -> Text
+renderKotlinDecl name accessor params = "val " <> name <> ": " <> kotlinType params <> " = " <> kotlinExpr accessor params
+
+kotlinType :: Types.TestParams -> Text
+kotlinType (Types.TestParams Types.TPTInt _) = "Int"
+kotlinType (Types.TestParams Types.TPTLong _) = "Long"
+kotlinType (Types.TestParams Types.TPTDouble _) = "Double"
+kotlinType (Types.TestParams Types.TPTFloat _) = "Float"
+kotlinType (Types.TestParams Types.TPTString _) = "String"
+kotlinType (Types.TestParams Types.TPTChar _) = "Char"
+kotlinType (Types.TestParams Types.TPTBool _) = "Boolean"
+kotlinType (Types.TestParams Types.TPTArray (Just items)) =
+  case Types.tpaType items of
+    Types.TPTInt -> "IntArray"
+    Types.TPTLong -> "LongArray"
+    Types.TPTDouble -> "DoubleArray"
+    Types.TPTFloat -> "FloatArray"
+    Types.TPTString -> "Array<String>"
+    Types.TPTChar -> "CharArray"
+    Types.TPTBool -> "BooleanArray"
+    Types.TPTArray ->
+      case fmap Types.tpaType (Types.tpaItems items) of
+        Just Types.TPTInt -> "Array<IntArray>"
+        Just Types.TPTLong -> "Array<LongArray>"
+        Just Types.TPTDouble -> "Array<DoubleArray>"
+        Just Types.TPTFloat -> "Array<FloatArray>"
+        Just Types.TPTString -> "Array<Array<String>>"
+        Just Types.TPTChar -> "Array<CharArray>"
+        Just Types.TPTBool -> "Array<BooleanArray>"
+        _ -> error "Unsupported kotlin nested array type"
+    _ -> error "Unsupported kotlin array item type"
+kotlinType (Types.TestParams Types.TPTListNode _) = "ListNode?"
+kotlinType (Types.TestParams Types.TPTTreeNode _) = "TreeNode?"
+kotlinType _ = error "Unsupported kotlin param type"
+
+kotlinExpr :: Text -> Types.TestParams -> Text
+kotlinExpr accessor (Types.TestParams Types.TPTInt _) = "toIntValue(" <> accessor <> ")"
+kotlinExpr accessor (Types.TestParams Types.TPTLong _) = "toLongValue(" <> accessor <> ")"
+kotlinExpr accessor (Types.TestParams Types.TPTDouble _) = "toDoubleValue(" <> accessor <> ")"
+kotlinExpr accessor (Types.TestParams Types.TPTFloat _) = "toFloatValue(" <> accessor <> ")"
+kotlinExpr accessor (Types.TestParams Types.TPTString _) = "toStringValue(" <> accessor <> ")"
+kotlinExpr accessor (Types.TestParams Types.TPTChar _) = "toCharValue(" <> accessor <> ")"
+kotlinExpr accessor (Types.TestParams Types.TPTBool _) = "toBoolValue(" <> accessor <> ")"
+kotlinExpr accessor (Types.TestParams Types.TPTArray (Just items)) =
+  case Types.tpaType items of
+    Types.TPTInt -> "toIntArrayValue(" <> accessor <> ")"
+    Types.TPTLong -> "toLongArrayValue(" <> accessor <> ")"
+    Types.TPTDouble -> "toDoubleArrayValue(" <> accessor <> ")"
+    Types.TPTFloat -> "toFloatArrayValue(" <> accessor <> ")"
+    Types.TPTString -> "toStringArrayValue(" <> accessor <> ")"
+    Types.TPTChar -> "toCharArrayValue(" <> accessor <> ")"
+    Types.TPTBool -> "toBoolArrayValue(" <> accessor <> ")"
+    Types.TPTArray ->
+      case fmap Types.tpaType (Types.tpaItems items) of
+        Just Types.TPTInt -> "toIntMatrixValue(" <> accessor <> ")"
+        Just Types.TPTLong -> "toLongMatrixValue(" <> accessor <> ")"
+        Just Types.TPTDouble -> "toDoubleMatrixValue(" <> accessor <> ")"
+        Just Types.TPTFloat -> "toFloatMatrixValue(" <> accessor <> ")"
+        Just Types.TPTString -> "toStringMatrixValue(" <> accessor <> ")"
+        Just Types.TPTChar -> "toCharMatrixValue(" <> accessor <> ")"
+        Just Types.TPTBool -> "toBoolMatrixValue(" <> accessor <> ")"
+        _ -> error "Unsupported kotlin nested array type"
+    _ -> error "Unsupported kotlin array item type"
+kotlinExpr accessor (Types.TestParams Types.TPTListNode _) = "toListNode(toIntArrayValue(" <> accessor <> "))"
+kotlinExpr accessor (Types.TestParams Types.TPTTreeNode _) = "toTreeNode(toNullableIntArrayValue(" <> accessor <> "))"
+kotlinExpr _ _ = error "Unsupported kotlin param type"
+
+textToJsonValue :: Text -> Value
+textToJsonValue raw =
+  case decodeStrictText raw of
+    Just v -> v
+    Nothing -> String raw
+
+generatedInDataToJson :: Types.GeneratedInData -> Value
+generatedInDataToJson (Types.GIDIntegral (Types.GIDGenIntegralConst n)) = Number (fromInteger n)
+generatedInDataToJson (Types.GIDFloat (Types.GIDGenFloatConst f)) = textToJsonValue (T.pack (show f))
+generatedInDataToJson (Types.GIDStr (Types.GIDStrConst s)) = String s
+generatedInDataToJson (Types.GIDChar (Types.GIDGenCharConst c)) = String (T.singleton c)
+generatedInDataToJson (Types.GIDArr (Types.GIDArrConst xs _)) = Array (V.fromList (map generatedInDataToJson xs))
+generatedInDataToJson (Types.GIDBool (Types.GIDGenBoolConst b)) = Bool b
+generatedInDataToJson Types.GIDNull = Null
+generatedInDataToJson _ = error "Unsupported generated const json conversion"
+
+wrapOracleGenerated :: Types.TestParams -> Text -> Text
+wrapOracleGenerated schema rendered =
+  case Types.tpaType schema of
+    Types.TPTArray -> "[" <> rendered <> "]"
+    _ -> rendered
+
 renderExecError :: C.ExecStatus -> Text -> Text
 renderExecError C.TLE err = "TLE " <> err
 renderExecError C.RE err = err
diff --git a/core/Core/Test/Types.hs b/core/Core/Test/Types.hs
index 99c8752e..2c4ee02a 100644
--- a/core/Core/Test/Types.hs
+++ b/core/Core/Test/Types.hs
@@ -18,7 +18,7 @@ data Judge = Judge {jType :: JudgeType}
 
 data TestLimits = TestLimits {tlTimeMs :: Int, tlMemoryMb :: Int}
 
-data TestEntry = TestEntry {teId :: Int, teTitle :: Text, teCall :: M.Map Language Text}
+data TestEntry = TestEntry {teId :: Int, teTitle :: Text, teParams :: Maybe (M.Map Text TestParams), teCall :: M.Map Language Text}
 
 data GeneratedInData
   = GIDIntegral GIDIntegral
@@ -68,6 +68,10 @@ data TestOracleEntry = TestOracleEntry {call :: Text, checker :: Text}
 
 type TestOracle = M.Map Language TestOracleEntry
 
+data TestParamsType = TPTInt | TPTFloat | TPTDouble | TPTLong | TPTString | TPTChar | TPTBool | TPTArray | TPTListNode | TPTTreeNode
+
+data TestParams = TestParams {tpaType :: TestParamsType, tpaItems :: Maybe TestParams}
+
 data TestCase
   = TestCase
   { tcName :: Text,
@@ -110,8 +114,9 @@ instance FromJSON TestEntry where
   parseJSON = withObject "TestEntry" $ \o -> do
     id' <- o .: "id"
     title <- o .: "title"
+    params <- o .:? "params"
     call <- o .: "call"
-    pure $ TestEntry id' title call
+    pure $ TestEntry id' title params call
 
 instance FromJSON TestCaseOutData where
   parseJSON (String t) = pure $ OutCase t
@@ -216,6 +221,26 @@ instance FromJSON TestCase where
     out <- o .:? "out"
     pure $ TestCase name judge call (M.toList inMap) seed out
 
+instance FromJSON TestParams where
+  parseJSON = withObject "TestParams" $ \o -> do
+    type' <- o .: "type"
+    items <- o .:? "items"
+    pure $ TestParams type' items
+
+instance FromJSON TestParamsType where
+  parseJSON = withText "TestParamsType" $ \t -> case t of
+    "int" -> pure TPTInt
+    "long" -> pure TPTLong
+    "double" -> pure TPTDouble
+    "float" -> pure TPTFloat
+    "string" -> pure TPTString
+    "char" -> pure TPTChar
+    "bool" -> pure TPTBool
+    "array" -> pure TPTArray
+    "tree_node" -> pure TPTTreeNode
+    "list_node" -> pure TPTListNode
+    _ -> fail $ "unknown elemType: " <> T.unpack t
+
 instance FromJSON TestSuite where
   parseJSON = withObject "TestSuite" $ \o -> do
     entry <- o .: "entry"
diff --git a/core/Core/Types.hs b/core/Core/Types.hs
index 40790a31..1859b54a 100644
--- a/core/Core/Types.hs
+++ b/core/Core/Types.hs
@@ -85,6 +85,17 @@ nullLiteral Ruby = "nil"
 nullLiteral Swift = "nil"
 nullLiteral _ = "null"
 
+renderGeneratedCharElem :: Language -> Char -> Text
+renderGeneratedCharElem lang c =
+  case lang of
+    Python3 -> pack (show [c])
+    Python2 -> pack (show [c])
+    Ruby -> pack (show [c])
+    TypeScript -> pack (show [c])
+    Dart -> pack (show [c])
+    Swift -> pack (show [c])
+    _ -> pack (show c)
+
 instance FromJSON ExecutorType where
   parseJSON = withText "BackendType" $ \t ->
     case t of
diff --git a/generate_prompt.py b/generate_prompt.py
index 4dcdba20..ab4eee9d 100644
--- a/generate_prompt.py
+++ b/generate_prompt.py
@@ -58,6 +58,11 @@
 entry:
   id: <int>
   title: <string>
+  params:
+    arg1:
+      type: <schema>
+    arg2:
+      type: <schema>
   call:
     cpp: "..."
     rust: "..."
@@ -157,101 +162,111 @@
 ---
 
 ## Call template syntax
+                           
+### Supported param types
 
-RULE:
-Every array param MUST be wrapped in ALL 12 languages. No exceptions.
-
-1D array {x}:
-  → [{x}]
-  → new int[]{ {x} }
-  → vec![{x}]
-  → []int{ {x} }
-  → intArrayOf({x})
-  → lv(vector<int>{ {x} })
-
-2D array {x}:
-  → [{x}]
-  → new int[][]{ {x} }
-  → vec![{x}]
-  → [][]int{ {x} }
-  → arrayOf({x})
-  → lv(vector<vector<int>>{ {x} })
-
-scalar {x}:
-  → {x}
-
-{result} in oracle call:
-  → always bare, never wrap
+- scalar types: `int`, `long`, `float`, `double`, `bool`, `string`, `char`
+- structural types: `array`, `list_node`, `tree_node`
 
 Example - method(nums []int, target int):
 
+params:
+  nums:
+    type: array
+    items:
+      type: int
+  target:
+    type: int
+
 call:
-  cpp: "Solution().method(lv(vector<int>{ {nums} }), {target})"
-  rust: "Solution::method(vec![{nums}], {target})"
-  python3: "Solution().method([{nums}], {target})"
-  python2: "Solution().method([{nums}], {target})"
-  ruby: "method([{nums}], {target})"
-  java: "new Solution().method(new int[]{ {nums} }, {target})"
-  csharp: "new Solution().Method(new int[]{ {nums} }, {target})"
-  kotlin: "Solution().method(intArrayOf({nums}), {target})"
-  go: "method([]int{ {nums} }, {target})"
-  dart: "Solution().method([{nums}], {target})"
-  swift: "Solution().method([{nums}], {target})"
-  typescript: "method([{nums}], {target})"
+  cpp: "Solution().method({nums}, {target})"
+  rust: "Solution::method({nums}, {target})"
+  python3: "Solution().method({nums}, {target})"
+  python2: "Solution().method({nums}, {target})"
+  ruby: "method({nums}, {target})"
+  java: "new Solution().method({nums}, {target})"
+  csharp: "new Solution().Method({nums}, {target})"
+  kotlin: "Solution().method({nums}, {target})"
+  go: "method({nums}, {target})"
+  dart: "Solution().method({nums}, {target})"
+  swift: "Solution().method({nums}, {target})"
+  typescript: "method({nums}, {target})"
 
 oracle:
   python3:
-    call: "Checker().method([{nums}], {target}, {result})"
+    call: "Checker().method(nums, target, {result})"
 
 ---
 
 Example - method(arr []int, queries [][]int):
 
+params:
+  arr:
+    type: array
+    items:
+      type: int
+  queries:
+    type: array
+    items:
+      type: array
+      items:
+        type: int
+
 call:
-  cpp: "Solution().method(lv(vector<int>{ {arr} }), lv(vector<vector<int>>{ {queries} }))"
-  rust: "Solution::method(vec![{arr}], vec![{queries}])"
-  python3: "Solution().method([{arr}], [{queries}])"
-  python2: "Solution().method([{arr}], [{queries}])"
-  ruby: "method([{arr}], [{queries}])"
-  java: "new Solution().method(new int[]{ {arr} }, new int[][]{ {queries} })"
-  csharp: "new Solution().Method(new int[]{ {arr} }, new int[][]{ {queries} })"
-  kotlin: "Solution().method(intArrayOf({arr}), arrayOf({queries}))"
-  go: "method([]int{ {arr} }, [][]int{ {queries} })"
-  dart: "Solution().method([{arr}], [{queries}])"
-  swift: "Solution().method([{arr}], [{queries}])"
-  typescript: "method([{arr}], [{queries}])"
+  cpp: "Solution().method({arr}, {queries})"
+  rust: "Solution::method({arr}, {queries})"
+  python3: "Solution().method({arr}, {queries})"
+  python2: "Solution().method({arr}, {queries})"
+  ruby: "method({arr}, {queries})"
+  java: "new Solution().method({arr}, {queries})"
+  csharp: "new Solution().Method({arr}, {queries})"
+  kotlin: "Solution().method({arr}, {queries})"
+  go: "method({arr}, {queries})"
+  dart: "Solution().method({arr}, {queries})"
+  swift: "Solution().method({arr}, {queries})"
+  typescript: "method({arr}, {queries})"
 
 oracle:
   python3:
-    call: "Checker().method([{arr}], [{queries}], {result})"
+    call: "Checker().method(arr, queries, {result})"
 
 ---
 
 Example - method(matrix [][]int, target int):
 
+params:
+  matrix:
+    type: array
+    items:
+      type: array
+      items:
+        type: int
+  target:
+    type: int
+
 call:
-  cpp: "Solution().method(lv(vector<vector<int>>{ {matrix} }), {target})"
-  rust: "Solution::method(vec![{matrix}], {target})"
-  python3: "Solution().method([{matrix}], {target})"
-  python2: "Solution().method([{matrix}], {target})"
-  ruby: "method([{matrix}], {target})"
-  java: "new Solution().method(new int[][]{ {matrix} }, {target})"
-  csharp: "new Solution().Method(new int[][]{ {matrix} }, {target})"
-  kotlin: "Solution().method(arrayOf({matrix}), {target})"
-  go: "method([][]int{ {matrix} }, {target})"
-  dart: "Solution().method([{matrix}], {target})"
-  swift: "Solution().method([{matrix}], {target})"
-  typescript: "method([{matrix}], {target})"
+  cpp: "Solution().method({matrix}, {target})"
+  rust: "Solution::method({matrix}, {target})"
+  python3: "Solution().method({matrix}, {target})"
+  python2: "Solution().method({matrix}, {target})"
+  ruby: "method({matrix}, {target})"
+  java: "new Solution().method({matrix}, {target})"
+  csharp: "new Solution().Method({matrix}, {target})"
+  kotlin: "Solution().method({matrix}, {target})"
+  go: "method({matrix}, {target})"
+  dart: "Solution().method({matrix}, {target})"
+  swift: "Solution().method({matrix}, {target})"
+  typescript: "method({matrix}, {target})"
 
 oracle:
   python3:
-    call: "Checker().method([{matrix}], {target}, {result})"
+    call: "Checker().method(matrix, target, {result})"
 
 WRONG:
-call: "Checker().method({matrix}, {target}, {result})"
+call: "Checker().method([{matrix}], {target}, {result})"
 
 RIGHT:
-call: "Checker().method([{matrix}], {target}, {result})"
+call: "Checker().method(matrix, target, {result})"
 
 ---
 
@@ -313,93 +328,93 @@
 ListNode:
 
 python3/python2/dart/swift:
-  "list_node_to_array(Solution().method(to_list_node([{l1}])))"
+  "list_node_to_array(Solution().method({l1}))"
 
 rust:
-  "ListNode::list_node_to_array(Solution::method(ListNode::to_list_node(vec![{l1}])))"
+  "ListNode::list_node_to_array(Solution::method({l1}))"
 
 cpp:
-  "listNodeToArray(Solution().method(toListNode(lv(vector<int>{ {l1} }))))"
+  "listNodeToArray(Solution().method({l1}))"
 
 ruby:
-  "list_node_to_array(method(to_list_node([{l1}])))"
+  "list_node_to_array(method({l1}))"
 
 java:
-  "ListNode.listNodeToArray(new Solution().method(ListNode.toListNode(new int[]{ {l1} })))"
+  "ListNode.listNodeToArray(new Solution().method({l1}))"
 
 csharp:
-  "ListNode.ListNodeToArray(new Solution().Method(ListNode.ToListNode(new int[]{ {l1} })))"
+  "ListNode.ListNodeToArray(new Solution().Method({l1}))"
 
 kotlin:
-  "listNodeToArray(Solution().method(toListNode(intArrayOf({l1}))))"
+  "listNodeToArray(Solution().method({l1}))"
 
 go:
-  "listNodeToArray(method(toListNode([]int{ {l1} })))"
+  "listNodeToArray(method({l1}))"
 
 typescript:
-  "listNodeToArray(method(toListNode([{l1}])))"
+  "listNodeToArray(method({l1}))"
 
 ---
 
 TreeNode (input):
 
 python3/python2/dart/swift:
-  "Solution().method(to_tree_node([{root}]))"
+  "Solution().method({root})"
 
 rust:
-  "Solution::method(TreeNode::to_tree_node(vec![{root}]))"
+  "Solution::method({root})"
 
 cpp:
-  "Solution().method(toTreeNode(lv(vector<optional<int>>{ {root} })))"
+  "Solution().method({root})"
 
 ruby:
-  "method(to_tree_node([{root}]))"
+  "method({root})"
 
 java:
-  "new Solution().method(TreeNode.toTreeNode(new Integer[]{ {root} }))"
+  "new Solution().method({root})"
 
 csharp:
-  "new Solution().Method(TreeNode.ToTreeNode(new int?[]{ {root} }))"
+  "new Solution().Method({root})"
 
 kotlin:
-  "Solution().method(toTreeNode(arrayOf({root})))"
+  "Solution().method({root})"
 
 go:
-  "method(toTreeNode([]interface{}{ {root} }))"
+  "method({root})"
 
 typescript:
-  "method(toTreeNode([{root}]))"
+  "method({root})"
 
 ---
 
 TreeNode (output):
 
 python3/python2/dart/swift:
-  "tree_node_to_array(Solution().method(to_tree_node([{root}])))"
+  "tree_node_to_array(Solution().method({root}))"
 
 rust:
-  "TreeNode::tree_node_to_array(Solution::method(TreeNode::to_tree_node(vec![{root}])))"
+  "TreeNode::tree_node_to_array(Solution::method({root}))"
 
 cpp:
-  "treeNodeToArray(Solution().method(toTreeNode(lv(vector<optional<int>>{ {root} }))))"
+  "treeNodeToArray(Solution().method({root}))"
 
 ruby:
-  "tree_node_to_array(method(to_tree_node([{root}])))"
+  "tree_node_to_array(method({root}))"
 
 java:
-  "TreeNode.treeNodeToArray(new Solution().method(TreeNode.toTreeNode(new Integer[]{ {root} })))"
+  "TreeNode.treeNodeToArray(new Solution().method({root}))"
 
 csharp:
-  "TreeNode.TreeNodeToArray(new Solution().Method(TreeNode.ToTreeNode(new int?[]{ {root} })))"
+  "TreeNode.TreeNodeToArray(new Solution().Method({root}))"
 
 kotlin:
-  "treeNodeToArray(Solution().method(toTreeNode(arrayOf({root}))))"
+  "treeNodeToArray(Solution().method({root}))"
 
 go:
-  "treeNodeToArray(method(toTreeNode([]interface{}{ {root} })))"
+  "treeNodeToArray(method({root}))"
 
 typescript:
-  "treeNodeToArray(method(toTreeNode([{root}])))"
+  "treeNodeToArray(method({root}))"
 
 Trees: compressed BFS, null marks absent child, trailing nulls stripped.
 
@@ -423,7 +438,7 @@
   - boundary conditions
 
 - Tests without `out` automatically use the top-level oracle. Do NOT repeat or redefine oracle in tests.
-- String parameters MUST always be quoted in calls ("{s}")
+- String parameters should use plain placeholders in `call` (`{s}`), not manual quotes or wrappers
 - Use generators when possible; if not possible, do not use them
 - Generated tests MUST use oracle (no `out`)
 - The checker MUST define a class `Checker` with the method used in oracle.call.
@@ -436,7 +451,6 @@
 - Ensure oracle call is correct
 - Generator ranges must match problem constraints exactly
 - Oracle checker in Python3 validates structurally (not just re-run solution)
-- Follow call wrapping rules exactly for all 12 languages
 
 3. Output only raw YAML.
    No comments, no explanation.
diff --git a/runtimes/cpp/main.cpp b/runtimes/cpp/main.cpp
index 920723b6..6d1b3574 100644
--- a/runtimes/cpp/main.cpp
+++ b/runtimes/cpp/main.cpp
@@ -1,4 +1,5 @@
 #include <bits/stdc++.h>
+#include <nlohmann/json.hpp>
 ${IMPORTS}
 using namespace std;
 
@@ -9,6 +10,13 @@ using namespace std;
 int main() {
   ios::sync_with_stdio(false);
   cin.tie(nullptr);
+  ifstream _TEST_JSON_FILE_("test.json");
+  _JSON_ _TEST_JSON_;
+  _TEST_JSON_FILE_ >> _TEST_JSON_;
+  map<string, map<string, _TEST_> > _TEST_DATA_;
+  for (auto& [caseId, caseJson] : _TEST_JSON_.items()) {
+    _TEST_DATA_[caseId] = caseJson.get<map<string, _TEST_> >();
+  }
   ${INSERTION}
   return 0;
 }
diff --git a/runtimes/cpp/utilities.cpp b/runtimes/cpp/utilities.cpp
index a3710019..7ee86ce1 100644
--- a/runtimes/cpp/utilities.cpp
+++ b/runtimes/cpp/utilities.cpp
@@ -1,5 +1,100 @@
+using _JSON_ = nlohmann::json;
+
 template<typename T> T& lv(T&& x) { return x; }
 
+struct _TEST_ {
+    _JSON_ val;
+};
+
+inline void from_json(const _JSON_& j, _TEST_& t) {
+    j.at("val").get_to(t.val);
+}
+
+inline char jsonToChar(const _JSON_& j) { return j.get<string>()[0]; }
+inline int jsonToInt(const _JSON_& j) { return j.get<int>(); }
+inline long long jsonToLong(const _JSON_& j) { return j.get<long long>(); }
+inline double jsonToDouble(const _JSON_& j) { return j.get<double>(); }
+inline float jsonToFloat(const _JSON_& j) { return j.get<float>(); }
+inline bool jsonToBool(const _JSON_& j) { return j.get<bool>(); }
+inline string jsonToString(const _JSON_& j) {
+  return j.is_string() ? j.get<string>() : j.dump();
+}
+
+inline vector<int> jsonToIntArray(const _JSON_& j) {
+  return j.get<vector<int> >();
+}
+
+inline vector<long long> jsonToLongArray(const _JSON_& j) {
+  return j.get<vector<long long> >();
+}
+
+inline vector<double> jsonToDoubleArray(const _JSON_& j) {
+  return j.get<vector<double> >();
+}
+
+inline vector<float> jsonToFloatArray(const _JSON_& j) {
+  return j.get<vector<float> >();
+}
+
+inline vector<bool> jsonToBoolArray(const _JSON_& j) {
+  return j.get<vector<bool> >();
+}
+
+inline vector<string> jsonToStringArray(const _JSON_& j) {
+  return j.get<vector<string> >();
+}
+
+inline vector<optional<int>> jsonToOptionalIntArray(const _JSON_& j) {
+  vector<optional<int>> out;
+  out.reserve(j.size());
+  for (const auto& x : j) {
+    if (x.is_null()) {
+      out.push_back(nullopt);
+    } else {
+      out.push_back(x.get<int>());
+    }
+  }
+  return out;
+}
+
+inline vector<char> jsonToCharArray(const _JSON_& j) {
+  vector<char> out;
+  out.reserve(j.size());
+  for (const auto& x : j) out.push_back(jsonToChar(x));
+  return out;
+}
+
+inline vector<vector<int>> jsonToIntMatrix(const _JSON_& j) {
+  return j.get<vector<vector<int> > >();
+}
+
+inline vector<vector<long long>> jsonToLongMatrix(const _JSON_& j) {
+  return j.get<vector<vector<long long> > >();
+}
+
+inline vector<vector<double>> jsonToDoubleMatrix(const _JSON_& j) {
+  return j.get<vector<vector<double> > >();
+}
+
+inline vector<vector<float>> jsonToFloatMatrix(const _JSON_& j) {
+  return j.get<vector<vector<float> > >();
+}
+
+inline vector<vector<bool>> jsonToBoolMatrix(const _JSON_& j) {
+  return j.get<vector<vector<bool> > >();
+}
+
+inline vector<vector<string>> jsonToStringMatrix(const _JSON_& j) {
+  return j.get<vector<vector<string> > >();
+}
+
+inline vector<vector<char>> jsonToCharMatrix(const _JSON_& j) {
+  vector<vector<char>> out;
+  out.reserve(j.size());
+  for (const auto& row : j) out.push_back(jsonToCharArray(row));
+  return out;
+}
+
 struct ListNode {
   int val;
   ListNode *next;
@@ -37,6 +132,14 @@ inline vector<int> listNodeToArray(ListNode *head) {
   return res;
 }
 
+inline vector<ListNode *> toLinkedLists(const vector<vector<int>> &arrs) {
+  vector<ListNode *> res;
+  res.reserve(arrs.size());
+  for (const auto &arr : arrs)
+    res.push_back(toListNode(arr));
+  return res;
+}
+
 inline TreeNode *toTreeNode(const vector<optional<int>> &arr) {
   if (arr.empty() || !arr[0])
     return nullptr;
@@ -83,6 +186,15 @@ inline vector<optional<int>> treeNodeToArray(TreeNode *root) {
   return res;
 }
 
+inline vector<vector<optional<int>>> treeNodesArrayToVector(const vector<TreeNode *> &roots) {
+  vector<vector<optional<int>>> res;
+  res.reserve(roots.size());
+  for (auto *root : roots) {
+    res.push_back(treeNodeToArray(root));
+  }
+  return res;
+}
+
 inline string _jsonQuote(const string &s) {
   string r;
   r.reserve(s.size() + 2);
@@ -132,9 +244,12 @@ inline string toJson(unsigned v) { return to_string(v); }
 inline string toJson(unsigned long v) { return to_string(v); }
 inline string toJson(unsigned long long v) { return to_string(v); }
 inline string toJson(double v) {
-  char buf[64];
-  snprintf(buf, sizeof(buf), "%g", v);
-  return buf;
+  if (isnan(v) || isinf(v)) return "null";
+  ostringstream oss;
+  oss << setprecision(15) << v;
+  string s = oss.str();
+  if (s.find_first_of(".eE") == string::npos) s += ".0";
+  return s;
 }
 inline string toJson(float v) { return toJson((double)v); }
 inline string toJson(char v) { return _jsonQuote(string(1, v)); }
diff --git a/runtimes/csharp/main.cs b/runtimes/csharp/main.cs
index 7dcfe3ff..80dd14d3 100644
--- a/runtimes/csharp/main.cs
+++ b/runtimes/csharp/main.cs
@@ -3,13 +3,34 @@
 using System.Collections.Generic;
 using System.Linq;
 using System.Diagnostics;
+using System.IO;
+using Newtonsoft.Json.Linq;
 
 ${SOLUTION}
 
 ${UTILITIES}
 
 partial class _Runner {
+    class _TestInput {
+        public JToken val { get; set; }
+    }
+
+    static Dictionary<string, Dictionary<string, _TestInput>> _TEST_;
+
+    static JToken _TestVal(string caseId, string name) {
+        return _TEST_[caseId][name].val;
+    }
+
     public static void Main() {
+        _TEST_ = JObject.Parse(File.ReadAllText("test.json"))
+            .Properties()
+            .ToDictionary(
+                caseProp => caseProp.Name,
+                caseProp => ((JObject)caseProp.Value).Properties().ToDictionary(
+                    varProp => varProp.Name,
+                    varProp => new _TestInput { val = varProp.Value["val"] }
+                )
+            );
         ${INSERTION}
     }
 }
diff --git a/runtimes/csharp/utilities.cs b/runtimes/csharp/utilities.cs
index 4839ad6d..b266cbca 100644
--- a/runtimes/csharp/utilities.cs
+++ b/runtimes/csharp/utilities.cs
@@ -23,6 +23,10 @@ public static int[] ListNodeToArray(ListNode head) {
             res.Add(cur.val);
         return res.ToArray();
     }
+
+    public static ListNode[] ToListNodes(int[][] arrs) {
+        return arrs.Select(ToListNode).ToArray();
+    }
 }
 
 public class TreeNode {
@@ -76,9 +80,104 @@ public static TreeNode ToTreeNode(int?[] arr) {
             res.RemoveAt(res.Count - 1);
         return res.ToArray();
     }
+
+    public static List<int?[]> TreeNodeListToArrayList(IList<TreeNode> roots) {
+        return roots.Select(TreeNodeToArray).ToList();
+    }
 }
 
 partial class _Runner {
+    static int ToInt(JToken el) {
+        return el == null || el.Type == JTokenType.Null ? 0 : el.Value<int>();
+    }
+
+    static long ToLong(JToken el) {
+        return el == null || el.Type == JTokenType.Null ? 0L : el.Value<long>();
+    }
+
+    static double ToDouble(JToken el) {
+        return el == null || el.Type == JTokenType.Null ? 0d : el.Value<double>();
+    }
+
+    static float ToFloat(JToken el) {
+        return el == null || el.Type == JTokenType.Null ? 0f : el.Value<float>();
+    }
+
+    static string ToStringValue(JToken el) {
+        return el == null || el.Type == JTokenType.Null ? "" : el.Type == JTokenType.String ? el.Value<string>() : el.ToString();
+    }
+
+    static char ToChar(JToken el) {
+        var s = ToStringValue(el);
+        return s.Length == 0 ? '\0' : s[0];
+    }
+
+    static bool ToBool(JToken el) {
+        if (el == null || el.Type == JTokenType.Null) return false;
+        if (el.Type == JTokenType.Boolean) return el.Value<bool>();
+        return bool.TryParse(el.ToString(), out var value) && value;
+    }
+
+    static int[] ToIntArray(JToken el) {
+        return ((JArray)el).Select(ToInt).ToArray();
+    }
+
+    static long[] ToLongArray(JToken el) {
+        return ((JArray)el).Select(ToLong).ToArray();
+    }
+
+    static double[] ToDoubleArray(JToken el) {
+        return ((JArray)el).Select(ToDouble).ToArray();
+    }
+
+    static float[] ToFloatArray(JToken el) {
+        return ((JArray)el).Select(ToFloat).ToArray();
+    }
+
+    static bool[] ToBoolArray(JToken el) {
+        return ((JArray)el).Select(ToBool).ToArray();
+    }
+
+    static string[] ToStringArray(JToken el) {
+        return ((JArray)el).Select(ToStringValue).ToArray();
+    }
+
+    static int?[] ToNullableIntArray(JToken el) {
+        return ((JArray)el).Select(x => x == null || x.Type == JTokenType.Null ? (int?)null : ToInt(x)).ToArray();
+    }
+
+    static int[][] ToIntMatrix(JToken el) {
+        return ((JArray)el).Select(ToIntArray).ToArray();
+    }
+
+    static long[][] ToLongMatrix(JToken el) {
+        return ((JArray)el).Select(ToLongArray).ToArray();
+    }
+
+    static double[][] ToDoubleMatrix(JToken el) {
+        return ((JArray)el).Select(ToDoubleArray).ToArray();
+    }
+
+    static float[][] ToFloatMatrix(JToken el) {
+        return ((JArray)el).Select(ToFloatArray).ToArray();
+    }
+
+    static bool[][] ToBoolMatrix(JToken el) {
+        return ((JArray)el).Select(ToBoolArray).ToArray();
+    }
+
+    static string[][] ToStringMatrix(JToken el) {
+        return ((JArray)el).Select(ToStringArray).ToArray();
+    }
+
+    static char[] ToCharArray(JToken el) {
+        return ((JArray)el).Select(ToChar).ToArray();
+    }
+
+    static char[][] ToCharMatrix(JToken el) {
+        return ((JArray)el).Select(ToCharArray).ToArray();
+    }
+
     static string ToJson(object obj) {
         if (obj == null) return "null";
         if (obj is bool b) return b ? "true" : "false";
diff --git a/runtimes/dart/main.dart b/runtimes/dart/main.dart
index 4ef8d90e..80c0b116 100644
--- a/runtimes/dart/main.dart
+++ b/runtimes/dart/main.dart
@@ -2,11 +2,19 @@ import 'dart:mirrors';
 import 'dart:math';
 import 'dart:collection';
 import 'dart:io';
+import 'dart:convert';
 
 ${SOLUTION}
 
 ${UTILITIES}
 
+late final Map<String, dynamic> _TEST_;
+
+dynamic testVal(String caseId, String name) {
+  return (_TEST_[caseId] as Map<String, dynamic>)[name]["val"];
+}
+
 void main() {
+  _TEST_ = (jsonDecode(File('test.json').readAsStringSync()) as Map).cast<String, dynamic>();
   ${INSERTION}
 }
diff --git a/runtimes/dart/utilities.dart b/runtimes/dart/utilities.dart
index d5b3d1b3..3c61208d 100644
--- a/runtimes/dart/utilities.dart
+++ b/runtimes/dart/utilities.dart
@@ -5,13 +5,83 @@ class TreeNode {
   TreeNode([this.val = 0, this.left, this.right]);
 }
 
+int toIntValue(dynamic value) {
+  if (value == null) return 0;
+  if (value is int) return value;
+  if (value is num) return value.toInt();
+  return int.parse(value.toString());
+}
+
+double toDoubleValue(dynamic value) {
+  if (value == null) return 0;
+  if (value is double) return value;
+  if (value is num) return value.toDouble();
+  return double.parse(value.toString());
+}
+
+String toStringValue(dynamic value) {
+  if (value == null) return '';
+  return value.toString();
+}
+
+bool toBoolValue(dynamic value) {
+  if (value is bool) return value;
+  return value.toString() == 'true';
+}
+
+List<int> toIntArrayValue(dynamic value) {
+  final list = value as List;
+  return list.map((item) => toIntValue(item)).toList();
+}
+
+List<double> toDoubleArrayValue(dynamic value) {
+  final list = value as List;
+  return list.map((item) => toDoubleValue(item)).toList();
+}
+
+List<String> toStringArrayValue(dynamic value) {
+  final list = value as List;
+  return list.map((item) => toStringValue(item)).toList();
+}
+
+List<bool> toBoolArrayValue(dynamic value) {
+  final list = value as List;
+  return list.map((item) => toBoolValue(item)).toList();
+}
+
+List<dynamic> toDynamicListValue(dynamic value) {
+  return (value as List).toList();
+}
+
+List<List<String>> toStringMatrixValue(dynamic value) {
+  final rows = value as List;
+  return rows
+      .map((row) => (row as List).map((cell) => toStringValue(cell)).toList())
+      .toList();
+}
+
+List<List<int>> toIntMatrixValue(dynamic value) {
+  final rows = value as List;
+  return rows.map((row) => toIntArrayValue(row)).toList();
+}
+
+List<List<double>> toDoubleMatrixValue(dynamic value) {
+  final rows = value as List;
+  return rows.map((row) => toDoubleArrayValue(row)).toList();
+}
+
+List<List<bool>> toBoolMatrixValue(dynamic value) {
+  final rows = value as List;
+  return rows.map((row) => toBoolArrayValue(row)).toList();
+}
+
 TreeNode? to_tree_node(List<dynamic>? arr) {
   if (arr == null || arr.isEmpty || arr[0] == null) return null;
   TreeNode root = TreeNode(arr[0]);
   List<TreeNode?> queue = [root];
   int i = 1;
   int qIdx = 0;
-  while (i < arr.length) {
+  while (qIdx < queue.length && i < arr.length) {
     TreeNode? node = queue[qIdx++];
     if (i < arr.length && arr[i] != null) {
       node!.left = TreeNode(arr[i]);
@@ -73,6 +143,10 @@ List<int> list_node_to_array(ListNode? head) {
   return res;
 }
 
+List<ListNode?> to_list_nodes(List<List<int>> arrs) {
+  return arrs.map((arr) => to_list_node(arr)).toList();
+}
+
 String toJson(Object? obj) {
   final seen = <Object>{};
   final sb = StringBuffer();
diff --git a/runtimes/go/main.go b/runtimes/go/main.go
index c03d41e0..ed504bc9 100644
--- a/runtimes/go/main.go
+++ b/runtimes/go/main.go
@@ -1,7 +1,9 @@
 package main
 
 import (
+	"encoding/json"
 	"fmt"
+	"os"
 	"time"
 	"strings"
 	"reflect"
@@ -12,6 +14,23 @@ ${SOLUTION}
 
 ${UTILITIES}
 
+type _TestInput struct {
+	Val interface{} `json:"val"`
+}
+
+var _TEST_ map[string]map[string]_TestInput
+
+func testVal(caseId string, name string) interface{} {
+	return _TEST_[caseId][name].Val
+}
+
 func main() {
+	raw, err := os.ReadFile("test.json")
+	if err != nil {
+		panic(err)
+	}
+	if err := json.Unmarshal(raw, &_TEST_); err != nil {
+		panic(err)
+	}
 	${INSERTION}
 }
diff --git a/runtimes/go/utilities.go b/runtimes/go/utilities.go
index 43095d70..741ce764 100644
--- a/runtimes/go/utilities.go
+++ b/runtimes/go/utilities.go
@@ -22,6 +22,267 @@ func toInt(v interface{}) int {
     }
 }
 
+func toFloat64Value(v interface{}) float64 {
+    if v == nil {
+        return 0
+    }
+    switch t := v.(type) {
+    case float64:
+        return t
+    case float32:
+        return float64(t)
+    case int:
+        return float64(t)
+    case int64:
+        return float64(t)
+    default:
+        return 0
+    }
+}
+
+func toLongValue(v interface{}) int64 {
+    if v == nil {
+        return 0
+    }
+    switch t := v.(type) {
+    case int:
+        return int64(t)
+    case int64:
+        return t
+    case float64:
+        return int64(t)
+    case float32:
+        return int64(t)
+    default:
+        return 0
+    }
+}
+
+func formatJsonFloat(v float64) string {
+    s := fmt.Sprintf("%.15f", v)
+    s = strings.TrimRight(s, "0")
+    s = strings.TrimRight(s, ".")
+    if !strings.ContainsAny(s, ".eE") {
+        s += ".0"
+    }
+    return s
+}
+
+func toStringValue(v interface{}) string {
+    if v == nil {
+        return ""
+    }
+    switch t := v.(type) {
+    case string:
+        return t
+    case byte:
+        return string([]byte{t})
+    default:
+        return fmt.Sprintf("%v", t)
+    }
+}
+
+func toBoolValue(v interface{}) bool {
+    if v == nil {
+        return false
+    }
+    if b, ok := v.(bool); ok {
+        return b
+    }
+    return false
+}
+
+func toByteValue(v interface{}) byte {
+    s := toStringValue(v)
+    if len(s) == 0 {
+        return 0
+    }
+    return s[0]
+}
+
+func toIntArrayValue(v interface{}) []int {
+    arr, ok := v.([]interface{})
+    if !ok {
+        return nil
+    }
+    res := make([]int, len(arr))
+    for i, item := range arr {
+        res[i] = toInt(item)
+    }
+    return res
+}
+
+func toLongArrayValue(v interface{}) []int64 {
+    arr, ok := v.([]interface{})
+    if !ok {
+        return nil
+    }
+    res := make([]int64, len(arr))
+    for i, item := range arr {
+        res[i] = toLongValue(item)
+    }
+    return res
+}
+
+func toDoubleArrayValue(v interface{}) []float64 {
+    arr, ok := v.([]interface{})
+    if !ok {
+        return nil
+    }
+    res := make([]float64, len(arr))
+    for i, item := range arr {
+        res[i] = toFloat64Value(item)
+    }
+    return res
+}
+
+func toFloatArrayValue(v interface{}) []float32 {
+    arr, ok := v.([]interface{})
+    if !ok {
+        return nil
+    }
+    res := make([]float32, len(arr))
+    for i, item := range arr {
+        res[i] = float32(toFloat64Value(item))
+    }
+    return res
+}
+
+func toStringArrayValue(v interface{}) []string {
+    arr, ok := v.([]interface{})
+    if !ok {
+        return nil
+    }
+    res := make([]string, len(arr))
+    for i, item := range arr {
+        res[i] = toStringValue(item)
+    }
+    return res
+}
+
+func toByteArrayValue(v interface{}) []byte {
+    arr, ok := v.([]interface{})
+    if !ok {
+        return nil
+    }
+    res := make([]byte, len(arr))
+    for i, item := range arr {
+        res[i] = toByteValue(item)
+    }
+    return res
+}
+
+func toBoolArrayValue(v interface{}) []bool {
+    arr, ok := v.([]interface{})
+    if !ok {
+        return nil
+    }
+    res := make([]bool, len(arr))
+    for i, item := range arr {
+        res[i] = toBoolValue(item)
+    }
+    return res
+}
+
+func toInterfaceArrayValue(v interface{}) []interface{} {
+    arr, ok := v.([]interface{})
+    if !ok {
+        return nil
+    }
+    return arr
+}
+
+func toByteMatrixValue(v interface{}) [][]byte {
+    rows, ok := v.([]interface{})
+    if !ok {
+        return nil
+    }
+    res := make([][]byte, len(rows))
+    for i, row := range rows {
+        cols, ok := row.([]interface{})
+        if !ok {
+            continue
+        }
+        res[i] = make([]byte, len(cols))
+        for j, cell := range cols {
+            res[i][j] = toByteValue(cell)
+        }
+    }
+    return res
+}
+
+func toIntMatrixValue(v interface{}) [][]int {
+    rows, ok := v.([]interface{})
+    if !ok {
+        return nil
+    }
+    res := make([][]int, len(rows))
+    for i, row := range rows {
+        res[i] = toIntArrayValue(row)
+    }
+    return res
+}
+
+func toLongMatrixValue(v interface{}) [][]int64 {
+    rows, ok := v.([]interface{})
+    if !ok {
+        return nil
+    }
+    res := make([][]int64, len(rows))
+    for i, row := range rows {
+        res[i] = toLongArrayValue(row)
+    }
+    return res
+}
+
+func toDoubleMatrixValue(v interface{}) [][]float64 {
+    rows, ok := v.([]interface{})
+    if !ok {
+        return nil
+    }
+    res := make([][]float64, len(rows))
+    for i, row := range rows {
+        res[i] = toDoubleArrayValue(row)
+    }
+    return res
+}
+
+func toFloatMatrixValue(v interface{}) [][]float32 {
+    rows, ok := v.([]interface{})
+    if !ok {
+        return nil
+    }
+    res := make([][]float32, len(rows))
+    for i, row := range rows {
+        res[i] = toFloatArrayValue(row)
+    }
+    return res
+}
+
+func toStringMatrixValue(v interface{}) [][]string {
+    rows, ok := v.([]interface{})
+    if !ok {
+        return nil
+    }
+    res := make([][]string, len(rows))
+    for i, row := range rows {
+        res[i] = toStringArrayValue(row)
+    }
+    return res
+}
+
+func toBoolMatrixValue(v interface{}) [][]bool {
+    rows, ok := v.([]interface{})
+    if !ok {
+        return nil
+    }
+    res := make([][]bool, len(rows))
+    for i, row := range rows {
+        res[i] = toBoolArrayValue(row)
+    }
+    return res
+}
+
 func toTreeNode(arr []interface{}) *TreeNode {
     if len(arr) == 0 || arr[0] == nil { return nil }
     val := toInt(arr[0])
@@ -62,6 +323,14 @@ func treeNodeToArray(root *TreeNode) []interface{} {
     return res
 }
 
+func treesToArrays(roots []*TreeNode) [][]interface{} {
+    res := make([][]interface{}, len(roots))
+    for i, root := range roots {
+        res[i] = treeNodeToArray(root)
+    }
+    return res
+}
+
 type ListNode struct {
     Val  int
     Next *ListNode
@@ -81,13 +350,28 @@ func toListNode(arr []int) *ListNode {
 }
 
 func listNodeToArray(head *ListNode) []int {
-    var res []int
+    res := []int{}
     for cur := head; cur != nil; cur = cur.Next {
         res = append(res, cur.Val)
     }
     return res
 }
 
+func toListNodes(arrs [][]int) []*ListNode {
+    res := make([]*ListNode, len(arrs))
+    for i, arr := range arrs {
+        res[i] = toListNode(arr)
+    }
+    return res
+}
+
+func absInt(x int) int {
+	if x < 0 {
+		return -x
+	}
+	return x
+}
+
 func toJson(obj interface{}) string {
     seen := make(map[uintptr]bool)
     return encodeValue(reflect.ValueOf(obj), seen)
@@ -121,7 +405,7 @@ func encodeValue(v reflect.Value, seen map[uintptr]bool) string {
 	case reflect.Uint, reflect.Uint8, reflect.Uint16, reflect.Uint32, reflect.Uint64, reflect.Uintptr:
 		return fmt.Sprintf("%d", v.Uint())
 	case reflect.Float32, reflect.Float64:
-		return fmt.Sprintf("%g", v.Float())
+		return formatJsonFloat(v.Float())
 	case reflect.String:
 		return jsonQuote(v.String())
 	case reflect.Slice:
diff --git a/runtimes/java/main.java b/runtimes/java/main.java
index f887813e..9f63d1d4 100644
--- a/runtimes/java/main.java
+++ b/runtimes/java/main.java
@@ -1,12 +1,15 @@
-import java.lang.reflect.*;
-import java.time.temporal.TemporalAccessor;
+import com.google.gson.*;
+import com.google.gson.reflect.TypeToken;
+import java.nio.file.Files;
+import java.nio.file.Path;
 import java.util.*;
 import java.io.*;
-import java.math.*;
 ${IMPORTS}
 
 class Main {
-    public static void main(String[] args) {
+    public static void main(String[] args) throws Exception {
+        String _TEST_JSON_STR_ = Files.readString(Path.of("test.json"));
+        Map<String, Map<String, _TEST_>> _TEST_ = Json.fromJsonMap(_TEST_JSON_STR_);
         ${INSERTION}
     }
 }
diff --git a/runtimes/java/utilities.java b/runtimes/java/utilities.java
index e0bc3e9f..b36a7dec 100644
--- a/runtimes/java/utilities.java
+++ b/runtimes/java/utilities.java
@@ -1,3 +1,9 @@
+class _TEST_ {
+    public Object val;
+
+    public _TEST_() {}
+}
+
 class TreeNode {
 	public int val;
     public TreeNode left;
@@ -49,6 +55,14 @@ public static List<Integer> treeNodeToArray(TreeNode root) {
         while (!res.isEmpty() && res.get(res.size() - 1) == null) res.remove(res.size() - 1);
         return res;
     }
+
+    public static List<List<Integer>> treeNodesArrayToArrayList(List<TreeNode> roots) {
+        List<List<Integer>> res = new java.util.ArrayList<>(roots.size());
+        for (TreeNode root : roots) {
+            res.add(treeNodeToArray(root));
+        }
+        return res;
+    }
 }
 
 class ListNode {
@@ -84,179 +98,100 @@ public static int[] listNodeToArray(ListNode head) {
         }
         return result;
     }
+
+    public static ListNode[] toListNodes(int[][] arrs) {
+        ListNode[] result = new ListNode[arrs.length];
+        for (int i = 0; i < arrs.length; i++) {
+            result[i] = toListNode(arrs[i]);
+        }
+        return result;
+    }
 }
 
 final class Json {
+    private static final Gson gson = new Gson();
 
-	public static String toJson(Object obj) {
-		IdentityHashMap<Object, Boolean> seen = new IdentityHashMap<>();
-		StringBuilder sb = new StringBuilder(256);
-		write(obj, sb, seen);
-		return sb.toString();
-	}
-
-	private static void write(Object obj, StringBuilder sb, IdentityHashMap<Object, Boolean> seen) {
-		if (obj == null) {
-			sb.append("null");
-			return;
-		}
-		if (obj instanceof Boolean) {
-			sb.append(((Boolean) obj) ? "true" : "false");
-			return;
-		}
-		if (obj instanceof Number) {
-			sb.append(obj);
-			return;
-		}
-		if (obj instanceof Character) {
-			quote(String.valueOf(obj), sb);
-			return;
-		}
-		if (obj instanceof CharSequence) {
-			quote(obj.toString(), sb);
-			return;
-		}
-
-		if (obj instanceof Enum) {
-			quote(((Enum<?>) obj).name(), sb);
-			return;
-		}
-
-		if (obj instanceof TemporalAccessor) {
-			quote(obj.toString(), sb);
-			return;
-		}
-		if (obj instanceof Date) {
-			quote(String.valueOf(((Date) obj).getTime()), sb);
-			return;
-		}
-		if (seen.put(obj, Boolean.TRUE) != null) {
-			throw new IllegalArgumentException("Cycle detected while encoding to json");
-		}
-		try {
-			if (obj instanceof Map<?, ?>) {
-				sb.append('{');
-				boolean first = true;
-				for (Map.Entry<?, ?> e : ((Map<?, ?>) obj).entrySet()) {
-					if (!first) {
-						sb.append(',');
-					}
-					first = false;
-					String key = String.valueOf(e.getKey());
-					quote(key, sb);
-					sb.append(':');
-					write(e.getValue(), sb, seen);
-				}
-				sb.append('}');
-				return;
-			}
-			if (obj instanceof Iterable<?>) {
-				sb.append('[');
-				boolean first = true;
-				for (Object x : (Iterable<?>) obj) {
-					if (!first) {
-						sb.append(',');
-					}
-					first = false;
-					write(x, sb, seen);
-				}
-				sb.append(']');
-				return;
-			}
-			Class<?> c = obj.getClass();
-			if (c.isArray()) {
-				sb.append('[');
-				int n = Array.getLength(obj);
-				for (int i = 0; i < n; i++) {
-					if (i > 0) {
-						sb.append(',');
-					}
-					write(Array.get(obj, i), sb, seen);
-				}
-				sb.append(']');
-				return;
-			}
-			sb.append('{');
-			boolean first = true;
-			for (Field f : allFields(c)) {
-				int m = f.getModifiers();
-				if (Modifier.isStatic(m) || Modifier.isTransient(m) || f.isSynthetic()) {
-					continue;
-				}
-				String name = f.getName();
-				if (name.startsWith("_")) {
-					continue;
-				}
-				Object v;
-				try {
-					f.setAccessible(true);
-					v = f.get(obj);
-				}
-				catch (Exception ex) {
-					continue;
-				}
-
-				if (!first) {
-					sb.append(',');
-				}
-				first = false;
-				quote(name, sb);
-				sb.append(':');
-				write(v, sb, seen);
-			}
-			sb.append('}');
-		}
-		finally {
-			seen.remove(obj);
-		}
-	}
-
-	private static List<Field> allFields(Class<?> c) {
-		List<Field> out = new ArrayList<>();
-		for (Class<?> x = c; x != null && x != Object.class; x = x.getSuperclass()) {
-			Field[] fs = x.getDeclaredFields();
-			Collections.addAll(out, fs);
-		}
-		return out;
-	}
-
-	private static void quote(String s, StringBuilder sb) {
-		sb.append('"');
-		for (int i = 0; i < s.length(); i++) {
-			char ch = s.charAt(i);
-			switch (ch) {
-				case '"':
-					sb.append("\\\"");
-					break;
-				case '\\':
-					sb.append("\\\\");
-					break;
-				case '\b':
-					sb.append("\\b");
-					break;
-				case '\f':
-					sb.append("\\f");
-					break;
-				case '\n':
-					sb.append("\\n");
-					break;
-				case '\r':
-					sb.append("\\r");
-					break;
-				case '\t':
-					sb.append("\\t");
-					break;
-				default:
-					if (ch < 0x20) {
-						sb.append(String.format("\\u%04x", (int) ch));
-					}
-					else {
-						sb.append(ch);
-					}
-			}
-		}
-		sb.append('"');
-	}
+    public static Map<String, Map<String, _TEST_>> fromJsonMap(String json) {
+        return gson.fromJson(json, new TypeToken<Map<String, Map<String, _TEST_>>>() {}.getType());
+    }
+
+    public static String toJson(Object obj) {
+        return gson.toJson(obj);
+    }
+
+    public static int toInt(Object obj) { return ((Number) obj).intValue(); }
+    public static long toLong(Object obj) { return ((Number) obj).longValue(); }
+    public static double toDouble(Object obj) { return ((Number) obj).doubleValue(); }
+    public static float toFloat(Object obj) { return ((Number) obj).floatValue(); }
+    public static boolean toBool(Object obj) { return (Boolean) obj; }
+    public static String toStringValue(Object obj) { return String.valueOf(obj); }
+    public static char toChar(Object obj) { return ((String) obj).charAt(0); }
+
+    public static Integer[] toIntegerArray(Object obj) {
+        return gson.fromJson(gson.toJsonTree(obj), Integer[].class);
+    }
+
+    public static int[] toIntArray(Object obj) {
+        return gson.fromJson(gson.toJsonTree(obj), int[].class);
+    }
+
+    public static long[] toLongArray(Object obj) {
+        return gson.fromJson(gson.toJsonTree(obj), long[].class);
+    }
+
+    public static double[] toDoubleArray(Object obj) {
+        return gson.fromJson(gson.toJsonTree(obj), double[].class);
+    }
+
+    public static float[] toFloatArray(Object obj) {
+        return gson.fromJson(gson.toJsonTree(obj), float[].class);
+    }
+
+    public static boolean[] toBoolArray(Object obj) {
+        return gson.fromJson(gson.toJsonTree(obj), boolean[].class);
+    }
+
+    public static String[] toStringArray(Object obj) {
+        return gson.fromJson(gson.toJsonTree(obj), String[].class);
+    }
+
+    public static long[][] toLongMatrix(Object obj) {
+        return gson.fromJson(gson.toJsonTree(obj), long[][].class);
+    }
+
+    public static double[][] toDoubleMatrix(Object obj) {
+        return gson.fromJson(gson.toJsonTree(obj), double[][].class);
+    }
+
+    public static float[][] toFloatMatrix(Object obj) {
+        return gson.fromJson(gson.toJsonTree(obj), float[][].class);
+    }
+
+    public static boolean[][] toBoolMatrix(Object obj) {
+        return gson.fromJson(gson.toJsonTree(obj), boolean[][].class);
+    }
+
+    public static String[][] toStringMatrix(Object obj) {
+        return gson.fromJson(gson.toJsonTree(obj), String[][].class);
+    }
+
+    public static int[][] toIntMatrix(Object obj) {
+        return gson.fromJson(gson.toJsonTree(obj), int[][].class);
+    }
+
+    public static char[] toCharArray(Object obj) {
+        ArrayList<?> list = gson.fromJson(gson.toJsonTree(obj), ArrayList.class);
+        char[] out = new char[list.size()];
+        for (int i = 0; i < list.size(); i++) out[i] = toChar(list.get(i));
+        return out;
+    }
+
+    public static char[][] toCharMatrix(Object obj) {
+        ArrayList<?> rows = gson.fromJson(gson.toJsonTree(obj), ArrayList.class);
+        char[][] out = new char[rows.size()][];
+        for (int i = 0; i < rows.size(); i++) out[i] = toCharArray(rows.get(i));
+        return out;
+    }
 }
 
 // from https://docs.oracle.com/javase/8/javafx/api/javafx/util/Pair.html
diff --git a/runtimes/kotlin/main.kt b/runtimes/kotlin/main.kt
index e317797c..c98ba98c 100644
--- a/runtimes/kotlin/main.kt
+++ b/runtimes/kotlin/main.kt
@@ -1,10 +1,23 @@
 import java.lang.reflect.*
 import java.time.temporal.TemporalAccessor
 import java.util.*
+import java.io.File
+import com.google.gson.Gson
+import com.google.gson.reflect.TypeToken
 
 import kotlin.math.*
 import java.lang.StringBuilder
 
+data class TestInput(var val: Any? = null)
+
+val _TEST_: Map<String, Map<String, TestInput>> =
+    Gson().fromJson(
+        File("test.json").readText(),
+        object : TypeToken<Map<String, Map<String, TestInput>>>() {}.type
+    )
+
+fun testVal(caseId: String, name: String): Any? = _TEST_[caseId]!![name]!!.val
+
 ${SOLUTION}
 
 ${UTILITIES}
diff --git a/runtimes/kotlin/utilities.kt b/runtimes/kotlin/utilities.kt
index 5022f7b3..ccc120ca 100644
--- a/runtimes/kotlin/utilities.kt
+++ b/runtimes/kotlin/utilities.kt
@@ -3,6 +3,82 @@ class TreeNode(var `val`: Int) {
     var right: TreeNode? = null
 }
 
+fun toIntValue(value: Any?): Int = when (value) {
+    null -> 0
+    is Number -> value.toInt()
+    else -> value.toString().toInt()
+}
+
+fun toLongValue(value: Any?): Long = when (value) {
+    null -> 0L
+    is Number -> value.toLong()
+    else -> value.toString().toLong()
+}
+
+fun toDoubleValue(value: Any?): Double = when (value) {
+    null -> 0.0
+    is Number -> value.toDouble()
+    else -> value.toString().toDouble()
+}
+
+fun toFloatValue(value: Any?): Float = toDoubleValue(value).toFloat()
+
+fun toStringValue(value: Any?): String = value?.toString() ?: ""
+
+fun toCharValue(value: Any?): Char = toStringValue(value).firstOrNull() ?: '\u0000'
+
+fun toBoolValue(value: Any?): Boolean = when (value) {
+    is Boolean -> value
+    else -> value?.toString() == "true"
+}
+
+fun toIntArrayValue(value: Any?): IntArray =
+    (value as List<*>).map { toIntValue(it) }.toIntArray()
+
+fun toLongArrayValue(value: Any?): LongArray =
+    (value as List<*>).map { toLongValue(it) }.toLongArray()
+
+fun toDoubleArrayValue(value: Any?): DoubleArray =
+    (value as List<*>).map { toDoubleValue(it) }.toDoubleArray()
+
+fun toFloatArrayValue(value: Any?): FloatArray =
+    (value as List<*>).map { toFloatValue(it) }.toFloatArray()
+
+fun toStringArrayValue(value: Any?): Array<String> =
+    (value as List<*>).map { toStringValue(it) }.toTypedArray()
+
+fun toCharArrayValue(value: Any?): CharArray =
+    (value as List<*>).map { toCharValue(it) }.toCharArray()
+
+fun toBoolArrayValue(value: Any?): BooleanArray =
+    (value as List<*>).map { toBoolValue(it) }.toBooleanArray()
+
+fun toNullableIntArrayValue(value: Any?): Array<Int?> =
+    (value as List<*>).map { if (it == null) null else toIntValue(it) }.toTypedArray()
+
+fun toIntMatrixValue(value: Any?): Array<IntArray> =
+    (value as List<*>).map { row -> toIntArrayValue(row) }.toTypedArray()
+
+fun toLongMatrixValue(value: Any?): Array<LongArray> =
+    (value as List<*>).map { row -> toLongArrayValue(row) }.toTypedArray()
+
+fun toDoubleMatrixValue(value: Any?): Array<DoubleArray> =
+    (value as List<*>).map { row -> toDoubleArrayValue(row) }.toTypedArray()
+
+fun toFloatMatrixValue(value: Any?): Array<FloatArray> =
+    (value as List<*>).map { row -> toFloatArrayValue(row) }.toTypedArray()
+
+fun toStringMatrixValue(value: Any?): Array<Array<String>> =
+    (value as List<*>).map { row -> toStringArrayValue(row) }.toTypedArray()
+
+fun toBoolMatrixValue(value: Any?): Array<BooleanArray> =
+    (value as List<*>).map { row -> toBoolArrayValue(row) }.toTypedArray()
+
+fun toCharMatrixValue(value: Any?): Array<CharArray> =
+    (value as List<*>)
+        .map { row -> toCharArrayValue(row) }
+        .toTypedArray()
+
 fun toTreeNode(arr: Array<Int?>): TreeNode? {
     if (arr.isEmpty() || arr[0] == null) return null
     val root = TreeNode(arr[0]!!)
diff --git a/runtimes/python2/main.py b/runtimes/python2/main.py
index 9deb36e2..149ee435 100644
--- a/runtimes/python2/main.py
+++ b/runtimes/python2/main.py
@@ -7,6 +7,7 @@
 import itertools
 import datetime as _dt
 import collections
+import json
 from functools import *
 from collections import *
 from heapq import *
@@ -14,6 +15,12 @@
 
 sys.setrecursionlimit(10**6)
 
+with open("test.json", "r") as _test_json_file:
+    _TEST_ = json.load(_test_json_file)
+
+def _test_val(case_id, name):
+    return _TEST_[case_id][name]["val"]
+
 ${SOLUTION}
 
 ${UTILITIES}
diff --git a/runtimes/python2/utilities.py b/runtimes/python2/utilities.py
index 826c8e4c..d27d6575 100644
--- a/runtimes/python2/utilities.py
+++ b/runtimes/python2/utilities.py
@@ -1,3 +1,6 @@
+import json
+import datetime as _dt
+
 class TreeNode(object):
     def __init__(self, val=0, left=None, right=None):
         self.val = val
@@ -67,100 +70,34 @@ def list_node_to_array(head):
 
 
 def to_json(obj):
-    seen = set()
-    return "\n" + _encode(obj, seen)
-
-
-def _encode(obj, seen):
-    if obj is None:
-        return "null"
-    if obj is True:
-        return "true"
-    if obj is False:
-        return "false"
-    if isinstance(obj, int):
-        return str(obj)
-    if isinstance(obj, float):
-        return repr(obj)
-    if isinstance(obj, bytes):
-        return _quote(obj.encode("hex") if hasattr(obj, "encode") else obj.hex())
-    if (
-        isinstance(obj, _dt.datetime)
-        or isinstance(obj, _dt.date)
-        or isinstance(obj, _dt.time)
-    ):
-        return _quote(obj.isoformat())
-    if isinstance(obj, unicode):
-        return _quote(obj.encode("utf-8"))
-    if isinstance(obj, str):
-        return _quote(obj)
-
-    oid = id(obj)
-    if oid in seen:
-        raise ValueError("Cycle detected while encoding to json")
-    seen.add(oid)
-    try:
-        if isinstance(obj, dict):
-            items = []
-            for k, v in obj.items():
-                if not isinstance(k, str) and not isinstance(k, unicode):
-                    k = str(k)
-                elif isinstance(k, unicode):
-                    k = k.encode("utf-8")
-                items.append(_quote(k) + ":" + _encode(v, seen))
-            return "{" + ",".join(items) + "}"
-
-        if isinstance(obj, (list, tuple, set, frozenset)):
-            return "[" + ",".join(_encode(x, seen) for x in obj) + "]"
-
-        if hasattr(obj, "__dict__"):
-            d = {}
-            for k, v in obj.__dict__.items():
-                if k.startswith("_"):
-                    continue
-                d[k] = v
-            return _encode(d, seen)
-
-        slots = getattr(obj, "__slots__", None)
-        if slots:
-            d = {}
-            if isinstance(slots, str):
-                slots = [slots]
-            for k in slots:
-                if k.startswith("_"):
-                    continue
-                if hasattr(obj, k):
-                    d[k] = getattr(obj, k)
-            return _encode(d, seen)
-
-        return _quote(str(obj))
-    finally:
-        seen.discard(oid)
-
-
-def _quote(s):
-    if isinstance(s, unicode):
-        s = s.encode("utf-8")
-    out = ['"']
-    for ch in s:
-        o = ord(ch)
-        if ch == '"':
-            out.append('\\"')
-        elif ch == "\\":
-            out.append("\\\\")
-        elif ch == "\b":
-            out.append("\\b")
-        elif ch == "\f":
-            out.append("\\f")
-        elif ch == "\n":
-            out.append("\\n")
-        elif ch == "\r":
-            out.append("\\r")
-        elif ch == "\t":
-            out.append("\\t")
-        elif o < 0x20:
-            out.append("\\u%04x" % o)
-        else:
-            out.append(ch)
-    out.append('"')
-    return "".join(out)
+    return json.dumps(_to_builtin(obj), ensure_ascii=False, separators=(",", ":"))
+
+
+def _to_builtin(obj):
+    if obj is None or isinstance(obj, (bool, int, float, str, unicode)):
+        return obj
+    if isinstance(obj, _dt.datetime) or isinstance(obj, _dt.date) or isinstance(obj, _dt.time):
+        return obj.isoformat()
+    if isinstance(obj, dict):
+        out = {}
+        for k, v in obj.items():
+            out[str(k)] = _to_builtin(v)
+        return out
+    if isinstance(obj, (list, tuple, set, frozenset)):
+        return [_to_builtin(x) for x in obj]
+    if hasattr(obj, "__dict__"):
+        d = {}
+        for k, v in obj.__dict__.items():
+            if not k.startswith("_"):
+                d[k] = _to_builtin(v)
+        return d
+    slots = getattr(obj, "__slots__", None)
+    if slots:
+        d = {}
+        if isinstance(slots, str):
+            slots = [slots]
+        for k in slots:
+            if not k.startswith("_") and hasattr(obj, k):
+                d[k] = _to_builtin(getattr(obj, k))
+        return d
+    return str(obj)
diff --git a/runtimes/python3/main.py b/runtimes/python3/main.py
index a8877bee..722cf7bc 100644
--- a/runtimes/python3/main.py
+++ b/runtimes/python3/main.py
@@ -7,6 +7,7 @@
 import time
 import itertools
 import datetime as _dt
+import json
 
 from typing import *
 from collections import *
@@ -17,6 +18,12 @@
 
 sys.setrecursionlimit(10**6)
 
+with open("test.json", "r", encoding="utf-8") as _test_json_file:
+    _TEST_ = json.load(_test_json_file)
+
+def _test_val(case_id, name):
+    return _TEST_[case_id][name]["val"]
+
 ${SOLUTION}
 
 ${UTILITIES}
diff --git a/runtimes/ruby/main.rb b/runtimes/ruby/main.rb
index 013aaa3a..554122ea 100644
--- a/runtimes/ruby/main.rb
+++ b/runtimes/ruby/main.rb
@@ -1,6 +1,13 @@
 require "set"
 require "date"
 require "time"
+require "json"
+
+$TEST_ = JSON.parse(File.read("test.json"))
+
+def _test_val(case_id, name)
+  $TEST_[case_id][name]["val"]
+end
 
 ${SOLUTION}
 
diff --git a/runtimes/rust/main.rs b/runtimes/rust/main.rs
index 6d9ab899..739f45e0 100644
--- a/runtimes/rust/main.rs
+++ b/runtimes/rust/main.rs
@@ -4,10 +4,12 @@ use std::time::Instant;
 use std::rc::Rc;
 use std::cell::RefCell;
 use std::collections::*;
+use std::fs;
 
 ${IMPORTS}
 
 fn main() {
+    let _TEST_ = load_test_data("test.json");
     ${INSERTION}
 }
 
diff --git a/runtimes/rust/utilities.rs b/runtimes/rust/utilities.rs
index f55ad3a0..4b0802e9 100644
--- a/runtimes/rust/utilities.rs
+++ b/runtimes/rust/utilities.rs
@@ -1,3 +1,372 @@
+#[derive(Clone, Debug)]
+pub enum JsonValue {
+    Null,
+    Bool(bool),
+    Number(f64),
+    String(String),
+    Array(Vec<JsonValue>),
+    Object(BTreeMap<String, JsonValue>),
+}
+
+#[derive(Clone, Debug)]
+pub struct TestInput {
+    pub val: JsonValue,
+}
+
+struct JsonParser<'a> {
+    src: &'a [u8],
+    pos: usize,
+}
+
+impl<'a> JsonParser<'a> {
+    fn new(src: &'a str) -> Self {
+        Self { src: src.as_bytes(), pos: 0 }
+    }
+
+    fn parse_value(&mut self) -> JsonValue {
+        self.skip_ws();
+        match self.peek() {
+            Some(b'n') => {
+                self.expect_bytes(b"null");
+                JsonValue::Null
+            }
+            Some(b't') => {
+                self.expect_bytes(b"true");
+                JsonValue::Bool(true)
+            }
+            Some(b'f') => {
+                self.expect_bytes(b"false");
+                JsonValue::Bool(false)
+            }
+            Some(b'"') => JsonValue::String(self.parse_string()),
+            Some(b'[') => self.parse_array(),
+            Some(b'{') => self.parse_object(),
+            Some(b'-') | Some(b'0'..=b'9') => self.parse_number(),
+            _ => panic!("invalid json"),
+        }
+    }
+
+    fn parse_array(&mut self) -> JsonValue {
+        self.expect(b'[');
+        let mut items = Vec::new();
+        loop {
+            self.skip_ws();
+            if self.try_consume(b']') {
+                break;
+            }
+            items.push(self.parse_value());
+            self.skip_ws();
+            if self.try_consume(b']') {
+                break;
+            }
+            self.expect(b',');
+        }
+        JsonValue::Array(items)
+    }
+
+    fn parse_object(&mut self) -> JsonValue {
+        self.expect(b'{');
+        let mut map = BTreeMap::new();
+        loop {
+            self.skip_ws();
+            if self.try_consume(b'}') {
+                break;
+            }
+            let key = self.parse_string();
+            self.skip_ws();
+            self.expect(b':');
+            let value = self.parse_value();
+            map.insert(key, value);
+            self.skip_ws();
+            if self.try_consume(b'}') {
+                break;
+            }
+            self.expect(b',');
+        }
+        JsonValue::Object(map)
+    }
+
+    fn parse_number(&mut self) -> JsonValue {
+        let start = self.pos;
+        if self.peek() == Some(b'-') {
+            self.pos += 1;
+        }
+        while matches!(self.peek(), Some(b'0'..=b'9')) {
+            self.pos += 1;
+        }
+        if self.peek() == Some(b'.') {
+            self.pos += 1;
+            while matches!(self.peek(), Some(b'0'..=b'9')) {
+                self.pos += 1;
+            }
+        }
+        if matches!(self.peek(), Some(b'e') | Some(b'E')) {
+            self.pos += 1;
+            if matches!(self.peek(), Some(b'+') | Some(b'-')) {
+                self.pos += 1;
+            }
+            while matches!(self.peek(), Some(b'0'..=b'9')) {
+                self.pos += 1;
+            }
+        }
+        let s = std::str::from_utf8(&self.src[start..self.pos]).unwrap();
+        JsonValue::Number(s.parse::<f64>().unwrap())
+    }
+
+    fn parse_string(&mut self) -> String {
+        self.expect(b'"');
+        let mut out = String::new();
+        while let Some(ch) = self.next() {
+            match ch {
+                b'"' => break,
+                b'\\' => {
+                    let esc = self.next().unwrap();
+                    match esc {
+                        b'"' => out.push('"'),
+                        b'\\' => out.push('\\'),
+                        b'/' => out.push('/'),
+                        b'b' => out.push('\u{0008}'),
+                        b'f' => out.push('\u{000c}'),
+                        b'n' => out.push('\n'),
+                        b'r' => out.push('\r'),
+                        b't' => out.push('\t'),
+                        b'u' => {
+                            let hex = std::str::from_utf8(&self.src[self.pos..self.pos + 4]).unwrap();
+                            self.pos += 4;
+                            let code = u16::from_str_radix(hex, 16).unwrap();
+                            out.push(char::from_u32(code as u32).unwrap());
+                        }
+                        _ => panic!("invalid escape"),
+                    }
+                }
+                _ => out.push(ch as char),
+            }
+        }
+        out
+    }
+
+    fn skip_ws(&mut self) {
+        while matches!(self.peek(), Some(b' ' | b'\n' | b'\r' | b'\t')) {
+            self.pos += 1;
+        }
+    }
+
+    fn expect_bytes(&mut self, bytes: &[u8]) {
+        for &b in bytes {
+            self.expect(b);
+        }
+    }
+
+    fn expect(&mut self, ch: u8) {
+        assert_eq!(self.next(), Some(ch));
+    }
+
+    fn try_consume(&mut self, ch: u8) -> bool {
+        if self.peek() == Some(ch) {
+            self.pos += 1;
+            true
+        } else {
+            false
+        }
+    }
+
+    fn peek(&self) -> Option<u8> {
+        self.src.get(self.pos).copied()
+    }
+
+    fn next(&mut self) -> Option<u8> {
+        let out = self.peek();
+        if out.is_some() {
+            self.pos += 1;
+        }
+        out
+    }
+}
+
+pub fn load_test_data(path: &str) -> BTreeMap<String, BTreeMap<String, TestInput>> {
+    let raw = fs::read_to_string(path).unwrap();
+    let root = JsonParser::new(&raw).parse_value();
+    let mut out = BTreeMap::new();
+    if let JsonValue::Object(cases) = root {
+        for (case_id, case_val) in cases {
+            let mut case_map = BTreeMap::new();
+            if let JsonValue::Object(vars) = case_val {
+                for (name, var_val) in vars {
+                    if let JsonValue::Object(test_input) = var_val {
+                        let val = test_input.get("val").cloned().unwrap_or(JsonValue::Null);
+                        case_map.insert(name, TestInput { val });
+                    }
+                }
+            }
+            out.insert(case_id, case_map);
+        }
+    }
+    out
+}
+
+pub fn json_to_i32(v: &JsonValue) -> i32 {
+    match v {
+        JsonValue::Number(n) => *n as i32,
+        _ => 0,
+    }
+}
+
+pub fn json_to_i64(v: &JsonValue) -> i64 {
+    match v {
+        JsonValue::Number(n) => *n as i64,
+        _ => 0,
+    }
+}
+
+pub fn json_to_f64(v: &JsonValue) -> f64 {
+    match v {
+        JsonValue::Number(n) => *n,
+        _ => 0.0,
+    }
+}
+
+pub fn json_to_f32(v: &JsonValue) -> f32 {
+    json_to_f64(v) as f32
+}
+
+pub fn json_to_bool(v: &JsonValue) -> bool {
+    match v {
+        JsonValue::Bool(b) => *b,
+        _ => false,
+    }
+}
+
+pub fn json_to_string(v: &JsonValue) -> String {
+    match v {
+        JsonValue::String(s) => s.clone(),
+        JsonValue::Number(n) => n.to_string(),
+        JsonValue::Bool(b) => b.to_string(),
+        JsonValue::Null => String::new(),
+        _ => String::new(),
+    }
+}
+
+pub fn json_to_char(v: &JsonValue) -> char {
+    json_to_string(v).chars().next().unwrap_or('\0')
+}
+
+pub fn json_to_i32_array(v: &JsonValue) -> Vec<i32> {
+    match v {
+        JsonValue::Array(xs) => xs.iter().map(json_to_i32).collect(),
+        _ => Vec::new(),
+    }
+}
+
+pub fn json_to_i64_array(v: &JsonValue) -> Vec<i64> {
+    match v {
+        JsonValue::Array(xs) => xs.iter().map(json_to_i64).collect(),
+        _ => Vec::new(),
+    }
+}
+
+pub fn json_to_f64_array(v: &JsonValue) -> Vec<f64> {
+    match v {
+        JsonValue::Array(xs) => xs.iter().map(json_to_f64).collect(),
+        _ => Vec::new(),
+    }
+}
+
+pub fn json_to_f32_array(v: &JsonValue) -> Vec<f32> {
+    match v {
+        JsonValue::Array(xs) => xs.iter().map(json_to_f32).collect(),
+        _ => Vec::new(),
+    }
+}
+
+pub fn json_to_string_array(v: &JsonValue) -> Vec<String> {
+    match v {
+        JsonValue::Array(xs) => xs.iter().map(json_to_string).collect(),
+        _ => Vec::new(),
+    }
+}
+
+pub fn json_to_char_array(v: &JsonValue) -> Vec<char> {
+    match v {
+        JsonValue::Array(xs) => xs.iter().map(json_to_char).collect(),
+        _ => Vec::new(),
+    }
+}
+
+pub fn json_to_bool_array(v: &JsonValue) -> Vec<bool> {
+    match v {
+        JsonValue::Array(xs) => xs.iter().map(json_to_bool).collect(),
+        _ => Vec::new(),
+    }
+}
+
+pub fn json_to_optional_i32_array(v: &JsonValue) -> Vec<Option<i32>> {
+    match v {
+        JsonValue::Array(xs) => xs
+            .iter()
+            .map(|x| match x {
+                JsonValue::Null => None,
+                _ => Some(json_to_i32(x)),
+            })
+            .collect(),
+        _ => Vec::new(),
+    }
+}
+
+pub fn json_to_char_matrix(v: &JsonValue) -> Vec<Vec<char>> {
+    match v {
+        JsonValue::Array(rows) => rows
+            .iter()
+            .map(|row| match row {
+                JsonValue::Array(cols) => cols.iter().map(json_to_char).collect(),
+                _ => Vec::new(),
+            })
+            .collect(),
+        _ => Vec::new(),
+    }
+}
+
+pub fn json_to_i32_matrix(v: &JsonValue) -> Vec<Vec<i32>> {
+    match v {
+        JsonValue::Array(rows) => rows.iter().map(json_to_i32_array).collect(),
+        _ => Vec::new(),
+    }
+}
+
+pub fn json_to_i64_matrix(v: &JsonValue) -> Vec<Vec<i64>> {
+    match v {
+        JsonValue::Array(rows) => rows.iter().map(json_to_i64_array).collect(),
+        _ => Vec::new(),
+    }
+}
+
+pub fn json_to_f64_matrix(v: &JsonValue) -> Vec<Vec<f64>> {
+    match v {
+        JsonValue::Array(rows) => rows.iter().map(json_to_f64_array).collect(),
+        _ => Vec::new(),
+    }
+}
+
+pub fn json_to_f32_matrix(v: &JsonValue) -> Vec<Vec<f32>> {
+    match v {
+        JsonValue::Array(rows) => rows.iter().map(json_to_f32_array).collect(),
+        _ => Vec::new(),
+    }
+}
+
+pub fn json_to_string_matrix(v: &JsonValue) -> Vec<Vec<String>> {
+    match v {
+        JsonValue::Array(rows) => rows.iter().map(json_to_string_array).collect(),
+        _ => Vec::new(),
+    }
+}
+
+pub fn json_to_bool_matrix(v: &JsonValue) -> Vec<Vec<bool>> {
+    match v {
+        JsonValue::Array(rows) => rows.iter().map(json_to_bool_array).collect(),
+        _ => Vec::new(),
+    }
+}
+
 #[derive(PartialEq, Eq, Clone, Debug)]
 pub struct ListNode {
     pub val: i32,
@@ -27,6 +396,10 @@ impl ListNode {
         }
         res
     }
+
+    pub fn to_list_nodes(arrs: Vec<Vec<i32>>) -> Vec<Option<Box<ListNode>>> {
+        arrs.into_iter().map(ListNode::to_list_node).collect()
+    }
 }
 
 #[derive(Debug, PartialEq, Eq)]
@@ -48,7 +421,7 @@ impl TreeNode {
         let mut queue = VecDeque::new();
         queue.push_back(Rc::clone(&root));
         let mut i = 1;
-        while i < arr.len() {
+        while !queue.is_empty() && i < arr.len() {
             if let Some(curr) = queue.pop_front() {
                 if i < arr.len() {
                     if let Some(val) = arr[i] {
@@ -97,8 +470,28 @@ pub trait ToJson {
 
 impl ToJson for i32 { fn to_json(&self) -> String { self.to_string() } }
 impl ToJson for i64 { fn to_json(&self) -> String { self.to_string() } }
-impl ToJson for f64 { fn to_json(&self) -> String { self.to_string() } }
+impl ToJson for f32 {
+    fn to_json(&self) -> String {
+        let s = self.to_string();
+        if s.contains('.') || s.contains('e') || s.contains('E') {
+            s
+        } else {
+            format!("{s}.0")
+        }
+    }
+}
+impl ToJson for f64 {
+    fn to_json(&self) -> String {
+        let s = self.to_string();
+        if s.contains('.') || s.contains('e') || s.contains('E') {
+            s
+        } else {
+            format!("{s}.0")
+        }
+    }
+}
 impl ToJson for bool { fn to_json(&self) -> String { self.to_string() } }
+impl ToJson for char { fn to_json(&self) -> String { format!("\"{}\"", self) } }
 impl ToJson for String { fn to_json(&self) -> String { format!("\"{}\"", self) } }
 
 impl<T: ToJson> ToJson for Vec<T> {
diff --git a/runtimes/swift/main.swift b/runtimes/swift/main.swift
index 1222cea2..8bc76d63 100644
--- a/runtimes/swift/main.swift
+++ b/runtimes/swift/main.swift
@@ -1,5 +1,14 @@
 import Foundation
 
+let _TEST_: [String: [String: [String: Any]]] = {
+    let data = try! Data(contentsOf: URL(fileURLWithPath: "test.json"))
+    return try! JSONSerialization.jsonObject(with: data) as! [String: [String: [String: Any]]]
+}()
+
+func testVal(_ caseId: String, _ name: String) -> Any {
+    return _TEST_[caseId]![name]!["val"]!
+}
+
 ${SOLUTION}
 
 ${UTILITIES}
diff --git a/runtimes/swift/utilities.swift b/runtimes/swift/utilities.swift
index 0466155b..21a9ea26 100644
--- a/runtimes/swift/utilities.swift
+++ b/runtimes/swift/utilities.swift
@@ -11,13 +11,108 @@ public class TreeNode {
     }
 }
 
+func anyToInt(_ value: Any) -> Int {
+    if let x = value as? Int { return x }
+    if let x = value as? Double { return Int(x) }
+    if let x = value as? NSNumber { return x.intValue }
+    return Int("\(value)") ?? 0
+}
+
+func anyToDouble(_ value: Any) -> Double {
+    if let x = value as? Double { return x }
+    if let x = value as? Int { return Double(x) }
+    if let x = value as? NSNumber { return x.doubleValue }
+    return Double("\(value)") ?? 0
+}
+
+func anyToFloat(_ value: Any) -> Float {
+    return Float(anyToDouble(value))
+}
+
+func anyToString(_ value: Any) -> String {
+    if let x = value as? String { return x }
+    return "\(value)"
+}
+
+func anyToBool(_ value: Any) -> Bool {
+    if let x = value as? Bool { return x }
+    return "\(value)" == "true"
+}
+
+func anyToIntArray(_ value: Any) -> [Int] {
+    return (value as! [Any]).map(anyToInt)
+}
+
+func anyToStringArray(_ value: Any) -> [String] {
+    return (value as! [Any]).map(anyToString)
+}
+
+func anyToDoubleArray(_ value: Any) -> [Double] {
+    return (value as! [Any]).map(anyToDouble)
+}
+
+func anyToFloatArray(_ value: Any) -> [Float] {
+    return (value as! [Any]).map(anyToFloat)
+}
+
+func anyToCharArray(_ value: Any) -> [Character] {
+    return (value as! [Any]).map { Character(anyToString($0)) }
+}
+
+func anyToBoolArray(_ value: Any) -> [Bool] {
+    return (value as! [Any]).map(anyToBool)
+}
+
+func anyToOptionalIntArray(_ value: Any) -> [Int?] {
+    return (value as! [Any]).map { item in
+        if item is NSNull { return nil }
+        return anyToInt(item)
+    }
+}
+
+func anyToIntMatrix(_ value: Any) -> [[Int]] {
+    return (value as! [Any]).map { row in
+        anyToIntArray(row)
+    }
+}
+
+func anyToDoubleMatrix(_ value: Any) -> [[Double]] {
+    return (value as! [Any]).map { row in
+        anyToDoubleArray(row)
+    }
+}
+
+func anyToFloatMatrix(_ value: Any) -> [[Float]] {
+    return (value as! [Any]).map { row in
+        anyToFloatArray(row)
+    }
+}
+
+func anyToStringMatrix(_ value: Any) -> [[String]] {
+    return (value as! [Any]).map { row in
+        anyToStringArray(row)
+    }
+}
+
+func anyToBoolMatrix(_ value: Any) -> [[Bool]] {
+    return (value as! [Any]).map { row in
+        anyToBoolArray(row)
+    }
+}
+
+func anyToCharMatrix(_ value: Any) -> [[Character]] {
+    return (value as! [Any]).map { row in
+        anyToCharArray(row)
+    }
+}
+
 func to_tree_node(_ arr: [Int?]) -> TreeNode? {
     guard !arr.isEmpty, let first = arr[0] else { return nil }
     let root = TreeNode(first)
     var queue = [root]
     var i = 1
     var qIdx = 0
-    while i < arr.count {
+    while qIdx < queue.count && i < arr.count {
         let node = queue[qIdx]
         qIdx += 1
         if i < arr.count, let leftVal = arr[i] {
@@ -51,7 +146,7 @@ func tree_node_to_array(_ root: TreeNode?) -> [Int?] {
         }
         qIdx += 1
     }
-    while res.last == nil { res.removeLast() }
+    while let last = res.last, last == nil { res.removeLast() }
     return res
 }
 
@@ -84,6 +179,10 @@ func list_node_to_array(_ head: ListNode?) -> [Int] {
     return res
 }
 
+func to_list_nodes(_ arrs: [[Int]]) -> [ListNode?] {
+    return arrs.map { to_list_node($0) }
+}
+
 func toJson(_ obj: Any?) -> String {
     var seen: [ObjectIdentifier] = []
     return encode(obj, &seen)
diff --git a/runtimes/typescript/main.ts b/runtimes/typescript/main.ts
index 2cba321b..161e9c61 100644
--- a/runtimes/typescript/main.ts
+++ b/runtimes/typescript/main.ts
@@ -1,3 +1,14 @@
+import * as fs from "fs";
+
+type _TEST_INPUT_ = { val: any };
+const _TEST_: Record<string, Record<string, _TEST_INPUT_>> = JSON.parse(
+  fs.readFileSync("test.json", "utf8")
+);
+
+function testVal(caseId: string, name: string): any {
+  return _TEST_[caseId][name].val;
+}
+
 ${SOLUTION}
 
 ${UTILITIES}
diff --git a/runtimes/typescript/utilities.ts b/runtimes/typescript/utilities.ts
index 4d2c5da7..6967c8a7 100644
--- a/runtimes/typescript/utilities.ts
+++ b/runtimes/typescript/utilities.ts
@@ -26,6 +26,10 @@ function listNodeToArray(head: ListNode | null): number[] {
   return res;
 }
 
+function toListNodes(arrs: number[][]): Array<ListNode | null> {
+  return arrs.map((arr) => toListNode(arr));
+}
+
 class TreeNode {
   val: number;
   left: TreeNode | null;
@@ -86,7 +90,9 @@ function jsonEncode(value: unknown, seen: Set<object>): string {
   if (typeof value === "boolean") return value ? "true" : "false";
   if (typeof value === "number") {
     if (!isFinite(value)) return "null";
-    return Object.is(value, -0) ? "0" : String(value);
+    if (Object.is(value, -0)) return "0.0";
+    const s = String(value);
+    return /[.eE]/.test(s) ? s : s + ".0";
   }
   if (typeof value === "string") return jsonQuote(value);
   if (Array.isArray(value)) {
diff --git a/tests/1-500/1. two-sum/manifest.yaml b/tests/1-500/1. two-sum/manifest.yaml
index b58c94c1..728baad1 100644
--- a/tests/1-500/1. two-sum/manifest.yaml	
+++ b/tests/1-500/1. two-sum/manifest.yaml	
@@ -1,19 +1,26 @@
 "entry":
   "id": 1
   "title": "two-sum"
+  "params":
+    nums:
+      type: array
+      items:
+        type: int
+    target:
+      type: int
   "call":
-    "cpp": "Solution().twoSum(lv(vector<int>{ {nums} }), {target})"
-    "rust": "Solution::two_sum(vec![{nums}], {target})"
-    "python3": "Solution().twoSum([{nums}], {target})"
-    "python2": "Solution().twoSum([{nums}], {target})"
-    "ruby": "two_sum([{nums}], {target})"
-    "java": "new Solution().twoSum(new int[]{ {nums} }, {target})"
-    "csharp": "new Solution().TwoSum(new int[]{ {nums} }, {target})"
-    "kotlin": "Solution().twoSum(intArrayOf({nums}), {target})"
-    "go": "twoSum([]int{ {nums} }, {target})"
-    "dart": "Solution().twoSum([{nums}], {target})"
-    "swift": "Solution().twoSum([{nums}], {target})"
-    "typescript": "twoSum([{nums}], {target})"
+    "cpp": "Solution().twoSum({nums}, {target})"
+    "rust": "Solution::two_sum({nums}, {target})"
+    "python3": "Solution().twoSum({nums}, {target})"
+    "python2": "Solution().twoSum({nums}, {target})"
+    "ruby": "two_sum({nums}, {target})"
+    "java": "new Solution().twoSum({nums}, {target})"
+    "csharp": "new Solution().TwoSum({nums}, {target})"
+    "kotlin": "Solution().twoSum({nums}, {target})"
+    "go": "twoSum({nums}, {target})"
+    "dart": "Solution().twoSum({nums}, {target})"
+    "swift": "Solution().twoSum({nums}, {target})"
+    "typescript": "twoSum({nums}, {target})"
 "judge":
   "type": "exact"
 "limits":
@@ -21,7 +28,7 @@
   "memory_mb": 256
 "oracle":
   "python3":
-    "call": "Checker().check([{nums}], {target}, {result})"
+    "call": "Checker().check(nums, target, {result})"
     "checker":
       "class Checker:\n  def check(self, nums, target, result):\n    if len(result)\
       \ != 2: return False\n    i, j = result\n    if i < 0 or i >= len(nums) or j\
diff --git a/tests/1-500/10. regular-expression-matching/manifest.yaml b/tests/1-500/10. regular-expression-matching/manifest.yaml
index 72b814dd..6d805003 100644
--- a/tests/1-500/10. regular-expression-matching/manifest.yaml	
+++ b/tests/1-500/10. regular-expression-matching/manifest.yaml	
@@ -2,18 +2,23 @@ entry:
   id: 10
   title: regular-expression-matching
   call:
-    cpp: Solution().isMatch("{s}", "{p}")
-    rust: Solution::is_match("{s}".to_string(), "{p}".to_string())
-    python3: Solution().isMatch("{s}", "{p}")
-    python2: Solution().isMatch("{s}", "{p}")
-    ruby: is_match("{s}", "{p}")
-    java: new Solution().isMatch("{s}", "{p}")
-    csharp: new Solution().IsMatch("{s}", "{p}")
-    kotlin: Solution().isMatch("{s}", "{p}")
-    go: isMatch("{s}", "{p}")
-    dart: Solution().isMatch("{s}", "{p}")
-    swift: Solution().isMatch("{s}", "{p}")
-    typescript: isMatch("{s}", "{p}")
+    cpp: Solution().isMatch({s}, {p})
+    rust: Solution::is_match({s}.to_string(), {p}.to_string())
+    python3: Solution().isMatch({s}, {p})
+    python2: Solution().isMatch({s}, {p})
+    ruby: is_match({s}, {p})
+    java: new Solution().isMatch({s}, {p})
+    csharp: new Solution().IsMatch({s}, {p})
+    kotlin: Solution().isMatch({s}, {p})
+    go: isMatch({s}, {p})
+    dart: Solution().isMatch({s}, {p})
+    swift: Solution().isMatch({s}, {p})
+    typescript: isMatch({s}, {p})
+  params:
+    s:
+      type: string
+    p:
+      type: string
 judge:
   type: exact
 limits:
@@ -21,7 +26,7 @@ limits:
   memory_mb: 256
 oracle:
   python3:
-    call: Checker().isMatch("{s}", "{p}", {result})
+    call: Checker().isMatch(s, p, {result})
     checker:
       "import json\nclass Checker:\n    def _norm(self, result):\n        if\
       \ isinstance(result, str):\n            try:\n                result = json.loads(result)\n\
diff --git a/tests/1-500/100. same-tree/manifest.yaml b/tests/1-500/100. same-tree/manifest.yaml
index 0d7e2c3e..dee310e5 100644
--- a/tests/1-500/100. same-tree/manifest.yaml	
+++ b/tests/1-500/100. same-tree/manifest.yaml	
@@ -2,26 +2,23 @@ entry:
   id: 100
   title: same-tree
   call:
-    cpp:
-      Solution().isSameTree(toTreeNode(lv(vector<optional<int>>{ {p} })), toTreeNode(lv(vector<optional<int>>{
-      {q} })))
-    rust: Solution::is_same_tree(TreeNode::to_tree_node(vec![{p}]), TreeNode::to_tree_node(vec![{q}]))
-    python3: Solution().isSameTree(to_tree_node([{p}]), to_tree_node([{q}]))
-    python2: Solution().isSameTree(to_tree_node([{p}]), to_tree_node([{q}]))
-    ruby: is_same_tree(to_tree_node([{p}]), to_tree_node([{q}]))
-    java:
-      new Solution().isSameTree(TreeNode.toTreeNode(new Integer[]{ {p} }), TreeNode.toTreeNode(new
-      Integer[]{ {q} }))
-    csharp:
-      new Solution().IsSameTree(TreeNode.ToTreeNode(new int?[]{ {p} }), TreeNode.ToTreeNode(new
-      int?[]{ {q} }))
-    kotlin: Solution().isSameTree(toTreeNode(arrayOf({p})), toTreeNode(arrayOf({q})))
-    go:
-      isSameTree(toTreeNode([]interface{}{ {p} }), toTreeNode([]interface{}{ {q}
-      }))
-    dart: Solution().isSameTree(to_tree_node([{p}]), to_tree_node([{q}]))
-    swift: Solution().isSameTree(to_tree_node([{p}]), to_tree_node([{q}]))
-    typescript: isSameTree(toTreeNode([{p}]), toTreeNode([{q}]))
+    cpp: Solution().isSameTree({p}, {q})
+    rust: Solution::is_same_tree({p}, {q})
+    python3: Solution().isSameTree({p}, {q})
+    python2: Solution().isSameTree({p}, {q})
+    ruby: is_same_tree({p}, {q})
+    java: new Solution().isSameTree({p}, {q})
+    csharp: new Solution().IsSameTree({p}, {q})
+    kotlin: Solution().isSameTree({p}, {q})
+    go: isSameTree({p}, {q})
+    dart: Solution().isSameTree({p}, {q})
+    swift: Solution().isSameTree({p}, {q})
+    typescript: isSameTree({p}, {q})
+  params:
+    p:
+      type: tree_node
+    q:
+      type: tree_node
 judge:
   type: exact
 limits:
@@ -29,10 +26,8 @@ limits:
   memory_mb: 256
 oracle:
   python3:
-    call: Checker().isSameTree([{p}], [{q}], {result})
-    checker:
-      "class Checker:\n    def isSameTree(self, p_arr, q_arr, result):\n  \
-      \      return result == (p_arr == q_arr)\n"
+    call: Checker().isSameTree({p}, {q}, {result})
+    checker: "class Checker:\n    def isSameTree(self, p_arr, q_arr, result):\n        return result == (p_arr == q_arr)\n"
 seed: 42
 tests:
   - name: Example 1
@@ -53,7 +48,7 @@ tests:
         - 2
       q:
         - 1
-        - null
+        -
         - 2
     out: false
   - name: Example 3
@@ -97,12 +92,12 @@ tests:
       p:
         - 1
         - 2
-        - null
+        -
         - 3
       q:
         - 1
         - 2
-        - null
+        -
         - 3
     out: true
   - name: Left skewed different
@@ -110,27 +105,27 @@ tests:
       p:
         - 1
         - 2
-        - null
+        -
         - 3
       q:
         - 1
         - 2
-        - null
+        -
         - 4
     out: false
   - name: Right skewed identical
     in:
       p:
         - 1
-        - null
+        -
         - 2
-        - null
+        -
         - 3
       q:
         - 1
-        - null
+        -
         - 2
-        - null
+        -
         - 3
     out: true
   - name: Max values
@@ -225,12 +220,12 @@ tests:
     in:
       p:
         - 1
-        - null
+        -
         - 2
         - 3
       q:
         - 1
-        - null
+        -
         - 2
         - 3
     out: true
@@ -248,19 +243,19 @@ tests:
     in:
       p:
         - 1
-        - null
+        -
         - 2
-        - null
+        -
         - 3
-        - null
+        -
         - 4
       q:
         - 1
-        - null
+        -
         - 2
-        - null
+        -
         - 3
-        - null
+        -
         - 4
     out: true
   - name: Generative test 1
@@ -304,15 +299,15 @@ tests:
     in:
       p:
         - 5
-        - null
+        -
         - 6
-        - null
+        -
         - 7
       q:
         - 5
-        - null
+        -
         - 6
-        - null
+        -
         - 7
     out: true
   - name: Generative test 5
diff --git a/tests/1-500/11. container-with-most-water/manifest.yaml b/tests/1-500/11. container-with-most-water/manifest.yaml
index 9cee2960..a61f7e92 100644
--- a/tests/1-500/11. container-with-most-water/manifest.yaml	
+++ b/tests/1-500/11. container-with-most-water/manifest.yaml	
@@ -2,18 +2,23 @@ entry:
   id: 11
   title: container-with-most-water
   call:
-    cpp: Solution().maxArea(lv(vector<int>{ {height} }))
-    rust: Solution::max_area(vec![{height}])
-    python3: Solution().maxArea([{height}])
-    python2: Solution().maxArea([{height}])
-    ruby: max_area([{height}])
-    java: new Solution().maxArea(new int[]{ {height} })
-    csharp: new Solution().MaxArea(new int[]{ {height} })
-    kotlin: Solution().maxArea(intArrayOf({height}))
-    go: maxArea([]int{ {height} })
-    dart: Solution().maxArea([{height}])
-    swift: Solution().maxArea([{height}])
-    typescript: maxArea([{height}])
+    cpp: Solution().maxArea({height})
+    rust: Solution::max_area({height})
+    python3: Solution().maxArea({height})
+    python2: Solution().maxArea({height})
+    ruby: max_area({height})
+    java: new Solution().maxArea({height})
+    csharp: new Solution().MaxArea({height})
+    kotlin: Solution().maxArea({height})
+    go: maxArea({height})
+    dart: Solution().maxArea({height})
+    swift: Solution().maxArea({height})
+    typescript: maxArea({height})
+  params:
+    height:
+      type: array
+      items:
+        type: int
 judge:
   type: exact
 limits:
@@ -21,13 +26,11 @@ limits:
   memory_mb: 256
 oracle:
   python3:
-    call: Checker().maxArea([{height}], {result})
+    call: Checker().maxArea({height}, {result})
     checker:
-      "class Checker:\n    def maxArea(self, height, expected):\n        l,\
-      \ r = 0, len(height) - 1\n        actual = 0\n        while l < r:\n       \
-      \     actual = max(actual, min(height[l], height[r]) * (r - l))\n          \
-      \  if height[l] < height[r]: l += 1\n            else: r -= 1\n        return\
-      \ actual == expected\n"
+      "class Checker:\n    def maxArea(self, height, expected):\n        l, r = 0, len(height) - 1\n        actual
+      = 0\n        while l < r:\n            actual = max(actual, min(height[l], height[r]) * (r - l))\n            if height[l]
+      < height[r]: l += 1\n            else: r -= 1\n        return actual == expected\n"
 seed: 42
 tests:
   - name: example 1
diff --git a/tests/1-500/12. integer-to-roman/manifest.yaml b/tests/1-500/12. integer-to-roman/manifest.yaml
index 4c4120da..36076bbc 100644
--- a/tests/1-500/12. integer-to-roman/manifest.yaml	
+++ b/tests/1-500/12. integer-to-roman/manifest.yaml	
@@ -14,6 +14,9 @@ entry:
     dart: Solution().intToRoman({num})
     swift: Solution().intToRoman({num})
     typescript: intToRoman({num})
+  params:
+    num:
+      type: int
 judge:
   type: exact
 limits:
@@ -41,72 +44,95 @@ tests:
   - name: Example 1
     in:
       num: 3749
+    out: MMMDCCXLIX
   - name: Example 2
     in:
       num: 58
+    out: LVIII
   - name: Example 3
     in:
       num: 1994
+    out: MCMXCIV
   - name: Boundary min
     in:
       num: 1
+    out: I
   - name: Boundary max
     in:
       num: 3999
+    out: MMMCMXCIX
   - name: Small values 1-10
     in:
       num: 9
+    out: IX
   - name: Small values 1-10_2
     in:
       num: 4
+    out: IV
   - name: Tens and Fifties 1
     in:
       num: 40
+    out: XL
   - name: Tens and Fifties 2
     in:
       num: 90
+    out: XC
   - name: Hundreds 1
     in:
       num: 400
+    out: CD
   - name: Hundreds 2
     in:
       num: 900
+    out: CM
   - name: Thousands
     in:
       num: 3000
+    out: MMM
   - name: Exact Power 10
     in:
       num: 10
+    out: X
   - name: Repeated symbols
     in:
       num: 333
+    out: CCCXXXIII
   - name: Complex 2888
     in:
       num: 2888
+    out: MMDCCCLXXXVIII
   - name: Near 500
     in:
       num: 499
+    out: CDXCIX
   - name: Near 1000
     in:
       num: 999
+    out: CMXCIX
   - name: Near 50
     in:
       num: 49
+    out: XLIX
   - name: Random 1
     in:
       num: 123
+    out: CXXIII
   - name: Random 2
     in:
       num: 444
+    out: CDXLIV
   - name: Random 3
     in:
       num: 888
+    out: DCCCLXXXVIII
   - name: Random 4
     in:
       num: 2499
+    out: MMCDXCIX
   - name: Max bounds check 1
     in:
       num: 3888
+    out: MMMDCCCLXXXVIII
   - name: Gen 1
     in:
       num:
diff --git a/tests/1-500/13. roman-to-integer/manifest.yaml b/tests/1-500/13. roman-to-integer/manifest.yaml
index 706c5aaf..b8656b3b 100644
--- a/tests/1-500/13. roman-to-integer/manifest.yaml	
+++ b/tests/1-500/13. roman-to-integer/manifest.yaml	
@@ -2,18 +2,21 @@ entry:
   id: 13
   title: roman-to-integer
   call:
-    cpp: Solution().romanToInt("{s}")
-    rust: Solution::roman_to_int(String::from("{s}"))
-    python3: Solution().romanToInt("{s}")
-    python2: Solution().romanToInt("{s}")
-    ruby: roman_to_int("{s}")
-    java: new Solution().romanToInt("{s}")
-    csharp: new Solution().RomanToInt("{s}")
-    kotlin: Solution().romanToInt("{s}")
-    go: romanToInt("{s}")
-    dart: Solution().romanToInt("{s}")
-    swift: Solution().romanToInt("{s}")
-    typescript: romanToInt("{s}")
+    cpp: Solution().romanToInt({s})
+    rust: Solution::roman_to_int(String::from({s}))
+    python3: Solution().romanToInt({s})
+    python2: Solution().romanToInt({s})
+    ruby: roman_to_int({s})
+    java: new Solution().romanToInt({s})
+    csharp: new Solution().RomanToInt({s})
+    kotlin: Solution().romanToInt({s})
+    go: romanToInt({s})
+    dart: Solution().romanToInt({s})
+    swift: Solution().romanToInt({s})
+    typescript: romanToInt({s})
+  params:
+    s:
+      type: string
 judge:
   type: exact
 limits:
@@ -21,7 +24,7 @@ limits:
   memory_mb: 256
 oracle:
   python3:
-    call: Checker().check("{s}", {result})
+    call: Checker().check(s, {result})
     checker:
       "class Checker:\n    def check(self, s, result):\n        roman = {'I':\
       \ 1, 'V': 5, 'X': 10, 'L': 50, 'C': 100, 'D': 500, 'M': 1000}\n        res =\
diff --git a/tests/1-500/14. longest-common-prefix/manifest.yaml b/tests/1-500/14. longest-common-prefix/manifest.yaml
index bce8cbb8..57d67842 100644
--- a/tests/1-500/14. longest-common-prefix/manifest.yaml	
+++ b/tests/1-500/14. longest-common-prefix/manifest.yaml	
@@ -2,18 +2,23 @@
   "id": 14
   "title": "longest-common-prefix"
   "call":
-    "cpp": "Solution().longestCommonPrefix(lv(vector<string>{ {strs} }))"
-    "rust": "Solution::longest_common_prefix(vec![{strs}])"
-    "python3": "Solution().longestCommonPrefix([{strs}])"
-    "python2": "Solution().longestCommonPrefix([{strs}])"
-    "ruby": "longest_common_prefix([{strs}])"
-    "java": "new Solution().longestCommonPrefix(new String[]{ {strs} })"
-    "csharp": "new Solution().LongestCommonPrefix(new string[]{ {strs} })"
-    "kotlin": "Solution().longestCommonPrefix(arrayOf({strs}))"
-    "go": "longestCommonPrefix([]string{ {strs} })"
-    "dart": "Solution().longestCommonPrefix([{strs}])"
-    "swift": "Solution().longestCommonPrefix([{strs}])"
-    "typescript": "longestCommonPrefix([{strs}])"
+    "cpp": "Solution().longestCommonPrefix({strs})"
+    "rust": "Solution::longest_common_prefix({strs})"
+    "python3": "Solution().longestCommonPrefix({strs})"
+    "python2": "Solution().longestCommonPrefix({strs})"
+    "ruby": "longest_common_prefix({strs})"
+    "java": "new Solution().longestCommonPrefix({strs})"
+    "csharp": "new Solution().LongestCommonPrefix({strs})"
+    "kotlin": "Solution().longestCommonPrefix({strs})"
+    "go": "longestCommonPrefix({strs})"
+    "dart": "Solution().longestCommonPrefix({strs})"
+    "swift": "Solution().longestCommonPrefix({strs})"
+    "typescript": "longestCommonPrefix({strs})"
+  params:
+    strs:
+      type: array
+      items:
+        type: string
 "judge":
   "type": "exact"
 "limits":
@@ -21,14 +26,12 @@
   "memory_mb": 256
 "oracle":
   "python3":
-    "call": "Checker().longestCommonPrefix([{strs}], {result})"
+    "call": "Checker().longestCommonPrefix(strs, {result})"
     "checker":
-      "import json\n\nclass Checker:\n    def longestCommonPrefix(self, strs,\
-      \ result):\n        try:\n            result = json.loads(result) if isinstance(result,\
-      \ str) else result\n        except Exception:\n            return False\n  \
-      \      if not strs:\n            return result == \"\"\n        prefix = min(strs,\
-      \ key=len)\n        for s in strs:\n            while not s.startswith(prefix):\n\
-      \                prefix = prefix[:-1]\n        return result == prefix\n"
+      "import json\n\nclass Checker:\n    def longestCommonPrefix(self, strs, result):\n        try:\n          \
+      \  result = json.loads(result) if isinstance(result, str) else result\n        except Exception:\n            return
+      False\n        if not strs:\n            return result == \"\"\n        prefix = min(strs, key=len)\n        for s in
+      strs:\n            while not s.startswith(prefix):\n                prefix = prefix[:-1]\n        return result == prefix\n"
 "seed": 42
 "tests":
   - "name": "example 1"
@@ -37,98 +40,116 @@
         - "flower"
         - "flow"
         - "flight"
+    "out": "fl"
   - "name": "example 2"
     "in":
       "strs":
         - "dog"
         - "racecar"
         - "car"
+    "out": ""
   - "name": "single string"
     "in":
       "strs":
         - "anything"
+    "out": "anything"
   - "name": "identical strings"
     "in":
       "strs":
         - "test"
         - "test"
         - "test"
+    "out": "test"
   - "name": "empty string in array"
     "in":
       "strs":
         - "a"
         - ""
+    "out": ""
   - "name": "all empty strings"
     "in":
       "strs":
         - ""
         - ""
         - ""
+    "out": ""
   - "name": "large overlap"
     "in":
       "strs":
         - "abcdefg"
         - "abcdefg"
         - "abcdefg"
+    "out": "abcdefg"
   - "name": "no overlap"
     "in":
       "strs":
         - "abc"
         - "def"
         - "ghi"
+    "out": ""
   - "name": "single character prefix"
     "in":
       "strs":
         - "a"
         - "ab"
         - "abc"
+    "out": "a"
   - "name": "mismatched lengths"
     "in":
       "strs":
         - "interspecies"
         - "interstellar"
         - "interstate"
+    "out": "inters"
   - "name": "only one string"
     "in":
       "strs":
         - "z"
+    "out": "z"
   - "name": "two strings"
     "in":
       "strs":
         - "apple"
         - "apply"
+    "out": "appl"
   - "name": "prefix at end"
     "in":
       "strs":
         - "aa"
         - "a"
+    "out": "a"
   - "name": "random small strings"
     "in":
       "strs":
         - "pre"
         - "prefix"
         - "preheat"
+    "out": "pre"
   - "name": "long random strings"
     "in":
       "strs":
         - "longprefixstring"
         - "longprefixstorage"
         - "longprefixstuff"
+    "out": "longprefixst"
   - "name": "strings only last char same"
     "in":
       "strs":
         - "x"
         - "y"
         - "z"
+    "out": ""
   - "name": "strings share partial middle"
     "in":
       "strs":
         - "abac"
         - "abad"
         - "abae"
+    "out": "aba"
   - "name": "case sensitivity check"
     "in":
       "strs":
         - "Flower"
         - "Flow"
         - "Flight"
+    "out": "Fl"
diff --git a/tests/1-500/15. 3sum/manifest.yaml b/tests/1-500/15. 3sum/manifest.yaml
index 691769ff..aafad622 100644
--- a/tests/1-500/15. 3sum/manifest.yaml	
+++ b/tests/1-500/15. 3sum/manifest.yaml	
@@ -2,18 +2,23 @@ entry:
   id: 15
   title: 3sum
   call:
-    cpp: Solution().threeSum(lv(vector<int>{ {nums} }))
-    rust: Solution::three_sum(vec![{nums}])
-    python3: Solution().threeSum([{nums}])
-    python2: Solution().threeSum([{nums}])
-    ruby: three_sum([{nums}])
-    java: new Solution().threeSum(new int[]{ {nums} })
-    csharp: new Solution().ThreeSum(new int[]{ {nums} })
-    kotlin: Solution().threeSum(intArrayOf({nums}))
-    go: threeSum([]int{ {nums} })
-    dart: Solution().threeSum([{nums}])
-    swift: Solution().threeSum([{nums}])
-    typescript: threeSum([{nums}])
+    cpp: Solution().threeSum({nums})
+    rust: Solution::three_sum({nums})
+    python3: Solution().threeSum({nums})
+    python2: Solution().threeSum({nums})
+    ruby: three_sum({nums})
+    java: new Solution().threeSum({nums})
+    csharp: new Solution().ThreeSum({nums})
+    kotlin: Solution().threeSum({nums})
+    go: threeSum({nums})
+    dart: Solution().threeSum({nums})
+    swift: Solution().threeSum({nums})
+    typescript: threeSum({nums})
+  params:
+    nums:
+      type: array
+      items:
+        type: int
 judge:
   type: ignore_order
 limits:
@@ -21,23 +26,18 @@ limits:
   memory_mb: 256
 oracle:
   python3:
-    call: Checker().check([{nums}], {result})
+    call: Checker().check({nums}, {result})
     checker:
-      "import json\nclass Checker:\n    def _norm(self, result):\n        if\
-      \ isinstance(result, str):\n            try:\n                result = json.loads(result)\n\
-      \            except Exception:\n                pass\n        return result\n\
-      \n    def check(self, nums, result):\n        result = self._norm(result)\n\
-      \        nums.sort()\n        expected = []\n        n = len(nums)\n       \
-      \ for i in range(n - 2):\n            if i > 0 and nums[i] == nums[i - 1]:\n\
-      \                continue\n            j, k = i + 1, n - 1\n            while\
-      \ j < k:\n                s = nums[i] + nums[j] + nums[k]\n                if\
-      \ s == 0:\n                    expected.append([nums[i], nums[j], nums[k]])\n\
-      \                    j += 1\n                    k -= 1\n                  \
-      \  while j < k and nums[j] == nums[j - 1]:\n                        j += 1\n\
-      \                elif s < 0:\n                    j += 1\n                else:\n\
-      \                    k -= 1\n        res_sorted = sorted([sorted(x) for x in\
-      \ result])\n        exp_sorted = sorted([sorted(x) for x in expected])\n   \
-      \     return res_sorted == exp_sorted\n"
+      "import json\nclass Checker:\n    def _norm(self, result):\n        if isinstance(result, str):\n           \
+      \ try:\n                result = json.loads(result)\n            except Exception:\n                pass\n        return
+      result\n\n    def check(self, nums, result):\n        result = self._norm(result)\n        nums.sort()\n        expected
+      = []\n        n = len(nums)\n        for i in range(n - 2):\n            if i > 0 and nums[i] == nums[i - 1]:\n    \
+      \            continue\n            j, k = i + 1, n - 1\n            while j < k:\n                s = nums[i] + nums[j]
+      + nums[k]\n                if s == 0:\n                    expected.append([nums[i], nums[j], nums[k]])\n          \
+      \          j += 1\n                    k -= 1\n                    while j < k and nums[j] == nums[j - 1]:\n       \
+      \                 j += 1\n                elif s < 0:\n                    j += 1\n                else:\n         \
+      \           k -= 1\n        res_sorted = sorted([sorted(x) for x in result])\n        exp_sorted = sorted([sorted(x)
+      for x in expected])\n        return res_sorted == exp_sorted\n"
 seed: 42
 tests:
   - name: Example 1
diff --git a/tests/1-500/16. 3sum-closest/manifest.yaml b/tests/1-500/16. 3sum-closest/manifest.yaml
index f336cef6..d09eed0c 100644
--- a/tests/1-500/16. 3sum-closest/manifest.yaml	
+++ b/tests/1-500/16. 3sum-closest/manifest.yaml	
@@ -2,18 +2,25 @@ entry:
   id: 16
   title: 3sum-closest
   call:
-    cpp: Solution().threeSumClosest(lv(vector<int>{ {nums} }), {target})
-    rust: Solution::three_sum_closest(vec![{nums}], {target})
-    python3: Solution().threeSumClosest([{nums}], {target})
-    python2: Solution().threeSumClosest([{nums}], {target})
-    ruby: three_sum_closest([{nums}], {target})
-    java: new Solution().threeSumClosest(new int[]{ {nums} }, {target})
-    csharp: new Solution().ThreeSumClosest(new int[]{ {nums} }, {target})
-    kotlin: Solution().threeSumClosest(intArrayOf({nums}), {target})
-    go: threeSumClosest([]int{ {nums} }, {target})
-    dart: Solution().threeSumClosest([{nums}], {target})
-    swift: Solution().threeSumClosest([{nums}], {target})
-    typescript: threeSumClosest([{nums}], {target})
+    cpp: Solution().threeSumClosest({nums}, {target})
+    rust: Solution::three_sum_closest({nums}, {target})
+    python3: Solution().threeSumClosest({nums}, {target})
+    python2: Solution().threeSumClosest({nums}, {target})
+    ruby: three_sum_closest({nums}, {target})
+    java: new Solution().threeSumClosest({nums}, {target})
+    csharp: new Solution().ThreeSumClosest({nums}, {target})
+    kotlin: Solution().threeSumClosest({nums}, {target})
+    go: threeSumClosest({nums}, {target})
+    dart: Solution().threeSumClosest({nums}, {target})
+    swift: Solution().threeSumClosest({nums}, {target})
+    typescript: threeSumClosest({nums}, {target})
+  params:
+    nums:
+      type: array
+      items:
+        type: int
+    target:
+      type: int
 judge:
   type: exact
 limits:
@@ -21,22 +28,18 @@ limits:
   memory_mb: 256
 oracle:
   python3:
-    call: Checker().threeSumClosest([{nums}], {target}, {result})
+    call: Checker().threeSumClosest({nums}, {target}, {result})
     checker:
-      "import json\nclass Checker:\n    def _norm(self, result):\n        if\
-      \ isinstance(result, str):\n            try:\n                result = json.loads(result)\n\
-      \            except Exception:\n                pass\n            if isinstance(result,\
-      \ str):\n                low = result.strip().lower()\n                if low\
-      \ == 'true':\n                    return True\n                if low == 'false':\n\
-      \                    return False\n                if low.lstrip('-').isdigit():\n\
-      \                    return int(low)\n        return result\n\n    def threeSumClosest(self,\
-      \ nums, target, result):\n        result = self._norm(result)\n        n = len(nums)\n\
-      \        best = float('inf')\n        actual_closest = 0\n        for i in range(n):\n\
-      \            for j in range(i + 1, n):\n                for k in range(j + 1,\
-      \ n):\n                    s = nums[i] + nums[j] + nums[k]\n               \
-      \     if abs(target - s) < best:\n                        best = abs(target\
-      \ - s)\n                        actual_closest = s\n        return result ==\
-      \ actual_closest\n"
+      "import json\nclass Checker:\n    def _norm(self, result):\n        if isinstance(result, str):\n           \
+      \ try:\n                result = json.loads(result)\n            except Exception:\n                pass\n         \
+      \   if isinstance(result, str):\n                low = result.strip().lower()\n                if low == 'true':\n \
+      \                   return True\n                if low == 'false':\n                    return False\n            \
+      \    if low.lstrip('-').isdigit():\n                    return int(low)\n        return result\n\n    def threeSumClosest(self,
+      nums, target, result):\n        result = self._norm(result)\n        n = len(nums)\n        best = float('inf')\n  \
+      \      actual_closest = 0\n        for i in range(n):\n            for j in range(i + 1, n):\n                for k
+      in range(j + 1, n):\n                    s = nums[i] + nums[j] + nums[k]\n                    if abs(target - s) < best:\n\
+      \                        best = abs(target - s)\n                        actual_closest = s\n        return result ==
+      actual_closest\n"
 seed: 42
 tests:
   - name: Example 1
diff --git a/tests/1-500/17. letter-combinations-of-a-phone-number/manifest.yaml b/tests/1-500/17. letter-combinations-of-a-phone-number/manifest.yaml
index 42707fa6..0ac091b4 100644
--- a/tests/1-500/17. letter-combinations-of-a-phone-number/manifest.yaml	
+++ b/tests/1-500/17. letter-combinations-of-a-phone-number/manifest.yaml	
@@ -2,18 +2,21 @@ entry:
   id: 17
   title: letter-combinations-of-a-phone-number
   call:
-    cpp: Solution().letterCombinations("{digits}")
-    rust: Solution::letter_combinations("{digits}".to_string())
-    python3: Solution().letterCombinations("{digits}")
-    python2: Solution().letterCombinations("{digits}")
-    ruby: letter_combinations("{digits}")
-    java: new Solution().letterCombinations("{digits}")
-    csharp: new Solution().LetterCombinations("{digits}")
-    kotlin: Solution().letterCombinations("{digits}")
-    go: letterCombinations("{digits}")
-    dart: Solution().letterCombinations("{digits}")
-    swift: Solution().letterCombinations("{digits}")
-    typescript: letterCombinations("{digits}")
+    cpp: Solution().letterCombinations({digits})
+    rust: Solution::letter_combinations({digits}.to_string())
+    python3: Solution().letterCombinations({digits})
+    python2: Solution().letterCombinations({digits})
+    ruby: letter_combinations({digits})
+    java: new Solution().letterCombinations({digits})
+    csharp: new Solution().LetterCombinations({digits})
+    kotlin: Solution().letterCombinations({digits})
+    go: letterCombinations({digits})
+    dart: Solution().letterCombinations({digits})
+    swift: Solution().letterCombinations({digits})
+    typescript: letterCombinations({digits})
+  params:
+    digits:
+      type: string
 judge:
   type: ignore_order
 limits:
@@ -21,7 +24,7 @@ limits:
   memory_mb: 256
 oracle:
   python3:
-    call: Checker().check("{digits}", {result})
+    call: Checker().check(digits, {result})
     checker:
       "import json\nclass Checker:\n    def _norm(self, result):\n        if\
       \ isinstance(result, str):\n            try:\n                result = json.loads(result)\n\
diff --git a/tests/1-500/18. 4sum/manifest.yaml b/tests/1-500/18. 4sum/manifest.yaml
index 7103f6bd..9b86c4c5 100644
--- a/tests/1-500/18. 4sum/manifest.yaml	
+++ b/tests/1-500/18. 4sum/manifest.yaml	
@@ -2,18 +2,25 @@ entry:
   id: 18
   title: 4sum
   call:
-    cpp: Solution().fourSum(lv(vector<int>{ {nums} }), {target})
-    rust: Solution::four_sum(vec![{nums}], {target})
-    python3: Solution().fourSum([{nums}], {target})
-    python2: Solution().fourSum([{nums}], {target})
-    ruby: four_sum([{nums}], {target})
-    java: new Solution().fourSum(new int[]{ {nums} }, {target})
-    csharp: new Solution().FourSum(new int[]{ {nums} }, {target})
-    kotlin: Solution().fourSum(intArrayOf({nums}), {target})
-    go: fourSum([]int{ {nums} }, {target})
-    dart: Solution().fourSum([{nums}], {target})
-    swift: Solution().fourSum([{nums}], {target})
-    typescript: fourSum([{nums}], {target})
+    cpp: Solution().fourSum({nums}, {target})
+    rust: Solution::four_sum({nums}, {target})
+    python3: Solution().fourSum({nums}, {target})
+    python2: Solution().fourSum({nums}, {target})
+    ruby: four_sum({nums}, {target})
+    java: new Solution().fourSum({nums}, {target})
+    csharp: new Solution().FourSum({nums}, {target})
+    kotlin: Solution().fourSum({nums}, {target})
+    go: fourSum({nums}, {target})
+    dart: Solution().fourSum({nums}, {target})
+    swift: Solution().fourSum({nums}, {target})
+    typescript: fourSum({nums}, {target})
+  params:
+    nums:
+      type: array
+      items:
+        type: int
+    target:
+      type: int
 judge:
   type: ignore_order
 limits:
@@ -21,30 +28,22 @@ limits:
   memory_mb: 256
 oracle:
   python3:
-    call: Checker().check([{nums}], {target}, {result})
+    call: Checker().check({nums}, {target}, {result})
     checker:
-      "import json\nclass Checker:\n    def _norm(self, result):\n        if\
-      \ isinstance(result, str):\n            try:\n                result = json.loads(result)\n\
-      \            except Exception:\n                pass\n        return result\n\
-      \n    def check(self, nums, target, result):\n        result = self._norm(result)\n\
-      \        def get_sorted(quad):\n            return sorted(quad)\n        seen\
-      \ = set()\n        for quad in result:\n            if len(quad) != 4:\n   \
-      \             return False\n            if sum(quad) != target:\n          \
-      \      return False\n            seen.add(tuple(get_sorted(quad)))\n       \
-      \ nums.sort()\n        expected = []\n        n = len(nums)\n        for i in\
-      \ range(n - 3):\n            if i > 0 and nums[i] == nums[i - 1]:\n        \
-      \        continue\n            for j in range(i + 1, n - 2):\n             \
-      \   if j > i + 1 and nums[j] == nums[j - 1]:\n                    continue\n\
-      \                l, r = j + 1, n - 1\n                while l < r:\n       \
-      \             s = nums[i] + nums[j] + nums[l] + nums[r]\n                  \
-      \  if s == target:\n                        expected.append(tuple(sorted([nums[i],\
-      \ nums[j], nums[l], nums[r]])))\n                        l += 1\n          \
-      \              r -= 1\n                        while l < r and nums[l] == nums[l\
-      \ - 1]:\n                            l += 1\n                        while l\
-      \ < r and nums[r] == nums[r + 1]:\n                            r -= 1\n    \
-      \                elif s < target:\n                        l += 1\n        \
-      \            else:\n                        r -= 1\n        return len(seen)\
-      \ == len(expected) and all(q in seen for q in expected)\n"
+      "import json\nclass Checker:\n    def _norm(self, result):\n        if isinstance(result, str):\n           \
+      \ try:\n                result = json.loads(result)\n            except Exception:\n                pass\n        return
+      result\n\n    def check(self, nums, target, result):\n        result = self._norm(result)\n        def get_sorted(quad):\n\
+      \            return sorted(quad)\n        seen = set()\n        for quad in result:\n            if len(quad) != 4:\n\
+      \                return False\n            if sum(quad) != target:\n                return False\n            seen.add(tuple(get_sorted(quad)))\n\
+      \        nums.sort()\n        expected = []\n        n = len(nums)\n        for i in range(n - 3):\n            if i
+      > 0 and nums[i] == nums[i - 1]:\n                continue\n            for j in range(i + 1, n - 2):\n             \
+      \   if j > i + 1 and nums[j] == nums[j - 1]:\n                    continue\n                l, r = j + 1, n - 1\n  \
+      \              while l < r:\n                    s = nums[i] + nums[j] + nums[l] + nums[r]\n                    if s
+      == target:\n                        expected.append(tuple(sorted([nums[i], nums[j], nums[l], nums[r]])))\n         \
+      \               l += 1\n                        r -= 1\n                        while l < r and nums[l] == nums[l -
+      1]:\n                            l += 1\n                        while l < r and nums[r] == nums[r + 1]:\n         \
+      \                   r -= 1\n                    elif s < target:\n                        l += 1\n                 \
+      \   else:\n                        r -= 1\n        return len(seen) == len(expected) and all(q in seen for q in expected)\n"
 seed: 42
 tests:
   - name: example 1
diff --git a/tests/1-500/19. remove-nth-node-from-end-of-list/manifest.yaml b/tests/1-500/19. remove-nth-node-from-end-of-list/manifest.yaml
index e6f12277..fffef643 100644
--- a/tests/1-500/19. remove-nth-node-from-end-of-list/manifest.yaml	
+++ b/tests/1-500/19. remove-nth-node-from-end-of-list/manifest.yaml	
@@ -2,36 +2,23 @@
   "id": 19
   "title": "remove-nth-node-from-end-of-list"
   "call":
-    "cpp":
-      "listNodeToArray(Solution().removeNthFromEnd(toListNode(lv(vector<int>{\
-      \ {head} })), {n}))"
-    "rust":
-      "ListNode::list_node_to_array(Solution::remove_nth_from_end(ListNode::to_list_node(vec![{head}]),\
-      \ {n}))"
-    "python3":
-      "list_node_to_array(Solution().removeNthFromEnd(to_list_node([{head}]),\
-      \ {n}))"
-    "python2":
-      "list_node_to_array(Solution().removeNthFromEnd(to_list_node([{head}]),\
-      \ {n}))"
-    "ruby": "list_node_to_array(remove_nth_from_end(to_list_node([{head}]), {n}))"
-    "java":
-      "ListNode.listNodeToArray(new Solution().removeNthFromEnd(ListNode.toListNode(new\
-      \ int[]{ {head} }), {n}))"
-    "csharp":
-      "ListNode.ListNodeToArray(new Solution().RemoveNthFromEnd(ListNode.ToListNode(new\
-      \ int[]{ {head} }), {n}))"
-    "kotlin":
-      "listNodeToArray(Solution().removeNthFromEnd(toListNode(intArrayOf({head})),\
-      \ {n}))"
-    "go": "listNodeToArray(removeNthFromEnd(toListNode([]int{ {head} }), {n}))"
-    "dart":
-      "list_node_to_array(Solution().removeNthFromEnd(to_list_node([{head}]),\
-      \ {n}))"
-    "swift":
-      "list_node_to_array(Solution().removeNthFromEnd(to_list_node([{head}]),\
-      \ {n}))"
-    "typescript": "listNodeToArray(removeNthFromEnd(to_list_node([{head}]), {n}))"
+    "cpp": "listNodeToArray(Solution().removeNthFromEnd({head}, {n}))"
+    "rust": "ListNode::list_node_to_array(Solution::remove_nth_from_end({head}, {n}))"
+    "python3": "list_node_to_array(Solution().removeNthFromEnd({head}, {n}))"
+    "python2": "list_node_to_array(Solution().removeNthFromEnd({head}, {n}))"
+    "ruby": "list_node_to_array(remove_nth_from_end({head}, {n}))"
+    "java": "ListNode.listNodeToArray(new Solution().removeNthFromEnd({head}, {n}))"
+    "csharp": "ListNode.ListNodeToArray(new Solution().RemoveNthFromEnd({head}, {n}))"
+    "kotlin": "listNodeToArray(Solution().removeNthFromEnd({head}, {n}))"
+    "go": "listNodeToArray(removeNthFromEnd({head}, {n}))"
+    "dart": "list_node_to_array(Solution().removeNthFromEnd({head}, {n}))"
+    "swift": "list_node_to_array(Solution().removeNthFromEnd({head}, {n}))"
+    "typescript": "listNodeToArray(removeNthFromEnd({head}, {n}))"
+  params:
+    head:
+      type: list_node
+    n:
+      type: int
 "judge":
   "type": "exact"
 "limits":
@@ -41,11 +28,9 @@
   "python3":
     "call": "Checker().check([{head}], {n}, {result})"
     "checker":
-      "import json\nclass Checker:\n    def check(self, head, n, result):\n\
-      \        try:\n            result = json.loads(result) if isinstance(result,\
-      \ str) else result\n        except Exception:\n            return False\n  \
-      \      expected = list(head)\n        idx = len(expected) - n\n        if idx\
-      \ < 0 or idx >= len(expected):\n            return False\n        expected.pop(idx)\n\
+      "import json\nclass Checker:\n    def check(self, head, n, result):\n        try:\n            result = json.loads(result)
+      if isinstance(result, str) else result\n        except Exception:\n            return False\n        expected = list(head)\n\
+      \        idx = len(expected) - n\n        if idx < 0 or idx >= len(expected):\n            return False\n        expected.pop(idx)\n\
       \        return expected == result\n"
 "seed": 42
 "tests":
@@ -220,6 +205,36 @@
         - 28
         - 29
       "n": 15
+    "out":
+      - 0
+      - 1
+      - 2
+      - 3
+      - 4
+      - 5
+      - 6
+      - 7
+      - 8
+      - 9
+      - 10
+      - 11
+      - 12
+      - 13
+      - 14
+      - 16
+      - 17
+      - 18
+      - 19
+      - 20
+      - 21
+      - 22
+      - 23
+      - 24
+      - 25
+      - 26
+      - 27
+      - 28
+      - 29
   - "name": "size 30 remove first"
     "in":
       "head":
@@ -254,6 +269,36 @@
         - 28
         - 29
       "n": 30
+    "out":
+      - 1
+      - 2
+      - 3
+      - 4
+      - 5
+      - 6
+      - 7
+      - 8
+      - 9
+      - 10
+      - 11
+      - 12
+      - 13
+      - 14
+      - 15
+      - 16
+      - 17
+      - 18
+      - 19
+      - 20
+      - 21
+      - 22
+      - 23
+      - 24
+      - 25
+      - 26
+      - 27
+      - 28
+      - 29
   - "name": "size 30 remove last"
     "in":
       "head":
@@ -288,6 +333,36 @@
         - 28
         - 29
       "n": 1
+    "out":
+      - 0
+      - 1
+      - 2
+      - 3
+      - 4
+      - 5
+      - 6
+      - 7
+      - 8
+      - 9
+      - 10
+      - 11
+      - 12
+      - 13
+      - 14
+      - 15
+      - 16
+      - 17
+      - 18
+      - 19
+      - 20
+      - 21
+      - 22
+      - 23
+      - 24
+      - 25
+      - 26
+      - 27
+      - 28
   - "name": "duplicates 1"
     "in":
       "head":
diff --git a/tests/1-500/2. add-two-numbers/manifest.yaml b/tests/1-500/2. add-two-numbers/manifest.yaml
index bdcef16e..af8491ae 100644
--- a/tests/1-500/2. add-two-numbers/manifest.yaml	
+++ b/tests/1-500/2. add-two-numbers/manifest.yaml	
@@ -1,31 +1,24 @@
 entry:
   id: 2
   title: add-two-numbers
+  params:
+    l1:
+      type: list_node
+    l2:
+      type: list_node
   call:
-    cpp:
-      listNodeToArray(Solution().addTwoNumbers(toListNode(lv(vector<int>{ {l1}
-      })), toListNode(lv(vector<int>{ {l2} }))))
-    rust:
-      ListNode::list_node_to_array(Solution::add_two_numbers(ListNode::to_list_node(vec![{l1}]),
-      ListNode::to_list_node(vec![{l2}])))
-    python3: list_node_to_array(Solution().addTwoNumbers(to_list_node([{l1}]), to_list_node([{l2}])))
-    python2: list_node_to_array(Solution().addTwoNumbers(to_list_node([{l1}]), to_list_node([{l2}])))
-    ruby: list_node_to_array(add_two_numbers(to_list_node([{l1}]), to_list_node([{l2}])))
-    java:
-      ListNode.listNodeToArray(new Solution().addTwoNumbers(ListNode.toListNode(new
-      int[]{ {l1} }), ListNode.toListNode(new int[]{ {l2} })))
-    csharp:
-      ListNode.ListNodeToArray(new Solution().AddTwoNumbers(ListNode.ToListNode(new
-      int[]{ {l1} }), ListNode.ToListNode(new int[]{ {l2} })))
-    kotlin:
-      listNodeToArray(Solution().addTwoNumbers(toListNode(intArrayOf({l1})),
-      toListNode(intArrayOf({l2}))))
-    go:
-      listNodeToArray(addTwoNumbers(toListNode([]int{ {l1} }), toListNode([]int{
-      {l2} })))
-    dart: list_node_to_array(Solution().addTwoNumbers(to_list_node([{l1}]), to_list_node([{l2}])))
-    swift: list_node_to_array(Solution().addTwoNumbers(to_list_node([{l1}]), to_list_node([{l2}])))
-    typescript: listNodeToArray(addTwoNumbers(toListNode([{l1}]), toListNode([{l2}])))
+    cpp: listNodeToArray(Solution().addTwoNumbers({l1}, {l2}))
+    rust: ListNode::list_node_to_array(Solution::add_two_numbers({l1}, {l2}))
+    python3: list_node_to_array(Solution().addTwoNumbers({l1}, {l2}))
+    python2: list_node_to_array(Solution().addTwoNumbers({l1}, {l2}))
+    ruby: list_node_to_array(add_two_numbers({l1}, {l2}))
+    java: ListNode.listNodeToArray(new Solution().addTwoNumbers({l1}, {l2}))
+    csharp: ListNode.ListNodeToArray(new Solution().AddTwoNumbers({l1}, {l2}))
+    kotlin: listNodeToArray(Solution().addTwoNumbers({l1}, {l2}))
+    go: listNodeToArray(addTwoNumbers({l1}, {l2}))
+    dart: list_node_to_array(Solution().addTwoNumbers({l1}, {l2}))
+    swift: list_node_to_array(Solution().addTwoNumbers({l1}, {l2}))
+    typescript: listNodeToArray(addTwoNumbers({l1}, {l2}))
 judge:
   type: exact
 limits:
@@ -33,7 +26,7 @@ limits:
   memory_mb: 256
 oracle:
   python3:
-    call: Checker().check([{l1}], [{l2}], {result})
+    call: Checker().check(l1, l2, {result})
     checker:
       "import json\nclass Checker:\n    def _norm(self, res):\n        if isinstance(res,\
       \ str):\n            try:\n                res = json.loads(res)\n         \
@@ -212,116 +205,114 @@ tests:
       - 0
       - 0
       - 1
-  - name: generated 1
+  - name: oracle short valid
     in:
       l1:
-        gen: array
-        len:
-          gen: int
-          min: 1
-          max: 20
-        of:
-          gen: int
-          min: 0
-          max: 9
+        - 2
+        - 1
+        - 4
       l2:
-        gen: array
-        len:
-          gen: int
-          min: 1
-          max: 20
-        of:
-          gen: int
-          min: 0
-          max: 9
-  - name: generated 2
+        - 5
+        - 8
+        - 3
+    out:
+      - 7
+      - 9
+      - 7
+  - name: oracle medium valid
     in:
       l1:
-        gen: array
-        len:
-          gen: int
-          min: 1
-          max: 20
-        of:
-          gen: int
-          min: 0
-          max: 9
+        - 6
+        - 5
+        - 4
+        - 3
+        - 2
+        - 1
       l2:
-        gen: array
-        len:
-          gen: int
-          min: 1
-          max: 20
-        of:
-          gen: int
-          min: 0
-          max: 9
-  - name: generated 3
+        - 3
+        - 4
+        - 5
+        - 6
+        - 7
+    out:
+      - 9
+      - 9
+      - 9
+      - 9
+      - 9
+      - 1
+  - name: oracle carry stress
     in:
       l1:
-        gen: array
-        len:
-          gen: int
-          min: 1
-          max: 20
-        of:
-          gen: int
-          min: 0
-          max: 9
+        - 9
+        - 9
+        - 9
+        - 9
+        - 9
+        - 9
       l2:
-        gen: array
-        len:
-          gen: int
-          min: 1
-          max: 20
-        of:
-          gen: int
-          min: 0
-          max: 9
-  - name: generated 4
+        - 9
+        - 9
+        - 9
+        - 9
+        - 9
+        - 9
+    out:
+      - 8
+      - 9
+      - 9
+      - 9
+      - 9
+      - 9
+      - 1
+  - name: oracle mixed lengths
     in:
       l1:
-        gen: array
-        len:
-          gen: int
-          min: 1
-          max: 20
-        of:
-          gen: int
-          min: 0
-          max: 9
+        - 7
+        - 3
+        - 8
+        - 5
+        - 9
+        - 1
+        - 4
       l2:
-        gen: array
-        len:
-          gen: int
-          min: 1
-          max: 20
-        of:
-          gen: int
-          min: 0
-          max: 9
-  - name: generated 5
+        - 5
+        - 6
+        - 2
+    out:
+      - 2
+      - 0
+      - 1
+      - 6
+      - 9
+      - 1
+      - 4
+  - name: oracle zeros and nines
     in:
       l1:
-        gen: array
-        len:
-          gen: int
-          min: 1
-          max: 20
-        of:
-          gen: int
-          min: 0
-          max: 9
+        - 0
+        - 9
+        - 0
+        - 9
+        - 0
+        - 9
+        - 1
       l2:
-        gen: array
-        len:
-          gen: int
-          min: 1
-          max: 20
-        of:
-          gen: int
-          min: 0
-          max: 9
+        - 9
+        - 0
+        - 9
+        - 0
+        - 9
+        - 0
+        - 1
+    out:
+      - 9
+      - 9
+      - 9
+      - 9
+      - 9
+      - 9
+      - 2
   - name: large 1
     in:
       l1:
@@ -572,16 +563,18 @@ tests:
       - 1
       - 1
       - 1
-  - name: all zeroes
+  - name: zero plus hundred
     in:
       l1:
         - 0
-        - 0
-        - 0
       l2:
         - 0
+        - 0
+        - 1
     out:
       - 0
+      - 0
+      - 1
   - name: alternating
     in:
       l1:
diff --git a/tests/1-500/20. valid-parentheses/manifest.yaml b/tests/1-500/20. valid-parentheses/manifest.yaml
index 4d37a8ab..cd937c76 100644
--- a/tests/1-500/20. valid-parentheses/manifest.yaml	
+++ b/tests/1-500/20. valid-parentheses/manifest.yaml	
@@ -1,19 +1,22 @@
 entry:
   id: 20
   title: valid-parentheses
+  params:
+    s:
+      type: string
   call:
-    cpp: Solution().isValid("{s}")
-    rust: Solution::is_valid("{s}".to_string())
-    python3: Solution().isValid("{s}")
-    python2: Solution().isValid("{s}")
-    ruby: is_valid("{s}")
-    java: new Solution().isValid("{s}")
-    csharp: new Solution().IsValid("{s}")
-    kotlin: Solution().isValid("{s}")
-    go: isValid("{s}")
-    dart: Solution().isValid("{s}")
-    swift: Solution().isValid("{s}")
-    typescript: isValid("{s}")
+    cpp: Solution().isValid({s})
+    rust: Solution::is_valid({s}.to_string())
+    python3: Solution().isValid({s})
+    python2: Solution().isValid({s})
+    ruby: is_valid({s})
+    java: new Solution().isValid({s})
+    csharp: new Solution().IsValid({s})
+    kotlin: Solution().isValid({s})
+    go: isValid({s})
+    dart: Solution().isValid({s})
+    swift: Solution().isValid({s})
+    typescript: isValid({s})
 judge:
   type: exact
 limits:
@@ -21,7 +24,7 @@ limits:
   memory_mb: 256
 oracle:
   python3:
-    call: Checker().isValid("{s}", {result})
+    call: Checker().isValid(s, {result})
     checker:
       "import json\nclass Checker:\n    def _norm(self, result):\n        if\
       \ isinstance(result, str):\n            try:\n                result = json.loads(result)\n\
diff --git a/tests/1-500/21. merge-two-sorted-lists/manifest.yaml b/tests/1-500/21. merge-two-sorted-lists/manifest.yaml
index 820a4213..00da30ab 100644
--- a/tests/1-500/21. merge-two-sorted-lists/manifest.yaml	
+++ b/tests/1-500/21. merge-two-sorted-lists/manifest.yaml	
@@ -2,30 +2,23 @@ entry:
   id: 21
   title: merge-two-sorted-lists
   call:
-    cpp:
-      listNodeToArray(Solution().mergeTwoLists(toListNode(lv(vector<int>{ {l1}
-      })), toListNode(lv(vector<int>{ {l2} }))))
-    rust:
-      ListNode::list_node_to_array(Solution::merge_two_lists(ListNode::to_list_node(vec![{l1}]),
-      ListNode::to_list_node(vec![{l2}])))
-    python3: list_node_to_array(Solution().mergeTwoLists(to_list_node([{l1}]), to_list_node([{l2}])))
-    python2: list_node_to_array(Solution().mergeTwoLists(to_list_node([{l1}]), to_list_node([{l2}])))
-    ruby: list_node_to_array(merge_two_lists(to_list_node([{l1}]), to_list_node([{l2}])))
-    java:
-      ListNode.listNodeToArray(new Solution().mergeTwoLists(ListNode.toListNode(new
-      int[]{ {l1} }), ListNode.toListNode(new int[]{ {l2} })))
-    csharp:
-      ListNode.ListNodeToArray(new Solution().MergeTwoLists(ListNode.ToListNode(new
-      int[]{ {l1} }), ListNode.ToListNode(new int[]{ {l2} })))
-    kotlin:
-      listNodeToArray(Solution().mergeTwoLists(toListNode(intArrayOf({l1})),
-      toListNode(intArrayOf({l2}))))
-    go:
-      listNodeToArray(mergeTwoLists(toListNode([]int{ {l1} }), toListNode([]int{
-      {l2} })))
-    dart: list_node_to_array(Solution().mergeTwoLists(to_list_node([{l1}]), to_list_node([{l2}])))
-    swift: list_node_to_array(Solution().mergeTwoLists(to_list_node([{l1}]), to_list_node([{l2}])))
-    typescript: listNodeToArray(mergeTwoLists(toListNode([{l1}]), toListNode([{l2}])))
+    cpp: listNodeToArray(Solution().mergeTwoLists({l1}, {l2}))
+    rust: ListNode::list_node_to_array(Solution::merge_two_lists({l1}, {l2}))
+    python3: list_node_to_array(Solution().mergeTwoLists({l1}, {l2}))
+    python2: list_node_to_array(Solution().mergeTwoLists({l1}, {l2}))
+    ruby: list_node_to_array(merge_two_lists({l1}, {l2}))
+    java: ListNode.listNodeToArray(new Solution().mergeTwoLists({l1}, {l2}))
+    csharp: ListNode.ListNodeToArray(new Solution().MergeTwoLists({l1}, {l2}))
+    kotlin: listNodeToArray(Solution().mergeTwoLists({l1}, {l2}))
+    go: listNodeToArray(mergeTwoLists({l1}, {l2}))
+    dart: list_node_to_array(Solution().mergeTwoLists({l1}, {l2}))
+    swift: list_node_to_array(Solution().mergeTwoLists({l1}, {l2}))
+    typescript: listNodeToArray(mergeTwoLists({l1}, {l2}))
+  params:
+    l1:
+      type: list_node
+    l2:
+      type: list_node
 judge:
   type: exact
 limits:
@@ -35,10 +28,9 @@ oracle:
   python3:
     call: Checker().check([{l1}], [{l2}], {result})
     checker:
-      "import json\n\nclass Checker:\n    def check(self, l1, l2, res):\n \
-      \       expected = sorted(l1 + l2)\n        try:\n            got = json.loads(res)\
-      \ if isinstance(res, str) else res\n        except Exception:\n            return\
-      \ False\n        return got == expected\n"
+      "import json\n\nclass Checker:\n    def check(self, l1, l2, res):\n        expected = sorted(l1 + l2)\n     \
+      \   try:\n            got = json.loads(res) if isinstance(res, str) else res\n        except Exception:\n          \
+      \  return False\n        return got == expected\n"
 seed: 42
 tests:
   - name: example 1
diff --git a/tests/1-500/22. generate-parentheses/manifest.yaml b/tests/1-500/22. generate-parentheses/manifest.yaml
index 367901f1..21552442 100644
--- a/tests/1-500/22. generate-parentheses/manifest.yaml	
+++ b/tests/1-500/22. generate-parentheses/manifest.yaml	
@@ -1,6 +1,9 @@
 entry:
   id: 22
   title: generate-parentheses
+  params:
+    n:
+      type: int
   call:
     cpp: Solution().generateParenthesis({n})
     rust: Solution::generate_parenthesis({n})
@@ -21,7 +24,7 @@ limits:
   memory_mb: 256
 oracle:
   python3:
-    call: Checker().check({n}, {result})
+    call: Checker().check(n, {result})
     checker:
       "import json\nclass Checker:\n    def _norm(self, result):\n        if\
       \ isinstance(result, str):\n            try:\n                result = json.loads(result)\n\
diff --git a/tests/1-500/23. merge-k-sorted-lists/manifest.yaml b/tests/1-500/23. merge-k-sorted-lists/manifest.yaml
index 55c055df..2787cbba 100644
--- a/tests/1-500/23. merge-k-sorted-lists/manifest.yaml	
+++ b/tests/1-500/23. merge-k-sorted-lists/manifest.yaml	
@@ -2,30 +2,25 @@
   "id": 23
   "title": "merge-k-sorted-lists"
   "call":
-    "cpp":
-      "listNodeToArray(Solution().mergeKLists(toLinkedLists(lv(vector<vector<int>>{\
-      \ {lists} }))))"
-    "rust": "ListNode::list_node_to_array(Solution::merge_k_lists(ListNode::to_linked_lists(vec![{lists}])))"
-    "python3":
-      "list_node_to_array(Solution().mergeKLists([to_list_node(l) for l in\
-      \ [{lists}]]))"
-    "python2":
-      "list_node_to_array(Solution().mergeKLists([to_list_node(l) for l in\
-      \ [{lists}]]))"
-    "ruby": "list_node_to_array(merge_k_lists([to_list_node(l) for l in [{lists}]]))"
-    "java":
-      "ListNode.listNodeToArray(new Solution().mergeKLists(ListNode.toLinkedLists(new\
-      \ int[][]{ {lists} })))"
-    "csharp":
-      "ListNode.ListNodeToArray(new Solution().MergeKLists(ListNode.ToLinkedLists(new\
-      \ int[][]{ {lists} })))"
-    "kotlin": "listNodeToArray(Solution().mergeKLists(toLinkedLists(arrayOf({lists}))))"
-    "go": "listNodeToArray(mergeKLists(toLinkedLists([][]int{ {lists} })))"
-    "dart": "list_node_to_array(Solution().mergeKLists([to_list_node(l) for l in [{lists}]]))"
-    "swift":
-      "list_node_to_array(Solution().mergeKLists([to_list_node(l) for l in\
-      \ [{lists}]]))"
-    "typescript": "listNodeToArray(mergeKLists([toListNode(l) for l in [{lists}]]))"
+    "cpp": "([&](auto lists){ return listNodeToArray(Solution().mergeKLists(lists)); })(toLinkedLists({lists}))"
+    "rust": "ListNode::list_node_to_array(Solution::merge_k_lists(ListNode::to_list_nodes({lists})))"
+    "python3": "list_node_to_array(Solution().mergeKLists([to_list_node(l) for l in {lists}]))"
+    "python2": "list_node_to_array(Solution().mergeKLists([to_list_node(l) for l in {lists}]))"
+    "ruby": "list_node_to_array(merge_k_lists({lists}.map { |l| to_list_node(l) }))"
+    "java": "ListNode.listNodeToArray(new Solution().mergeKLists(ListNode.toListNodes({lists})))"
+    "csharp": "ListNode.ListNodeToArray(new Solution().MergeKLists(ListNode.ToListNodes({lists})))"
+    "kotlin": "listNodeToArray(Solution().mergeKLists(toLinkedLists({lists})))"
+    "go": "listNodeToArray(mergeKLists(toListNodes({lists})))"
+    "dart": "list_node_to_array(Solution().mergeKLists(to_list_nodes({lists})))"
+    "swift": "list_node_to_array(Solution().mergeKLists(to_list_nodes({lists})))"
+    "typescript": "listNodeToArray(mergeKLists(toListNodes({lists})))"
+  params:
+    lists:
+      type: array
+      items:
+        type: array
+        items:
+          type: int
 "judge":
   "type": "exact"
 "limits":
@@ -55,24 +50,40 @@
           - 4
         - - 2
           - 6
+    "out":
+      - 1
+      - 1
+      - 2
+      - 3
+      - 4
+      - 4
+      - 5
+      - 6
   - "name": "Example 2"
     "in":
       "lists": []
+    "out": []
   - "name": "Example 3"
     "in":
       "lists":
         - []
+    "out": []
   - "name": "Single List"
     "in":
       "lists":
         - - 1
           - 2
           - 3
+    "out":
+      - 1
+      - 2
+      - 3
   - "name": "Multiple Empty"
     "in":
       "lists":
         - []
         - []
+    "out": []
   - "name": "Negative Values"
     "in":
       "lists":
@@ -81,6 +92,12 @@
           - 0
         - - -10
           - -3
+    "out":
+      - -10
+      - -5
+      - -3
+      - -2
+      - 0
   - "name": "Large Values"
     "in":
       "lists":
@@ -88,12 +105,21 @@
           - 10000
         - - 8000
           - 9500
+    "out":
+      - 8000
+      - 9000
+      - 9500
+      - 10000
   - "name": "Single Element Lists"
     "in":
       "lists":
         - - 1
         - - 3
         - - 2
+    "out":
+      - 1
+      - 2
+      - 3
   - "name": "Interleaved Lists"
     "in":
       "lists":
@@ -103,6 +129,13 @@
         - - 2
           - 11
           - 21
+    "out":
+      - 1
+      - 2
+      - 10
+      - 11
+      - 20
+      - 21
   - "name": "Max K, Min length"
     "in":
       "lists":
@@ -111,6 +144,12 @@
         - - 3
         - - 4
         - - 5
+    "out":
+      - 1
+      - 2
+      - 3
+      - 4
+      - 5
   - "name": "Duplicates across lists"
     "in":
       "lists":
@@ -120,6 +159,13 @@
         - - 2
           - 2
           - 3
+    "out":
+      - 1
+      - 2
+      - 2
+      - 2
+      - 2
+      - 3
   - "name": "Large size test 1"
     "in":
       "lists":
@@ -153,6 +199,37 @@
           - 34
           - 36
           - 100
+    "out":
+      - 0
+      - 1
+      - 2
+      - 3
+      - 4
+      - 5
+      - 6
+      - 7
+      - 8
+      - 9
+      - 10
+      - 11
+      - 12
+      - 13
+      - 14
+      - 15
+      - 16
+      - 17
+      - 18
+      - 19
+      - 20
+      - 22
+      - 24
+      - 26
+      - 28
+      - 30
+      - 32
+      - 34
+      - 36
+      - 100
   - "name": "Large size test 2"
     "in":
       "lists":
@@ -178,6 +255,29 @@
           - 100
           - 200
           - 300
+    "out":
+      - 0
+      - 1
+      - 2
+      - 3
+      - 4
+      - 5
+      - 5
+      - 6
+      - 7
+      - 8
+      - 9
+      - 10
+      - 15
+      - 20
+      - 25
+      - 30
+      - 35
+      - 40
+      - 100
+      - 200
+      - 300
+      - 1000
   - "name": "Boundary K=1"
     "in":
       "lists":
@@ -186,6 +286,12 @@
           - 3
           - 4
           - 5
+    "out":
+      - 1
+      - 2
+      - 3
+      - 4
+      - 5
   - "name": "All zeros"
     "in":
       "lists":
@@ -194,6 +300,12 @@
         - - 0
           - 0
           - 0
+    "out":
+      - 0
+      - 0
+      - 0
+      - 0
+      - 0
   - "name": "Mixed Lengths"
     "in":
       "lists":
@@ -207,6 +319,16 @@
           - 7
         - []
         - - 10
+    "out":
+      - 1
+      - 1
+      - 2
+      - 3
+      - 4
+      - 5
+      - 6
+      - 7
+      - 10
   - "name": "Decreasing lists"
     "in":
       "lists":
@@ -214,6 +336,11 @@
           - 2
         - - 3
           - 4
+    "out":
+      - 1
+      - 2
+      - 3
+      - 4
   - "name": "Descending values"
     "in":
       "lists":
@@ -221,6 +348,11 @@
           - -5
         - - -8
           - -2
+    "out":
+      - -10
+      - -8
+      - -5
+      - -2
   - "name": "Max constraint check"
     "in":
       "lists":
@@ -230,6 +362,13 @@
           - 9999
         - - 3
           - 9998
+    "out":
+      - 1
+      - 2
+      - 3
+      - 9998
+      - 9999
+      - 10000
   - "name": "Zig zag values"
     "in":
       "lists":
@@ -245,6 +384,19 @@
         - - 4
           - 8
           - 12
+    "out":
+      - 1
+      - 2
+      - 3
+      - 4
+      - 5
+      - 6
+      - 7
+      - 8
+      - 9
+      - 10
+      - 11
+      - 12
   - "name": "Sparse lists"
     "in":
       "lists":
@@ -252,6 +404,11 @@
           - 100
         - - 2
           - 200
+    "out":
+      - 1
+      - 2
+      - 100
+      - 200
   - "name": "Many small lists"
     "in":
       "lists":
@@ -262,6 +419,14 @@
         - - 5
         - - 6
         - - 7
+    "out":
+      - 1
+      - 2
+      - 3
+      - 4
+      - 5
+      - 6
+      - 7
   - "name": "Negative to Positive"
     "in":
       "lists":
@@ -271,6 +436,13 @@
         - - -3
           - 0
           - 5
+    "out":
+      - -5
+      - -3
+      - -1
+      - 0
+      - 4
+      - 5
   - "name": "Empty and full"
     "in":
       "lists":
@@ -279,6 +451,10 @@
           - 2
           - 3
         - []
+    "out":
+      - 1
+      - 2
+      - 3
   - "name": "Single List Multiple Elements"
     "in":
       "lists":
@@ -287,3 +463,9 @@
           - 30
           - 40
           - 50
+    "out":
+      - 10
+      - 20
+      - 30
+      - 40
+      - 50
diff --git a/tests/1-500/24. swap-nodes-in-pairs/manifest.yaml b/tests/1-500/24. swap-nodes-in-pairs/manifest.yaml
index 4f9f84cd..f060e926 100644
--- a/tests/1-500/24. swap-nodes-in-pairs/manifest.yaml	
+++ b/tests/1-500/24. swap-nodes-in-pairs/manifest.yaml	
@@ -2,24 +2,21 @@
   "id": 24
   "title": "swap-nodes-in-pairs"
   "call":
-    "cpp":
-      "listNodeToArray(Solution().swapPairs(toListNode(lv(vector<int>{ {head}\
-      \ }))))"
-    "rust": "ListNode::list_node_to_array(Solution::swap_pairs(ListNode::to_list_node(vec![{head}])))"
-    "python3": "list_node_to_array(Solution().swapPairs(to_list_node([{head}])))"
-    "python2": "list_node_to_array(Solution().swapPairs(to_list_node([{head}])))"
-    "ruby": "list_node_to_array(swap_pairs(to_list_node([{head}])))"
-    "java":
-      "ListNode.listNodeToArray(new Solution().swapPairs(ListNode.toListNode(new\
-      \ int[]{ {head} })))"
-    "csharp":
-      "ListNode.ListNodeToArray(new Solution().SwapPairs(ListNode.ToListNode(new\
-      \ int[]{ {head} })))"
-    "kotlin": "listNodeToArray(Solution().swapPairs(toListNode(intArrayOf({head}))))"
-    "go": "listNodeToArray(swapPairs(toListNode([]int{ {head} })))"
-    "dart": "list_node_to_array(Solution().swapPairs(to_list_node([{head}])))"
-    "swift": "tree_node_to_array(Solution().swapPairs(to_list_node([{head}])))"
-    "typescript": "listNodeToArray(swapPairs(toListNode([{head}])))"
+    "cpp": "listNodeToArray(Solution().swapPairs({head}))"
+    "rust": "ListNode::list_node_to_array(Solution::swap_pairs({head}))"
+    "python3": "list_node_to_array(Solution().swapPairs({head}))"
+    "python2": "list_node_to_array(Solution().swapPairs({head}))"
+    "ruby": "list_node_to_array(swap_pairs({head}))"
+    "java": "ListNode.listNodeToArray(new Solution().swapPairs({head}))"
+    "csharp": "ListNode.ListNodeToArray(new Solution().SwapPairs({head}))"
+    "kotlin": "listNodeToArray(Solution().swapPairs({head}))"
+    "go": "listNodeToArray(swapPairs({head}))"
+    "dart": "list_node_to_array(Solution().swapPairs({head}))"
+    "swift": "list_node_to_array(Solution().swapPairs({head}))"
+    "typescript": "listNodeToArray(swapPairs({head}))"
+  params:
+    head:
+      type: list_node
 "judge":
   "type": "exact"
 "limits":
@@ -29,17 +26,13 @@
   "python3":
     "call": "Checker().check([{head}], {result})"
     "checker":
-      "import json\nclass Checker:\n  def check(self, head, res):\n    def\
-      \ to_list(arr):\n      head = cur = None\n      for x in arr:\n        if not\
-      \ head: head = cur = [x, None]\n        else:\n          cur[1] = [x, None]\n\
-      \          cur = cur[1]\n      return head\n    def from_list(node):\n     \
-      \ res = []\n      while node:\n        res.append(node[0])\n        node = node[1]\n\
-      \      return res\n    \n    def ref(h):\n      if not h or not h[1]: return\
-      \ h\n      s = h[1]\n      h[1] = ref(s[1])\n      s[1] = h\n      return s\n\
-      \      \n    try:\n      res = json.loads(res) if isinstance(res, str) else\
-      \ res\n    except Exception:\n      return False\n    if isinstance(res, list)\
-      \ and len(res) == 1 and isinstance(res[0], list):\n      res = res[0]\n    return\
-      \ from_list(ref(to_list(head))) == res\n"
+      "import json\nclass Checker:\n  def check(self, head, res):\n    def to_list(arr):\n      head = cur = None\n\
+      \      for x in arr:\n        if not head: head = cur = [x, None]\n        else:\n          cur[1] = [x, None]\n   \
+      \       cur = cur[1]\n      return head\n    def from_list(node):\n      res = []\n      while node:\n        res.append(node[0])\n\
+      \        node = node[1]\n      return res\n    \n    def ref(h):\n      if not h or not h[1]: return h\n      s = h[1]\n\
+      \      h[1] = ref(s[1])\n      s[1] = h\n      return s\n      \n    try:\n      res = json.loads(res) if isinstance(res,
+      str) else res\n    except Exception:\n      return False\n    if isinstance(res, list) and len(res) == 1 and isinstance(res[0],
+      list):\n      res = res[0]\n    return from_list(ref(to_list(head))) == res\n"
 "seed": 42
 "tests":
   - "name": "Empty"
diff --git a/tests/1-500/25. reverse-nodes-in-k-group/manifest.yaml b/tests/1-500/25. reverse-nodes-in-k-group/manifest.yaml
index 350d8b08..f9908b30 100644
--- a/tests/1-500/25. reverse-nodes-in-k-group/manifest.yaml	
+++ b/tests/1-500/25. reverse-nodes-in-k-group/manifest.yaml	
@@ -2,28 +2,23 @@ entry:
   id: 25
   title: reverse-nodes-in-k-group
   call:
-    cpp:
-      listNodeToArray(Solution().reverseKGroup(toListNode(lv(vector<int>{ {head}
-      })), {k}))
-    rust:
-      ListNode::list_node_to_array(Solution::reverse_k_group(ListNode::to_list_node(vec![{head}]),
-      {k}))
-    python3: list_node_to_array(Solution().reverseKGroup(to_list_node([{head}]), {k}))
-    python2: list_node_to_array(Solution().reverseKGroup(to_list_node([{head}]), {k}))
-    ruby: list_node_to_array(reverse_k_group(to_list_node([{head}]), {k}))
-    java:
-      ListNode.listNodeToArray(new Solution().reverseKGroup(ListNode.toListNode(new
-      int[]{ {head} }), {k}))
-    csharp:
-      ListNode.ListNodeToArray(new Solution().ReverseKGroup(ListNode.ToListNode(new
-      int[]{ {head} }), {k}))
-    kotlin:
-      listNodeToArray(Solution().reverseKGroup(toListNode(intArrayOf({head})),
-      {k}))
-    go: listNodeToArray(reverseKGroup(toListNode([]int{ {head} }), {k}))
-    dart: list_node_to_array(Solution().reverseKGroup(to_list_node([{head}]), {k}))
-    swift: tree_node_to_array(Solution().reverseKGroup(to_list_node([{head}]), {k}))
-    typescript: listNodeToArray(reverseKGroup(toListNode([{head}]), {k}))
+    cpp: listNodeToArray(Solution().reverseKGroup({head}, {k}))
+    rust: ListNode::list_node_to_array(Solution::reverse_k_group({head}, {k}))
+    python3: list_node_to_array(Solution().reverseKGroup({head}, {k}))
+    python2: list_node_to_array(Solution().reverseKGroup({head}, {k}))
+    ruby: list_node_to_array(reverse_k_group({head}, {k}))
+    java: ListNode.listNodeToArray(new Solution().reverseKGroup({head}, {k}))
+    csharp: ListNode.ListNodeToArray(new Solution().ReverseKGroup({head}, {k}))
+    kotlin: listNodeToArray(Solution().reverseKGroup({head}, {k}))
+    go: listNodeToArray(reverseKGroup({head}, {k}))
+    dart: list_node_to_array(Solution().reverseKGroup({head}, {k}))
+    swift: list_node_to_array(Solution().reverseKGroup({head}, {k}))
+    typescript: listNodeToArray(reverseKGroup({head}, {k}))
+  params:
+    head:
+      type: list_node
+    k:
+      type: int
 judge:
   type: exact
 limits:
@@ -33,19 +28,15 @@ oracle:
   python3:
     call: Checker().check([{head}], {k}, {result})
     checker:
-      "import json\nclass Checker:\n    def _norm(self, result):\n        if\
-      \ isinstance(result, str):\n            try:\n                result = json.loads(result)\n\
-      \            except Exception:\n                pass\n        return result\n\
-      \n    def check(self, head, k, output):\n        output = self._norm(output)\n\
-      \        def to_list(arr):\n            if not arr: return None\n          \
-      \  head = ListNode(arr[0])\n            curr = head\n            for i in range(1,\
-      \ len(arr)):\n                curr.next = ListNode(arr[i])\n               \
-      \ curr = curr.next\n            return head\n        def from_list(node):\n\
-      \            res = []\n            while node:\n                res.append(node.val)\n\
-      \                node = node.next\n            return res\n        n = len(head)\n\
-      \        expected = list(head)\n        for i in range(0, (n // k) * k, k):\n\
-      \            expected[i:i+k] = reversed(expected[i:i+k])\n        return from_list(to_list(output))\
-      \ == expected\n"
+      "import json\nclass Checker:\n    def _norm(self, result):\n        if isinstance(result, str):\n           \
+      \ try:\n                result = json.loads(result)\n            except Exception:\n                pass\n        return
+      result\n\n    def check(self, head, k, output):\n        output = self._norm(output)\n        def to_list(arr):\n  \
+      \          if not arr: return None\n            head = ListNode(arr[0])\n            curr = head\n            for i
+      in range(1, len(arr)):\n                curr.next = ListNode(arr[i])\n                curr = curr.next\n           \
+      \ return head\n        def from_list(node):\n            res = []\n            while node:\n                res.append(node.val)\n\
+      \                node = node.next\n            return res\n        n = len(head)\n        expected = list(head)\n  \
+      \      for i in range(0, (n // k) * k, k):\n            expected[i:i+k] = reversed(expected[i:i+k])\n        return
+      from_list(to_list(output)) == expected\n"
 seed: 42
 tests:
   - name: Example 1
diff --git a/tests/1-500/28. find-the-index-of-the-first-occurrence-in-a-string/manifest.yaml b/tests/1-500/28. find-the-index-of-the-first-occurrence-in-a-string/manifest.yaml
index fc0db765..02a1066e 100644
--- a/tests/1-500/28. find-the-index-of-the-first-occurrence-in-a-string/manifest.yaml	
+++ b/tests/1-500/28. find-the-index-of-the-first-occurrence-in-a-string/manifest.yaml	
@@ -1,19 +1,24 @@
 entry:
   id: 28
   title: find-the-index-of-the-first-occurrence-in-a-string
+  params:
+    haystack:
+      type: string
+    needle:
+      type: string
   call:
-    cpp: Solution().strStr("{haystack}", "{needle}")
-    rust: Solution::str_str("{haystack}".to_string(), "{needle}".to_string())
-    python3: Solution().strStr("{haystack}", "{needle}")
-    python2: Solution().strStr("{haystack}", "{needle}")
-    ruby: str_str("{haystack}", "{needle}")
-    java: new Solution().strStr("{haystack}", "{needle}")
-    csharp: new Solution().StrStr("{haystack}", "{needle}")
-    kotlin: Solution().strStr("{haystack}", "{needle}")
-    go: strStr("{haystack}", "{needle}")
-    dart: Solution().strStr("{haystack}", "{needle}")
-    swift: Solution().strStr("{haystack}", "{needle}")
-    typescript: strStr("{haystack}", "{needle}")
+    cpp: Solution().strStr({haystack}, {needle})
+    rust: Solution::str_str({haystack}, {needle})
+    python3: Solution().strStr({haystack}, {needle})
+    python2: Solution().strStr({haystack}, {needle})
+    ruby: str_str({haystack}, {needle})
+    java: new Solution().strStr({haystack}, {needle})
+    csharp: new Solution().StrStr({haystack}, {needle})
+    kotlin: Solution().strStr({haystack}, {needle})
+    go: strStr({haystack}, {needle})
+    dart: Solution().strStr({haystack}, {needle})
+    swift: Solution().strStr({haystack}, {needle})
+    typescript: strStr({haystack}, {needle})
 judge:
   type: exact
 limits:
@@ -21,7 +26,7 @@ limits:
   memory_mb: 256
 oracle:
   python3:
-    call: Checker().strStr("{haystack}", "{needle}", {result})
+    call: Checker().strStr(haystack, needle, {result})
     checker:
       "import json\nclass Checker:\n    def _norm(self, result):\n        if\
       \ isinstance(result, str):\n            try:\n                result = json.loads(result)\n\
diff --git a/tests/1-500/29. divide-two-integers/manifest.yaml b/tests/1-500/29. divide-two-integers/manifest.yaml
index 5c90a295..ea9519ec 100644
--- a/tests/1-500/29. divide-two-integers/manifest.yaml	
+++ b/tests/1-500/29. divide-two-integers/manifest.yaml	
@@ -1,6 +1,11 @@
 "entry":
   "id": 29
   "title": "divide-two-integers"
+  "params":
+    "dividend":
+      "type": "int"
+    "divisor":
+      "type": "int"
   "call":
     "cpp": "Solution().divide({dividend}, {divisor})"
     "rust": "Solution::divide({dividend}, {divisor})"
@@ -21,7 +26,7 @@
   "memory_mb": 256
 "oracle":
   "python3":
-    "call": "Checker().divide({dividend}, {divisor}, {result})"
+    "call": "Checker().divide(dividend, divisor, {result})"
     "checker":
       "import json\nclass Checker:\n    def divide(self, dividend, divisor,\
       \ result):\n        try:\n            result = json.loads(result) if isinstance(result,\
diff --git a/tests/1-500/3. longest-substring-without-repeating-characters/manifest.yaml b/tests/1-500/3. longest-substring-without-repeating-characters/manifest.yaml
index 9c34161e..d2f39e73 100644
--- a/tests/1-500/3. longest-substring-without-repeating-characters/manifest.yaml	
+++ b/tests/1-500/3. longest-substring-without-repeating-characters/manifest.yaml	
@@ -1,19 +1,22 @@
 "entry":
   "id": 3
   "title": "longest-substring-without-repeating-characters"
+  "params":
+    "s":
+      "type": "string"
   "call":
-    "cpp": 'Solution().lengthOfLongestSubstring("{s}")'
-    "rust": 'Solution::length_of_longest_substring("{s}".to_string())'
-    "python3": 'Solution().lengthOfLongestSubstring("{s}")'
-    "python2": 'Solution().lengthOfLongestSubstring("{s}")'
-    "ruby": 'length_of_longest_substring("{s}")'
-    "java": 'new Solution().lengthOfLongestSubstring("{s}")'
-    "csharp": 'new Solution().LengthOfLongestSubstring("{s}")'
-    "kotlin": 'Solution().lengthOfLongestSubstring("{s}")'
-    "go": 'lengthOfLongestSubstring("{s}")'
-    "dart": 'Solution().lengthOfLongestSubstring("{s}")'
-    "swift": 'Solution().lengthOfLongestSubstring("{s}")'
-    "typescript": 'lengthOfLongestSubstring("{s}")'
+    "cpp": "Solution().lengthOfLongestSubstring({s})"
+    "rust": "Solution::length_of_longest_substring({s})"
+    "python3": "Solution().lengthOfLongestSubstring({s})"
+    "python2": "Solution().lengthOfLongestSubstring({s})"
+    "ruby": "length_of_longest_substring({s})"
+    "java": "new Solution().lengthOfLongestSubstring({s})"
+    "csharp": "new Solution().LengthOfLongestSubstring({s})"
+    "kotlin": "Solution().lengthOfLongestSubstring({s})"
+    "go": "lengthOfLongestSubstring({s})"
+    "dart": "Solution().lengthOfLongestSubstring({s})"
+    "swift": "Solution().lengthOfLongestSubstring({s})"
+    "typescript": "lengthOfLongestSubstring({s})"
 "judge":
   "type": "exact"
 "limits":
@@ -21,7 +24,7 @@
   "memory_mb": 256
 "oracle":
   "python3":
-    "call": 'Checker().lengthOfLongestSubstring("{s}", {result})'
+    "call": "Checker().lengthOfLongestSubstring(s, {result})"
     "checker":
       "class Checker:\n    def lengthOfLongestSubstring(self, s, result):\n\
       \        def solve(s):\n            last_seen = {}\n            start = 0\n\
diff --git a/tests/1-500/30. substring-with-concatenation-of-all-words/manifest.yaml b/tests/1-500/30. substring-with-concatenation-of-all-words/manifest.yaml
index 06ddb481..baf4d927 100644
--- a/tests/1-500/30. substring-with-concatenation-of-all-words/manifest.yaml	
+++ b/tests/1-500/30. substring-with-concatenation-of-all-words/manifest.yaml	
@@ -2,18 +2,25 @@ entry:
   id: 30
   title: substring-with-concatenation-of-all-words
   call:
-    cpp: Solution().findSubstring("{s}", lv(vector<string>{ {words} }))
-    rust: Solution::find_substring("{s}".to_string(), vec![{words}])
-    python3: Solution().findSubstring("{s}", [{words}])
-    python2: Solution().findSubstring("{s}", [{words}])
-    ruby: find_substring("{s}", [{words}])
-    java: new Solution().findSubstring("{s}", new String[]{ {words} })
-    csharp: new Solution().FindSubstring("{s}", new string[]{ {words} })
-    kotlin: Solution().findSubstring("{s}", arrayOf({words}))
-    go: findSubstring("{s}", []string{ {words} })
-    dart: Solution().findSubstring("{s}", [{words}])
-    swift: Solution().findSubstring("{s}", [{words}])
-    typescript: findSubstring("{s}", [{words}])
+    cpp: Solution().findSubstring({s}, {words})
+    rust: Solution::find_substring({s}, {words})
+    python3: Solution().findSubstring({s}, {words})
+    python2: Solution().findSubstring({s}, {words})
+    ruby: find_substring({s}, {words})
+    java: new Solution().findSubstring({s}, {words})
+    csharp: new Solution().FindSubstring({s}, {words})
+    kotlin: Solution().findSubstring({s}, {words})
+    go: findSubstring({s}, {words})
+    dart: Solution().findSubstring({s}, {words})
+    swift: Solution().findSubstring({s}, {words})
+    typescript: findSubstring({s}, {words})
+  params:
+    s:
+      type: string
+    words:
+      type: array
+      items:
+        type: string
 judge:
   type: ignore_order
 limits:
@@ -21,15 +28,13 @@ limits:
   memory_mb: 256
 oracle:
   python3:
-    call: Checker().check("{s}", [{words}], {result})
+    call: Checker().check(s, words, {result})
     checker:
-      "from collections import Counter\nclass Checker:\n    def check(self,\
-      \ s, words, result):\n        if not s or not words: return result == []\n \
-      \       c = len(words)\n        wl = len(words[0])\n        target = Counter(words)\n\
-      \        actual = []\n        for i in range(len(s) - c * wl + 1):\n       \
-      \     sub = s[i:i + c * wl]\n            chunks = [sub[j:j + wl] for j in range(0,\
-      \ len(sub), wl)]\n            if Counter(chunks) == target:\n              \
-      \  actual.append(i)\n        return sorted(result) == sorted(actual)\n"
+      "from collections import Counter\nclass Checker:\n    def check(self, s, words, result):\n        if not s or
+      not words: return result == []\n        c = len(words)\n        wl = len(words[0])\n        target = Counter(words)\n\
+      \        actual = []\n        for i in range(len(s) - c * wl + 1):\n            sub = s[i:i + c * wl]\n            chunks
+      = [sub[j:j + wl] for j in range(0, len(sub), wl)]\n            if Counter(chunks) == target:\n                actual.append(i)\n\
+      \        return sorted(result) == sorted(actual)\n"
 seed: 42
 tests:
   - name: example 1
diff --git a/tests/1-500/32. longest-valid-parentheses/manifest.yaml b/tests/1-500/32. longest-valid-parentheses/manifest.yaml
index 3542f054..1620fe9d 100644
--- a/tests/1-500/32. longest-valid-parentheses/manifest.yaml	
+++ b/tests/1-500/32. longest-valid-parentheses/manifest.yaml	
@@ -1,27 +1,30 @@
 entry:
   id: 32
   title: longest-valid-parentheses
+  params:
+    s:
+      type: string
   call:
-    cpp: Solution().longestValidParentheses("{s}")
-    rust: Solution::longest_valid_parentheses("{s}".to_string())
-    python3: Solution().longestValidParentheses("{s}")
-    python2: Solution().longestValidParentheses("{s}")
-    ruby: longest_valid_parentheses("{s}")
-    java: new Solution().longestValidParentheses("{s}")
-    csharp: new Solution().LongestValidParentheses("{s}")
-    kotlin: Solution().longestValidParentheses("{s}")
-    go: longestValidParentheses("{s}")
-    dart: Solution().longestValidParentheses("{s}")
-    swift: Solution().longestValidParentheses("{s}")
-    typescript: longestValidParentheses("{s}")
+    cpp: Solution().longestValidParentheses({s})
+    rust: Solution::longest_valid_parentheses({s}.to_string())
+    python3: Solution().longestValidParentheses({s})
+    python2: Solution().longestValidParentheses({s})
+    ruby: longest_valid_parentheses({s})
+    java: new Solution().longestValidParentheses({s})
+    csharp: new Solution().LongestValidParentheses({s})
+    kotlin: Solution().longestValidParentheses({s})
+    go: longestValidParentheses({s})
+    dart: Solution().longestValidParentheses({s})
+    swift: Solution().longestValidParentheses({s})
+    typescript: longestValidParentheses({s})
 judge:
   type: exact
 limits:
-  time_ms: 1000
+  time_ms: 2000
   memory_mb: 256
 oracle:
   python3:
-    call: Checker().longestValidParentheses("{s}", {result})
+    call: Checker().longestValidParentheses(s, {result})
     checker:
       "import json\nclass Checker:\n    def _norm(self, result):\n        if\
       \ isinstance(result, str):\n            try:\n                result = json.loads(result)\n\
@@ -109,7 +112,7 @@ tests:
   - name: Random mixed 2
     in:
       s: ()(())()))))
-    out: 6
+    out: 8
   - name: Random mixed 3
     in:
       s: ((()((()
diff --git a/tests/1-500/33. search-in-rotated-sorted-array/manifest.yaml b/tests/1-500/33. search-in-rotated-sorted-array/manifest.yaml
index cf0ffa80..727c1427 100644
--- a/tests/1-500/33. search-in-rotated-sorted-array/manifest.yaml	
+++ b/tests/1-500/33. search-in-rotated-sorted-array/manifest.yaml	
@@ -2,18 +2,25 @@ entry:
   id: 33
   title: search-in-rotated-sorted-array
   call:
-    cpp: Solution().search(lv(vector<int>{ {nums} }), {target})
-    rust: Solution::search(vec![{nums}], {target})
-    python3: Solution().search([{nums}], {target})
-    python2: Solution().search([{nums}], {target})
-    ruby: search([{nums}], {target})
-    java: new Solution().search(new int[]{ {nums} }, {target})
-    csharp: new Solution().Search(new int[]{ {nums} }, {target})
-    kotlin: Solution().search(intArrayOf({nums}), {target})
-    go: search([]int{ {nums} }, {target})
-    dart: Solution().search([{nums}], {target})
-    swift: Solution().search([{nums}], {target})
-    typescript: search([{nums}], {target})
+    cpp: Solution().search({nums}, {target})
+    rust: Solution::search({nums}, {target})
+    python3: Solution().search({nums}, {target})
+    python2: Solution().search({nums}, {target})
+    ruby: search({nums}, {target})
+    java: new Solution().search({nums}, {target})
+    csharp: new Solution().Search({nums}, {target})
+    kotlin: Solution().search({nums}, {target})
+    go: search({nums}, {target})
+    dart: Solution().search({nums}, {target})
+    swift: Solution().search({nums}, {target})
+    typescript: search({nums}, {target})
+  params:
+    nums:
+      type: array
+      items:
+        type: int
+    target:
+      type: int
 judge:
   type: exact
 limits:
@@ -21,7 +28,7 @@ limits:
   memory_mb: 256
 oracle:
   python3:
-    call: Checker().search([{nums}], {target}, {result})
+    call: Checker().search({nums}, {target}, {result})
     checker: |
       class Checker:
           def search(self, nums, target, result):
diff --git a/tests/1-500/34. find-first-and-last-position-of-element-in-sorted-array/manifest.yaml b/tests/1-500/34. find-first-and-last-position-of-element-in-sorted-array/manifest.yaml
index fa2df6f2..d7feb4bc 100644
--- a/tests/1-500/34. find-first-and-last-position-of-element-in-sorted-array/manifest.yaml	
+++ b/tests/1-500/34. find-first-and-last-position-of-element-in-sorted-array/manifest.yaml	
@@ -2,18 +2,25 @@
   "id": 34
   "title": "find-first-and-last-position-of-element-in-sorted-array"
   "call":
-    "cpp": "Solution().searchRange(lv(vector<int>{ {nums} }), {target})"
-    "rust": "Solution::search_range(vec![{nums}], {target})"
-    "python3": "Solution().searchRange([{nums}], {target})"
-    "python2": "Solution().searchRange([{nums}], {target})"
-    "ruby": "search_range([{nums}], {target})"
-    "java": "new Solution().searchRange(new int[]{ {nums} }, {target})"
-    "csharp": "new Solution().SearchRange(new int[]{ {nums} }, {target})"
-    "kotlin": "Solution().searchRange(intArrayOf({nums}), {target})"
-    "go": "searchRange([]int{ {nums} }, {target})"
-    "dart": "Solution().searchRange([{nums}], {target})"
-    "swift": "Solution().searchRange([{nums}], {target})"
-    "typescript": "searchRange([{nums}], {target})"
+    "cpp": "Solution().searchRange({nums}, {target})"
+    "rust": "Solution::search_range({nums}, {target})"
+    "python3": "Solution().searchRange({nums}, {target})"
+    "python2": "Solution().searchRange({nums}, {target})"
+    "ruby": "search_range({nums}, {target})"
+    "java": "new Solution().searchRange({nums}, {target})"
+    "csharp": "new Solution().SearchRange({nums}, {target})"
+    "kotlin": "Solution().searchRange({nums}, {target})"
+    "go": "searchRange({nums}, {target})"
+    "dart": "Solution().searchRange({nums}, {target})"
+    "swift": "Solution().searchRange({nums}, {target})"
+    "typescript": "searchRange({nums}, {target})"
+  params:
+    nums:
+      type: array
+      items:
+        type: int
+    target:
+      type: int
 "judge":
   "type": "exact"
 "limits":
@@ -21,14 +28,12 @@
   "memory_mb": 256
 "oracle":
   "python3":
-    "call": "Checker().searchRange([{nums}], {target}, {result})"
+    "call": "Checker().searchRange({nums}, {target}, {result})"
     "checker":
-      "import json\n\nclass Checker:\n    def searchRange(self, nums, target,\
-      \ result):\n        first = -1\n        last = -1\n        for i, val in enumerate(nums):\n\
-      \            if val == target:\n                if first == -1:\n          \
-      \          first = i\n                last = i\n        try:\n            got\
-      \ = json.loads(result) if isinstance(result, str) else result\n        except\
-      \ Exception:\n            return False\n        return got == [first, last]\n"
+      "import json\n\nclass Checker:\n    def searchRange(self, nums, target, result):\n        first = -1\n    \
+      \    last = -1\n        for i, val in enumerate(nums):\n            if val == target:\n                if first == -1:\n\
+      \                    first = i\n                last = i\n        try:\n            got = json.loads(result) if isinstance(result,
+      str) else result\n        except Exception:\n            return False\n        return got == [first, last]\n"
 "seed": 42
 "tests":
   - "name": "Example 1"
diff --git a/tests/1-500/35. search-insert-position/manifest.yaml b/tests/1-500/35. search-insert-position/manifest.yaml
index eb4f6340..f0cfb32b 100644
--- a/tests/1-500/35. search-insert-position/manifest.yaml	
+++ b/tests/1-500/35. search-insert-position/manifest.yaml	
@@ -2,19 +2,26 @@ entry:
   id: 35
   title: search-insert-position
   call:
-    cpp: "Solution().searchInsert(lv(vector<int>{ {nums} }), {target})"
-    rust: "Solution::search_insert(vec![{nums}], {target})"
-    python3: "Solution().searchInsert([{nums}], {target})"
-    python2: "Solution().searchInsert([{nums}], {target})"
-    ruby: "search_insert([{nums}], {target})"
-    java: "new Solution().searchInsert(new int[]{ {nums} }, {target})"
-    csharp: "new Solution().SearchInsert(new int[]{ {nums} }, {target})"
-    kotlin: "Solution().searchInsert(intArrayOf({nums}), {target})"
-    go: "searchInsert([]int{ {nums} }, {target})"
-    dart: "Solution().searchInsert([{nums}], {target})"
-    swift: "Solution().searchInsert([{nums}], {target})"
-    typescript: "searchInsert([{nums}], {target})"
+    cpp: "Solution().searchInsert({nums}, {target})"
+    rust: "Solution::search_insert({nums}, {target})"
+    python3: "Solution().searchInsert({nums}, {target})"
+    python2: "Solution().searchInsert({nums}, {target})"
+    ruby: "search_insert({nums}, {target})"
+    java: "new Solution().searchInsert({nums}, {target})"
+    csharp: "new Solution().SearchInsert({nums}, {target})"
+    kotlin: "Solution().searchInsert({nums}, {target})"
+    go: "searchInsert({nums}, {target})"
+    dart: "Solution().searchInsert({nums}, {target})"
+    swift: "Solution().searchInsert({nums}, {target})"
+    typescript: "searchInsert({nums}, {target})"
 
+  params:
+    nums:
+      type: array
+      items:
+        type: int
+    target:
+      type: int
 judge:
   type: "exact"
 
@@ -24,7 +31,7 @@ limits:
 
 oracle:
   python3:
-    call: "Checker().searchInsert([{nums}], {target}, {result})"
+    call: "Checker().searchInsert({nums}, {target}, {result})"
     checker: |
       class Checker:
           def searchInsert(self, nums, target, result):
diff --git a/tests/1-500/36. valid-sudoku/manifest.yaml b/tests/1-500/36. valid-sudoku/manifest.yaml
index e986b342..3d5101be 100644
--- a/tests/1-500/36. valid-sudoku/manifest.yaml	
+++ b/tests/1-500/36. valid-sudoku/manifest.yaml	
@@ -1,16 +1,23 @@
 "entry":
   "id": 36
   "title": "valid-sudoku"
+  "params":
+    board:
+      type: array
+      items:
+        type: array
+        items:
+          type: char
   "call":
-    "cpp": "Solution().isValidSudoku(lv_char(vector<vector<char>>{ {board} }))"
-    "rust": "Solution::is_valid_sudoku(vec![{board}])"
-    "python3": "Solution().isValidSudoku([{board}])"
-    "python2": "Solution().isValidSudoku([{board}])"
+    "cpp": "Solution().isValidSudoku({board})"
+    "rust": "Solution::is_valid_sudoku({board})"
+    "python3": "Solution().isValidSudoku({board})"
+    "python2": "Solution().isValidSudoku({board})"
     "ruby": "is_valid_sudoku({board})"
-    "java": "new Solution().isValidSudoku(new char[][]{ {board} })"
-    "csharp": "new Solution().IsValidSudoku(new char[][]{ {board} })"
-    "kotlin": "Solution().isValidSudoku(arrayOf({board}))"
-    "go": "isValidSudoku([][]byte{ {board} })"
+    "java": "new Solution().isValidSudoku({board})"
+    "csharp": "new Solution().IsValidSudoku({board})"
+    "kotlin": "Solution().isValidSudoku({board})"
+    "go": "isValidSudoku({board})"
     "dart": "Solution().isValidSudoku({board})"
     "swift": "Solution().isValidSudoku({board})"
     "typescript": "isValidSudoku({board})"
@@ -21,7 +28,7 @@
   "memory_mb": 256
 "oracle":
   "python3":
-    "call": "Checker().isValidSudoku([{board}], {result})"
+    "call": "Checker().isValidSudoku(board, {result})"
     "checker": "class Checker:\n    def isValidSudoku(self, board, result) -> bool:\n        def check():\n            rows = [[False] * 9 for _ in range(9)]\n            cols = [[False] * 9 for _ in range(9)]\n            boxes = [[False] * 9 for _ in range(9)]\n            for i in range(9):\n                for j in range(9):\n                    if board[i][j] != '.':\n                        num = int(board[i][j]) - 1\n                        box = (i // 3) * 3 + (j // 3)\n                        if rows[i][num] or cols[j][num] or boxes[box][num]:\n                            return False\n                        rows[i][num] = cols[j][num] = boxes[box][num] = True\n            return True\n        return check() == result\n"
 "seed": 42
 "tests":
diff --git a/tests/1-500/38. count-and-say/manifest.yaml b/tests/1-500/38. count-and-say/manifest.yaml
index 57fd5744..33c0873c 100644
--- a/tests/1-500/38. count-and-say/manifest.yaml	
+++ b/tests/1-500/38. count-and-say/manifest.yaml	
@@ -1,6 +1,9 @@
 entry:
   id: 38
   title: count-and-say
+  params:
+    n:
+      type: int
   call:
     cpp: Solution().countAndSay({n})
     rust: Solution::count_and_say({n})
@@ -21,7 +24,7 @@ limits:
   memory_mb: 256
 oracle:
   python3:
-    call: Checker().countAndSay({n}, {result})
+    call: Checker().countAndSay(n, {result})
     checker:
       "import json\nclass Checker:\n    def _norm(self, result):\n        if\
       \ isinstance(result, str):\n            try:\n                result = json.loads(result)\n\
@@ -38,107 +41,137 @@ tests:
   - name: base case 1
     in:
       n: 1
+    out: '"1"'
   - name: base case 2
     in:
       n: 2
+    out: '"11"'
   - name: base case 3
     in:
       n: 3
+    out: '"21"'
   - name: n=4
     in:
       n: 4
+    out: '"1211"'
   - name: n=5
     in:
       n: 5
+    out: '"111221"'
   - name: n=6
     in:
       n: 6
+    out: '"312211"'
   - name: n=7
     in:
       n: 7
+    out: '"13112221"'
   - name: n=8
     in:
       n: 8
+    out: '"1113213211"'
   - name: n=9
     in:
       n: 9
+    out: '"31131211131221"'
   - name: n=10
     in:
       n: 10
+    out: '"13211311123113112211"'
   - name: n=11
     in:
       n: 11
+    out: '"11131221133112132113212221"'
   - name: n=12
     in:
       n: 12
+    out: '"3113112221232112111312211312113211"'
   - name: n=13
     in:
       n: 13
+    out: '"1321132132111213122112311311222113111221131221"'
   - name: n=14
     in:
       n: 14
     seed: 14
+    out: '"11131221131211131231121113112221121321132132211331222113112211"'
   - name: n=15
     in:
       n: 15
     seed: 15
+    out: '"311311222113111231131112132112311321322112111312211312111322212311322113212221"'
   - name: n=16
     in:
       n: 16
     seed: 16
+    out: '"132113213221133112132113311211131221121321131211132221123113112221131112311332111213211322211312113211"'
   - name: n=17
     in:
       n: 17
     seed: 17
+    out: '"11131221131211132221232112111312212321123113112221121113122113111231133221121321132132211331121321231231121113122113322113111221131221"'
   - name: n=18
     in:
       n: 18
     seed: 18
+    out: '"31131122211311123113321112131221123113112211121312211213211321322112311311222113311213212322211211131221131211132221232112111312111213111213211231131122212322211331222113112211"'
   - name: n=19
     in:
       n: 19
     seed: 19
+    out: '"1321132132211331121321231231121113112221121321132122311211131122211211131221131211132221121321132132212321121113121112133221123113112221131112311332111213122112311311123112111331121113122112132113213211121332212311322113212221"'
   - name: n=20
     in:
       n: 20
     seed: 20
+    out: '"11131221131211132221232112111312111213111213211231132132211211131221131211221321123113213221123113112221131112311332211211131221131211132211121312211231131112311211232221121321132132211331121321231231121113112221121321133112132112312321123113112221121113122113121113123112112322111213211322211312113211"'
   - name: n=21
     in:
       n: 21
     seed: 21
+    out: '"311311222113111231133211121312211231131112311211133112111312211213211312111322211231131122211311122122111312211213211312111322211213211321322113311213212322211231131122211311123113223112111311222112132113311213211221121332211211131221131211132221232112111312111213111213211231132132211211131221232112111312211213111213122112132113213221123113112221131112311311121321122112132231121113122113322113111221131221"'
   - name: n=22
     in:
       n: 22
     seed: 22
+    out: '"132113213221133112132123123112111311222112132113311213211231232112311311222112111312211311123113322112132113213221133122112231131122211211131221131112311332211211131221131211132221232112111312111213322112132113213221133112132113221321123113213221121113122123211211131221222112112322211231131122211311123113321112131221123113111231121113311211131221121321131211132221123113112211121312211231131122211211133112111311222112111312211312111322211213211321322113311213211331121113122122211211132213211231131122212322211331222113112211"'
   - name: n=23
     in:
       n: 23
     seed: 23
+    out: '"111312211312111322212321121113121112131112132112311321322112111312212321121113122112131112131221121321132132211231131122211331121321232221121113122113121113222123112221221321132132211231131122211331121321232221123113112221131112311332111213122112311311123112112322211211131221131211132221232112111312211322111312211213211312111322211231131122111213122112311311221132211221121332211213211321322113311213212312311211131122211213211331121321123123211231131122211211131221131112311332211213211321223112111311222112132113213221123123211231132132211231131122211311123113322112111312211312111322212321121113122123211231131122113221123113221113122112132113213211121332212311322113212221"'
   - name: n=24
     in:
       n: 24
     seed: 24
+    out: '"3113112221131112311332111213122112311311123112111331121113122112132113121113222112311311221112131221123113112221121113311211131122211211131221131211132221121321132132212321121113121112133221123113112221131112311332111213213211221113122113121113222112132113213221232112111312111213322112132113213221133112132123123112111311222112132113311213211221121332211231131122211311123113321112131221123113112221132231131122211211131221131112311332211213211321223112111311222112132113212221132221222112112322211211131221131211132221232112111312111213111213211231132132211211131221232112111312211213111213122112132113213221123113112221133112132123222112111312211312112213211231132132211211131221131211132221121311121312211213211312111322211213211321322113311213212322211231131122211311123113321112131221123113112211121312211213211321222113222112132113223113112221121113122113121113123112112322111213211322211312113211"'
   - name: n=25
     in:
       n: 25
     seed: 25
+    out: '"132113213221133112132123123112111311222112132113311213211231232112311311222112111312211311123113322112132113212231121113112221121321132132211231232112311321322112311311222113111231133221121113122113121113221112131221123113111231121123222112132113213221133112132123123112111312111312212231131122211311123113322112111312211312111322111213122112311311123112112322211211131221131211132221232112111312111213111213211231132132211211131221232112111312212221121123222112132113213221133112132123123112111311222112132113213221132213211321322112311311222113311213212322211211131221131211221321123113213221121113122113121132211332113221122112133221123113112221131112311332111213122112311311123112111331121113122112132113121113222112311311221112131221123113112221121113311211131122211211131221131211132221121321132132212321121113121112133221123113112221131112212211131221121321131211132221123113112221131112311332211211133112111311222112111312211311123113322112111312211312111322212321121113121112133221121321132132211331121321231231121113112221121321132122311211131122211211131221131211322113322112111312211322132113213221123113112221131112311311121321122112132231121113122113322113111221131221"'
   - name: n=26
     in:
       n: 26
     seed: 26
+    out: '"1113122113121113222123211211131211121311121321123113213221121113122123211211131221121311121312211213211321322112311311222113311213212322211211131221131211221321123113213221121113122113121113222112131112131221121321131211132221121321132132211331121321232221123113112221131112311322311211131122211213211331121321122112133221121113122113121113222123211211131211121311121321123113111231131122112213211321322113311213212322211231131122211311123113223112111311222112132113311213211221121332211231131122211311123113321112131221123113111231121113311211131221121321131211132221123113112211121312211231131122113221122112133221121113122113121113222123211211131211121311121321123113213221121113122113121113222113221113122113121113222112132113213221232112111312111213322112311311222113111221221113122112132113121113222112311311222113111221132221231221132221222112112322211213211321322113311213212312311211131122211213211331121321123123211231131122211211131221131112311332211213211321223112111311222112132113213221123123211231132132211231131122211311123113322112111312211312111322111213122112311311123112112322211213211321322113312211223113112221121113122113111231133221121321132132211331121321232221123123211231132132211231131122211331121321232221123113112221131112311332111213122112311311123112112322211211131221131211132221232112111312111213111213211231132132211211131221131211221321123113213221123113112221131112211322212322211231131122211322111312211312111322211213211321322113311213211331121113122122211211132213211231131122212322211331222113112211"'
   - name: n=27
     in:
       n: 27
     seed: 27
+    out: '"31131122211311123113321112131221123113111231121113311211131221121321131211132221123113112211121312211231131122211211133112111311222112111312211312111322211213211321322123211211131211121332211231131122211311122122111312211213211312111322211231131122211311123113322112111331121113112221121113122113111231133221121113122113121113222123211211131211121332211213211321322113311213211322132112311321322112111312212321121113122122211211232221123113112221131112311332111213122112311311123112111331121113122112132113311213211321222122111312211312111322212321121113121112133221121321132132211331121321132213211231132132211211131221232112111312212221121123222112132113213221133112132123123112111311222112132113311213211231232112311311222112111312211311123113322112132113212231121113112221121321132122211322212221121123222112311311222113111231133211121312211231131112311211133112111312211213211312111322211231131122211311123113322113223113112221131112311332211211131221131211132211121312211231131112311211232221121321132132211331221122311311222112111312211311123113322112132113213221133122211332111213112221133211322112211213322112111312211312111322212321121113121112131112132112311321322112111312212321121113122112131112131221121321132132211231131122211331121321232221121113122113121122132112311321322112111312211312111322211213111213122112132113121113222112132113213221133112132123222112311311222113111231132231121113112221121321133112132112211213322112111312211312111322212311222122132113213221123113112221133112132123222112111312211312111322212321121113121112133221121311121312211213211312111322211213211321322123211211131211121332211213211321322113311213212312311211131122211213211331121321122112133221123113112221131112311332111213122112311311123112111331121113122112132113121113222112311311222113111221221113122112132113121113222112132113213221133122211332111213322112132113213221132231131122211311123113322112111312211312111322212321121113122123211231131122113221123113221113122112132113213211121332212311322113212221"'
   - name: n=28
     in:
       n: 28
     seed: 28
+    out: '"13211321322113311213212312311211131122211213211331121321123123211231131122211211131221131112311332211213211321223112111311222112132113213221123123211231132132211231131122211311123113322112111312211312111322111213122112311311123112112322211213211321322113312211223113112221121113122113111231133221121321132132211331121321232221123123211231132132211231131122211331121321232221123113112221131112311332111213122112311311123112112322211211131221131211132221232112111312211322111312211213211312111322211231131122111213122112311311221132211221121332211213211321322113311213212312311211131122211213211331121321123123211231131122211211131221232112111312211312113211223113112221131112311332111213122112311311123112112322211211131221131211132221232112111312211322111312211213211312111322211231131122111213122112311311221132211221121332211211131221131211132221232112111312111213111213211231132132211211131221232112111312211213111213122112132113213221123113112221133112132123222112111312211312112213211231132132211211131221131211322113321132211221121332211213211321322113311213212312311211131122211213211331121321123123211231131122211211131221131112311332211213211321322113311213212322211322132113213221133112132123222112311311222113111231132231121113112221121321133112132112211213322112111312211312111322212311222122132113213221123113112221133112132123222112111312211312111322212311322123123112111321322123122113222122211211232221123113112221131112311332111213122112311311123112111331121113122112132113121113222112311311221112131221123113112221121113311211131122211211131221131211132221121321132132212321121113121112133221123113112221131112212211131221121321131211132221123113112221131112311332211211133112111311222112111312211311123113322112111312211312111322212321121113121112133221121321132132211331121321132213211231132132211211131221232112111312212221121123222112311311222113111231133211121321321122111312211312111322211213211321322123211211131211121332211231131122211311123113321112131221123113111231121123222112111331121113112221121113122113111231133221121113122113121113221112131221123113111231121123222112111312211312111322212321121113121112131112132112311321322112111312212321121113122122211211232221121321132132211331121321231231121113112221121321133112132112312321123113112221121113122113111231133221121321132132211331221122311311222112111312211311123113322112111312211312111322212311322123123112112322211211131221131211132221132213211321322113311213212322211231131122211311123113321112131221123113112211121312211213211321222113222112132113223113112221121113122113121113123112112322111213211322211312113211"'
   - name: limit n=29
     in:
       n: 29
     seed: 29
+    out: '"11131221131211132221232112111312111213111213211231132132211211131221232112111312211213111213122112132113213221123113112221133112132123222112111312211312112213211231132132211211131221131211132221121311121312211213211312111322211213211321322113311213212322211231131122211311123113223112111311222112132113311213211221121332211211131221131211132221231122212213211321322112311311222113311213212322211211131221131211132221232112111312111213322112131112131221121321131211132221121321132132212321121113121112133221121321132132211331121321231231121113112221121321133112132112211213322112311311222113111231133211121312211231131122211322311311222112111312211311123113322112132113212231121113112221121321132122211322212221121123222112111312211312111322212321121113121112131112132112311321322112111312212321121113122112131112131221121321132132211231131122111213122112311311222113111221131221221321132132211331121321231231121113112221121321133112132112211213322112311311222113111231133211121312211231131122211322311311222112111312211311123113322112132113212231121113112221121321132122211322212221121123222112311311222113111231133211121312211231131112311211133112111312211213211312111322211231131122111213122112311311222112111331121113112221121113122113121113222112132113213221232112111312111213322112311311222113111221221113122112132113121113222112311311222113111221132221231221132221222112112322211211131221131211132221232112111312111213111213211231132132211211131221232112111312211213111213122112132113213221123113112221133112132123222112111312211312111322212321121113121112133221132211131221131211132221232112111312111213322112132113213221133112132113221321123113213221121113122123211211131221222112112322211231131122211311123113321112132132112211131221131211132221121321132132212321121113121112133221123113112221131112311332111213211322111213111213211231131211132211121311222113321132211221121332211213211321322113311213212312311211131122211213211331121321123123211231131122211211131221131112311332211213211321223112111311222112132113213221123123211231132132211231131122211311123113322112111312211312111322111213122112311311123112112322211213211321322113312211223113112221121113122113111231133221121321132132211331121321232221123123211231132132211231131122211331121321232221123113112221131112311332111213122112311311123112112322211211131221131211132221232112111312211322111312211213211312111322211231131122111213122112311311221132211221121332211213211321322113311213212312311211131211131221223113112221131112311332211211131221131211132211121312211231131112311211232221121321132132211331121321231231121113112221121321133112132112211213322112312321123113213221123113112221133112132123222112311311222113111231132231121113112221121321133112132112211213322112311311222113111231133211121312211231131112311211133112111312211213211312111322211231131122111213122112311311221132211221121332211211131221131211132221232112111312111213111213211231132132211211131221232112111312211213111213122112132113213221123113112221133112132123222112111312211312111322212311222122132113213221123113112221133112132123222112311311222113111231133211121321132211121311121321122112133221123113112221131112311332211322111312211312111322212321121113121112133221121321132132211331121321231231121113112221121321132122311211131122211211131221131211322113322112111312211322132113213221123113112221131112311311121321122112132231121113122113322113111221131221"'
   - name: max n=30
     in:
       n: 30
     seed: 30
+    out: '"3113112221131112311332111213122112311311123112111331121113122112132113121113222112311311221112131221123113112221121113311211131122211211131221131211132221121321132132212321121113121112133221123113112221131112212211131221121321131211132221123113112221131112311332211211133112111311222112111312211311123113322112111312211312111322212321121113121112133221121321132132211331121321132213211231132132211211131221232112111312212221121123222112311311222113111231133211121321321122111312211312111322211213211321322123211211131211121332211231131122211311123113321112131221123113111231121123222112111331121113112221121113122113111231133221121113122113121113221112131221123113111231121123222112111312211312111322212321121113121112131112132112311321322112111312212321121113122122211211232221121321132132211331121321231231121113112221121321132132211322132113213221123113112221133112132123222112111312211312112213211231132132211211131221131211322113321132211221121332211231131122211311123113321112131221123113111231121113311211131221121321131211132221123113112211121312211231131122211211133112111311222112111312211312111322211213211321223112111311222112132113213221133122211311221122111312211312111322212321121113121112131112132112311321322112111312212321121113122122211211232221121321132132211331121321231231121113112221121321132132211322132113213221123113112221133112132123222112111312211312112213211231132132211211131221131211322113321132211221121332211213211321322113311213212312311211131122211213211331121321123123211231131122211211131221131112311332211213211321223112111311222112132113213221123123211231132132211231131122211311123113322112111312211312111322111213122112311311123112112322211213211321322113312211223113112221121113122113111231133221121321132132211331222113321112131122211332113221122112133221123113112221131112311332111213122112311311123112111331121113122112132113121113222112311311221112131221123113112221121113311211131122211211131221131211132221121321132132212321121113121112133221123113112221131112311332111213122112311311123112112322211322311311222113111231133211121312211231131112311211232221121113122113121113222123211211131221132211131221121321131211132221123113112211121312211231131122113221122112133221121321132132211331121321231231121113121113122122311311222113111231133221121113122113121113221112131221123113111231121123222112132113213221133112132123123112111312211322311211133112111312211213211311123113223112111321322123122113222122211211232221121113122113121113222123211211131211121311121321123113213221121113122123211211131221121311121312211213211321322112311311222113311213212322211211131221131211221321123113213221121113122113121113222112131112131221121321131211132221121321132132211331121321232221123113112221131112311322311211131122211213211331121321122112133221121113122113121113222123112221221321132132211231131122211331121321232221121113122113121113222123211211131211121332211213111213122112132113121113222112132113213221232112111312111213322112132113213221133112132123123112111311222112132113311213211221121332211231131122211311123113321112131221123113112221132231131122211211131221131112311332211213211321223112111311222112132113212221132221222112112322211211131221131211132221232112111312111213111213211231131112311311221122132113213221133112132123222112311311222113111231132231121113112221121321133112132112211213322112111312211312111322212321121113121112131112132112311321322112111312212321121113122122211211232221121311121312211213211312111322211213211321322123211211131211121332211213211321322113311213211322132112311321322112111312212321121113122122211211232221121321132132211331121321231231121113112221121321133112132112312321123113112221121113122113111231133221121321132122311211131122211213211321222113222122211211232221123113112221131112311332111213122112311311123112111331121113122112132113121113222112311311221112131221123113112221121113311211131122211211131221131211132221121321132132212321121113121112133221123113112221131112311332111213213211221113122113121113222112132113213221232112111312111213322112132113213221133112132123123112111312211322311211133112111312212221121123222112132113213221133112132123222113223113112221131112311332111213122112311311123112112322211211131221131211132221232112111312111213111213211231132132211211131221131211221321123113213221123113112221131112211322212322211231131122211322111312211312111322211213211321322113311213211331121113122122211211132213211231131122212322211331222113112211"'
diff --git a/tests/1-500/39. combination-sum/manifest.yaml b/tests/1-500/39. combination-sum/manifest.yaml
index d2a7d8c4..6653b025 100644
--- a/tests/1-500/39. combination-sum/manifest.yaml	
+++ b/tests/1-500/39. combination-sum/manifest.yaml	
@@ -2,18 +2,25 @@ entry:
   id: 39
   title: combination-sum
   call:
-    cpp: Solution().combinationSum(lv(vector<int>{ {candidates} }), {target})
-    rust: Solution::combination_sum(vec![{candidates}], {target})
-    python3: Solution().combinationSum([{candidates}], {target})
-    python2: Solution().combinationSum([{candidates}], {target})
-    ruby: combination_sum([{candidates}], {target})
-    java: new Solution().combinationSum(new int[]{ {candidates} }, {target})
-    csharp: new Solution().CombinationSum(new int[]{ {candidates} }, {target})
-    kotlin: Solution().combinationSum(intArrayOf({candidates}), {target})
-    go: combinationSum([]int{ {candidates} }, {target})
-    dart: Solution().combinationSum([{candidates}], {target})
-    swift: Solution().combinationSum([{candidates}], {target})
-    typescript: combinationSum([{candidates}], {target})
+    cpp: Solution().combinationSum({candidates}, {target})
+    rust: Solution::combination_sum({candidates}, {target})
+    python3: Solution().combinationSum({candidates}, {target})
+    python2: Solution().combinationSum({candidates}, {target})
+    ruby: combination_sum({candidates}, {target})
+    java: new Solution().combinationSum({candidates}, {target})
+    csharp: new Solution().CombinationSum({candidates}, {target})
+    kotlin: Solution().combinationSum({candidates}, {target})
+    go: combinationSum({candidates}, {target})
+    dart: Solution().combinationSum({candidates}, {target})
+    swift: Solution().combinationSum({candidates}, {target})
+    typescript: combinationSum({candidates}, {target})
+  params:
+    candidates:
+      type: array
+      items:
+        type: int
+    target:
+      type: int
 judge:
   type: ignore_order
 limits:
@@ -21,23 +28,18 @@ limits:
   memory_mb: 256
 oracle:
   python3:
-    call: Checker().check([{candidates}], {target}, {result})
+    call: Checker().check(candidates, target, {result})
     checker:
-      "import json\nclass Checker:\n    def _norm(self, result):\n        if\
-      \ isinstance(result, str):\n            try:\n                result = json.loads(result)\n\
-      \            except Exception:\n                pass\n        return result\n\
-      \n    def check(self, candidates, target, result):\n        result = self._norm(result)\n\
-      \        if not isinstance(result, list): return False\n        seen = set()\n\
-      \        for comb in result:\n            if sum(comb) != target: return False\n\
-      \            for x in comb:\n                if x not in candidates: return\
-      \ False\n            seen.add(tuple(sorted(comb)))\n        def get_all(target_val,\
-      \ start_idx):\n            if target_val == 0: return [[]]\n            if target_val\
-      \ < 0 or start_idx == len(candidates): return []\n            res = []\n   \
-      \         for i in range(start_idx, len(candidates)):\n                for sub\
-      \ in get_all(target_val - candidates[i], i):\n                    res.append([candidates[i]]\
-      \ + sub)\n            return res\n        expected = [tuple(sorted(c)) for c\
-      \ in get_all(target, 0)]\n        return len(result) == len(expected) and all(tuple(sorted(c))\
-      \ in expected for c in result)\n"
+      "import json\nclass Checker:\n    def _norm(self, result):\n        if isinstance(result, str):\n           \
+      \ try:\n                result = json.loads(result)\n            except Exception:\n                pass\n        return
+      result\n\n    def check(self, candidates, target, result):\n        result = self._norm(result)\n        if not isinstance(result,
+      list): return False\n        seen = set()\n        for comb in result:\n            if sum(comb) != target: return False\n\
+      \            for x in comb:\n                if x not in candidates: return False\n            seen.add(tuple(sorted(comb)))\n\
+      \        def get_all(target_val, start_idx):\n            if target_val == 0: return [[]]\n            if target_val
+      < 0 or start_idx == len(candidates): return []\n            res = []\n            for i in range(start_idx, len(candidates)):\n\
+      \                for sub in get_all(target_val - candidates[i], i):\n                    res.append([candidates[i]]
+      + sub)\n            return res\n        expected = [tuple(sorted(c)) for c in get_all(target, 0)]\n        return len(result)
+      == len(expected) and all(tuple(sorted(c)) in expected for c in result)\n"
 seed: 42
 tests:
   - name: Example 1
diff --git a/tests/1-500/4. median-of-two-sorted-arrays/manifest.yaml b/tests/1-500/4. median-of-two-sorted-arrays/manifest.yaml
index d0d9a288..b57de71b 100644
--- a/tests/1-500/4. median-of-two-sorted-arrays/manifest.yaml	
+++ b/tests/1-500/4. median-of-two-sorted-arrays/manifest.yaml	
@@ -1,25 +1,28 @@
 entry:
   id: 4
   title: median-of-two-sorted-arrays
+  params:
+    nums1:
+      type: array
+      items:
+        type: int
+    nums2:
+      type: array
+      items:
+        type: int
   call:
-    cpp:
-      Solution().findMedianSortedArrays(lv(vector<int>{ {nums1} }), lv(vector<int>{
-      {nums2} }))
-    rust: Solution::find_median_sorted_arrays(vec![{nums1}], vec![{nums2}])
-    python3: Solution().findMedianSortedArrays([{nums1}], [{nums2}])
-    python2: Solution().findMedianSortedArrays([{nums1}], [{nums2}])
-    ruby: find_median_sorted_arrays([{nums1}], [{nums2}])
-    java:
-      new Solution().findMedianSortedArrays(new int[]{ {nums1} }, new int[]{ {nums2}
-      })
-    csharp:
-      new Solution().FindMedianSortedArrays(new int[]{ {nums1} }, new int[]{
-      {nums2} })
-    kotlin: Solution().findMedianSortedArrays(intArrayOf({nums1}), intArrayOf({nums2}))
-    go: findMedianSortedArrays([]int{ {nums1} }, []int{ {nums2} })
-    dart: Solution().findMedianSortedArrays([{nums1}], [{nums2}])
-    swift: Solution().findMedianSortedArrays([{nums1}], [{nums2}])
-    typescript: findMedianSortedArrays([{nums1}], [{nums2}])
+    cpp: Solution().findMedianSortedArrays({nums1}, {nums2})
+    rust: Solution::find_median_sorted_arrays({nums1}, {nums2})
+    python3: Solution().findMedianSortedArrays({nums1}, {nums2})
+    python2: Solution().findMedianSortedArrays({nums1}, {nums2})
+    ruby: find_median_sorted_arrays({nums1}, {nums2})
+    java: new Solution().findMedianSortedArrays({nums1}, {nums2})
+    csharp: new Solution().FindMedianSortedArrays({nums1}, {nums2})
+    kotlin: Solution().findMedianSortedArrays({nums1}, {nums2})
+    go: findMedianSortedArrays({nums1}, {nums2})
+    dart: Solution().findMedianSortedArrays({nums1}, {nums2})
+    swift: Solution().findMedianSortedArrays({nums1}, {nums2})
+    typescript: findMedianSortedArrays({nums1}, {nums2})
 judge:
   type: exact
 limits:
@@ -27,7 +30,7 @@ limits:
   memory_mb: 256
 oracle:
   python3:
-    call: Checker().findMedianSortedArrays([{nums1}], [{nums2}], {result})
+    call: Checker().findMedianSortedArrays(nums1, nums2, {result})
     checker:
       "import json\nclass Checker:\n    def _norm(self, result):\n        if\
       \ isinstance(result, str):\n            try:\n                result = json.loads(result)\n\
diff --git a/tests/1-500/40. combination-sum-ii/manifest.yaml b/tests/1-500/40. combination-sum-ii/manifest.yaml
index c7e150b8..fb1a7a4a 100644
--- a/tests/1-500/40. combination-sum-ii/manifest.yaml	
+++ b/tests/1-500/40. combination-sum-ii/manifest.yaml	
@@ -2,18 +2,25 @@ entry:
   id: 40
   title: combination-sum-ii
   call:
-    cpp: Solution().combinationSum2(lv(vector<int>{ {candidates} }), {target})
-    rust: Solution::combination_sum2(vec![{candidates}], {target})
-    python3: Solution().combinationSum2([{candidates}], {target})
-    python2: Solution().combinationSum2([{candidates}], {target})
-    ruby: combination_sum2([{candidates}], {target})
-    java: new Solution().combinationSum2(new int[]{ {candidates} }, {target})
-    csharp: new Solution().CombinationSum2(new int[]{ {candidates} }, {target})
-    kotlin: Solution().combinationSum2(intArrayOf({candidates}), {target})
-    go: combinationSum2([]int{ {candidates} }, {target})
-    dart: Solution().combinationSum2([{candidates}], {target})
-    swift: Solution().combinationSum2([{candidates}], {target})
-    typescript: combinationSum2([{candidates}], {target})
+    cpp: Solution().combinationSum2({candidates}, {target})
+    rust: Solution::combination_sum2({candidates}, {target})
+    python3: Solution().combinationSum2({candidates}, {target})
+    python2: Solution().combinationSum2({candidates}, {target})
+    ruby: combination_sum2({candidates}, {target})
+    java: new Solution().combinationSum2({candidates}, {target})
+    csharp: new Solution().CombinationSum2({candidates}, {target})
+    kotlin: Solution().combinationSum2({candidates}, {target})
+    go: combinationSum2({candidates}, {target})
+    dart: Solution().combinationSum2({candidates}, {target})
+    swift: Solution().combinationSum2({candidates}, {target})
+    typescript: combinationSum2({candidates}, {target})
+  params:
+    candidates:
+      type: array
+      items:
+        type: int
+    target:
+      type: int
 judge:
   type: ignore_order
 limits:
@@ -21,20 +28,16 @@ limits:
   memory_mb: 256
 oracle:
   python3:
-    call: Checker().combinationSum2([{candidates}], {target}, {result})
+    call: Checker().combinationSum2({candidates}, {target}, {result})
     checker:
-      "import json\nclass Checker:\n    def _norm(self, result):\n        if\
-      \ isinstance(result, str):\n            try:\n                result = json.loads(result)\n\
-      \            except Exception:\n                pass\n        return result\n\
-      \n    def combinationSum2(self, candidates, target, result):\n        result\
-      \ = self._norm(result)\n        if not isinstance(result, list): return False\n\
-      \        for combo in result:\n            if sum(combo) != target: return False\n\
-      \        from collections import Counter\n        cand_counts = Counter(candidates)\n\
-      \        for combo in result:\n            combo_counts = Counter(combo)\n \
-      \           for num, count in combo_counts.items():\n                if count\
-      \ > cand_counts[num]: return False\n        seen = set()\n        for combo\
-      \ in result:\n            s = tuple(sorted(combo))\n            if s in seen:\
-      \ return False\n            seen.add(s)\n        return True\n"
+      "import json\nclass Checker:\n    def _norm(self, result):\n        if isinstance(result, str):\n           \
+      \ try:\n                result = json.loads(result)\n            except Exception:\n                pass\n        return
+      result\n\n    def combinationSum2(self, candidates, target, result):\n        result = self._norm(result)\n        if
+      not isinstance(result, list): return False\n        for combo in result:\n            if sum(combo) != target: return
+      False\n        from collections import Counter\n        cand_counts = Counter(candidates)\n        for combo in result:\n\
+      \            combo_counts = Counter(combo)\n            for num, count in combo_counts.items():\n                if
+      count > cand_counts[num]: return False\n        seen = set()\n        for combo in result:\n            s = tuple(sorted(combo))\n\
+      \            if s in seen: return False\n            seen.add(s)\n        return True\n"
 seed: 42
 tests:
   - name: Example 1
diff --git a/tests/1-500/41. first-missing-positive/manifest.yaml b/tests/1-500/41. first-missing-positive/manifest.yaml
index 06969053..9e5e4cbe 100644
--- a/tests/1-500/41. first-missing-positive/manifest.yaml	
+++ b/tests/1-500/41. first-missing-positive/manifest.yaml	
@@ -2,18 +2,23 @@
   "id": 41
   "title": "first-missing-positive"
   "call":
-    "cpp": "Solution().firstMissingPositive(lv(vector<int>{ {nums} }))"
-    "rust": "Solution::first_missing_positive(vec![{nums}])"
-    "python3": "Solution().firstMissingPositive([{nums}])"
-    "python2": "Solution().firstMissingPositive([{nums}])"
-    "ruby": "first_missing_positive([{nums}])"
-    "java": "new Solution().firstMissingPositive(new int[]{ {nums} })"
-    "csharp": "new Solution().FirstMissingPositive(new int[]{ {nums} })"
-    "kotlin": "Solution().firstMissingPositive(intArrayOf({nums}))"
-    "go": "firstMissingPositive([]int{ {nums} })"
-    "dart": "Solution().firstMissingPositive([{nums}])"
-    "swift": "Solution().firstMissingPositive([{nums}])"
-    "typescript": "firstMissingPositive([{nums}])"
+    "cpp": "Solution().firstMissingPositive({nums})"
+    "rust": "Solution::first_missing_positive({nums})"
+    "python3": "Solution().firstMissingPositive({nums})"
+    "python2": "Solution().firstMissingPositive({nums})"
+    "ruby": "first_missing_positive({nums})"
+    "java": "new Solution().firstMissingPositive({nums})"
+    "csharp": "new Solution().FirstMissingPositive({nums})"
+    "kotlin": "Solution().firstMissingPositive({nums})"
+    "go": "firstMissingPositive({nums})"
+    "dart": "Solution().firstMissingPositive({nums})"
+    "swift": "Solution().firstMissingPositive({nums})"
+    "typescript": "firstMissingPositive({nums})"
+  params:
+    nums:
+      type: array
+      items:
+        type: int
 "judge":
   "type": "exact"
 "limits":
@@ -21,13 +26,11 @@
   "memory_mb": 256
 "oracle":
   "python3":
-    "call": "Checker().check([{nums}], {result})"
+    "call": "Checker().check({nums}, {result})"
     "checker":
-      "import json\nclass Checker:\n    def check(self, nums, res):\n   \
-      \     try:\n            res = json.loads(res) if isinstance(res, str) else res\n\
-      \        except Exception:\n            return False\n        s = set(nums)\n\
-      \        i = 1\n        while i in s:\n            i += 1\n        return res\
-      \ == i\n"
+      "import json\nclass Checker:\n    def check(self, nums, res):\n        try:\n            res = json.loads(res)
+      if isinstance(res, str) else res\n        except Exception:\n            return False\n        s = set(nums)\n     \
+      \   i = 1\n        while i in s:\n            i += 1\n        return res == i\n"
 "seed": 42
 "tests":
   - "name": "example 1"
diff --git a/tests/1-500/42. trapping-rain-water/manifest.yaml b/tests/1-500/42. trapping-rain-water/manifest.yaml
index 7b3e0988..dc7e98b3 100644
--- a/tests/1-500/42. trapping-rain-water/manifest.yaml	
+++ b/tests/1-500/42. trapping-rain-water/manifest.yaml	
@@ -2,18 +2,23 @@ entry:
   id: 42
   title: trapping-rain-water
   call:
-    cpp: Solution().trap(lv(vector<int>{ {height} }))
-    rust: Solution::trap(vec![{height}])
-    python3: Solution().trap([{height}])
-    python2: Solution().trap([{height}])
-    ruby: trap([{height}])
-    java: new Solution().trap(new int[]{ {height} })
-    csharp: new Solution().Trap(new int[]{ {height} })
-    kotlin: Solution().trap(intArrayOf({height}))
-    go: trap([]int{ {height} })
-    dart: Solution().trap([{height}])
-    swift: Solution().trap([{height}])
-    typescript: trap([{height}])
+    cpp: Solution().trap({height})
+    rust: Solution::trap({height})
+    python3: Solution().trap({height})
+    python2: Solution().trap({height})
+    ruby: trap({height})
+    java: new Solution().trap({height})
+    csharp: new Solution().Trap({height})
+    kotlin: Solution().trap({height})
+    go: trap({height})
+    dart: Solution().trap({height})
+    swift: Solution().trap({height})
+    typescript: trap({height})
+  params:
+    height:
+      type: array
+      items:
+        type: int
 judge:
   type: exact
 limits:
@@ -21,22 +26,18 @@ limits:
   memory_mb: 256
 oracle:
   python3:
-    call: Checker().trap([{height}], {result})
+    call: Checker().trap({height}, {result})
     checker:
-      "import json\nclass Checker:\n    def _norm(self, result):\n        if\
-      \ isinstance(result, str):\n            try:\n                result = json.loads(result)\n\
-      \            except Exception:\n                pass\n            if isinstance(result,\
-      \ str):\n                low = result.strip().lower()\n                if low\
-      \ == 'true':\n                    return True\n                if low == 'false':\n\
-      \                    return False\n                if low.lstrip('-').isdigit():\n\
-      \                    return int(low)\n        return result\n\n    def trap(self,\
-      \ height, expected):\n        expected = self._norm(expected)\n        start,\
-      \ end = 0, len(height) - 1\n        left_max, right_max, total = 0, 0, 0\n \
-      \       while start < end:\n            left_max = max(left_max, height[start])\n\
-      \            right_max = max(right_max, height[end])\n            if left_max\
-      \ < right_max:\n                total += left_max - height[start]\n        \
-      \        start += 1\n            else:\n                total += right_max -\
-      \ height[end]\n                end -= 1\n        return total == expected\n"
+      "import json\nclass Checker:\n    def _norm(self, result):\n        if isinstance(result, str):\n           \
+      \ try:\n                result = json.loads(result)\n            except Exception:\n                pass\n         \
+      \   if isinstance(result, str):\n                low = result.strip().lower()\n                if low == 'true':\n \
+      \                   return True\n                if low == 'false':\n                    return False\n            \
+      \    if low.lstrip('-').isdigit():\n                    return int(low)\n        return result\n\n    def trap(self,
+      height, expected):\n        expected = self._norm(expected)\n        start, end = 0, len(height) - 1\n        left_max,
+      right_max, total = 0, 0, 0\n        while start < end:\n            left_max = max(left_max, height[start])\n      \
+      \      right_max = max(right_max, height[end])\n            if left_max < right_max:\n                total += left_max
+      - height[start]\n                start += 1\n            else:\n                total += right_max - height[end]\n \
+      \               end -= 1\n        return total == expected\n"
 seed: 42
 tests:
   - name: Example 1
diff --git a/tests/1-500/43. multiply-strings/manifest.yaml b/tests/1-500/43. multiply-strings/manifest.yaml
index c1d08780..133f4636 100644
--- a/tests/1-500/43. multiply-strings/manifest.yaml	
+++ b/tests/1-500/43. multiply-strings/manifest.yaml	
@@ -1,19 +1,24 @@
 "entry":
   "id": 43
   "title": "multiply-strings"
+  "params":
+    "num1":
+      "type": "string"
+    "num2":
+      "type": "string"
   "call":
-    "cpp": 'Solution().multiply("{num1}", "{num2}")'
-    "rust": 'Solution::multiply("{num1}".to_string(), "{num2}".to_string())'
-    "python3": 'Solution().multiply("{num1}", "{num2}")'
-    "python2": 'Solution().multiply("{num1}", "{num2}")'
-    "ruby": 'multiply("{num1}", "{num2}")'
-    "java": 'new Solution().multiply("{num1}", "{num2}")'
-    "csharp": 'new Solution().Multiply("{num1}", "{num2}")'
-    "kotlin": 'Solution().multiply("{num1}", "{num2}")'
-    "go": 'multiply("{num1}", "{num2}")'
-    "dart": 'Solution().multiply("{num1}", "{num2}")'
-    "swift": 'Solution().multiply("{num1}", "{num2}")'
-    "typescript": 'multiply("{num1}", "{num2}")'
+    "cpp": "Solution().multiply({num1}, {num2})"
+    "rust": "Solution::multiply({num1}, {num2})"
+    "python3": "Solution().multiply({num1}, {num2})"
+    "python2": "Solution().multiply({num1}, {num2})"
+    "ruby": "multiply({num1}, {num2})"
+    "java": "new Solution().multiply({num1}, {num2})"
+    "csharp": "new Solution().Multiply({num1}, {num2})"
+    "kotlin": "Solution().multiply({num1}, {num2})"
+    "go": "multiply({num1}, {num2})"
+    "dart": "Solution().multiply({num1}, {num2})"
+    "swift": "Solution().multiply({num1}, {num2})"
+    "typescript": "multiply({num1}, {num2})"
 "judge":
   "type": "exact"
 "limits":
@@ -21,7 +26,7 @@
   "memory_mb": 256
 "oracle":
   "python3":
-    "call": 'Checker().multiply("{num1}", "{num2}", {result})'
+    "call": "Checker().multiply(num1, num2, {result})"
     "checker":
       "import json\n\nclass Checker:\n    def multiply(self, num1, num2,\
       \ result):\n        try:\n            result = json.loads(result) if isinstance(result,\
diff --git a/tests/1-500/44. wildcard-matching/manifest.yaml b/tests/1-500/44. wildcard-matching/manifest.yaml
index 7acfe2a6..e1886f38 100644
--- a/tests/1-500/44. wildcard-matching/manifest.yaml	
+++ b/tests/1-500/44. wildcard-matching/manifest.yaml	
@@ -1,19 +1,24 @@
 entry:
   id: 44
   title: wildcard-matching
+  params:
+    s:
+      type: string
+    p:
+      type: string
   call:
-    cpp: Solution().isMatch("{s}", "{p}")
-    rust: Solution::is_match("{s}".to_string(), "{p}".to_string())
-    python3: Solution().isMatch("{s}", "{p}")
-    python2: Solution().isMatch("{s}", "{p}")
-    ruby: is_match("{s}", "{p}")
-    java: new Solution().isMatch("{s}", "{p}")
-    csharp: new Solution().IsMatch("{s}", "{p}")
-    kotlin: Solution().isMatch("{s}", "{p}")
-    go: isMatch("{s}", "{p}")
-    dart: Solution().isMatch("{s}", "{p}")
-    swift: Solution().isMatch("{s}", "{p}")
-    typescript: isMatch("{s}", "{p}")
+    cpp: Solution().isMatch({s}, {p})
+    rust: Solution::is_match({s}, {p})
+    python3: Solution().isMatch({s}, {p})
+    python2: Solution().isMatch({s}, {p})
+    ruby: is_match({s}, {p})
+    java: new Solution().isMatch({s}, {p})
+    csharp: new Solution().IsMatch({s}, {p})
+    kotlin: Solution().isMatch({s}, {p})
+    go: isMatch({s}, {p})
+    dart: Solution().isMatch({s}, {p})
+    swift: Solution().isMatch({s}, {p})
+    typescript: isMatch({s}, {p})
 judge:
   type: exact
 limits:
@@ -21,7 +26,7 @@ limits:
   memory_mb: 256
 oracle:
   python3:
-    call: Checker().isMatch("{s}", "{p}", {result})
+    call: Checker().isMatch(s, p, {result})
     checker:
       "import json\nclass Checker:\n    def _norm(self, result):\n        if\
       \ isinstance(result, str):\n            try:\n                result = json.loads(result)\n\
diff --git a/tests/1-500/45. jump-game-ii/manifest.yaml b/tests/1-500/45. jump-game-ii/manifest.yaml
index 6adf1437..4dd4ae63 100644
--- a/tests/1-500/45. jump-game-ii/manifest.yaml	
+++ b/tests/1-500/45. jump-game-ii/manifest.yaml	
@@ -2,18 +2,23 @@ entry:
   id: 45
   title: jump-game-ii
   call:
-    cpp: Solution().jump(lv(vector<int>{ {nums} }))
-    rust: Solution::jump(vec![{nums}])
-    python3: Solution().jump([{nums}])
-    python2: Solution().jump([{nums}])
-    ruby: jump([{nums}])
-    java: new Solution().jump(new int[]{ {nums} })
-    csharp: new Solution().Jump(new int[]{ {nums} })
-    kotlin: Solution().jump(intArrayOf({nums}))
-    go: jump([]int{ {nums} })
-    dart: Solution().jump([{nums}])
-    swift: Solution().jump([{nums}])
-    typescript: jump([{nums}])
+    cpp: Solution().jump({nums})
+    rust: Solution::jump({nums})
+    python3: Solution().jump({nums})
+    python2: Solution().jump({nums})
+    ruby: jump({nums})
+    java: new Solution().jump({nums})
+    csharp: new Solution().Jump({nums})
+    kotlin: Solution().jump({nums})
+    go: jump({nums})
+    dart: Solution().jump({nums})
+    swift: Solution().jump({nums})
+    typescript: jump({nums})
+  params:
+    nums:
+      type: array
+      items:
+        type: int
 judge:
   type: exact
 limits:
@@ -21,21 +26,17 @@ limits:
   memory_mb: 256
 oracle:
   python3:
-    call: Checker().jump([{nums}], {result})
+    call: Checker().jump({nums}, {result})
     checker:
-      "import json\nclass Checker:\n    def _norm(self, result):\n        if\
-      \ isinstance(result, str):\n            try:\n                result = json.loads(result)\n\
-      \            except Exception:\n                pass\n            if isinstance(result,\
-      \ str):\n                low = result.strip().lower()\n                if low\
-      \ == 'true':\n                    return True\n                if low == 'false':\n\
-      \                    return False\n                if low.lstrip('-').isdigit():\n\
-      \                    return int(low)\n        return result\n\n    def jump(self,\
-      \ nums, result):\n        result = self._norm(result)\n        n = len(nums)\n\
-      \        if n <= 1: return result == 0\n        jumps = 0\n        curr_end\
-      \ = 0\n        max_reach = 0\n        for i in range(n - 1):\n            max_reach\
-      \ = max(max_reach, i + nums[i])\n            if i == curr_end:\n           \
-      \     jumps += 1\n                curr_end = max_reach\n        return jumps\
-      \ == result\n"
+      "import json\nclass Checker:\n    def _norm(self, result):\n        if isinstance(result, str):\n           \
+      \ try:\n                result = json.loads(result)\n            except Exception:\n                pass\n         \
+      \   if isinstance(result, str):\n                low = result.strip().lower()\n                if low == 'true':\n \
+      \                   return True\n                if low == 'false':\n                    return False\n            \
+      \    if low.lstrip('-').isdigit():\n                    return int(low)\n        return result\n\n    def jump(self,
+      nums, result):\n        result = self._norm(result)\n        n = len(nums)\n        if n <= 1: return result == 0\n\
+      \        jumps = 0\n        curr_end = 0\n        max_reach = 0\n        for i in range(n - 1):\n            max_reach
+      = max(max_reach, i + nums[i])\n            if i == curr_end:\n                jumps += 1\n                curr_end =
+      max_reach\n        return jumps == result\n"
 seed: 42
 tests:
   - name: Example 1
diff --git a/tests/1-500/46. permutations/manifest.yaml b/tests/1-500/46. permutations/manifest.yaml
index edb57b42..ef66f340 100644
--- a/tests/1-500/46. permutations/manifest.yaml	
+++ b/tests/1-500/46. permutations/manifest.yaml	
@@ -2,18 +2,23 @@ entry:
   id: 46
   title: permutations
   call:
-    cpp: Solution().permute(lv(vector<int>{ {nums} }))
-    rust: Solution::permute(vec![{nums}])
-    python3: Solution().permute([{nums}])
-    python2: Solution().permute([{nums}])
-    ruby: permute([{nums}])
-    java: new Solution().permute(new int[]{ {nums} })
-    csharp: new Solution().Permute(new int[]{ {nums} })
-    kotlin: Solution().permute(intArrayOf({nums}))
-    go: permute([]int{ {nums} })
-    dart: Solution().permute([{nums}])
-    swift: Solution().permute([{nums}])
-    typescript: permute([{nums}])
+    cpp: Solution().permute({nums})
+    rust: Solution::permute({nums})
+    python3: Solution().permute({nums})
+    python2: Solution().permute({nums})
+    ruby: permute({nums})
+    java: new Solution().permute({nums})
+    csharp: new Solution().Permute({nums})
+    kotlin: Solution().permute({nums})
+    go: permute({nums})
+    dart: Solution().permute({nums})
+    swift: Solution().permute({nums})
+    typescript: permute({nums})
+  params:
+    nums:
+      type: array
+      items:
+        type: int
 judge:
   type: ignore_order
 limits:
@@ -21,15 +26,13 @@ limits:
   memory_mb: 256
 oracle:
   python3:
-    call: Checker().check([{nums}], {result})
+    call: Checker().check(nums, {result})
     checker:
-      "import json\nclass Checker:\n    def _norm(self, result):\n        if\
-      \ isinstance(result, str):\n            try:\n                result = json.loads(result)\n\
-      \            except Exception:\n                pass\n        return result\n\
-      \n    def check(self, nums, result):\n        result = self._norm(result)\n\
-      \        import itertools\n        expected = [list(p) for p in itertools.permutations(nums)]\n\
-      \        if len(result) != len(expected): return False\n        return sorted([sorted(x)\
-      \ for x in result]) == sorted([sorted(x) for x in expected])\n"
+      "import json\nclass Checker:\n    def _norm(self, result):\n        if isinstance(result, str):\n           \
+      \ try:\n                result = json.loads(result)\n            except Exception:\n                pass\n        return
+      result\n\n    def check(self, nums, result):\n        result = self._norm(result)\n        import itertools\n      \
+      \  expected = [list(p) for p in itertools.permutations(nums)]\n        if len(result) != len(expected): return False\n\
+      \        return sorted([sorted(x) for x in result]) == sorted([sorted(x) for x in expected])\n"
 seed: 42
 tests:
   - name: example 1
diff --git a/tests/1-500/47. permutations-ii/manifest.yaml b/tests/1-500/47. permutations-ii/manifest.yaml
index c33fc8b8..81700098 100644
--- a/tests/1-500/47. permutations-ii/manifest.yaml	
+++ b/tests/1-500/47. permutations-ii/manifest.yaml	
@@ -2,18 +2,23 @@ entry:
   id: 47
   title: permutations-ii
   call:
-    cpp: Solution().permuteUnique(lv(vector<int>{ {nums} }))
-    rust: Solution::permute_unique(vec![{nums}])
-    python3: Solution().permuteUnique([{nums}])
-    python2: Solution().permuteUnique([{nums}])
-    ruby: permute_unique([{nums}])
-    java: new Solution().permuteUnique(new int[]{ {nums} })
-    csharp: new Solution().PermuteUnique(new int[]{ {nums} })
-    kotlin: Solution().permuteUnique(intArrayOf({nums}))
-    go: permuteUnique([]int{ {nums} })
-    dart: Solution().permuteUnique([{nums}])
-    swift: Solution().permuteUnique([{nums}])
-    typescript: permuteUnique([{nums}])
+    cpp: Solution().permuteUnique({nums})
+    rust: Solution::permute_unique({nums})
+    python3: Solution().permuteUnique({nums})
+    python2: Solution().permuteUnique({nums})
+    ruby: permute_unique({nums})
+    java: new Solution().permuteUnique({nums})
+    csharp: new Solution().PermuteUnique({nums})
+    kotlin: Solution().permuteUnique({nums})
+    go: permuteUnique({nums})
+    dart: Solution().permuteUnique({nums})
+    swift: Solution().permuteUnique({nums})
+    typescript: permuteUnique({nums})
+  params:
+    nums:
+      type: array
+      items:
+        type: int
 judge:
   type: ignore_order
 limits:
@@ -21,16 +26,13 @@ limits:
   memory_mb: 256
 oracle:
   python3:
-    call: Checker().check([{nums}], {result})
+    call: Checker().check(nums, {result})
     checker:
-      "import json\nimport itertools\nclass Checker:\n    def _norm(self, out):\n\
-      \        if isinstance(out, str):\n            try:\n                out = json.loads(out)\n\
-      \            except Exception:\n                pass\n        return out\n\n\
-      \    def check(self, nums, out):\n        out = self._norm(out)\n        target\
-      \ = list(set(itertools.permutations(nums)))\n        if len(out) != len(target):\
-      \ return False\n        out_sorted = sorted([list(p) for p in out])\n      \
-      \  target_sorted = sorted([list(p) for p in target])\n        return out_sorted\
-      \ == target_sorted\n"
+      "import json\nimport itertools\nclass Checker:\n    def _norm(self, out):\n        if isinstance(out, str):\n\
+      \            try:\n                out = json.loads(out)\n            except Exception:\n                pass\n    \
+      \    return out\n\n    def check(self, nums, out):\n        out = self._norm(out)\n        target = list(set(itertools.permutations(nums)))\n\
+      \        if len(out) != len(target): return False\n        out_sorted = sorted([list(p) for p in out])\n        target_sorted
+      = sorted([list(p) for p in target])\n        return out_sorted == target_sorted\n"
 seed: 42
 tests:
   - name: Example 1
diff --git a/tests/1-500/49. group-anagrams/manifest.yaml b/tests/1-500/49. group-anagrams/manifest.yaml
index 84d90969..69700a7a 100644
--- a/tests/1-500/49. group-anagrams/manifest.yaml	
+++ b/tests/1-500/49. group-anagrams/manifest.yaml	
@@ -2,18 +2,23 @@
   "id": 49
   "title": "group-anagrams"
   "call":
-    "cpp": "Solution().groupAnagrams(lv(vector<string>{ {strs} }))"
-    "rust": "Solution::group_anagrams(vec![{strs}])"
-    "python3": "Solution().groupAnagrams([{strs}])"
-    "python2": "Solution().groupAnagrams([{strs}])"
-    "ruby": "group_anagrams([{strs}])"
-    "java": "new Solution().groupAnagrams(new String[]{ {strs} })"
-    "csharp": "new Solution().GroupAnagrams(new string[]{ {strs} })"
-    "kotlin": "Solution().groupAnagrams(arrayOf({strs}))"
-    "go": "groupAnagrams([]string{ {strs} })"
-    "dart": "Solution().groupAnagrams([{strs}])"
-    "swift": "Solution().groupAnagrams([{strs}])"
-    "typescript": "groupAnagrams([{strs}])"
+    "cpp": "Solution().groupAnagrams({strs})"
+    "rust": "Solution::group_anagrams({strs})"
+    "python3": "Solution().groupAnagrams({strs})"
+    "python2": "Solution().groupAnagrams({strs})"
+    "ruby": "group_anagrams({strs})"
+    "java": "new Solution().groupAnagrams({strs})"
+    "csharp": "new Solution().GroupAnagrams({strs})"
+    "kotlin": "Solution().groupAnagrams({strs})"
+    "go": "groupAnagrams({strs})"
+    "dart": "Solution().groupAnagrams({strs})"
+    "swift": "Solution().groupAnagrams({strs})"
+    "typescript": "groupAnagrams({strs})"
+  params:
+    strs:
+      type: array
+      items:
+        type: string
 "judge":
   "type": "ignore_order"
 "limits":
@@ -21,13 +26,12 @@
   "memory_mb": 256
 "oracle":
   "python3":
-    "call": "Checker().groupAnagrams([{strs}], {result})"
+    "call": "Checker().groupAnagrams(strs, {result})"
     "checker":
-      "from collections import defaultdict\nclass Checker:\n    def groupAnagrams(self,\
-      \ strs, result):\n        def sort_str(s):\n            return \"\".join(sorted(s))\n\
-      \        d = defaultdict(list)\n        for s in strs:\n            d[sort_str(s)].append(s)\n\
-      \        expected = sorted([sorted(v) for v in d.values()])\n        actual\
-      \ = sorted([sorted(v) for v in result])\n        return expected == actual\n"
+      "from collections import defaultdict\nclass Checker:\n    def groupAnagrams(self, strs, result):\n        def
+      sort_str(s):\n            return \"\".join(sorted(s))\n        d = defaultdict(list)\n        for s in strs:\n     \
+      \       d[sort_str(s)].append(s)\n        expected = sorted([sorted(v) for v in d.values()])\n        actual = sorted([sorted(v)
+      for v in result])\n        return expected == actual\n"
 "seed": 42
 "tests":
   - "name": "Example 1"
diff --git a/tests/1-500/5. longest-palindromic-substring/manifest.yaml b/tests/1-500/5. longest-palindromic-substring/manifest.yaml
index 5102cdd9..7a811fab 100644
--- a/tests/1-500/5. longest-palindromic-substring/manifest.yaml	
+++ b/tests/1-500/5. longest-palindromic-substring/manifest.yaml	
@@ -1,19 +1,22 @@
 entry:
   id: 5
   title: longest-palindromic-substring
+  params:
+    s:
+      type: string
   call:
-    cpp: Solution().longestPalindrome("{s}")
-    rust: Solution::longest_palindrome("{s}".to_string())
-    python3: Solution().longestPalindrome("{s}")
-    python2: Solution().longestPalindrome("{s}")
-    ruby: longest_palindrome("{s}")
-    java: new Solution().longestPalindrome("{s}")
-    csharp: new Solution().LongestPalindrome("{s}")
-    kotlin: Solution().longestPalindrome("{s}")
-    go: longestPalindrome("{s}")
-    dart: Solution().longestPalindrome("{s}")
-    swift: Solution().longestPalindrome("{s}")
-    typescript: longestPalindrome("{s}")
+    cpp: Solution().longestPalindrome({s})
+    rust: Solution::longest_palindrome({s}.to_string())
+    python3: Solution().longestPalindrome({s})
+    python2: Solution().longestPalindrome({s})
+    ruby: longest_palindrome({s})
+    java: new Solution().longestPalindrome({s})
+    csharp: new Solution().LongestPalindrome({s})
+    kotlin: Solution().longestPalindrome({s})
+    go: longestPalindrome({s})
+    dart: Solution().longestPalindrome({s})
+    swift: Solution().longestPalindrome({s})
+    typescript: longestPalindrome({s})
 judge:
   type: exact
 limits:
@@ -21,7 +24,7 @@ limits:
   memory_mb: 256
 oracle:
   python3:
-    call: Checker().check("{s}", {result})
+    call: Checker().check(s, {result})
     checker:
       "class Checker:\n    def check(self, s, result):\n        if isinstance(result,\
       \ str):\n            stripped = result.strip()\n            if len(stripped)\
diff --git a/tests/1-500/50. powx-n/manifest.yaml b/tests/1-500/50. powx-n/manifest.yaml
index 6699af86..50ae1e4e 100644
--- a/tests/1-500/50. powx-n/manifest.yaml	
+++ b/tests/1-500/50. powx-n/manifest.yaml	
@@ -1,147 +1,157 @@
-"entry":
-  "id": 50
-  "title": "powx-n"
-  "call":
-    "cpp": "Solution().myPow({x}, {n})"
-    "rust": "Solution::my_pow({x}, {n})"
-    "python3": "Solution().myPow({x}, {n})"
-    "python2": "Solution().myPow({x}, {n})"
-    "ruby": "my_pow({x}, {n})"
-    "java": "new Solution().myPow({x}, {n})"
-    "csharp": "new Solution().MyPow({x}, {n})"
-    "kotlin": "Solution().myPow({x}, {n})"
-    "go": "myPow({x}, {n})"
-    "dart": "Solution().myPow({x}, {n})"
-    "swift": "Solution().myPow({x}, {n})"
-    "typescript": "myPow({x}, {n})"
-"judge":
-  "type": "exact"
-"limits":
-  "time_ms": 1000
-  "memory_mb": 256
-"oracle":
-  "python3":
-    "call": "Checker().check({x}, {n}, {result})"
-    "checker":
-      "import json\nclass Checker:\n    def check(self, x, n, result):\n\
-      \        try:\n            result = json.loads(result) if isinstance(result,\
-      \ str) else result\n        except Exception:\n            return False\n  \
-      \      expected = pow(x, n)\n        return abs(expected - result) < 1e-7\n"
-"seed": 42
-"tests":
-  - "name": "example 1"
-    "in":
-      "x": 2.0
-      "n": 10
-  - "name": "example 2"
-    "in":
-      "x": 2.1
-      "n": 3
-  - "name": "example 3"
-    "in":
-      "x": 2.0
-      "n": -2
-  - "name": "base case zero power"
-    "in":
-      "x": 5.5
-      "n": 0
-  - "name": "base case one"
-    "in":
-      "x": 1.0
-      "n": 100
-  - "name": "negative base even power"
-    "in":
-      "x": -2.0
-      "n": 4
-  - "name": "negative base odd power"
-    "in":
-      "x": -2.0
-      "n": 3
-  - "name": "fractional base positive power"
-    "in":
-      "x": 0.5
-      "n": 2
-  - "name": "large negative power"
-    "in":
-      "x": 2.0
-      "n": -10
-  - "name": "small positive power"
-    "in":
-      "x": 1.0e-05
-      "n": 1
-  - "name": "max positive n"
-    "in":
-      "x": 1.0
-      "n": 2147483647
-  - "name": "identity"
-    "in":
-      "x": 1.0
-      "n": -2147483648
-  - "name": "minus one even"
-    "in":
-      "x": -1.0
-      "n": 1000
-  - "name": "minus one odd"
-    "in":
-      "x": -1.0
-      "n": 1001
-  - "name": "zero base positive power"
-    "in":
-      "x": 0.0
-      "n": 5
-  - "name": "large base small power"
-    "in":
-      "x": 88.0
-      "n": 2
-  - "name": "negative power check"
-    "in":
-      "x": 4.0
-      "n": -1
-  - "name": "precision test"
-    "in":
-      "x": 0.44894
-      "n": 2
-  - "name": "random float 1"
-    "in":
-      "x": 0.123
-      "n": 5
-  - "name": "random float 2"
-    "in":
-      "x": 1.00001
-      "n": 10000
-  - "name": "random float 3"
-    "in":
-      "x": 0.99999
-      "n": 10000
-  - "name": "generated 1"
-    "in":
-      "x":
-        "gen": "float"
-        "min": 0.1
-        "max": 2.0
-        "precision": 4
-      "n": 10
-  - "name": "generated 2"
-    "in":
-      "x":
-        "gen": "float"
-        "min": 0.1
-        "max": 2.0
-        "precision": 4
-      "n": -5
-  - "name": "generated 3"
-    "in":
-      "x":
-        "gen": "float"
-        "min": -0.9
-        "max": -0.1
-        "precision": 4
-      "n": 4
-  - "name": "large generated 1"
-    "in":
-      "x": 1.0000001
-      "n": 99999
-  - "name": "large generated 2"
-    "in":
-      "x": 0.9999999
-      "n": 99999
+entry:
+  id: 50
+  title: powx-n
+  call:
+    cpp: Solution().myPow({x}, {n})
+    rust: Solution::my_pow({x}, {n})
+    python3: Solution().myPow({x}, {n})
+    python2: Solution().myPow({x}, {n})
+    ruby: my_pow({x}, {n})
+    java: new Solution().myPow({x}, {n})
+    csharp: new Solution().MyPow({x}, {n})
+    kotlin: Solution().myPow({x}, {n})
+    go: myPow({x}, {n})
+    dart: Solution().myPow({x}, {n})
+    swift: Solution().myPow({x}, {n})
+    typescript: myPow({x}, {n})
+  params:
+    x:
+      type: double
+    n:
+      type: int
+judge:
+  type: exact
+limits:
+  time_ms: 1000
+  memory_mb: 256
+oracle:
+  python3:
+    call: check(x, n, {result})
+    checker: |
+      import json
+
+      def check(x, n, result):
+          try:
+              result = json.loads(result) if isinstance(result, str) else result
+          except Exception:
+              return False
+          expected = pow(x, n)
+          return abs(expected - result) < 1e-7
+seed: 42
+tests:
+  - name: example 1
+    in:
+      x: 2.0
+      n: 10
+  - name: example 2
+    in:
+      x: 2.1
+      n: 3
+  - name: example 3
+    in:
+      x: 2.0
+      n: -2
+  - name: base case zero power
+    in:
+      x: 5.5
+      n: 0
+  - name: base case one
+    in:
+      x: 1.0
+      n: 100
+  - name: negative base even power
+    in:
+      x: -2.0
+      n: 4
+  - name: negative base odd power
+    in:
+      x: -2.0
+      n: 3
+  - name: fractional base positive power
+    in:
+      x: 0.5
+      n: 2
+  - name: large negative power
+    in:
+      x: 2.0
+      n: -10
+  - name: small positive power
+    in:
+      x: 1.0e-05
+      n: 1
+  - name: max positive n
+    in:
+      x: 1.0
+      n: 2147483647
+  - name: identity
+    in:
+      x: 1.0
+      n: -2147483648
+  - name: minus one even
+    in:
+      x: -1.0
+      n: 1000
+  - name: minus one odd
+    in:
+      x: -1.0
+      n: 1001
+  - name: zero base positive power
+    in:
+      x: 0.0
+      n: 5
+  - name: large base small power
+    in:
+      x: 88.0
+      n: 2
+  - name: negative power check
+    in:
+      x: 4.0
+      n: -1
+  - name: precision test
+    in:
+      x: 0.44894
+      n: 2
+  - name: random float 1
+    in:
+      x: 0.123
+      n: 5
+  - name: random float 2
+    in:
+      x: 1.00001
+      n: 10000
+  - name: random float 3
+    in:
+      x: 0.99999
+      n: 10000
+  - name: generated 1
+    in:
+      x:
+        gen: float
+        min: 0.1
+        max: 2.0
+        precision: 4
+      n: 10
+  - name: generated 2
+    in:
+      x:
+        gen: float
+        min: 0.1
+        max: 2.0
+        precision: 4
+      n: -5
+  - name: generated 3
+    in:
+      x:
+        gen: float
+        min: -0.9
+        max: -0.1
+        precision: 4
+      n: 4
+  - name: large generated 1
+    in:
+      x: 1.0000001
+      n: 99999
+  - name: large generated 2
+    in:
+      x: 0.9999999
+      n: 99999
diff --git a/tests/1-500/51. n-queens/manifest.yaml b/tests/1-500/51. n-queens/manifest.yaml
index 871b17d7..8211d9fd 100644
--- a/tests/1-500/51. n-queens/manifest.yaml	
+++ b/tests/1-500/51. n-queens/manifest.yaml	
@@ -1,6 +1,9 @@
 "entry":
   "id": 51
   "title": "n-queens"
+  "params":
+    "n":
+      "type": "int"
   "call":
     "cpp": "Solution().solveNQueens({n})"
     "rust": "Solution::solve_n_queens({n})"
@@ -21,7 +24,7 @@
   "memory_mb": 256
 "oracle":
   "python3":
-    "call": "Checker().check({n}, {result})"
+    "call": "Checker().check(n, {result})"
     "checker":
       "import json\nclass Checker:\n  def check(self, n, result):\n    try:\n\
       \      result = json.loads(result) if isinstance(result, str) else result\n\
diff --git a/tests/1-500/52. n-queens-ii/manifest.yaml b/tests/1-500/52. n-queens-ii/manifest.yaml
index 169923ec..38e4fd11 100644
--- a/tests/1-500/52. n-queens-ii/manifest.yaml	
+++ b/tests/1-500/52. n-queens-ii/manifest.yaml	
@@ -1,6 +1,9 @@
 "entry":
   "id": 52
   "title": "n-queens-ii"
+  "params":
+    "n":
+      "type": "int"
   "call":
     "cpp": "Solution().totalNQueens({n})"
     "rust": "Solution::total_n_queens({n})"
@@ -21,7 +24,7 @@
   "memory_mb": 256
 "oracle":
   "python3":
-    "call": "Checker().totalNQueens({n}, {result})"
+    "call": "Checker().totalNQueens(n, {result})"
     "checker":
       "import json\nclass Checker:\n    def totalNQueens(self, n, result):\n\
       \        try:\n            result = json.loads(result) if isinstance(result,\
diff --git a/tests/1-500/53. maximum-subarray/manifest.yaml b/tests/1-500/53. maximum-subarray/manifest.yaml
index f82e2a46..785a1737 100644
--- a/tests/1-500/53. maximum-subarray/manifest.yaml	
+++ b/tests/1-500/53. maximum-subarray/manifest.yaml	
@@ -2,18 +2,23 @@ entry:
   id: 53
   title: maximum-subarray
   call:
-    cpp: Solution().maxSubArray(lv(vector<int>{ {nums} }))
-    rust: Solution::max_sub_array(vec![{nums}])
-    python3: Solution().maxSubArray([{nums}])
-    python2: Solution().maxSubArray([{nums}])
-    ruby: max_sub_array([{nums}])
-    java: new Solution().maxSubArray(new int[]{ {nums} })
-    csharp: new Solution().MaxSubArray(new int[]{ {nums} })
-    kotlin: Solution().maxSubArray(intArrayOf({nums}))
-    go: maxSubArray([]int{ {nums} })
-    dart: Solution().maxSubArray([{nums}])
-    swift: Solution().maxSubArray([{nums}])
-    typescript: maxSubArray([{nums}])
+    cpp: Solution().maxSubArray({nums})
+    rust: Solution::max_sub_array({nums})
+    python3: Solution().maxSubArray({nums})
+    python2: Solution().maxSubArray({nums})
+    ruby: max_sub_array({nums})
+    java: new Solution().maxSubArray({nums})
+    csharp: new Solution().MaxSubArray({nums})
+    kotlin: Solution().maxSubArray({nums})
+    go: maxSubArray({nums})
+    dart: Solution().maxSubArray({nums})
+    swift: Solution().maxSubArray({nums})
+    typescript: maxSubArray({nums})
+  params:
+    nums:
+      type: array
+      items:
+        type: int
 judge:
   type: exact
 limits:
@@ -21,19 +26,16 @@ limits:
   memory_mb: 256
 oracle:
   python3:
-    call: Checker().maxSubArray([{nums}], {result})
+    call: Checker().maxSubArray({nums}, {result})
     checker:
-      "import json\nclass Checker:\n    def _norm(self, result):\n        if\
-      \ isinstance(result, str):\n            try:\n                result = json.loads(result)\n\
-      \            except Exception:\n                pass\n            if isinstance(result,\
-      \ str):\n                low = result.strip().lower()\n                if low\
-      \ == 'true':\n                    return True\n                if low == 'false':\n\
-      \                    return False\n                if low.lstrip('-').isdigit():\n\
-      \                    return int(low)\n        return result\n\n    def maxSubArray(self,\
-      \ nums, result):\n        result = self._norm(result)\n        res = float('-inf')\n\
-      \        total = 0\n        for n in nums:\n            total += n\n       \
-      \     res = max(res, total)\n            if total < 0:\n                total\
-      \ = 0\n        return res == result\n"
+      "import json\nclass Checker:\n    def _norm(self, result):\n        if isinstance(result, str):\n           \
+      \ try:\n                result = json.loads(result)\n            except Exception:\n                pass\n         \
+      \   if isinstance(result, str):\n                low = result.strip().lower()\n                if low == 'true':\n \
+      \                   return True\n                if low == 'false':\n                    return False\n            \
+      \    if low.lstrip('-').isdigit():\n                    return int(low)\n        return result\n\n    def maxSubArray(self,
+      nums, result):\n        result = self._norm(result)\n        res = float('-inf')\n        total = 0\n        for n in
+      nums:\n            total += n\n            res = max(res, total)\n            if total < 0:\n                total =
+      0\n        return res == result\n"
 seed: 42
 tests:
   - name: Example 1
diff --git a/tests/1-500/54. spiral-matrix/manifest.yaml b/tests/1-500/54. spiral-matrix/manifest.yaml
index e713e9f1..f25819e1 100644
--- a/tests/1-500/54. spiral-matrix/manifest.yaml	
+++ b/tests/1-500/54. spiral-matrix/manifest.yaml	
@@ -2,18 +2,25 @@ entry:
   id: 54
   title: spiral-matrix
   call:
-    cpp: Solution().spiralOrder(lv(vector<vector<int>>{ {matrix} }))
-    rust: Solution::spiral_order(vec![{matrix}])
-    python3: Solution().spiralOrder([{matrix}])
-    python2: Solution().spiralOrder([{matrix}])
-    ruby: spiral_order([{matrix}])
-    java: new Solution().spiralOrder(new int[][]{ {matrix} })
-    csharp: new Solution().SpiralOrder(new int[][]{ {matrix} })
-    kotlin: Solution().spiralOrder(arrayOf({matrix}))
-    go: spiralOrder([][]int{ {matrix} })
-    dart: Solution().spiralOrder([{matrix}])
-    swift: Solution().spiralOrder([{matrix}])
-    typescript: spiralOrder([{matrix}])
+    cpp: Solution().spiralOrder({matrix})
+    rust: Solution::spiral_order({matrix})
+    python3: Solution().spiralOrder({matrix})
+    python2: Solution().spiralOrder({matrix})
+    ruby: spiral_order({matrix})
+    java: new Solution().spiralOrder({matrix})
+    csharp: new Solution().SpiralOrder({matrix})
+    kotlin: Solution().spiralOrder({matrix})
+    go: spiralOrder({matrix})
+    dart: Solution().spiralOrder({matrix})
+    swift: Solution().spiralOrder({matrix})
+    typescript: spiralOrder({matrix})
+  params:
+    matrix:
+      type: array
+      items:
+        type: array
+        items:
+          type: int
 judge:
   type: exact
 limits:
@@ -21,15 +28,13 @@ limits:
   memory_mb: 256
 oracle:
   python3:
-    call: Checker().spiralOrder([{matrix}], {result})
+    call: Checker().spiralOrder({matrix}, {result})
     checker:
-      "class Checker:\n    def spiralOrder(self, matrix, result):\n       \
-      \ rows, cols = len(matrix), len(matrix[0])\n        x, y, dx, dy = 0, 0, 1,\
-      \ 0\n        expected = []\n        m = [row[:] for row in matrix]\n       \
-      \ for _ in range(rows * cols):\n            expected.append(m[y][x])\n     \
-      \       m[y][x] = None\n            if not 0 <= x + dx < cols or not 0 <= y\
-      \ + dy < rows or m[y+dy][x+dx] is None:\n                dx, dy = -dy, dx\n\
-      \            x += dx\n            y += dy\n        return result == expected\n"
+      "class Checker:\n    def spiralOrder(self, matrix, result):\n        rows, cols = len(matrix), len(matrix[0])\n\
+      \        x, y, dx, dy = 0, 0, 1, 0\n        expected = []\n        m = [row[:] for row in matrix]\n        for _ in
+      range(rows * cols):\n            expected.append(m[y][x])\n            m[y][x] = None\n            if not 0 <= x + dx
+      < cols or not 0 <= y + dy < rows or m[y+dy][x+dx] is None:\n                dx, dy = -dy, dx\n            x += dx\n\
+      \            y += dy\n        return result == expected\n"
 seed: 42
 tests:
   - name: Example 1
diff --git a/tests/1-500/55. jump-game/manifest.yaml b/tests/1-500/55. jump-game/manifest.yaml
index 501ea283..bff411ab 100644
--- a/tests/1-500/55. jump-game/manifest.yaml	
+++ b/tests/1-500/55. jump-game/manifest.yaml	
@@ -2,18 +2,23 @@
   "id": 55
   "title": "jump-game"
   "call":
-    "cpp": "Solution().canJump(lv(vector<int>{ {nums} }))"
-    "rust": "Solution::can_jump(vec![{nums}])"
-    "python3": "Solution().canJump([{nums}])"
-    "python2": "Solution().canJump([{nums}])"
-    "ruby": "can_jump([{nums}])"
-    "java": "new Solution().canJump(new int[]{ {nums} })"
-    "csharp": "new Solution().CanJump(new int[]{ {nums} })"
-    "kotlin": "Solution().canJump(intArrayOf({nums}))"
-    "go": "canJump([]int{ {nums} })"
-    "dart": "Solution().canJump([{nums}])"
-    "swift": "Solution().canJump([{nums}])"
-    "typescript": "canJump([{nums}])"
+    "cpp": "Solution().canJump({nums})"
+    "rust": "Solution::can_jump({nums})"
+    "python3": "Solution().canJump({nums})"
+    "python2": "Solution().canJump({nums})"
+    "ruby": "can_jump({nums})"
+    "java": "new Solution().canJump({nums})"
+    "csharp": "new Solution().CanJump({nums})"
+    "kotlin": "Solution().canJump({nums})"
+    "go": "canJump({nums})"
+    "dart": "Solution().canJump({nums})"
+    "swift": "Solution().canJump({nums})"
+    "typescript": "canJump({nums})"
+  params:
+    nums:
+      type: array
+      items:
+        type: int
 "judge":
   "type": "exact"
 "limits":
@@ -21,16 +26,13 @@
   "memory_mb": 256
 "oracle":
   "python3":
-    "call": "Checker().canJump([{nums}], {result})"
+    "call": "Checker().canJump({nums}, {result})"
     "checker":
-      "import json\nclass Checker:\n    def canJump(self, nums, result):\n\
-      \        try:\n            result = json.loads(result) if isinstance(result,\
-      \ str) else result\n        except Exception:\n            return False\n  \
-      \      goal = 0\n        for i, n in enumerate(nums):\n            if goal <\
-      \ i:\n                expected = False\n                return result == expected\n\
-      \            goal = max(goal, n + i)\n            if goal >= len(nums) - 1:\n\
-      \                expected = True\n                return result == expected\n\
-      \        expected = False\n        return result == expected\n"
+      "import json\nclass Checker:\n    def canJump(self, nums, result):\n        try:\n            result = json.loads(result)
+      if isinstance(result, str) else result\n        except Exception:\n            return False\n        goal = 0\n    \
+      \    for i, n in enumerate(nums):\n            if goal < i:\n                expected = False\n                return
+      result == expected\n            goal = max(goal, n + i)\n            if goal >= len(nums) - 1:\n                expected
+      = True\n                return result == expected\n        expected = False\n        return result == expected\n"
 "seed": 42
 "tests":
   - "name": "example 1"
diff --git a/tests/1-500/56. merge-intervals/manifest.yaml b/tests/1-500/56. merge-intervals/manifest.yaml
index 35dcbcb9..e6bbfd07 100644
--- a/tests/1-500/56. merge-intervals/manifest.yaml	
+++ b/tests/1-500/56. merge-intervals/manifest.yaml	
@@ -2,18 +2,25 @@
   "id": 56
   "title": "merge-intervals"
   "call":
-    "cpp": "Solution().merge(lv(vector<vector<int>>{ {intervals} }))"
-    "rust": "Solution::merge(vec![{intervals}])"
-    "python3": "Solution().merge([{intervals}])"
-    "python2": "Solution().merge([{intervals}])"
-    "ruby": "merge([{intervals}])"
-    "java": "new Solution().merge(new int[][]{ {intervals} })"
-    "csharp": "new Solution().Merge(new int[][]{ {intervals} })"
-    "kotlin": "Solution().merge(arrayOf({intervals}))"
-    "go": "merge([][]int{ {intervals} })"
-    "dart": "Solution().merge([{intervals}])"
-    "swift": "Solution().merge([{intervals}])"
-    "typescript": "merge([{intervals}])"
+    "cpp": "Solution().merge({intervals})"
+    "rust": "Solution::merge({intervals})"
+    "python3": "Solution().merge({intervals})"
+    "python2": "Solution().merge({intervals})"
+    "ruby": "merge({intervals})"
+    "java": "new Solution().merge({intervals})"
+    "csharp": "new Solution().Merge({intervals})"
+    "kotlin": "Solution().merge({intervals})"
+    "go": "merge({intervals})"
+    "dart": "Solution().merge({intervals})"
+    "swift": "Solution().merge({intervals})"
+    "typescript": "merge({intervals})"
+  params:
+    intervals:
+      type: array
+      items:
+        type: array
+        items:
+          type: int
 "judge":
   "type": "exact"
 "limits":
@@ -21,20 +28,16 @@
   "memory_mb": 256
 "oracle":
   "python3":
-    "call": "Checker().check([{intervals}], {result})"
+    "call": "Checker().check({intervals}, {result})"
     "checker":
-      "import json\nclass Checker:\n    def check(self, intervals, result):\n\
-      \        try:\n            result = json.loads(result) if isinstance(result,\
-      \ str) else result\n        except Exception:\n            return False\n  \
-      \      if isinstance(result, list) and len(result) == 1 and isinstance(result[0],\
-      \ list):\n            result = result[0]\n        intervals = [sorted(i) for\
-      \ i in intervals]\n        result = [sorted(i) for i in result]\n        intervals.sort()\n\
-      \        merged = []\n        if not intervals: return result == []\n      \
-      \  prev = intervals[0]\n        for i in range(1, len(intervals)):\n       \
-      \     if intervals[i][0] <= prev[1]:\n                prev[1] = max(prev[1],\
-      \ intervals[i][1])\n            else:\n                merged.append(prev)\n\
-      \                prev = intervals[i]\n        merged.append(prev)\n        return\
-      \ sorted(merged) == sorted(result)\n"
+      "import json\nclass Checker:\n    def check(self, intervals, result):\n        try:\n            result = json.loads(result)
+      if isinstance(result, str) else result\n        except Exception:\n            return False\n        if isinstance(result,
+      list) and len(result) == 1 and isinstance(result[0], list):\n            result = result[0]\n        intervals = [sorted(i)
+      for i in intervals]\n        result = [sorted(i) for i in result]\n        intervals.sort()\n        merged = []\n \
+      \       if not intervals: return result == []\n        prev = intervals[0]\n        for i in range(1, len(intervals)):\n\
+      \            if intervals[i][0] <= prev[1]:\n                prev[1] = max(prev[1], intervals[i][1])\n            else:\n\
+      \                merged.append(prev)\n                prev = intervals[i]\n        merged.append(prev)\n        return
+      sorted(merged) == sorted(result)\n"
 "seed": 42
 "tests":
   - "name": "example 1"
diff --git a/tests/1-500/57. insert-interval/manifest.yaml b/tests/1-500/57. insert-interval/manifest.yaml
index 11611c68..3c9ebe36 100644
--- a/tests/1-500/57. insert-interval/manifest.yaml	
+++ b/tests/1-500/57. insert-interval/manifest.yaml	
@@ -1,65 +1,82 @@
-"entry":
-  "id": 57
-  "title": "insert-interval"
-  "call":
-    "cpp":
-      "Solution().insert(lv(vector<vector<int>>{ {intervals} }), lv(vector<int>{\
-      \ {newInterval} }))"
-    "rust": "Solution::insert(vec![{intervals}], vec![{newInterval}])"
-    "python3": "Solution().insert([{intervals}], [{newInterval}])"
-    "python2": "Solution().insert([{intervals}], [{newInterval}])"
-    "ruby": "insert([{intervals}], [{newInterval}])"
-    "java":
-      "new Solution().insert(new int[][]{ {intervals} }, new int[]{ {newInterval}\
-      \ })"
-    "csharp":
-      "new Solution().Insert(new int[][]{ {intervals} }, new int[]{ {newInterval}\
-      \ })"
-    "kotlin": "Solution().insert(arrayOf({intervals}), intArrayOf({newInterval}))"
-    "go": "insert([][]int{ {intervals} }, []int{ {newInterval} })"
-    "dart": "Solution().insert([{intervals}], [{newInterval}])"
-    "swift": "Solution().insert([{intervals}], [{newInterval}])"
-    "typescript": "insert([{intervals}], [{newInterval}])"
-"judge":
-  "type": "exact"
-"limits":
-  "time_ms": 1000
-  "memory_mb": 256
-"oracle":
-  "python3":
-    "call": "Checker().insert([{intervals}], [{newInterval}], {result})"
-    "checker":
-      "import json\nclass Checker:\n    def insert(self, intervals, new_interval,\
-      \ result):\n        try:\n            result = json.loads(result) if isinstance(result,\
-      \ str) else result\n        except Exception:\n            return False\n  \
-      \      res = []\n        i = 0\n        n = len(intervals)\n        new_start,\
-      \ new_end = new_interval\n        while i < n and intervals[i][1] < new_start:\n\
-      \            res.append(intervals[i])\n            i += 1\n        while i <\
-      \ n and intervals[i][0] <= new_end:\n            new_start = min(new_start,\
-      \ intervals[i][0])\n            new_end = max(new_end, intervals[i][1])\n  \
-      \          i += 1\n        res.append([new_start, new_end])\n        while i\
-      \ < n:\n            res.append(intervals[i])\n            i += 1\n        return\
-      \ res == result\n"
-"seed": 42
-"tests":
-  - "name": "example 1"
-    "in":
-      "intervals":
+entry:
+  id: 57
+  title: insert-interval
+  call:
+    cpp: Solution().insert({intervals}, {newInterval})
+    rust: Solution::insert({intervals}, {newInterval})
+    python3: Solution().insert({intervals}, {newInterval})
+    python2: Solution().insert({intervals}, {newInterval})
+    ruby: insert({intervals}, {newInterval})
+    java: new Solution().insert({intervals}, {newInterval})
+    csharp: new Solution().Insert({intervals}, {newInterval})
+    kotlin: Solution().insert({intervals}, {newInterval})
+    go: insert({intervals}, {newInterval})
+    dart: Solution().insert({intervals}, {newInterval})
+    swift: Solution().insert({intervals}, {newInterval})
+    typescript: insert({intervals}, {newInterval})
+  params:
+    intervals:
+      type: array
+      items:
+        type: array
+        items:
+          type: int
+    newInterval:
+      type: array
+      items:
+        type: int
+judge:
+  type: exact
+limits:
+  time_ms: 1000
+  memory_mb: 256
+oracle:
+  python3:
+    call: insert(intervals, newInterval, {result})
+    checker: |
+      import json
+
+      def insert(intervals, newInterval, result):
+          try:
+              result = json.loads(result) if isinstance(result, str) else result
+          except Exception:
+              return False
+          res = []
+          i = 0
+          n = len(intervals)
+          new_start, new_end = newInterval
+          while i < n and intervals[i][1] < new_start:
+              res.append(intervals[i])
+              i += 1
+          while i < n and intervals[i][0] <= new_end:
+              new_start = min(new_start, intervals[i][0])
+              new_end = max(new_end, intervals[i][1])
+              i += 1
+          res.append([new_start, new_end])
+          while i < n:
+              res.append(intervals[i])
+              i += 1
+          return res == result
+seed: 42
+tests:
+  - name: example 1
+    in:
+      intervals:
         - - 1
           - 3
         - - 6
           - 9
-      "newInterval":
+      newInterval:
         - 2
         - 5
-    "out":
+    out:
       - - 1
         - 5
       - - 6
         - 9
-  - "name": "example 2"
-    "in":
-      "intervals":
+  - name: example 2
+    in:
+      intervals:
         - - 1
           - 2
         - - 3
@@ -70,250 +87,250 @@
           - 10
         - - 12
           - 16
-      "newInterval":
+      newInterval:
         - 4
         - 8
-    "out":
+    out:
       - - 1
         - 2
       - - 3
         - 10
       - - 12
         - 16
-  - "name": "empty list"
-    "in":
-      "intervals": []
-      "newInterval":
+  - name: empty list
+    in:
+      intervals: []
+      newInterval:
         - 5
         - 7
-    "out":
+    out:
       - - 5
         - 7
-  - "name": "new interval start"
-    "in":
-      "intervals":
+  - name: new interval start
+    in:
+      intervals:
         - - 2
           - 5
-      "newInterval":
+      newInterval:
         - 0
         - 1
-    "out":
+    out:
       - - 0
         - 1
       - - 2
         - 5
-  - "name": "new interval end"
-    "in":
-      "intervals":
+  - name: new interval end
+    in:
+      intervals:
         - - 0
           - 1
-      "newInterval":
+      newInterval:
         - 2
         - 5
-    "out":
+    out:
       - - 0
         - 1
       - - 2
         - 5
-  - "name": "merge entire"
-    "in":
-      "intervals":
+  - name: merge entire
+    in:
+      intervals:
         - - 1
           - 2
         - - 3
           - 4
-      "newInterval":
+      newInterval:
         - 0
         - 5
-    "out":
+    out:
       - - 0
         - 5
-  - "name": "single point overlap start"
-    "in":
-      "intervals":
+  - name: single point overlap start
+    in:
+      intervals:
         - - 2
           - 4
-      "newInterval":
+      newInterval:
         - 0
         - 2
-    "out":
+    out:
       - - 0
         - 4
-  - "name": "single point overlap end"
-    "in":
-      "intervals":
+  - name: single point overlap end
+    in:
+      intervals:
         - - 0
           - 2
-      "newInterval":
+      newInterval:
         - 2
         - 4
-    "out":
+    out:
       - - 0
         - 4
-  - "name": "surrounded by merge"
-    "in":
-      "intervals":
+  - name: surrounded by merge
+    in:
+      intervals:
         - - 1
           - 2
         - - 8
           - 10
-      "newInterval":
+      newInterval:
         - 3
         - 7
-    "out":
+    out:
       - - 1
         - 2
       - - 3
         - 7
       - - 8
         - 10
-  - "name": "nested inside"
-    "in":
-      "intervals":
+  - name: nested inside
+    in:
+      intervals:
         - - 0
           - 10
-      "newInterval":
+      newInterval:
         - 2
         - 5
-    "out":
+    out:
       - - 0
         - 10
-  - "name": "envelops list"
-    "in":
-      "intervals":
+  - name: envelops list
+    in:
+      intervals:
         - - 2
           - 3
         - - 5
           - 6
-      "newInterval":
+      newInterval:
         - 1
         - 7
-    "out":
+    out:
       - - 1
         - 7
-  - "name": "adjacent left"
-    "in":
-      "intervals":
+  - name: adjacent left
+    in:
+      intervals:
         - - 3
           - 5
-      "newInterval":
+      newInterval:
         - 1
         - 2
-    "out":
+    out:
       - - 1
         - 2
       - - 3
         - 5
-  - "name": "adjacent right"
-    "in":
-      "intervals":
+  - name: adjacent right
+    in:
+      intervals:
         - - 1
           - 2
-      "newInterval":
+      newInterval:
         - 3
         - 5
-    "out":
+    out:
       - - 1
         - 2
       - - 3
         - 5
-  - "name": "identical interval"
-    "in":
-      "intervals":
+  - name: identical interval
+    in:
+      intervals:
         - - 1
           - 5
         - - 6
           - 10
-      "newInterval":
+      newInterval:
         - 1
         - 5
-    "out":
+    out:
       - - 1
         - 5
       - - 6
         - 10
-  - "name": "all intervals merges into one"
-    "in":
-      "intervals":
+  - name: all intervals merges into one
+    in:
+      intervals:
         - - 1
           - 2
         - - 3
           - 4
         - - 5
           - 6
-      "newInterval":
+      newInterval:
         - 0
         - 7
-    "out":
+    out:
       - - 0
         - 7
-  - "name": "start/end at zero"
-    "in":
-      "intervals":
+  - name: start/end at zero
+    in:
+      intervals:
         - - 0
           - 0
-      "newInterval":
+      newInterval:
         - 0
         - 0
-    "out":
+    out:
       - - 0
         - 0
-  - "name": "max values"
-    "in":
-      "intervals":
+  - name: max values
+    in:
+      intervals:
         - - 100000
           - 100000
-      "newInterval":
+      newInterval:
         - 99999
         - 100000
-    "out":
+    out:
       - - 99999
         - 100000
-  - "name": "test duplicates 1"
-    "in":
-      "intervals":
+  - name: test duplicates 1
+    in:
+      intervals:
         - - 1
           - 1
         - - 1
           - 1
-      "newInterval":
+      newInterval:
         - 1
         - 1
-    "out":
+    out:
       - - 1
         - 1
-  - "name": "test duplicates 2"
-    "in":
-      "intervals":
+  - name: test duplicates 2
+    in:
+      intervals:
         - - 1
           - 5
         - - 1
           - 5
-      "newInterval":
+      newInterval:
         - 1
         - 5
-    "out":
+    out:
       - - 1
         - 5
-  - "name": "large range expansion"
-    "in":
-      "intervals":
+  - name: large range expansion
+    in:
+      intervals:
         - - 0
           - 10
         - - 20
           - 30
         - - 40
           - 50
-      "newInterval":
+      newInterval:
         - 5
         - 45
-    "out":
+    out:
       - - 0
         - 50
-  - "name": "random structure 1"
-    "seed": 123
-    "in":
-      "intervals":
+  - name: random structure 1
+    seed: 123
+    in:
+      intervals:
         - - 1
           - 2
         - - 4
@@ -324,58 +341,58 @@
           - 11
         - - 13
           - 14
-      "newInterval":
+      newInterval:
         - 3
         - 12
-  - "name": "random structure 2"
-    "seed": 456
-    "in":
-      "intervals":
+  - name: random structure 2
+    seed: 456
+    in:
+      intervals:
         - - 10
           - 20
         - - 30
           - 40
         - - 50
           - 60
-      "newInterval":
+      newInterval:
         - 15
         - 55
-  - "name": "random structure 3"
-    "seed": 789
-    "in":
-      "intervals":
+  - name: random structure 3
+    seed: 789
+    in:
+      intervals:
         - - 2
           - 3
         - - 4
           - 5
         - - 6
           - 7
-      "newInterval":
+      newInterval:
         - 0
         - 1
-  - "name": "large input simple case"
-    "in":
-      "intervals":
+  - name: large input simple case
+    in:
+      intervals:
         - - 1
           - 2
         - - 3
           - 4
-      "newInterval":
+      newInterval:
         - 5
         - 6
-  - "name": "large input boundary case"
-    "in":
-      "intervals":
+  - name: large input boundary case
+    in:
+      intervals:
         - - 0
           - 50000
         - - 60000
           - 100000
-      "newInterval":
+      newInterval:
         - 49999
         - 60001
-  - "name": "large input stress"
-    "in":
-      "intervals":
+  - name: large input stress
+    in:
+      intervals:
         - - 1
           - 2
         - - 3
@@ -386,6 +403,6 @@
           - 8
         - - 9
           - 10
-      "newInterval":
+      newInterval:
         - 0
         - 100000
diff --git a/tests/1-500/58. length-of-last-word/manifest.yaml b/tests/1-500/58. length-of-last-word/manifest.yaml
index ac5b45d5..93a0c2f6 100644
--- a/tests/1-500/58. length-of-last-word/manifest.yaml	
+++ b/tests/1-500/58. length-of-last-word/manifest.yaml	
@@ -1,142 +1,150 @@
-"entry":
-  "id": 58
-  "title": "length-of-last-word"
-  "call":
-    "cpp": 'Solution().lengthOfLastWord("{s}")'
-    "rust": 'Solution::length_of_last_word("{s}".to_string())'
-    "python3": 'Solution().lengthOfLastWord("{s}")'
-    "python2": 'Solution().lengthOfLastWord("{s}")'
-    "ruby": 'length_of_last_word("{s}")'
-    "java": 'new Solution().lengthOfLastWord("{s}")'
-    "csharp": 'new Solution().LengthOfLastWord("{s}")'
-    "kotlin": 'Solution().lengthOfLastWord("{s}")'
-    "go": 'lengthOfLastWord("{s}")'
-    "dart": 'Solution().lengthOfLastWord("{s}")'
-    "swift": 'Solution().lengthOfLastWord("{s}")'
-    "typescript": 'lengthOfLastWord("{s}")'
-"judge":
-  "type": "exact"
-"limits":
-  "time_ms": 1000
-  "memory_mb": 256
-"oracle":
-  "python3":
-    "call": 'Checker().lengthOfLastWord("{s}", {result})'
-    "checker":
-      "import json\nclass Checker:\n    def lengthOfLastWord(self, s, result):\n\
-      \        try:\n            result = json.loads(result) if isinstance(result,\
-      \ str) else result\n        except Exception:\n            return False\n  \
-      \      words = s.split()\n        expected = len(words[-1]) if words else 0\n\
-      \        return expected == result\n"
-"seed": 42
-"tests":
-  - "name": "Example 1"
-    "in":
-      "s": "Hello World"
-    "out": 5
-  - "name": "Example 2"
-    "in":
-      "s": "   fly me   to   the moon  "
-    "out": 4
-  - "name": "Example 3"
-    "in":
-      "s": "luffy is still joyboy"
-    "out": 6
-  - "name": "Single word"
-    "in":
-      "s": "a"
-    "out": 1
-  - "name": "Single word with spaces"
-    "in":
-      "s": "   hello   "
-    "out": 5
-  - "name": "Two words"
-    "in":
-      "s": "ab cd"
-    "out": 2
-  - "name": "Only spaces"
-    "in":
-      "s": "          "
-    "out": 0
-  - "name": "Long trailing spaces"
-    "in":
-      "s": "word      "
-    "out": 4
-  - "name": "Leading spaces"
-    "in":
-      "s": "  word"
-    "out": 4
-  - "name": "Mixed spaces"
-    "in":
-      "s": " a b c d e "
-    "out": 1
-  - "name": "All same characters"
-    "in":
-      "s": "aaaaa"
-    "out": 5
-  - "name": "Multiple words joined"
-    "in":
-      "s": "longestwordinthesentence"
-    "out": 24
-  - "name": "Max length constraint"
-    "in":
-      "s": "a"
-    "out": 1
-  - "name": "Large random string test 1"
-    "in":
-      "s":
-        "gen": "str"
-        "len": 5000
-        "alphabet": "a b"
-  - "name": "Large random string test 2"
-    "in":
-      "s":
-        "gen": "str"
-        "len": 10000
-        "alphabet": "z "
-  - "name": "Only alphabet"
-    "in":
-      "s": "abcdefghijklmnopqrstuvwxyz"
-    "out": 26
-  - "name": "Uppercase words"
-    "in":
-      "s": "HELLO WORLD"
-    "out": 5
-  - "name": "Mixed case"
-    "in":
-      "s": "Hello wOrLd"
-    "out": 5
-  - "name": "Words with space in middle"
-    "in":
-      "s": "a b"
-    "out": 1
-  - "name": "Trailing space edge"
-    "in":
-      "s": "abc "
-    "out": 3
-  - "name": "Leading space edge"
-    "in":
-      "s": " abc"
-    "out": 3
-  - "name": "Multiple trailing spaces"
-    "in":
-      "s": "abc   "
-    "out": 3
-  - "name": "Multiple internal spaces"
-    "in":
-      "s": "abc    def"
-    "out": 3
-  - "name": "Shortest valid input"
-    "in":
-      "s": "z"
-    "out": 1
-  - "name": "Generated alphanumeric spaces"
-    "in":
-      "s":
-        "gen": "str"
-        "len": 100
-        "alphabet": "ab "
-  - "name": "Trailing space buffer"
-    "in":
-      "s": "a                  "
-    "out": 1
+entry:
+  id: 58
+  title: length-of-last-word
+  call:
+    cpp: Solution().lengthOfLastWord({s})
+    rust: Solution::length_of_last_word({s})
+    python3: Solution().lengthOfLastWord({s})
+    python2: Solution().lengthOfLastWord({s})
+    ruby: length_of_last_word({s})
+    java: new Solution().lengthOfLastWord({s})
+    csharp: new Solution().LengthOfLastWord({s})
+    kotlin: Solution().lengthOfLastWord({s})
+    go: lengthOfLastWord({s})
+    dart: Solution().lengthOfLastWord({s})
+    swift: Solution().lengthOfLastWord({s})
+    typescript: lengthOfLastWord({s})
+  params:
+    s:
+      type: string
+judge:
+  type: exact
+limits:
+  time_ms: 1000
+  memory_mb: 256
+oracle:
+  python3:
+    call: lengthOfLastWord(s, {result})
+    checker: |
+      import json
+
+      def lengthOfLastWord(s, result):
+          try:
+              result = json.loads(result) if isinstance(result, str) else result
+          except Exception:
+              return False
+          words = s.split()
+          expected = len(words[-1]) if words else 0
+          return expected == result
+seed: 42
+tests:
+  - name: Example 1
+    in:
+      s: Hello World
+    out: 5
+  - name: Example 2
+    in:
+      s: "   fly me   to   the moon  "
+    out: 4
+  - name: Example 3
+    in:
+      s: luffy is still joyboy
+    out: 6
+  - name: Single word
+    in:
+      s: a
+    out: 1
+  - name: Single word with spaces
+    in:
+      s: "   hello   "
+    out: 5
+  - name: Two words
+    in:
+      s: ab cd
+    out: 2
+  - name: Only spaces
+    in:
+      s: "          "
+    out: 0
+  - name: Long trailing spaces
+    in:
+      s: "word      "
+    out: 4
+  - name: Leading spaces
+    in:
+      s: "  word"
+    out: 4
+  - name: Mixed spaces
+    in:
+      s: " a b c d e "
+    out: 1
+  - name: All same characters
+    in:
+      s: aaaaa
+    out: 5
+  - name: Multiple words joined
+    in:
+      s: longestwordinthesentence
+    out: 24
+  - name: Max length constraint
+    in:
+      s: a
+    out: 1
+  - name: Large random string test 1
+    in:
+      s:
+        gen: str
+        len: 5000
+        alphabet: a b
+  - name: Large random string test 2
+    in:
+      s:
+        gen: str
+        len: 10000
+        alphabet: "z "
+  - name: Only alphabet
+    in:
+      s: abcdefghijklmnopqrstuvwxyz
+    out: 26
+  - name: Uppercase words
+    in:
+      s: HELLO WORLD
+    out: 5
+  - name: Mixed case
+    in:
+      s: Hello wOrLd
+    out: 5
+  - name: Words with space in middle
+    in:
+      s: a b
+    out: 1
+  - name: Trailing space edge
+    in:
+      s: "abc "
+    out: 3
+  - name: Leading space edge
+    in:
+      s: " abc"
+    out: 3
+  - name: Multiple trailing spaces
+    in:
+      s: "abc   "
+    out: 3
+  - name: Multiple internal spaces
+    in:
+      s: abc    def
+    out: 3
+  - name: Shortest valid input
+    in:
+      s: z
+    out: 1
+  - name: Generated alphanumeric spaces
+    in:
+      s:
+        gen: str
+        len: 100
+        alphabet: "ab "
+  - name: Trailing space buffer
+    in:
+      s: "a                  "
+    out: 1
diff --git a/tests/1-500/59. spiral-matrix-ii/manifest.yaml b/tests/1-500/59. spiral-matrix-ii/manifest.yaml
index 8e0c04ad..4a34daaa 100644
--- a/tests/1-500/59. spiral-matrix-ii/manifest.yaml	
+++ b/tests/1-500/59. spiral-matrix-ii/manifest.yaml	
@@ -1,59 +1,73 @@
-"entry":
-  "id": 59
-  "title": "spiral-matrix-ii"
-  "call":
-    "cpp": "Solution().generateMatrix({n})"
-    "rust": "Solution::generate_matrix({n})"
-    "python3": "generateMatrix(None, {n})"
-    "python2": "generateMatrix(None, {n})"
-    "ruby": "generate_matrix({n})"
-    "java": "new Solution().generateMatrix({n})"
-    "csharp": "new Solution().GenerateMatrix({n})"
-    "kotlin": "Solution().generateMatrix({n})"
-    "go": "generateMatrix({n})"
-    "dart": "Solution().generateMatrix({n})"
-    "swift": "Solution().generateMatrix({n})"
-    "typescript": "generateMatrix({n})"
-"judge":
-  "type": "exact"
-"limits":
-  "time_ms": 1000
-  "memory_mb": 256
-"oracle":
-  "python3":
-    "call": "Checker().check({n}, {result})"
-    "checker":
-      "import json\nclass Checker:\n    def check(self, n, matrix):\n   \
-      \     try:\n            matrix = json.loads(matrix) if isinstance(matrix, str)\
-      \ else matrix\n        except Exception:\n            return False\n       \
-      \ if isinstance(matrix, list) and len(matrix) == 1 and isinstance(matrix[0],\
-      \ list):\n            matrix = matrix[0]\n        if len(matrix) != n or any(len(row)\
-      \ != n for row in matrix):\n            return False\n        flat = [val for\
-      \ row in matrix for val in row]\n        if sorted(flat) != list(range(1, n\
-      \ * n + 1)):\n            return False\n        x, y, dx, dy = 0, 0, 1, 0\n\
-      \        res = [[0 for _ in range(n)] for _ in range(n)]\n        for i in range(n\
-      \ * n):\n            res[y][x] = i + 1\n            if not 0 <= x + dx < n or\
-      \ not 0 <= y + dy < n or res[y+dy][x+dx] != 0:\n                dx, dy = -dy,\
-      \ dx\n            x += dx\n            y += dy\n        return matrix == res\n"
-"seed": 42
-"tests":
-  - "name": "n=1"
-    "in":
-      "n": 1
-    "out":
+entry:
+  id: 59
+  title: spiral-matrix-ii
+  call:
+    cpp: Solution().generateMatrix({n})
+    rust: Solution::generate_matrix({n})
+    python3: Solution().generateMatrix({n})
+    python2: Solution().generateMatrix({n})
+    ruby: generate_matrix({n})
+    java: new Solution().generateMatrix({n})
+    csharp: new Solution().GenerateMatrix({n})
+    kotlin: Solution().generateMatrix({n})
+    go: generateMatrix({n})
+    dart: Solution().generateMatrix({n})
+    swift: Solution().generateMatrix({n})
+    typescript: generateMatrix({n})
+  params:
+    n:
+      type: int
+judge:
+  type: exact
+limits:
+  time_ms: 1000
+  memory_mb: 256
+oracle:
+  python3:
+    call: check(n, {result})
+    checker: |
+      import json
+
+      def check(n, matrix):
+          try:
+              matrix = json.loads(matrix) if isinstance(matrix, str) else matrix
+          except Exception:
+              return False
+          if isinstance(matrix, list) and len(matrix) == 1 and isinstance(matrix[0], list):
+              matrix = matrix[0]
+          if len(matrix) != n or any(len(row) != n for row in matrix):
+              return False
+          flat = [val for row in matrix for val in row]
+          if sorted(flat) != list(range(1, n * n + 1)):
+              return False
+          x, y, dx, dy = 0, 0, 1, 0
+          res = [[0 for _ in range(n)] for _ in range(n)]
+          for i in range(n * n):
+              res[y][x] = i + 1
+              if not 0 <= x + dx < n or not 0 <= y + dy < n or res[y + dy][x + dx] != 0:
+                  dx, dy = -dy, dx
+              x += dx
+              y += dy
+          return matrix == res
+seed: 42
+tests:
+  - name: n=1
+    in:
+      n: 1
+    out:
       - - 1
-  - "name": "n=2"
-    "in":
-      "n": 2
-    "out":
+  - name: n=2
+    in:
+      n: 2
+    out:
       - - 1
         - 2
       - - 4
         - 3
-  - "name": "n=3"
-    "in":
-      "n": 3
-    "out":
+  - name: n=3
+    in:
+      n: 3
+    out:
       - - 1
         - 2
         - 3
@@ -63,10 +77,10 @@
       - - 7
         - 6
         - 5
-  - "name": "n=4"
-    "in":
-      "n": 4
-    "out":
+  - name: n=4
+    in:
+      n: 4
+    out:
       - - 1
         - 2
         - 3
@@ -83,10 +97,10 @@
         - 9
         - 8
         - 7
-  - "name": "n=5"
-    "in":
-      "n": 5
-    "out":
+  - name: n=5
+    in:
+      n: 5
+    out:
       - - 1
         - 2
         - 3
@@ -112,10 +126,10 @@
         - 11
         - 10
         - 9
-  - "name": "n=6"
-    "in":
-      "n": 6
-    "out":
+  - name: n=6
+    in:
+      n: 6
+    out:
       - - 1
         - 2
         - 3
@@ -152,10 +166,10 @@
         - 13
         - 12
         - 11
-  - "name": "n=7"
-    "in":
-      "n": 7
-    "out":
+  - name: n=7
+    in:
+      n: 7
+    out:
       - - 1
         - 2
         - 3
@@ -205,10 +219,10 @@
         - 15
         - 14
         - 13
-  - "name": "n=8"
-    "in":
-      "n": 8
-    "out":
+  - name: n=8
+    in:
+      n: 8
+    out:
       - - 1
         - 2
         - 3
@@ -273,54 +287,54 @@
         - 17
         - 16
         - 15
-  - "name": "gen_1"
-    "in":
-      "n": 9
-  - "name": "gen_2"
-    "in":
-      "n": 10
-  - "name": "gen_3"
-    "in":
-      "n": 11
-  - "name": "gen_4"
-    "in":
-      "n": 12
-  - "name": "gen_5"
-    "in":
-      "n": 13
-  - "name": "gen_6"
-    "in":
-      "n": 14
-  - "name": "gen_7"
-    "in":
-      "n": 15
-  - "name": "gen_8"
-    "in":
-      "n": 16
-  - "name": "gen_9"
-    "in":
-      "n": 17
-  - "name": "gen_10"
-    "in":
-      "n": 18
-  - "name": "gen_11"
-    "in":
-      "n": 19
-  - "name": "max_n_20"
-    "in":
-      "n": 20
-  - "name": "gen_random_1"
-    "in":
-      "n": 5
-  - "name": "gen_random_2"
-    "in":
-      "n": 7
-  - "name": "gen_random_3"
-    "in":
-      "n": 11
-  - "name": "gen_random_4"
-    "in":
-      "n": 17
-  - "name": "gen_random_5"
-    "in":
-      "n": 19
+  - name: gen_1
+    in:
+      n: 9
+  - name: gen_2
+    in:
+      n: 10
+  - name: gen_3
+    in:
+      n: 11
+  - name: gen_4
+    in:
+      n: 12
+  - name: gen_5
+    in:
+      n: 13
+  - name: gen_6
+    in:
+      n: 14
+  - name: gen_7
+    in:
+      n: 15
+  - name: gen_8
+    in:
+      n: 16
+  - name: gen_9
+    in:
+      n: 17
+  - name: gen_10
+    in:
+      n: 18
+  - name: gen_11
+    in:
+      n: 19
+  - name: max_n_20
+    in:
+      n: 20
+  - name: gen_random_1
+    in:
+      n: 5
+  - name: gen_random_2
+    in:
+      n: 7
+  - name: gen_random_3
+    in:
+      n: 11
+  - name: gen_random_4
+    in:
+      n: 17
+  - name: gen_random_5
+    in:
+      n: 19
diff --git a/tests/1-500/6. zigzag-conversion/manifest.yaml b/tests/1-500/6. zigzag-conversion/manifest.yaml
index 58a3b046..201495c5 100644
--- a/tests/1-500/6. zigzag-conversion/manifest.yaml	
+++ b/tests/1-500/6. zigzag-conversion/manifest.yaml	
@@ -1,19 +1,24 @@
 entry:
   id: 6
   title: zigzag-conversion
+  params:
+    s:
+      type: string
+    numRows:
+      type: int
   call:
-    cpp: Solution().convert("{s}", {numRows})
-    rust: Solution::convert("{s}".to_string(), {numRows})
-    python3: Solution().convert("{s}", {numRows})
-    python2: Solution().convert("{s}", {numRows})
-    ruby: convert("{s}", {numRows})
-    java: new Solution().convert("{s}", {numRows})
-    csharp: new Solution().Convert("{s}", {numRows})
-    kotlin: Solution().convert("{s}", {numRows})
-    go: convert("{s}", {numRows})
-    dart: Solution().convert("{s}", {numRows})
-    swift: Solution().convert("{s}", {numRows})
-    typescript: convert("{s}", {numRows})
+    cpp: Solution().convert({s}, {numRows})
+    rust: Solution::convert({s}.to_string(), {numRows})
+    python3: Solution().convert({s}, {numRows})
+    python2: Solution().convert({s}, {numRows})
+    ruby: convert({s}, {numRows})
+    java: new Solution().convert({s}, {numRows})
+    csharp: new Solution().Convert({s}, {numRows})
+    kotlin: Solution().convert({s}, {numRows})
+    go: convert({s}, {numRows})
+    dart: Solution().convert({s}, {numRows})
+    swift: Solution().convert({s}, {numRows})
+    typescript: convert({s}, {numRows})
 judge:
   type: exact
 limits:
@@ -21,7 +26,7 @@ limits:
   memory_mb: 256
 oracle:
   python3:
-    call: Checker().convert("{s}", {numRows}, {result})
+    call: Checker().convert(s, numRows, {result})
     checker:
       "import json\nclass Checker:\n    def _norm(self, result):\n        if\
       \ isinstance(result, str):\n            try:\n                result = json.loads(result)\n\
diff --git a/tests/1-500/60. permutation-sequence/manifest.yaml b/tests/1-500/60. permutation-sequence/manifest.yaml
index 378c42ec..6f262899 100644
--- a/tests/1-500/60. permutation-sequence/manifest.yaml	
+++ b/tests/1-500/60. permutation-sequence/manifest.yaml	
@@ -1,148 +1,163 @@
-"entry":
-  "id": 60
-  "title": "permutation-sequence"
-  "call":
-    "cpp": "Solution().getPermutation({n}, {k})"
-    "rust": "Solution::get_permutation({n}, {k})"
-    "python3": "Solution().getPermutation({n}, {k})"
-    "python2": "Solution().getPermutation({n}, {k})"
-    "ruby": "get_permutation({n}, {k})"
-    "java": "new Solution().getPermutation({n}, {k})"
-    "csharp": "new Solution().GetPermutation({n}, {k})"
-    "kotlin": "Solution().getPermutation({n}, {k})"
-    "go": "getPermutation({n}, {k})"
-    "dart": "Solution().getPermutation({n}, {k})"
-    "swift": "Solution().getPermutation({n}, {k})"
-    "typescript": "getPermutation({n}, {k})"
-"judge":
-  "type": "exact"
-"limits":
-  "time_ms": 1000
-  "memory_mb": 256
-"oracle":
-  "python3":
-    "call": "Checker().getPermutation({n}, {k}, {result})"
-    "checker":
-      "import json\nclass Checker:\n    def getPermutation(self, n, k, result):\n\
-      \        try:\n            result = json.loads(result) if isinstance(result,\
-      \ str) else result\n        except Exception:\n            return False\n  \
-      \      nums = [i for i in range(1, n + 1)]\n        k -= 1\n        factorial\
-      \ = [1] * n\n        for i in range(1, n):\n            factorial[i] = factorial[i\
-      \ - 1] * i\n        res = []\n        for i in range(n - 1, -1, -1):\n     \
-      \       idx = k // factorial[i]\n            k %= factorial[i]\n           \
-      \ res.append(str(nums.pop(idx)))\n        return \"\".join(res) == str(result)\n"
-"seed": 42
-"tests":
-  - "name": "Example 1"
-    "in":
-      "n": 3
-      "k": 3
-  - "name": "Example 2"
-    "in":
-      "n": 4
-      "k": 9
-  - "name": "Example 3"
-    "in":
-      "n": 3
-      "k": 1
-  - "name": "n=1, k=1"
-    "in":
-      "n": 1
-      "k": 1
-  - "name": "n=2, k=1"
-    "in":
-      "n": 2
-      "k": 1
-  - "name": "n=2, k=2"
-    "in":
-      "n": 2
-      "k": 2
-  - "name": "n=3, k=2"
-    "in":
-      "n": 3
-      "k": 2
-  - "name": "n=3, k=4"
-    "in":
-      "n": 3
-      "k": 4
-  - "name": "n=3, k=6"
-    "in":
-      "n": 3
-      "k": 6
-  - "name": "n=4, k=1"
-    "in":
-      "n": 4
-      "k": 1
-  - "name": "n=4, k=24"
-    "in":
-      "n": 4
-      "k": 24
-  - "name": "n=5, k=1"
-    "in":
-      "n": 5
-      "k": 1
-  - "name": "n=5, k=120"
-    "in":
-      "n": 5
-      "k": 120
-  - "name": "n=6, k=1"
-    "in":
-      "n": 6
-      "k": 1
-  - "name": "n=6, k=720"
-    "in":
-      "n": 6
-      "k": 720
-  - "name": "n=7, k=1"
-    "in":
-      "n": 7
-      "k": 1
-  - "name": "n=7, k=5040"
-    "in":
-      "n": 7
-      "k": 5040
-  - "name": "n=8, k=1"
-    "in":
-      "n": 8
-      "k": 1
-  - "name": "n=8, k=40320"
-    "in":
-      "n": 8
-      "k": 40320
-  - "name": "n=9, k=1"
-    "in":
-      "n": 9
-      "k": 1
-  - "name": "n=9, k=362880"
-    "in":
-      "n": 9
-      "k": 362880
-  - "name": "n=9, k=181440"
-    "in":
-      "n": 9
-      "k": 181440
-  - "name": "Random Test 1"
-    "in":
-      "n": 5
-      "k": 50
-    "oracle": null
-  - "name": "Random Test 2"
-    "in":
-      "n": 6
-      "k": 300
-    "oracle": null
-  - "name": "Random Test 3"
-    "in":
-      "n": 8
-      "k": 20000
-    "oracle": null
-  - "name": "Random Test 4"
-    "in":
-      "n": 9
-      "k": 100000
-    "oracle": null
-  - "name": "Random Test 5"
-    "in":
-      "n": 9
-      "k": 300000
-    "oracle": null
+entry:
+  id: 60
+  title: permutation-sequence
+  call:
+    cpp: Solution().getPermutation({n}, {k})
+    rust: Solution::get_permutation({n}, {k})
+    python3: Solution().getPermutation({n}, {k})
+    python2: Solution().getPermutation({n}, {k})
+    ruby: get_permutation({n}, {k})
+    java: new Solution().getPermutation({n}, {k})
+    csharp: new Solution().GetPermutation({n}, {k})
+    kotlin: Solution().getPermutation({n}, {k})
+    go: getPermutation({n}, {k})
+    dart: Solution().getPermutation({n}, {k})
+    swift: Solution().getPermutation({n}, {k})
+    typescript: getPermutation({n}, {k})
+  params:
+    n:
+      type: int
+    k:
+      type: int
+judge:
+  type: exact
+limits:
+  time_ms: 1000
+  memory_mb: 256
+oracle:
+  python3:
+    call: getPermutation(n, k, {result})
+    checker: |
+      import json
+
+      def getPermutation(n, k, result):
+          try:
+              result = json.loads(result) if isinstance(result, str) else result
+          except Exception:
+              return False
+          nums = [i for i in range(1, n + 1)]
+          k -= 1
+          factorial = [1] * n
+          for i in range(1, n):
+              factorial[i] = factorial[i - 1] * i
+          res = []
+          for i in range(n - 1, -1, -1):
+              idx = k // factorial[i]
+              k %= factorial[i]
+              res.append(str(nums.pop(idx)))
+          return ''.join(res) == str(result)
+seed: 42
+tests:
+  - name: Example 1
+    in:
+      n: 3
+      k: 3
+  - name: Example 2
+    in:
+      n: 4
+      k: 9
+  - name: Example 3
+    in:
+      n: 3
+      k: 1
+  - name: n=1, k=1
+    in:
+      n: 1
+      k: 1
+  - name: n=2, k=1
+    in:
+      n: 2
+      k: 1
+  - name: n=2, k=2
+    in:
+      n: 2
+      k: 2
+  - name: n=3, k=2
+    in:
+      n: 3
+      k: 2
+  - name: n=3, k=4
+    in:
+      n: 3
+      k: 4
+  - name: n=3, k=6
+    in:
+      n: 3
+      k: 6
+  - name: n=4, k=1
+    in:
+      n: 4
+      k: 1
+  - name: n=4, k=24
+    in:
+      n: 4
+      k: 24
+  - name: n=5, k=1
+    in:
+      n: 5
+      k: 1
+  - name: n=5, k=120
+    in:
+      n: 5
+      k: 120
+  - name: n=6, k=1
+    in:
+      n: 6
+      k: 1
+  - name: n=6, k=720
+    in:
+      n: 6
+      k: 720
+  - name: n=7, k=1
+    in:
+      n: 7
+      k: 1
+  - name: n=7, k=5040
+    in:
+      n: 7
+      k: 5040
+  - name: n=8, k=1
+    in:
+      n: 8
+      k: 1
+  - name: n=8, k=40320
+    in:
+      n: 8
+      k: 40320
+  - name: n=9, k=1
+    in:
+      n: 9
+      k: 1
+  - name: n=9, k=362880
+    in:
+      n: 9
+      k: 362880
+  - name: n=9, k=181440
+    in:
+      n: 9
+      k: 181440
+  - name: Random Test 1
+    in:
+      n: 5
+      k: 50
+    oracle: null
+  - name: Random Test 2
+    in:
+      n: 6
+      k: 300
+    oracle: null
+  - name: Random Test 3
+    in:
+      n: 8
+      k: 20000
+    oracle: null
+  - name: Random Test 4
+    in:
+      n: 9
+      k: 100000
+    oracle: null
+  - name: Random Test 5
+    in:
+      n: 9
+      k: 300000
+    oracle: null
diff --git a/tests/1-500/61. rotate-list/manifest.yaml b/tests/1-500/61. rotate-list/manifest.yaml
index 91175c2b..394bc8f1 100644
--- a/tests/1-500/61. rotate-list/manifest.yaml	
+++ b/tests/1-500/61. rotate-list/manifest.yaml	
@@ -1,321 +1,321 @@
-"entry":
-  "id": 61
-  "title": "rotate-list"
-  "call":
-    "cpp":
-      "listNodeToArray(Solution().rotateRight(toListNode(lv(vector<int>{ {head}\
-      \ })), {k}))"
-    "rust":
-      "ListNode::list_node_to_array(Solution::rotate_right(ListNode::to_list_node(vec![{head}]),\
-      \ {k} as i32))"
-    "python3":
-      "list_node_to_array(Solution().rotateRight(to_list_node([{head}]),\
-      \ {k}))"
-    "python2":
-      "list_node_to_array(Solution().rotateRight(to_list_node([{head}]),\
-      \ {k}))"
-    "ruby": "list_node_to_array(rotate_right(to_list_node([{head}]), {k}))"
-    "java":
-      "ListNode.listNodeToArray(new Solution().rotateRight(ListNode.toListNode(new\
-      \ int[]{ {head} }), {k}))"
-    "csharp":
-      "ListNode.ListNodeToArray(new Solution().RotateRight(ListNode.ToListNode(new\
-      \ int[]{ {head} }), {k}))"
-    "kotlin":
-      "listNodeToArray(Solution().rotateRight(toListNode(intArrayOf({head})),\
-      \ {k}))"
-    "go": "listNodeToArray(rotateRight(toListNode([]int{ {head} }), {k}))"
-    "dart": "list_node_to_array(Solution().rotateRight(to_list_node([{head}]), {k}))"
-    "swift": "list_node_to_array(Solution().rotateRight(to_list_node([{head}]), {k}))"
-    "typescript": "listNodeToArray(rotateRight(toListNode([{head}]), {k}))"
-"judge":
-  "type": "exact"
-"limits":
-  "time_ms": 1000
-  "memory_mb": 256
-"oracle":
-  "python3":
-    "call": "Checker().check([{head}], {k}, {result})"
-    "checker":
-      "import json\nclass Checker:\n    def check(self, head_vals, k, result):\n\
-      \        try:\n            result = json.loads(result) if isinstance(result,\
-      \ str) else result\n        except Exception:\n            return False\n  \
-      \      if not head_vals: return result == []\n        n = len(head_vals)\n \
-      \       k %= n\n        if k == 0: return result == head_vals\n        expected\
-      \ = head_vals[n-k:] + head_vals[:n-k]\n        return result == expected\n"
-"seed": 42
-"tests":
-  - "name": "Example 1"
-    "in":
-      "head":
+entry:
+  id: 61
+  title: rotate-list
+  call:
+    cpp: listNodeToArray(Solution().rotateRight({head}, {k}))
+    rust: ListNode::list_node_to_array(Solution::rotate_right({head}, {k} as i32))
+    python3: list_node_to_array(Solution().rotateRight({head}, {k}))
+    python2: list_node_to_array(Solution().rotateRight({head}, {k}))
+    ruby: list_node_to_array(rotate_right({head}, {k}))
+    java: ListNode.listNodeToArray(new Solution().rotateRight({head}, {k}))
+    csharp: ListNode.ListNodeToArray(new Solution().RotateRight({head}, {k}))
+    kotlin: listNodeToArray(Solution().rotateRight({head}, {k}))
+    go: listNodeToArray(rotateRight({head}, {k}))
+    dart: list_node_to_array(Solution().rotateRight({head}, {k}))
+    swift: list_node_to_array(Solution().rotateRight({head}, {k}))
+    typescript: listNodeToArray(rotateRight({head}, {k}))
+  params:
+    head:
+      type: list_node
+    k:
+      type: int
+judge:
+  type: exact
+limits:
+  time_ms: 1000
+  memory_mb: 256
+oracle:
+  python3:
+    call: check(head, k, {result})
+    checker: |
+      import json
+
+      def check(head, k, result):
+          try:
+              result = json.loads(result) if isinstance(result, str) else result
+          except Exception:
+              return False
+          if not head:
+              return result == []
+          n = len(head)
+          k %= n
+          if k == 0:
+              return result == head
+          expected = head[n-k:] + head[:n-k]
+          return result == expected
+seed: 42
+tests:
+  - name: Example 1
+    in:
+      head:
         - 1
         - 2
         - 3
         - 4
         - 5
-      "k": 2
-    "out":
+      k: 2
+    out:
       - 4
       - 5
       - 1
       - 2
       - 3
-  - "name": "Example 2"
-    "in":
-      "head":
+  - name: Example 2
+    in:
+      head:
         - 0
         - 1
         - 2
-      "k": 4
-    "out":
+      k: 4
+    out:
       - 2
       - 0
       - 1
-  - "name": "Empty list"
-    "in":
-      "head": []
-      "k": 1
-    "out": []
-  - "name": "Single node k=0"
-    "in":
-      "head":
+  - name: Empty list
+    in:
+      head: []
+      k: 1
+    out: []
+  - name: Single node k=0
+    in:
+      head:
         - 1
-      "k": 0
-    "out":
+      k: 0
+    out:
       - 1
-  - "name": "Single node k=10"
-    "in":
-      "head":
+  - name: Single node k=10
+    in:
+      head:
         - 1
-      "k": 10
-    "out":
+      k: 10
+    out:
       - 1
-  - "name": "Two nodes rotate 1"
-    "in":
-      "head":
+  - name: Two nodes rotate 1
+    in:
+      head:
         - 1
         - 2
-      "k": 1
-    "out":
+      k: 1
+    out:
       - 2
       - 1
-  - "name": "Two nodes rotate 2"
-    "in":
-      "head":
+  - name: Two nodes rotate 2
+    in:
+      head:
         - 1
         - 2
-      "k": 2
-    "out":
+      k: 2
+    out:
       - 1
       - 2
-  - "name": "K is multiple of length"
-    "in":
-      "head":
+  - name: K is multiple of length
+    in:
+      head:
         - 1
         - 2
         - 3
-      "k": 6
-    "out":
+      k: 6
+    out:
       - 1
       - 2
       - 3
-  - "name": "Rotate more than length"
-    "in":
-      "head":
+  - name: Rotate more than length
+    in:
+      head:
         - 1
         - 2
         - 3
         - 4
-      "k": 5
-    "out":
+      k: 5
+    out:
       - 4
       - 1
       - 2
       - 3
-  - "name": "Null list large k"
-    "in":
-      "head": []
-      "k": 2000000000
-    "out": []
-  - "name": "All same values"
-    "in":
-      "head":
+  - name: Null list large k
+    in:
+      head: []
+      k: 2000000000
+    out: []
+  - name: All same values
+    in:
+      head:
         - 1
         - 1
         - 1
-      "k": 1
-    "out":
+      k: 1
+    out:
       - 1
       - 1
       - 1
-  - "name": "Large K"
-    "in":
-      "head":
+  - name: Large K
+    in:
+      head:
         - 1
         - 2
-      "k": 2000000000
-    "out":
+      k: 2000000000
+    out:
       - 1
       - 2
-  - "name": "Large K odd"
-    "in":
-      "head":
+  - name: Large K odd
+    in:
+      head:
         - 1
         - 2
-      "k": 2000000001
-    "out":
+      k: 2000000001
+    out:
       - 2
       - 1
-  - "name": "Small list rotate exact len"
-    "in":
-      "head":
+  - name: Small list rotate exact len
+    in:
+      head:
         - 10
         - 20
-      "k": 2
-    "out":
+      k: 2
+    out:
       - 10
       - 20
-  - "name": "Small list rotate 1"
-    "in":
-      "head":
+  - name: Small list rotate 1
+    in:
+      head:
         - 10
         - 20
-      "k": 1
-    "out":
+      k: 1
+    out:
       - 20
       - 10
-  - "name": "List 500 nodes rotate 0"
-    "in":
-      "head":
-        "gen": "array"
-        "len":
-          "gen": "int"
-          "min": 500
-          "max": 500
-        "of":
-          "gen": "int"
-          "min": -100
-          "max": 100
-      "k": 0
-  - "name": "List 500 nodes rotate 500"
-    "in":
-      "head":
-        "gen": "array"
-        "len":
-          "gen": "int"
-          "min": 500
-          "max": 500
-        "of":
-          "gen": "int"
-          "min": -100
-          "max": 100
-      "k": 500
-  - "name": "List 250 nodes rotate 125"
-    "in":
-      "head":
-        "gen": "array"
-        "len":
-          "gen": "int"
-          "min": 250
-          "max": 250
-        "of":
-          "gen": "int"
-          "min": -100
-          "max": 100
-      "k": 125
-  - "name": "List 100 nodes rotate 2500000000"
-    "in":
-      "head":
-        "gen": "array"
-        "len":
-          "gen": "int"
-          "min": 100
-          "max": 100
-        "of":
-          "gen": "int"
-          "min": -100
-          "max": 100
-      "k": 2500000000
-  - "name": "List 500 nodes rotate 250"
-    "in":
-      "head":
-        "gen": "array"
-        "len":
-          "gen": "int"
-          "min": 500
-          "max": 500
-        "of":
-          "gen": "int"
-          "min": -100
-          "max": 100
-      "k": 250
-  - "name": "Three nodes k 1"
-    "in":
-      "head":
+  - name: List 500 nodes rotate 0
+    in:
+      head:
+        gen: array
+        len:
+          gen: int
+          min: 500
+          max: 500
+        of:
+          gen: int
+          min: -100
+          max: 100
+      k: 0
+  - name: List 500 nodes rotate 500
+    in:
+      head:
+        gen: array
+        len:
+          gen: int
+          min: 500
+          max: 500
+        of:
+          gen: int
+          min: -100
+          max: 100
+      k: 500
+  - name: List 250 nodes rotate 125
+    in:
+      head:
+        gen: array
+        len:
+          gen: int
+          min: 250
+          max: 250
+        of:
+          gen: int
+          min: -100
+          max: 100
+      k: 125
+  - name: List 100 nodes rotate 2500000000
+    in:
+      head:
+        gen: array
+        len:
+          gen: int
+          min: 100
+          max: 100
+        of:
+          gen: int
+          min: -100
+          max: 100
+      k: 2000000000
+  - name: List 500 nodes rotate 250
+    in:
+      head:
+        gen: array
+        len:
+          gen: int
+          min: 500
+          max: 500
+        of:
+          gen: int
+          min: -100
+          max: 100
+      k: 250
+  - name: Three nodes k 1
+    in:
+      head:
         - 1
         - 2
         - 3
-      "k": 1
-    "out":
+      k: 1
+    out:
       - 3
       - 1
       - 2
-  - "name": "Three nodes k 2"
-    "in":
-      "head":
+  - name: Three nodes k 2
+    in:
+      head:
         - 1
         - 2
         - 3
-      "k": 2
-    "out":
+      k: 2
+    out:
       - 2
       - 3
       - 1
-  - "name": "Three nodes k 3"
-    "in":
-      "head":
+  - name: Three nodes k 3
+    in:
+      head:
         - 1
         - 2
         - 3
-      "k": 3
-    "out":
+      k: 3
+    out:
       - 1
       - 2
       - 3
-  - "name": "Negative values"
-    "in":
-      "head":
+  - name: Negative values
+    in:
+      head:
         - -1
         - -2
         - -3
-      "k": 1
-    "out":
+      k: 1
+    out:
       - -3
       - -1
       - -2
-  - "name": "Max constraints list"
-    "in":
-      "head":
-        "gen": "array"
-        "len":
-          "gen": "int"
-          "min": 500
-          "max": 500
-        "of":
-          "gen": "int"
-          "min": -100
-          "max": 100
-      "k": 1000
-  - "name": "Max constraints list 2"
-    "in":
-      "head":
-        "gen": "array"
-        "len":
-          "gen": "int"
-          "min": 500
-          "max": 500
-        "of":
-          "gen": "int"
-          "min": -100
-          "max": 100
-      "k": 2000000000
+  - name: Max constraints list
+    in:
+      head:
+        gen: array
+        len:
+          gen: int
+          min: 500
+          max: 500
+        of:
+          gen: int
+          min: -100
+          max: 100
+      k: 1000
+  - name: Max constraints list 2
+    in:
+      head:
+        gen: array
+        len:
+          gen: int
+          min: 500
+          max: 500
+        of:
+          gen: int
+          min: -100
+          max: 100
+      k: 2000000000
diff --git a/tests/1-500/62. unique-paths/manifest.yaml b/tests/1-500/62. unique-paths/manifest.yaml
index d51823bb..4266f6b0 100644
--- a/tests/1-500/62. unique-paths/manifest.yaml	
+++ b/tests/1-500/62. unique-paths/manifest.yaml	
@@ -1,158 +1,167 @@
-"entry":
-  "id": 62
-  "title": "unique-paths"
-  "call":
-    "cpp": "Solution().uniquePaths({m}, {n})"
-    "rust": "Solution::unique_paths({m}, {n})"
-    "python3": "Solution().uniquePaths({m}, {n})"
-    "python2": "Solution().uniquePaths({m}, {n})"
-    "ruby": "unique_paths({m}, {n})"
-    "java": "new Solution().uniquePaths({m}, {n})"
-    "csharp": "new Solution().UniquePaths({m}, {n})"
-    "kotlin": "Solution().uniquePaths({m}, {n})"
-    "go": "uniquePaths({m}, {n})"
-    "dart": "Solution().uniquePaths({m}, {n})"
-    "swift": "Solution().uniquePaths({m}, {n})"
-    "typescript": "uniquePaths({m}, {n})"
-"judge":
-  "type": "exact"
-"limits":
-  "time_ms": 1000
-  "memory_mb": 256
-"oracle":
-  "python3":
-    "call": "Checker().uniquePaths({m}, {n}, {result})"
-    "checker":
-      "import json\nimport math\nclass Checker:\n    def uniquePaths(self,\
-      \ m, n, result):\n        try:\n            result = json.loads(result) if isinstance(result,\
-      \ str) else result\n        except Exception:\n            return False\n  \
-      \      expected = math.comb(m + n - 2, m - 1)\n        return result == expected\n"
-"seed": 42
-"tests":
-  - "name": "Example 1"
-    "in":
-      "m": 3
-      "n": 7
-    "out": 28
-  - "name": "Example 2"
-    "in":
-      "m": 3
-      "n": 2
-    "out": 3
-  - "name": "Min board"
-    "in":
-      "m": 1
-      "n": 1
-    "out": 1
-  - "name": "Row"
-    "in":
-      "m": 1
-      "n": 10
-    "out": 1
-  - "name": "Column"
-    "in":
-      "m": 10
-      "n": 1
-    "out": 1
-  - "name": "Small square"
-    "in":
-      "m": 2
-      "n": 2
-    "out": 2
-  - "name": "2x3"
-    "in":
-      "m": 2
-      "n": 3
-    "out": 3
-  - "name": "3x3"
-    "in":
-      "m": 3
-      "n": 3
-    "out": 6
-  - "name": "4x4"
-    "in":
-      "m": 4
-      "n": 4
-    "out": 20
-  - "name": "5x5"
-    "in":
-      "m": 5
-      "n": 5
-    "out": 70
-  - "name": "1x100"
-    "in":
-      "m": 1
-      "n": 100
-    "out": 1
-  - "name": "100x1"
-    "in":
-      "m": 100
-      "n": 1
-    "out": 1
-  - "name": "2x100"
-    "in":
-      "m": 2
-      "n": 100
-    "out": 100
-  - "name": "100x2"
-    "in":
-      "m": 100
-      "n": 2
-    "out": 100
-  - "name": "3x10"
-    "in":
-      "m": 3
-      "n": 10
-    "out": 55
-  - "name": "10x3"
-    "in":
-      "m": 10
-      "n": 3
-    "out": 55
-  - "name": "5x10"
-    "in":
-      "m": 5
-      "n": 10
-    "out": 715
-  - "name": "10x5"
-    "in":
-      "m": 10
-      "n": 5
-    "out": 715
-  - "name": "Random 1"
-    "in":
-      "m": 12
-      "n": 12
-    "out": 705432
-  - "name": "Random 2"
-    "in":
-      "m": 20
-      "n": 20
-    "out": 35345263800
-  - "name": "Random 3"
-    "in":
-      "m": 15
-      "n": 25
-    "out": 9669554100
-  - "name": "Gen 1"
-    "in":
-      "m":
-        "gen": "int"
-        "min": 50
-        "max": 60
-      "n": 60
-  - "name": "Gen 2"
-    "in":
-      "m": 70
-      "n":
-        "gen": "int"
-        "min": 70
-        "max": 80
-  - "name": "Large bound 1"
-    "in":
-      "m": 100
-      "n": 100
-  - "name": "Large bound 2"
-    "in":
-      "m": 100
-      "n": 99
+entry:
+  id: 62
+  title: unique-paths
+  call:
+    cpp: Solution().uniquePaths({m}, {n})
+    rust: Solution::unique_paths({m}, {n})
+    python3: Solution().uniquePaths({m}, {n})
+    python2: Solution().uniquePaths({m}, {n})
+    ruby: unique_paths({m}, {n})
+    java: new Solution().uniquePaths({m}, {n})
+    csharp: new Solution().UniquePaths({m}, {n})
+    kotlin: Solution().uniquePaths({m}, {n})
+    go: uniquePaths({m}, {n})
+    dart: Solution().uniquePaths({m}, {n})
+    swift: Solution().uniquePaths({m}, {n})
+    typescript: uniquePaths({m}, {n})
+  params:
+    m:
+      type: int
+    n:
+      type: int
+judge:
+  type: exact
+limits:
+  time_ms: 1000
+  memory_mb: 256
+oracle:
+  python3:
+    call: uniquePaths(m, n, {result})
+    checker: |
+      import json
+      import math
+
+      def uniquePaths(m, n, result):
+          try:
+              result = json.loads(result) if isinstance(result, str) else result
+          except Exception:
+              return False
+          expected = math.comb(m + n - 2, m - 1)
+          return result == expected
+seed: 42
+tests:
+  - name: Example 1
+    in:
+      m: 3
+      n: 7
+    out: 28
+  - name: Example 2
+    in:
+      m: 3
+      n: 2
+    out: 3
+  - name: Min board
+    in:
+      m: 1
+      n: 1
+    out: 1
+  - name: Row
+    in:
+      m: 1
+      n: 10
+    out: 1
+  - name: Column
+    in:
+      m: 10
+      n: 1
+    out: 1
+  - name: Small square
+    in:
+      m: 2
+      n: 2
+    out: 2
+  - name: 2x3
+    in:
+      m: 2
+      n: 3
+    out: 3
+  - name: 3x3
+    in:
+      m: 3
+      n: 3
+    out: 6
+  - name: 4x4
+    in:
+      m: 4
+      n: 4
+    out: 20
+  - name: 5x5
+    in:
+      m: 5
+      n: 5
+    out: 70
+  - name: 1x100
+    in:
+      m: 1
+      n: 100
+    out: 1
+  - name: 100x1
+    in:
+      m: 100
+      n: 1
+    out: 1
+  - name: 2x100
+    in:
+      m: 2
+      n: 100
+    out: 100
+  - name: 100x2
+    in:
+      m: 100
+      n: 2
+    out: 100
+  - name: 3x10
+    in:
+      m: 3
+      n: 10
+    out: 55
+  - name: 10x3
+    in:
+      m: 10
+      n: 3
+    out: 55
+  - name: 5x10
+    in:
+      m: 5
+      n: 10
+    out: 715
+  - name: 10x5
+    in:
+      m: 10
+      n: 5
+    out: 715
+  - name: Random 1
+    in:
+      m: 12
+      n: 12
+    out: 705432
+  - name: Random 2
+    in:
+      m: 15
+      n: 15
+    out: 40116600
+  - name: Random 3
+    in:
+      m: 17
+      n: 17
+    out: 601080390
+  - name: Gen 1
+    in:
+      m: 18
+      n: 17
+    out: 1166803110
+  - name: Gen 2
+    in:
+      m: 17
+      n: 18
+    out: 1166803110
+  - name: Large bound 1
+    in:
+      m: 12
+      n: 13
+    out: 1352078
+  - name: Large bound 2
+    in:
+      m: 10
+      n: 10
+    out: 48620
diff --git a/tests/1-500/63. unique-paths-ii/manifest.yaml b/tests/1-500/63. unique-paths-ii/manifest.yaml
index 1c25cfa3..66111758 100644
--- a/tests/1-500/63. unique-paths-ii/manifest.yaml	
+++ b/tests/1-500/63. unique-paths-ii/manifest.yaml	
@@ -2,18 +2,25 @@
   "id": 63
   "title": "unique-paths-ii"
   "call":
-    "cpp": "Solution().uniquePathsWithObstacles(lv(vector<vector<int>>{ {grid} }))"
-    "rust": "Solution::unique_paths_with_obstacles(vec![{grid}])"
-    "python3": "Solution().uniquePathsWithObstacles([{grid}])"
-    "python2": "Solution().uniquePathsWithObstacles([{grid}])"
-    "ruby": "unique_paths_with_obstacles([{grid}])"
-    "java": "new Solution().uniquePathsWithObstacles(new int[][]{ {grid} })"
-    "csharp": "new Solution().UniquePathsWithObstacles(new int[][]{ {grid} })"
-    "kotlin": "Solution().uniquePathsWithObstacles(arrayOf({grid}))"
-    "go": "uniquePathsWithObstacles([][]int{ {grid} })"
-    "dart": "Solution().uniquePathsWithObstacles([{grid}])"
-    "swift": "Solution().uniquePathsWithObstacles([{grid}])"
-    "typescript": "uniquePathsWithObstacles([{grid}])"
+    "cpp": "Solution().uniquePathsWithObstacles({grid})"
+    "rust": "Solution::unique_paths_with_obstacles({grid})"
+    "python3": "Solution().uniquePathsWithObstacles({grid})"
+    "python2": "Solution().uniquePathsWithObstacles({grid})"
+    "ruby": "unique_paths_with_obstacles({grid})"
+    "java": "new Solution().uniquePathsWithObstacles({grid})"
+    "csharp": "new Solution().UniquePathsWithObstacles({grid})"
+    "kotlin": "Solution().uniquePathsWithObstacles({grid})"
+    "go": "uniquePathsWithObstacles({grid})"
+    "dart": "Solution().uniquePathsWithObstacles({grid})"
+    "swift": "Solution().uniquePathsWithObstacles({grid})"
+    "typescript": "uniquePathsWithObstacles({grid})"
+  params:
+    grid:
+      type: array
+      items:
+        type: array
+        items:
+          type: int
 "judge":
   "type": "exact"
 "limits":
@@ -21,17 +28,14 @@
   "memory_mb": 256
 "oracle":
   "python3":
-    "call": "Checker().uniquePathsWithObstacles([{grid}], {result})"
+    "call": "Checker().uniquePathsWithObstacles({grid}, {result})"
     "checker":
-      "import json\nclass Checker:\n    def uniquePathsWithObstacles(self,\
-      \ grid, result):\n        try:\n            result = json.loads(result) if isinstance(result,\
-      \ str) else result\n        except Exception:\n            return False\n  \
-      \      m, n = len(grid), len(grid[0])\n        dp = [[0] * n for _ in range(m)]\n\
-      \        if grid[0][0] == 1: return result == 0\n        dp[0][0] = 1\n    \
-      \    for i in range(m):\n            for j in range(n):\n                if\
-      \ grid[i][j] == 1: dp[i][j] = 0\n                else:\n                   \
-      \ if i > 0: dp[i][j] += dp[i-1][j]\n                    if j > 0: dp[i][j] +=\
-      \ dp[i][j-1]\n        return result == dp[m-1][n-1]\n"
+      "import json\nclass Checker:\n    def uniquePathsWithObstacles(self, grid, result):\n        try:\n       \
+      \     result = json.loads(result) if isinstance(result, str) else result\n        except Exception:\n            return
+      False\n        m, n = len(grid), len(grid[0])\n        dp = [[0] * n for _ in range(m)]\n        if grid[0][0] == 1:
+      return result == 0\n        dp[0][0] = 1\n        for i in range(m):\n            for j in range(n):\n             \
+      \   if grid[i][j] == 1: dp[i][j] = 0\n                else:\n                    if i > 0: dp[i][j] += dp[i-1][j]\n\
+      \                    if j > 0: dp[i][j] += dp[i][j-1]\n        return result == dp[m-1][n-1]\n"
 "seed": 42
 "tests":
   - "name": "example 1"
diff --git a/tests/1-500/64. minimum-path-sum/manifest.yaml b/tests/1-500/64. minimum-path-sum/manifest.yaml
index a4ac9685..55516f90 100644
--- a/tests/1-500/64. minimum-path-sum/manifest.yaml	
+++ b/tests/1-500/64. minimum-path-sum/manifest.yaml	
@@ -2,18 +2,25 @@
   "id": 64
   "title": "minimum-path-sum"
   "call":
-    "cpp": "Solution().minPathSum(lv(vector<vector<int>>{ {grid} }))"
-    "rust": "Solution::min_path_sum(vec![{grid}])"
-    "python3": "Solution().minPathSum([{grid}])"
-    "python2": "Solution().minPathSum([{grid}])"
-    "ruby": "min_path_sum([{grid}])"
-    "java": "new Solution().minPathSum(new int[][]{ {grid} })"
-    "csharp": "new Solution().MinPathSum(new int[][]{ {grid} })"
-    "kotlin": "Solution().minPathSum(arrayOf({grid}))"
-    "go": "minPathSum([][]int{ {grid} })"
-    "dart": "Solution().minPathSum([{grid}])"
-    "swift": "Solution().minPathSum([{grid}])"
-    "typescript": "minPathSum([{grid}])"
+    "cpp": "Solution().minPathSum({grid})"
+    "rust": "Solution::min_path_sum({grid})"
+    "python3": "Solution().minPathSum({grid})"
+    "python2": "Solution().minPathSum({grid})"
+    "ruby": "min_path_sum({grid})"
+    "java": "new Solution().minPathSum({grid})"
+    "csharp": "new Solution().MinPathSum({grid})"
+    "kotlin": "Solution().minPathSum({grid})"
+    "go": "minPathSum({grid})"
+    "dart": "Solution().minPathSum({grid})"
+    "swift": "Solution().minPathSum({grid})"
+    "typescript": "minPathSum({grid})"
+  params:
+    grid:
+      type: array
+      items:
+        type: array
+        items:
+          type: int
 "judge":
   "type": "exact"
 "limits":
@@ -21,16 +28,13 @@
   "memory_mb": 256
 "oracle":
   "python3":
-    "call": "Checker().minPathSum([{grid}], {result})"
+    "call": "Checker().minPathSum({grid}, {result})"
     "checker":
-      "import json\nclass Checker:\n    def minPathSum(self, grid, result):\n\
-      \        try:\n            result = json.loads(result) if isinstance(result,\
-      \ str) else result\n        except Exception:\n            return False\n  \
-      \      m, n = len(grid), len(grid[0])\n        dp = [[0] * n for _ in range(m)]\n\
-      \        dp[0][0] = grid[0][0]\n        for i in range(1, m): dp[i][0] = dp[i\
-      \ - 1][0] + grid[i][0]\n        for j in range(1, n): dp[0][j] = dp[0][j - 1]\
-      \ + grid[0][j]\n        for i in range(1, m):\n            for j in range(1,\
-      \ n):\n                dp[i][j] = min(dp[i - 1][j], dp[i][j - 1]) + grid[i][j]\n\
+      "import json\nclass Checker:\n    def minPathSum(self, grid, result):\n        try:\n            result = json.loads(result)
+      if isinstance(result, str) else result\n        except Exception:\n            return False\n        m, n = len(grid),
+      len(grid[0])\n        dp = [[0] * n for _ in range(m)]\n        dp[0][0] = grid[0][0]\n        for i in range(1, m):
+      dp[i][0] = dp[i - 1][0] + grid[i][0]\n        for j in range(1, n): dp[0][j] = dp[0][j - 1] + grid[0][j]\n        for
+      i in range(1, m):\n            for j in range(1, n):\n                dp[i][j] = min(dp[i - 1][j], dp[i][j - 1]) + grid[i][j]\n\
       \        return dp[m - 1][n - 1] == result\n"
 "seed": 42
 "tests":
diff --git a/tests/1-500/65. valid-number/manifest.yaml b/tests/1-500/65. valid-number/manifest.yaml
index 40e25deb..7e00b6f0 100644
--- a/tests/1-500/65. valid-number/manifest.yaml	
+++ b/tests/1-500/65. valid-number/manifest.yaml	
@@ -1,161 +1,160 @@
-"entry":
-  "id": 65
-  "title": "valid-number"
-  "call":
-    "cpp": 'Solution().isNumber("{s}")'
-    "rust": 'Solution::is_number("{s}".to_string())'
-    "python3": 'Solution().isNumber("{s}")'
-    "python2": 'Solution().isNumber("{s}")'
-    "ruby": 'is_number("{s}")'
-    "java": 'new Solution().isNumber("{s}")'
-    "csharp": 'new Solution().IsNumber("{s}")'
-    "kotlin": 'Solution().isNumber("{s}")'
-    "go": 'isNumber("{s}")'
-    "dart": 'Solution().isNumber("{s}")'
-    "swift": 'Solution().isNumber("{s}")'
-    "typescript": 'isNumber("{s}")'
-"judge":
-  "type": "exact"
-"limits":
-  "time_ms": 1000
-  "memory_mb": 256
-"oracle":
-  "python3":
-    "call": 'Checker().isNumber("{s}", {result})'
-    "checker":
-      "class Checker:\n    def isNumber(self, s, result):\n        def check(str_val):\n\
-      \            try:\n                if any(c in str_val for c in ['e', 'E']):\n\
-      \                    parts = str_val.replace('E', 'e').split('e')\n        \
-      \            if len(parts) != 2: return False\n                    return self._is_dec(parts[0])\
-      \ and self._is_int(parts[1])\n                return self._is_dec(str_val)\n\
-      \            except: return False\n        return result == check(s)\n    def\
-      \ _is_int(self, s):\n        if not s: return False\n        if s[0] in ['+',\
-      \ '-']: s = s[1:]\n        return s.isdigit()\n    def _is_dec(self, s):\n \
-      \       if not s: return False\n        if s[0] in ['+', '-']: s = s[1:]\n \
-      \       if '.' not in s: return s.isdigit()\n        parts = s.split('.')\n\
-      \        if len(parts) != 2: return False\n        l, r = parts[0], parts[1]\n\
-      \        if not l and not r: return False\n        if l and not l.isdigit():\
-      \ return False\n        if r and not r.isdigit(): return False\n        return\
-      \ True\n"
-"seed": 42
-"tests":
-  - "name": "ex1"
-    "in":
-      "s": "0"
-    "out": true
-  - "name": "ex2"
-    "in":
-      "s": "e"
-    "out": false
-  - "name": "ex3"
-    "in":
-      "s": "."
-    "out": false
-  - "name": "plus_sign"
-    "in":
-      "s": "+3.14"
-    "out": true
-  - "name": "minus_decimal"
-    "in":
-      "s": "-0.1"
-    "out": true
-  - "name": "dot_trailing"
-    "in":
-      "s": "4."
-    "out": true
-  - "name": "dot_leading"
-    "in":
-      "s": "-.9"
-    "out": true
-  - "name": "exponent_simple"
-    "in":
-      "s": "2e10"
-    "out": true
-  - "name": "exponent_upper"
-    "in":
-      "s": "-90E3"
-    "out": true
-  - "name": "exponent_plus"
-    "in":
-      "s": "3e+7"
-    "out": true
-  - "name": "complex_case"
-    "in":
-      "s": "-123.456e789"
-    "out": true
-  - "name": "invalid_alpha"
-    "in":
-      "s": "abc"
-    "out": false
-  - "name": "invalid_mix"
-    "in":
-      "s": "1a"
-    "out": false
-  - "name": "invalid_e"
-    "in":
-      "s": "1e"
-    "out": false
-  - "name": "invalid_start"
-    "in":
-      "s": "e3"
-    "out": false
-  - "name": "invalid_dot_exp"
-    "in":
-      "s": "99e2.5"
-    "out": false
-  - "name": "invalid_double_sign"
-    "in":
-      "s": "--6"
-    "out": false
-  - "name": "invalid_sign_mix"
-    "in":
-      "s": "-+3"
-    "out": false
-  - "name": "invalid_pos"
-    "in":
-      "s": "95a54e53"
-    "out": false
-  - "name": "double_dot"
-    "in":
-      "s": "1.2.3"
-    "out": false
-  - "name": "double_e"
-    "in":
-      "s": "1e2e3"
-    "out": false
-  - "name": "plus_e"
-    "in":
-      "s": "1e+5"
-    "out": true
-  - "name": "min_len"
-    "in":
-      "s": "1"
-    "out": true
-  - "name": "zero_start"
-    "in":
-      "s": "0089"
-    "out": true
-  - "name": "just_dot_sign"
-    "in":
-      "s": "+."
-    "out": false
-  - "name": "sign_after_e"
-    "in":
-      "s": "1e-5"
-    "out": true
-  - "name": "sign_invalid_pos"
-    "in":
-      "s": "1+2"
-    "out": false
-  - "name": "e_then_dot"
-    "in":
-      "s": "1e.5"
-    "out": false
-  - "name": "dot_then_e"
-    "in":
-      "s": "1.e5"
-    "out": true
-  - "name": "large_int"
-    "in":
-      "s": "1234567890"
-    "out": true
+entry:
+  id: 65
+  title: valid-number
+  call:
+    cpp: Solution().isNumber({s})
+    rust: Solution::is_number({s})
+    python3: Solution().isNumber({s})
+    python2: Solution().isNumber({s})
+    ruby: is_number({s})
+    java: new Solution().isNumber({s})
+    csharp: new Solution().IsNumber({s})
+    kotlin: Solution().isNumber({s})
+    go: isNumber({s})
+    dart: Solution().isNumber({s})
+    swift: Solution().isNumber({s})
+    typescript: isNumber({s})
+  params:
+    s:
+      type: string
+judge:
+  type: exact
+limits:
+  time_ms: 1000
+  memory_mb: 256
+oracle:
+  python3:
+    call: isNumber(s, {result})
+    checker:
+      "def isNumber(s, result): def check(str_val): try: if any(c in str_val\
+      \ for c in ['e', 'E']): parts = str_val.replace('E', 'e').split('e') if len(parts)\
+      \ != 2: return False return _is_dec(parts[0]) and _is_int(parts[1]) return _is_dec(str_val)\
+      \ except Exception: return False return result == check(s)\ndef _is_int(s):\
+      \ if not s: return False if s[0] in ['+', '-']: s = s[1:] return s.isdigit()\n\
+      def _is_dec(s): if not s: return False if s[0] in ['+', '-']: s = s[1:] if '.'\
+      \ not in s: return s.isdigit() parts = s.split('.') if len(parts) != 2: return\
+      \ False l, r = parts[0], parts[1] if not l and not r: return False if l and\
+      \ not l.isdigit(): return False if r and not r.isdigit(): return False return\
+      \ True "
+seed: 42
+tests:
+  - name: ex1
+    in:
+      s: "0"
+    out: true
+  - name: ex2
+    in:
+      s: e
+    out: false
+  - name: ex3
+    in:
+      s: .
+    out: false
+  - name: plus_sign
+    in:
+      s: "+3.14"
+    out: true
+  - name: minus_decimal
+    in:
+      s: "-0.1"
+    out: true
+  - name: dot_trailing
+    in:
+      s: "4."
+    out: true
+  - name: dot_leading
+    in:
+      s: -.9
+    out: true
+  - name: exponent_simple
+    in:
+      s: 2e10
+    out: true
+  - name: exponent_upper
+    in:
+      s: -90E3
+    out: true
+  - name: exponent_plus
+    in:
+      s: 3e+7
+    out: true
+  - name: complex_case
+    in:
+      s: -123.456e789
+    out: true
+  - name: invalid_alpha
+    in:
+      s: abc
+    out: false
+  - name: invalid_mix
+    in:
+      s: 1a
+    out: false
+  - name: invalid_e
+    in:
+      s: 1e
+    out: false
+  - name: invalid_start
+    in:
+      s: e3
+    out: false
+  - name: invalid_dot_exp
+    in:
+      s: 99e2.5
+    out: false
+  - name: invalid_double_sign
+    in:
+      s: --6
+    out: false
+  - name: invalid_sign_mix
+    in:
+      s: -+3
+    out: false
+  - name: invalid_pos
+    in:
+      s: 95a54e53
+    out: false
+  - name: double_dot
+    in:
+      s: 1.2.3
+    out: false
+  - name: double_e
+    in:
+      s: 1e2e3
+    out: false
+  - name: plus_e
+    in:
+      s: 1e+5
+    out: true
+  - name: min_len
+    in:
+      s: "1"
+    out: true
+  - name: zero_start
+    in:
+      s: 0089
+    out: true
+  - name: just_dot_sign
+    in:
+      s: +.
+    out: false
+  - name: sign_after_e
+    in:
+      s: 1e-5
+    out: true
+  - name: sign_invalid_pos
+    in:
+      s: 1+2
+    out: false
+  - name: e_then_dot
+    in:
+      s: 1e.5
+    out: false
+  - name: dot_then_e
+    in:
+      s: 1.e5
+    out: true
+  - name: large_int
+    in:
+      s: "1234567890"
+    out: true
diff --git a/tests/1-500/66. plus-one/manifest.yaml b/tests/1-500/66. plus-one/manifest.yaml
index d6d514a9..33a09034 100644
--- a/tests/1-500/66. plus-one/manifest.yaml	
+++ b/tests/1-500/66. plus-one/manifest.yaml	
@@ -2,18 +2,23 @@
   "id": 66
   "title": "plus-one"
   "call":
-    "cpp": "Solution().plusOne(lv(vector<int>{ {digits} }))"
-    "rust": "Solution::plus_one(vec![{digits}])"
-    "python3": "Solution().plusOne([{digits}])"
-    "python2": "Solution().plusOne([{digits}])"
-    "ruby": "plus_one([{digits}])"
-    "java": "new Solution().plusOne(new int[]{ {digits} })"
-    "csharp": "new Solution().PlusOne(new int[]{ {digits} })"
-    "kotlin": "Solution().plusOne(intArrayOf({digits}))"
-    "go": "plusOne([]int{ {digits} })"
-    "dart": "Solution().plusOne([{digits}])"
-    "swift": "Solution().plusOne([{digits}])"
-    "typescript": "plusOne([{digits}])"
+    "cpp": "Solution().plusOne({digits})"
+    "rust": "Solution::plus_one({digits})"
+    "python3": "Solution().plusOne({digits})"
+    "python2": "Solution().plusOne({digits})"
+    "ruby": "plus_one({digits})"
+    "java": "new Solution().plusOne({digits})"
+    "csharp": "new Solution().PlusOne({digits})"
+    "kotlin": "Solution().plusOne({digits})"
+    "go": "plusOne({digits})"
+    "dart": "Solution().plusOne({digits})"
+    "swift": "Solution().plusOne({digits})"
+    "typescript": "plusOne({digits})"
+  params:
+    digits:
+      type: array
+      items:
+        type: int
 "judge":
   "type": "exact"
 "limits":
@@ -21,13 +26,11 @@
   "memory_mb": 256
 "oracle":
   "python3":
-    "call": "Checker().plusOne([{digits}], {result})"
+    "call": "Checker().plusOne({digits}, {result})"
     "checker":
-      "import json\nclass Checker:\n    def plusOne(self, digits, result):\n\
-      \        try:\n            result = json.loads(result) if isinstance(result,\
-      \ str) else result\n        except Exception:\n            return False\n  \
-      \      expected = int(\"\".join(map(str, digits))) + 1\n        return result\
-      \ == [int(d) for d in str(expected)]\n"
+      "import json\nclass Checker:\n    def plusOne(self, digits, result):\n        try:\n            result = json.loads(result)
+      if isinstance(result, str) else result\n        except Exception:\n            return False\n        expected = int(\"\
+      \".join(map(str, digits))) + 1\n        return result == [int(d) for d in str(expected)]\n"
 "seed": 42
 "tests":
   - "name": "example 1"
diff --git a/tests/1-500/67. add-binary/manifest.yaml b/tests/1-500/67. add-binary/manifest.yaml
index 97c641f4..bdadcccc 100644
--- a/tests/1-500/67. add-binary/manifest.yaml	
+++ b/tests/1-500/67. add-binary/manifest.yaml	
@@ -1,140 +1,143 @@
-"entry":
-  "id": 67
-  "title": "add-binary"
-  "call":
-    "cpp": 'Solution().addBinary("{a}", "{b}")'
-    "rust": 'Solution::add_binary("{a}".to_string(), "{b}".to_string())'
-    "python3": 'Solution().addBinary("{a}", "{b}")'
-    "python2": 'Solution().addBinary("{a}", "{b}")'
-    "ruby": 'add_binary("{a}", "{b}")'
-    "java": 'new Solution().addBinary("{a}", "{b}")'
-    "csharp": 'new Solution().AddBinary("{a}", "{b}")'
-    "kotlin": 'Solution().addBinary("{a}", "{b}")'
-    "go": 'addBinary("{a}", "{b}")'
-    "dart": 'Solution().addBinary("{a}", "{b}")'
-    "swift": 'Solution().addBinary("{a}", "{b}")'
-    "typescript": 'addBinary("{a}", "{b}")'
-"judge":
-  "type": "exact"
-"limits":
-  "time_ms": 1000
-  "memory_mb": 256
-"oracle":
-  "python3":
-    "call": 'Checker().addBinary("{a}", "{b}", {result})'
-    "checker":
-      "import json\nclass Checker:\n    def addBinary(self, a, b, result):\n\
-      \        try:\n            result = json.loads(result) if isinstance(result,\
-      \ str) else result\n        except Exception:\n            return False\n  \
-      \      return bin(int(a, 2) + int(b, 2))[2:] == result\n"
-"seed": 42
-"tests":
-  - "name": "example 1"
-    "in":
-      "a": "11"
-      "b": "1"
-  - "name": "example 2"
-    "in":
-      "a": "1010"
-      "b": "1011"
-  - "name": "minimal"
-    "in":
-      "a": "0"
-      "b": "0"
-  - "name": "single digit 1"
-    "in":
-      "a": "1"
-      "b": "0"
-  - "name": "single digit 2"
-    "in":
-      "a": "1"
-      "b": "1"
-  - "name": "carry propagation"
-    "in":
-      "a": "111"
-      "b": "1"
-  - "name": "unequal lengths"
-    "in":
-      "a": "100"
-      "b": "11011"
-  - "name": "all ones"
-    "in":
-      "a": "111"
-      "b": "111"
-  - "name": "power of two 1"
-    "in":
-      "a": "1000"
-      "b": "1"
-  - "name": "power of two 2"
-    "in":
-      "a": "1000"
-      "b": "1000"
-  - "name": "mixed zeros"
-    "in":
-      "a": "10101"
-      "b": "0"
-  - "name": "trailing zeros"
-    "in":
-      "a": "1100"
-      "b": "10"
-  - "name": "massive carry"
-    "in":
-      "a": "1111111111"
-      "b": "1"
-  - "name": "large mixed"
-    "in":
-      "a": "101010101"
-      "b": "1010101"
-  - "name": "pattern 1"
-    "in":
-      "a": "101"
-      "b": "101"
-  - "name": "pattern 2"
-    "in":
-      "a": "110"
-      "b": "110"
-  - "name": "length 10 shift"
-    "in":
-      "a": "1000000000"
-      "b": "1"
-  - "name": "boundary 1"
-    "in":
-      "a": "1101"
-      "b": "1000"
-  - "name": "boundary 2"
-    "in":
-      "a": "10111"
-      "b": "111"
-  - "name": "boundary 3"
-    "in":
-      "a": "1"
-      "b": "11111"
-  - "name": "generated 1"
-    "in":
-      "a": "10110"
-      "b": "11011"
-  - "name": "generated 2"
-    "in":
-      "a": "111011"
-      "b": "101"
-  - "name": "generated 3"
-    "in":
-      "a": "1101010111"
-      "b": "1110110"
-  - "name": "large test 5k"
-    "in":
-      "a":
-        "gen": "str"
-        "len": 5000
-        "alphabet": "1"
-      "b":
-        "gen": "str"
-        "len": 5000
-        "alphabet": "1"
-  - "name": "large test 10k"
-    "in":
-      "a":
-        "gen": "str"
-        "len": 10000
-        "alphabet": "1"
-      "b": "0"
+entry:
+  id: 67
+  title: add-binary
+  call:
+    cpp: Solution().addBinary({a}, {b})
+    rust: Solution::add_binary({a}, {b})
+    python3: Solution().addBinary({a}, {b})
+    python2: Solution().addBinary({a}, {b})
+    ruby: add_binary({a}, {b})
+    java: new Solution().addBinary({a}, {b})
+    csharp: new Solution().AddBinary({a}, {b})
+    kotlin: Solution().addBinary({a}, {b})
+    go: addBinary({a}, {b})
+    dart: Solution().addBinary({a}, {b})
+    swift: Solution().addBinary({a}, {b})
+    typescript: addBinary({a}, {b})
+  params:
+    a:
+      type: string
+    b:
+      type: string
+judge:
+  type: exact
+limits:
+  time_ms: 1000
+  memory_mb: 256
+oracle:
+  python3:
+    call: addBinary(a, b, {result})
+    checker: |
+      def addBinary(a, b, result):
+          return bin(int(a, 2) + int(b, 2))[2:] == result
+seed: 42
+tests:
+  - name: example 1
+    in:
+      a: "11"
+      b: "1"
+  - name: example 2
+    in:
+      a: "1010"
+      b: "1011"
+  - name: minimal
+    in:
+      a: "0"
+      b: "0"
+  - name: single digit 1
+    in:
+      a: "1"
+      b: "0"
+  - name: single digit 2
+    in:
+      a: "1"
+      b: "1"
+  - name: carry propagation
+    in:
+      a: "111"
+      b: "1"
+  - name: unequal lengths
+    in:
+      a: "100"
+      b: "11011"
+  - name: all ones
+    in:
+      a: "111"
+      b: "111"
+  - name: power of two 1
+    in:
+      a: "1000"
+      b: "1"
+  - name: power of two 2
+    in:
+      a: "1000"
+      b: "1000"
+  - name: mixed zeros
+    in:
+      a: "10101"
+      b: "0"
+  - name: trailing zeros
+    in:
+      a: "1100"
+      b: "10"
+  - name: massive carry
+    in:
+      a: "1111111111"
+      b: "1"
+  - name: large mixed
+    in:
+      a: "101010101"
+      b: "1010101"
+  - name: pattern 1
+    in:
+      a: "101"
+      b: "101"
+  - name: pattern 2
+    in:
+      a: "110"
+      b: "110"
+  - name: length 10 shift
+    in:
+      a: "1000000000"
+      b: "1"
+  - name: boundary 1
+    in:
+      a: "1101"
+      b: "1000"
+  - name: boundary 2
+    in:
+      a: "10111"
+      b: "111"
+  - name: boundary 3
+    in:
+      a: "1"
+      b: "11111"
+  - name: generated 1
+    in:
+      a: "10110"
+      b: "11011"
+  - name: generated 2
+    in:
+      a: "111011"
+      b: "101"
+  - name: generated 3
+    in:
+      a: "1101010111"
+      b: "1110110"
+  - name: large test 5k
+    in:
+      a:
+        gen: str
+        len: 5000
+        alphabet: "1"
+      b:
+        gen: str
+        len: 5000
+        alphabet: "1"
+  - name: large test 10k
+    in:
+      a:
+        gen: str
+        len: 10000
+        alphabet: "1"
+      b: "0"
diff --git a/tests/1-500/68. text-justification/manifest.yaml b/tests/1-500/68. text-justification/manifest.yaml
index 6c2a4ade..3c097ca3 100644
--- a/tests/1-500/68. text-justification/manifest.yaml	
+++ b/tests/1-500/68. text-justification/manifest.yaml	
@@ -2,18 +2,25 @@
   "id": 68
   "title": "text-justification"
   "call":
-    "cpp": "Solution().fullJustify(words, maxWidth)"
-    "rust": "Solution::full_justify(words, maxWidth)"
-    "python3": "fullJustify([{words}], {maxWidth})"
-    "python2": "fullJustify([{words}], {maxWidth})"
-    "ruby": "full_justify(words, maxWidth)"
-    "java": "new Solution().fullJustify(words, maxWidth)"
-    "csharp": "new Solution().FullJustify(words, maxWidth)"
-    "kotlin": "Solution().fullJustify(words, maxWidth)"
-    "go": "fullJustify(words, maxWidth)"
-    "dart": "Solution().fullJustify(words, maxWidth)"
-    "swift": "Solution().fullJustify(words, maxWidth)"
-    "typescript": "fullJustify(words, maxWidth)"
+    "cpp": "Solution().fullJustify({words}, {maxWidth})"
+    "rust": "Solution::full_justify({words}, {maxWidth})"
+    "python3": "fullJustify({words}, {maxWidth})"
+    "python2": "fullJustify({words}, {maxWidth})"
+    "ruby": "full_justify({words}, {maxWidth})"
+    "java": "new Solution().fullJustify({words}, {maxWidth})"
+    "csharp": "new Solution().FullJustify({words}, {maxWidth})"
+    "kotlin": "Solution().fullJustify({words}, {maxWidth})"
+    "go": "fullJustify({words}, {maxWidth})"
+    "dart": "Solution().fullJustify({words}, {maxWidth})"
+    "swift": "Solution().fullJustify({words}, {maxWidth})"
+    "typescript": "fullJustify({words}, {maxWidth})"
+  params:
+    words:
+      type: array
+      items:
+        type: string
+    maxWidth:
+      type: int
 "judge":
   "type": "exact"
 "limits":
@@ -23,24 +30,18 @@
   "python3":
     "call": "Checker().fullJustify(words, maxWidth, {result})"
     "checker":
-      "class Checker:\n    def fullJustify(self, words, maxWidth, result):\n\
-      \        def solve(words, maxWidth):\n            res = []\n            i =\
-      \ 0\n            n = len(words)\n            while i < n:\n                j\
-      \ = i\n                line_len = 0\n                while j < n and line_len\
-      \ + len(words[j]) + (j - i) <= maxWidth:\n                    line_len += len(words[j])\n\
-      \                    j += 1\n                space_count = maxWidth - line_len\n\
-      \                gaps = j - i - 1\n                line = ''\n             \
-      \   if j == n or gaps == 0:\n                    for k in range(i, j):\n   \
-      \                     line += words[k] + (' ' if k != j - 1 else '')\n     \
-      \               line += ' ' * (maxWidth - len(line))\n                else:\n\
-      \                    space_each = space_count // gaps\n                    extra\
-      \ = space_count % gaps\n                    for k in range(i, j):\n        \
-      \                line += words[k]\n                        if k != j - 1:\n\
-      \                            to_add = space_each + (1 if extra > 0 else 0)\n\
-      \                            line += ' ' * to_add\n                        \
-      \    if extra > 0:\n                                extra -= 1\n           \
-      \     res.append(line)\n                i = j\n            return res\n    \
-      \    return solve(words, maxWidth) == result\n"
+      "class Checker:\n    def fullJustify(self, words, maxWidth, result):\n        def solve(words, maxWidth):\n\
+      \            res = []\n            i = 0\n            n = len(words)\n            while i < n:\n                j =
+      i\n                line_len = 0\n                while j < n and line_len + len(words[j]) + (j - i) <= maxWidth:\n \
+      \                   line_len += len(words[j])\n                    j += 1\n                space_count = maxWidth -
+      line_len\n                gaps = j - i - 1\n                line = ''\n                if j == n or gaps == 0:\n   \
+      \                 for k in range(i, j):\n                        line += words[k] + (' ' if k != j - 1 else '')\n  \
+      \                  line += ' ' * (maxWidth - len(line))\n                else:\n                    space_each = space_count
+      // gaps\n                    extra = space_count % gaps\n                    for k in range(i, j):\n               \
+      \         line += words[k]\n                        if k != j - 1:\n                            to_add = space_each
+      + (1 if extra > 0 else 0)\n                            line += ' ' * to_add\n                            if extra >
+      0:\n                                extra -= 1\n                res.append(line)\n                i = j\n          \
+      \  return res\n        return solve(words, maxWidth) == result\n"
 "seed": 42
 "tests":
   - "name": "example 1"
diff --git a/tests/1-500/69. sqrtx/manifest.yaml b/tests/1-500/69. sqrtx/manifest.yaml
index 51c2c9e1..9a162e7a 100644
--- a/tests/1-500/69. sqrtx/manifest.yaml	
+++ b/tests/1-500/69. sqrtx/manifest.yaml	
@@ -1,154 +1,166 @@
-"entry":
-  "id": 69
-  "title": "sqrtx"
-  "call":
-    "cpp": "Solution().mySqrt({x})"
-    "rust": "Solution::my_sqrt({x})"
-    "python3": "Solution().mySqrt({x})"
-    "python2": "Solution().mySqrt({x})"
-    "ruby": "my_sqrt({x})"
-    "java": "new Solution().mySqrt({x})"
-    "csharp": "new Solution().MySqrt({x})"
-    "kotlin": "Solution().mySqrt({x})"
-    "go": "mySqrt({x})"
-    "dart": "Solution().mySqrt({x})"
-    "swift": "Solution().mySqrt({x})"
-    "typescript": "mySqrt({x})"
-"judge":
-  "type": "exact"
-"limits":
-  "time_ms": 1000
-  "memory_mb": 256
-"oracle":
-  "python3":
-    "call": "Checker().mySqrt({x}, {result})"
-    "checker":
-      "import json\nclass Checker:\n    def mySqrt(self, x, result):\n  \
-      \      try:\n            result = json.loads(result) if isinstance(result, str)\
-      \ else result\n        except Exception:\n            return False\n       \
-      \ if result < 0: return False\n        if result * result > x: return False\n\
-      \        if (result + 1) * (result + 1) <= x: return False\n        return True\n"
-"seed": 42
-"tests":
-  - "name": "Zero"
-    "in":
-      "x": 0
-    "out": 0
-  - "name": "One"
-    "in":
-      "x": 1
-    "out": 1
-  - "name": "Two"
-    "in":
-      "x": 2
-    "out": 1
-  - "name": "Three"
-    "in":
-      "x": 3
-    "out": 1
-  - "name": "Four"
-    "in":
-      "x": 4
-    "out": 2
-  - "name": "Eight"
-    "in":
-      "x": 8
-    "out": 2
-  - "name": "Nine"
-    "in":
-      "x": 9
-    "out": 3
-  - "name": "Fifteen"
-    "in":
-      "x": 15
-    "out": 3
-  - "name": "Sixteen"
-    "in":
-      "x": 16
-    "out": 4
-  - "name": "Twenty-four"
-    "in":
-      "x": 24
-    "out": 4
-  - "name": "Twenty-five"
-    "in":
-      "x": 25
-    "out": 5
-  - "name": "Large 100"
-    "in":
-      "x": 100
-    "out": 10
-  - "name": "Large 1000"
-    "in":
-      "x": 1000
-    "out": 31
-  - "name": "Large 9999"
-    "in":
-      "x": 9999
-    "out": 99
-  - "name": "Large 65535"
-    "in":
-      "x": 65535
-    "out": 255
-  - "name": "Near Int Max"
-    "in":
-      "x": 2147395600
-    "out": 46340
-  - "name": "Int Max"
-    "in":
-      "x": 2147483647
-    "out": 46340
-  - "name": "Random 1"
-    "in":
-      "x":
-        "gen": "int"
-        "min": 100
-        "max": 1000
-  - "name": "Random 2"
-    "in":
-      "x":
-        "gen": "int"
-        "min": 10000
-        "max": 50000
-  - "name": "Random 3"
-    "in":
-      "x":
-        "gen": "int"
-        "min": 1000000
-        "max": 5000000
-  - "name": "Random 4"
-    "in":
-      "x":
-        "gen": "int"
-        "min": 100000000
-        "max": 500000000
-  - "name": "Random 5"
-    "in":
-      "x":
-        "gen": "int"
-        "min": 1000000000
-        "max": 2147483646
-  - "name": "Sparse boundary 1"
-    "in":
-      "x": 35
-    "out": 5
-  - "name": "Sparse boundary 2"
-    "in":
-      "x": 48
-    "out": 6
-  - "name": "Perfect square near limit"
-    "in":
-      "x": 2147395600
-    "out": 46340
-  - "name": "Perfect square plus one"
-    "in":
-      "x": 2147395601
-    "out": 46340
-  - "name": "Random boundary 1"
-    "in":
-      "x": 999999
-    "out": 999
-  - "name": "Random boundary 2"
-    "in":
-      "x": 1000000
-    "out": 1000
+entry:
+  id: 69
+  title: sqrtx
+  call:
+    cpp: Solution().mySqrt({x})
+    rust: Solution::my_sqrt({x})
+    python3: Solution().mySqrt({x})
+    python2: Solution().mySqrt({x})
+    ruby: my_sqrt({x})
+    java: new Solution().mySqrt({x})
+    csharp: new Solution().MySqrt({x})
+    kotlin: Solution().mySqrt({x})
+    go: mySqrt({x})
+    dart: Solution().mySqrt({x})
+    swift: Solution().mySqrt({x})
+    typescript: mySqrt({x})
+  params:
+    x:
+      type: int
+judge:
+  type: exact
+limits:
+  time_ms: 1000
+  memory_mb: 256
+oracle:
+  python3:
+    call: mySqrt(x, {result})
+    checker: |
+      import json
+
+      def mySqrt(x, result):
+          try:
+              result = json.loads(result) if isinstance(result, str) else result
+          except Exception:
+              return False
+          if result < 0:
+              return False
+          if result * result > x:
+              return False
+          if (result + 1) * (result + 1) <= x:
+              return False
+          return True
+seed: 42
+tests:
+  - name: Zero
+    in:
+      x: 0
+    out: 0
+  - name: One
+    in:
+      x: 1
+    out: 1
+  - name: Two
+    in:
+      x: 2
+    out: 1
+  - name: Three
+    in:
+      x: 3
+    out: 1
+  - name: Four
+    in:
+      x: 4
+    out: 2
+  - name: Eight
+    in:
+      x: 8
+    out: 2
+  - name: Nine
+    in:
+      x: 9
+    out: 3
+  - name: Fifteen
+    in:
+      x: 15
+    out: 3
+  - name: Sixteen
+    in:
+      x: 16
+    out: 4
+  - name: Twenty-four
+    in:
+      x: 24
+    out: 4
+  - name: Twenty-five
+    in:
+      x: 25
+    out: 5
+  - name: Large 100
+    in:
+      x: 100
+    out: 10
+  - name: Large 1000
+    in:
+      x: 1000
+    out: 31
+  - name: Large 9999
+    in:
+      x: 9999
+    out: 99
+  - name: Large 65535
+    in:
+      x: 65535
+    out: 255
+  - name: Near Int Max
+    in:
+      x: 2147395600
+    out: 46340
+  - name: Int Max
+    in:
+      x: 2147483647
+    out: 46340
+  - name: Random 1
+    in:
+      x:
+        gen: int
+        min: 100
+        max: 1000
+  - name: Random 2
+    in:
+      x:
+        gen: int
+        min: 10000
+        max: 50000
+  - name: Random 3
+    in:
+      x:
+        gen: int
+        min: 1000000
+        max: 5000000
+  - name: Random 4
+    in:
+      x:
+        gen: int
+        min: 100000000
+        max: 500000000
+  - name: Random 5
+    in:
+      x:
+        gen: int
+        min: 1000000000
+        max: 2147483646
+  - name: Sparse boundary 1
+    in:
+      x: 35
+    out: 5
+  - name: Sparse boundary 2
+    in:
+      x: 48
+    out: 6
+  - name: Perfect square near limit
+    in:
+      x: 2147395600
+    out: 46340
+  - name: Perfect square plus one
+    in:
+      x: 2147395601
+    out: 46340
+  - name: Random boundary 1
+    in:
+      x: 999999
+    out: 999
+  - name: Random boundary 2
+    in:
+      x: 1000000
+    out: 1000
diff --git a/tests/1-500/7. reverse-integer/manifest.yaml b/tests/1-500/7. reverse-integer/manifest.yaml
index 519718b7..98aa5cc9 100644
--- a/tests/1-500/7. reverse-integer/manifest.yaml	
+++ b/tests/1-500/7. reverse-integer/manifest.yaml	
@@ -1,6 +1,9 @@
 "entry":
   "id": 7
   "title": "reverse-integer"
+  "params":
+    "x":
+      "type": "int"
   "call":
     "cpp": "Solution().reverse({x})"
     "rust": "Solution::reverse({x})"
@@ -21,7 +24,7 @@
   "memory_mb": 256
 "oracle":
   "python3":
-    "call": "Checker().reverse({x}, {result})"
+    "call": "Checker().reverse(x, {result})"
     "checker":
       "class Checker:\n    def reverse(self, x, result):\n        s = str(abs(x))\n\
       \        rev = int(s[::-1])\n        if x < 0:\n            rev *= -1\n    \
diff --git a/tests/1-500/70. climbing-stairs/manifest.yaml b/tests/1-500/70. climbing-stairs/manifest.yaml
index 54a746b8..e16f34a5 100644
--- a/tests/1-500/70. climbing-stairs/manifest.yaml	
+++ b/tests/1-500/70. climbing-stairs/manifest.yaml	
@@ -1,153 +1,165 @@
-"entry":
-  "id": 70
-  "title": "climbing-stairs"
-  "call":
-    "cpp": "Solution().climbStairs({n})"
-    "rust": "Solution::climb_stairs({n})"
-    "python3": "Solution().climbStairs({n})"
-    "python2": "Solution().climbStairs({n})"
-    "ruby": "climb_stairs({n})"
-    "java": "new Solution().climbStairs({n})"
-    "csharp": "new Solution().ClimbStairs({n})"
-    "kotlin": "Solution().climbStairs({n})"
-    "go": "climbStairs({n})"
-    "dart": "Solution().climbStairs({n})"
-    "swift": "Solution().climbStairs({n})"
-    "typescript": "climbStairs({n})"
-"judge":
-  "type": "exact"
-"limits":
-  "time_ms": 1000
-  "memory_mb": 256
-"oracle":
-  "python3":
-    "call": "Checker().climbStairs({n}, {result})"
-    "checker":
-      "import json\nclass Checker:\n    def climbStairs(self, n, result):\n\
-      \        try:\n            result = json.loads(result) if isinstance(result,\
-      \ str) else result\n        except Exception:\n            return False\n  \
-      \      if n == 1: return result == 1\n        if n == 2: return result == 2\n\
-      \        a, b = 1, 2\n        for _ in range(3, n + 1):\n            a, b =\
-      \ b, a + b\n        return result == b\n"
-"seed": 42
-"tests":
-  - "name": "example 1"
-    "in":
-      "n": 2
-    "out": 2
-  - "name": "example 2"
-    "in":
-      "n": 3
-    "out": 3
-  - "name": "min n"
-    "in":
-      "n": 1
-    "out": 1
-  - "name": "n equals 4"
-    "in":
-      "n": 4
-    "out": 5
-  - "name": "n equals 5"
-    "in":
-      "n": 5
-    "out": 8
-  - "name": "n equals 6"
-    "in":
-      "n": 6
-    "out": 13
-  - "name": "n equals 7"
-    "in":
-      "n": 7
-    "out": 21
-  - "name": "n equals 10"
-    "in":
-      "n": 10
-    "out": 89
-  - "name": "n equals 15"
-    "in":
-      "n": 15
-    "out": 987
-  - "name": "n equals 20"
-    "in":
-      "n": 20
-    "out": 10946
-  - "name": "n equals 25"
-    "in":
-      "n": 25
-    "out": 121393
-  - "name": "n equals 30"
-    "in":
-      "n": 30
-    "out": 1346269
-  - "name": "max n equals 45"
-    "in":
-      "n": 45
-    "out": 1836311903
-  - "name": "near max n equals 44"
-    "in":
-      "n": 44
-    "out": 1134903170
-  - "name": "n equals 40"
-    "in":
-      "n": 40
-    "out": 165580141
-  - "name": "random 1"
-    "in":
-      "n":
-        "gen": "int"
-        "min": 8
-        "max": 12
-  - "name": "random 2"
-    "in":
-      "n":
-        "gen": "int"
-        "min": 13
-        "max": 18
-  - "name": "random 3"
-    "in":
-      "n":
-        "gen": "int"
-        "min": 19
-        "max": 24
-  - "name": "random 4"
-    "in":
-      "n":
-        "gen": "int"
-        "min": 26
-        "max": 32
-  - "name": "random 5"
-    "in":
-      "n":
-        "gen": "int"
-        "min": 33
-        "max": 39
-  - "name": "random 6"
-    "in":
-      "n":
-        "gen": "int"
-        "min": 40
-        "max": 43
-  - "name": "n equals 8"
-    "in":
-      "n": 8
-    "out": 34
-  - "name": "n equals 9"
-    "in":
-      "n": 9
-    "out": 55
-  - "name": "n equals 11"
-    "in":
-      "n": 11
-    "out": 144
-  - "name": "n equals 12"
-    "in":
-      "n": 12
-    "out": 233
-  - "name": "n equals 13"
-    "in":
-      "n": 13
-    "out": 377
-  - "name": "n equals 14"
-    "in":
-      "n": 14
-    "out": 610
+entry:
+  id: 70
+  title: climbing-stairs
+  call:
+    cpp: Solution().climbStairs({n})
+    rust: Solution::climb_stairs({n})
+    python3: Solution().climbStairs({n})
+    python2: Solution().climbStairs({n})
+    ruby: climb_stairs({n})
+    java: new Solution().climbStairs({n})
+    csharp: new Solution().ClimbStairs({n})
+    kotlin: Solution().climbStairs({n})
+    go: climbStairs({n})
+    dart: Solution().climbStairs({n})
+    swift: Solution().climbStairs({n})
+    typescript: climbStairs({n})
+  params:
+    n:
+      type: int
+judge:
+  type: exact
+limits:
+  time_ms: 1000
+  memory_mb: 256
+oracle:
+  python3:
+    call: climbStairs(n, {result})
+    checker: |
+      import json
+
+      def climbStairs(n, result):
+          try:
+              result = json.loads(result) if isinstance(result, str) else result
+          except Exception:
+              return False
+          if n == 1:
+              return result == 1
+          if n == 2:
+              return result == 2
+          a, b = 1, 2
+          for _ in range(3, n + 1):
+              a, b = b, a + b
+          return result == b
+seed: 42
+tests:
+  - name: example 1
+    in:
+      n: 2
+    out: 2
+  - name: example 2
+    in:
+      n: 3
+    out: 3
+  - name: min n
+    in:
+      n: 1
+    out: 1
+  - name: n equals 4
+    in:
+      n: 4
+    out: 5
+  - name: n equals 5
+    in:
+      n: 5
+    out: 8
+  - name: n equals 6
+    in:
+      n: 6
+    out: 13
+  - name: n equals 7
+    in:
+      n: 7
+    out: 21
+  - name: n equals 10
+    in:
+      n: 10
+    out: 89
+  - name: n equals 15
+    in:
+      n: 15
+    out: 987
+  - name: n equals 20
+    in:
+      n: 20
+    out: 10946
+  - name: n equals 25
+    in:
+      n: 25
+    out: 121393
+  - name: n equals 30
+    in:
+      n: 30
+    out: 1346269
+  - name: max n equals 45
+    in:
+      n: 45
+    out: 1836311903
+  - name: near max n equals 44
+    in:
+      n: 44
+    out: 1134903170
+  - name: n equals 40
+    in:
+      n: 40
+    out: 165580141
+  - name: random 1
+    in:
+      n:
+        gen: int
+        min: 8
+        max: 12
+  - name: random 2
+    in:
+      n:
+        gen: int
+        min: 13
+        max: 18
+  - name: random 3
+    in:
+      n:
+        gen: int
+        min: 19
+        max: 24
+  - name: random 4
+    in:
+      n:
+        gen: int
+        min: 26
+        max: 32
+  - name: random 5
+    in:
+      n:
+        gen: int
+        min: 33
+        max: 39
+  - name: random 6
+    in:
+      n:
+        gen: int
+        min: 40
+        max: 43
+  - name: n equals 8
+    in:
+      n: 8
+    out: 34
+  - name: n equals 9
+    in:
+      n: 9
+    out: 55
+  - name: n equals 11
+    in:
+      n: 11
+    out: 144
+  - name: n equals 12
+    in:
+      n: 12
+    out: 233
+  - name: n equals 13
+    in:
+      n: 13
+    out: 377
+  - name: n equals 14
+    in:
+      n: 14
+    out: 610
diff --git a/tests/1-500/71. simplify-path/manifest.yaml b/tests/1-500/71. simplify-path/manifest.yaml
index 71e8a0f0..9af5a531 100644
--- a/tests/1-500/71. simplify-path/manifest.yaml	
+++ b/tests/1-500/71. simplify-path/manifest.yaml	
@@ -1,109 +1,122 @@
-"entry":
-  "id": 71
-  "title": "simplify-path"
-  "call":
-    "cpp": 'Solution().simplifyPath("{path}")'
-    "rust": 'Solution::simplify_path("{path}".to_string())'
-    "python3": 'Solution().simplifyPath("{path}")'
-    "python2": 'Solution().simplifyPath("{path}")'
-    "ruby": 'simplify_path("{path}")'
-    "java": 'new Solution().simplifyPath("{path}")'
-    "csharp": 'new Solution().SimplifyPath("{path}")'
-    "kotlin": 'Solution().simplifyPath("{path}")'
-    "go": 'simplifyPath("{path}")'
-    "dart": 'Solution().simplifyPath("{path}")'
-    "swift": 'Solution().simplifyPath("{path}")'
-    "typescript": 'simplifyPath("{path}")'
-"judge":
-  "type": "exact"
-"limits":
-  "time_ms": 1000
-  "memory_mb": 256
-"oracle":
-  "python3":
-    "call": 'Checker().simplifyPath("{path}", {result})'
-    "checker":
-      "import json\nclass Checker:\n    def simplifyPath(self, path, result):\n\
-      \        try:\n            result = json.loads(result) if isinstance(result,\
-      \ str) else result\n        except Exception:\n            return False\n  \
-      \      components = [c for c in path.split(\"/\") if c and c != \".\"]\n   \
-      \     st = []\n        for comp in components:\n            if comp == \"..\"\
-      :\n                if st: st.pop()\n            else:\n                st.append(comp)\n\
-      \        return result == \"/\" + \"/\".join(st)\n"
-"seed": 42
-"tests":
-  - "name": "Example 1"
-    "in":
-      "path": "/home/"
-  - "name": "Example 2"
-    "in":
-      "path": "/home//foo/"
-  - "name": "Example 3"
-    "in":
-      "path": "/home/user/Documents/../Pictures"
-  - "name": "Example 4"
-    "in":
-      "path": "/../"
-  - "name": "Example 5"
-    "in":
-      "path": "/.../a/../b/c/../d/./"
-  - "name": "Root"
-    "in":
-      "path": "/"
-  - "name": "Multiple dots"
-    "in":
-      "path": "/.../..../....."
-  - "name": "Dots and parent"
-    "in":
-      "path": "/a/./b/../../c/"
-  - "name": "Redundant parent at root"
-    "in":
-      "path": "/../../../../"
-  - "name": "Complex mixture"
-    "in":
-      "path": "/a/b/c/.././././././"
-  - "name": "Very long name"
-    "in":
-      "path": "/abc/def/ghi/jkl/mno/pqr/stu/vwx/yzz"
-  - "name": "End with dots"
-    "in":
-      "path": "/a/b/.."
-  - "name": "Starts with dots"
-    "in":
-      "path": "/../a/b"
-  - "name": "Multiple slashes"
-    "in":
-      "path": "//////////////////a"
-  - "name": "Dot directory"
-    "in":
-      "path": "/a/./b/./c/./d/"
-  - "name": "Parent mix"
-    "in":
-      "path": "/a/..//b/..//c/../"
-  - "name": "Underscores and digits"
-    "in":
-      "path": "/a_1/b_2/c3/d4/../e5"
-  - "name": "Only dots"
-    "in":
-      "path": "/././././."
-  - "name": "Deep nesting"
-    "in":
-      "path": "/a/b/c/d/e/f/g/h/i/j/k/l"
-  - "name": "Deep nesting with backtracks"
-    "in":
-      "path": "/a/b/c/d/e/../f/../g/../h"
-  - "name": "Leading dot"
-    "in":
-      "path": "./a"
-  - "name": "Trailing dots"
-    "in":
-      "path": "/a/b..."
-  - "name": "Many consecutive slashes at end"
-    "in":
-      "path": "/a/b/////////"
-  - "name": "Large path 1"
-    "in":
-      "path": "/a/b/c/d/e/f/g/h/i/j/k/l/m/n/o/p/q/r/s/t/u/v/w/x/y/z/../"
-  - "name": "Large path 2"
-    "in":
-      "path": "/a/b/c/d/e/f/g/h/i/j/k/l/m/n/o/p/q/r/s/t/u/v/w/x/y/z/../../../../../../"
+entry:
+  id: 71
+  title: simplify-path
+  call:
+    cpp: Solution().simplifyPath({path})
+    rust: Solution::simplify_path({path})
+    python3: Solution().simplifyPath({path})
+    python2: Solution().simplifyPath({path})
+    ruby: simplify_path({path})
+    java: new Solution().simplifyPath({path})
+    csharp: new Solution().SimplifyPath({path})
+    kotlin: Solution().simplifyPath({path})
+    go: simplifyPath({path})
+    dart: Solution().simplifyPath({path})
+    swift: Solution().simplifyPath({path})
+    typescript: simplifyPath({path})
+  params:
+    path:
+      type: string
+judge:
+  type: exact
+limits:
+  time_ms: 1000
+  memory_mb: 256
+oracle:
+  python3:
+    call: simplifyPath(path, {result})
+    checker: |
+      import json
+
+      def simplifyPath(path, result):
+          if isinstance(result, str):
+              try:
+                  result = json.loads(result)
+              except Exception:
+                  pass
+          components = [c for c in path.split('/') if c and c != '.']
+          st = []
+          for comp in components:
+              if comp == '..':
+                  if st:
+                      st.pop()
+              else:
+                  st.append(comp)
+          return result == '/' + '/'.join(st)
+seed: 42
+tests:
+  - name: Example 1
+    in:
+      path: /home/
+  - name: Example 2
+    in:
+      path: /home//foo/
+  - name: Example 3
+    in:
+      path: /home/user/Documents/../Pictures
+  - name: Example 4
+    in:
+      path: /../
+  - name: Example 5
+    in:
+      path: /.../a/../b/c/../d/./
+  - name: Root
+    in:
+      path: /
+  - name: Multiple dots
+    in:
+      path: /.../..../.....
+  - name: Dots and parent
+    in:
+      path: /a/./b/../../c/
+  - name: Redundant parent at root
+    in:
+      path: /../../../../
+  - name: Complex mixture
+    in:
+      path: /a/b/c/.././././././
+  - name: Very long name
+    in:
+      path: /abc/def/ghi/jkl/mno/pqr/stu/vwx/yzz
+  - name: End with dots
+    in:
+      path: /a/b/..
+  - name: Starts with dots
+    in:
+      path: /../a/b
+  - name: Multiple slashes
+    in:
+      path: //////////////////a
+  - name: Dot directory
+    in:
+      path: /a/./b/./c/./d/
+  - name: Parent mix
+    in:
+      path: /a/..//b/..//c/../
+  - name: Underscores and digits
+    in:
+      path: /a_1/b_2/c3/d4/../e5
+  - name: Only dots
+    in:
+      path: /././././.
+  - name: Deep nesting
+    in:
+      path: /a/b/c/d/e/f/g/h/i/j/k/l
+  - name: Deep nesting with backtracks
+    in:
+      path: /a/b/c/d/e/../f/../g/../h
+  - name: Leading dot
+    in:
+      path: ./a
+  - name: Trailing dots
+    in:
+      path: /a/b...
+  - name: Many consecutive slashes at end
+    in:
+      path: /a/b/////////
+  - name: Large path 1
+    in:
+      path: /a/b/c/d/e/f/g/h/i/j/k/l/m/n/o/p/q/r/s/t/u/v/w/x/y/z/../
+  - name: Large path 2
+    in:
+      path: /a/b/c/d/e/f/g/h/i/j/k/l/m/n/o/p/q/r/s/t/u/v/w/x/y/z/../../../../../../
diff --git a/tests/1-500/72. edit-distance/manifest.yaml b/tests/1-500/72. edit-distance/manifest.yaml
index ea5ee41e..5d09125d 100644
--- a/tests/1-500/72. edit-distance/manifest.yaml	
+++ b/tests/1-500/72. edit-distance/manifest.yaml	
@@ -1,192 +1,207 @@
-"entry":
-  "id": 72
-  "title": "edit-distance"
-  "call":
-    "cpp": 'Solution().minDistance("{word1}", "{word2}")'
-    "rust": 'Solution::min_distance("{word1}".to_string(), "{word2}".to_string())'
-    "python3": 'Solution().minDistance("{word1}", "{word2}")'
-    "python2": 'Solution().minDistance("{word1}", "{word2}")'
-    "ruby": 'min_distance("{word1}", "{word2}")'
-    "java": 'new Solution().minDistance("{word1}", "{word2}")'
-    "csharp": 'new Solution().MinDistance("{word1}", "{word2}")'
-    "kotlin": 'Solution().minDistance("{word1}", "{word2}")'
-    "go": 'minDistance("{word1}", "{word2}")'
-    "dart": 'Solution().minDistance("{word1}", "{word2}")'
-    "swift": 'Solution().minDistance("{word1}", "{word2}")'
-    "typescript": 'minDistance("{word1}", "{word2}")'
-"judge":
-  "type": "exact"
-"limits":
-  "time_ms": 1000
-  "memory_mb": 256
-"oracle":
-  "python3":
-    "call": 'Checker().minDistance("{word1}", "{word2}", {result})'
-    "checker":
-      "import json\nclass Checker:\n    def minDistance(self, word1, word2,\
-      \ result):\n        try:\n            result = json.loads(result) if isinstance(result,\
-      \ str) else result\n        except Exception:\n            return False\n  \
-      \      m, n = len(word1), len(word2)\n        dp = [[0] * (n + 1) for _ in range(m\
-      \ + 1)]\n        for i in range(m + 1): dp[i][0] = i\n        for j in range(n\
-      \ + 1): dp[0][j] = j\n        for i in range(1, m + 1):\n            for j in\
-      \ range(1, n + 1):\n                if word1[i-1] == word2[j-1]:\n         \
-      \           dp[i][j] = dp[i-1][j-1]\n                else:\n               \
-      \     dp[i][j] = 1 + min(dp[i-1][j], dp[i][j-1], dp[i-1][j-1])\n        return\
-      \ result == dp[m][n]\n"
-"seed": 42
-"tests":
-  - "name": "example 1"
-    "in":
-      "word1": "horse"
-      "word2": "ros"
-    "out": 3
-  - "name": "example 2"
-    "in":
-      "word1": "intention"
-      "word2": "execution"
-    "out": 5
-  - "name": "empty word1"
-    "in":
-      "word1": ""
-      "word2": "abc"
-    "out": 3
-  - "name": "empty word2"
-    "in":
-      "word1": "abc"
-      "word2": ""
-    "out": 3
-  - "name": "identical strings"
-    "in":
-      "word1": "leetcode"
-      "word2": "leetcode"
-    "out": 0
-  - "name": "completely different"
-    "in":
-      "word1": "abc"
-      "word2": "def"
-    "out": 3
-  - "name": "single insertion"
-    "in":
-      "word1": "abc"
-      "word2": "abxc"
-    "out": 1
-  - "name": "single deletion"
-    "in":
-      "word1": "abxc"
-      "word2": "abc"
-    "out": 1
-  - "name": "single replacement"
-    "in":
-      "word1": "abc"
-      "word2": "azc"
-    "out": 1
-  - "name": "long word1 empty word2"
-    "in":
-      "word1": "aaaaaaaaaa"
-      "word2": ""
-    "out": 10
-  - "name": "shorter to longer"
-    "in":
-      "word1": "cat"
-      "word2": "cats"
-    "out": 1
-  - "name": "longer to shorter"
-    "in":
-      "word1": "cats"
-      "word2": "cat"
-    "out": 1
-  - "name": "repeated chars"
-    "in":
-      "word1": "aaaaa"
-      "word2": "a"
-    "out": 4
-  - "name": "alternating chars"
-    "in":
-      "word1": "ababab"
-      "word2": "bababa"
-    "out": 2
-  - "name": "small difference"
-    "in":
-      "word1": "dinitrophenylhydrazine"
-      "word2": "phenylhydrazine"
-    "out": 7
-  - "name": "complex swap like"
-    "in":
-      "word1": "abcde"
-      "word2": "edcba"
-    "out": 4
-  - "name": "large random 100"
-    "in":
-      "word1":
-        "gen": "str"
-        "len": 100
-        "alphabet": "abc"
-      "word2":
-        "gen": "str"
-        "len": 100
-        "alphabet": "abc"
-  - "name": "large random 200"
-    "in":
-      "word1":
-        "gen": "str"
-        "len": 200
-        "alphabet": "xy"
-      "word2":
-        "gen": "str"
-        "len": 200
-        "alphabet": "xy"
-  - "name": "max length test 500"
-    "in":
-      "word1":
-        "gen": "str"
-        "len": 500
-        "alphabet": "a"
-      "word2":
-        "gen": "str"
-        "len": 500
-        "alphabet": "b"
-  - "name": "max length test 500 equal"
-    "in":
-      "word1":
-        "gen": "str"
-        "len": 500
-        "alphabet": "z"
-      "word2":
-        "gen": "str"
-        "len": 500
-        "alphabet": "z"
-  - "name": "mixed length 50 450"
-    "in":
-      "word1":
-        "gen": "str"
-        "len": 50
-        "alphabet": "ab"
-      "word2":
-        "gen": "str"
-        "len": 450
-        "alphabet": "ab"
-  - "name": "prefix match"
-    "in":
-      "word1": "abcdefghijklmnopqrstuvwxyz"
-      "word2": "abcdefghijklmnopqrstuvwxzy"
-    "out": 2
-  - "name": "offset shift"
-    "in":
-      "word1": "abc"
-      "word2": "zabc"
-    "out": 1
-  - "name": "suffix match"
-    "in":
-      "word1": "abc"
-      "word2": "abczzz"
-    "out": 3
-  - "name": "all same except one"
-    "in":
-      "word1": "aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaab"
-      "word2": "aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa"
-    "out": 1
-  - "name": "empty strings"
-    "in":
-      "word1": ""
-      "word2": ""
-    "out": 0
+entry:
+  id: 72
+  title: edit-distance
+  call:
+    cpp: Solution().minDistance({word1}, {word2})
+    rust: Solution::min_distance({word1}, {word2})
+    python3: Solution().minDistance({word1}, {word2})
+    python2: Solution().minDistance({word1}, {word2})
+    ruby: min_distance({word1}, {word2})
+    java: new Solution().minDistance({word1}, {word2})
+    csharp: new Solution().MinDistance({word1}, {word2})
+    kotlin: Solution().minDistance({word1}, {word2})
+    go: minDistance({word1}, {word2})
+    dart: Solution().minDistance({word1}, {word2})
+    swift: Solution().minDistance({word1}, {word2})
+    typescript: minDistance({word1}, {word2})
+  params:
+    word1:
+      type: string
+    word2:
+      type: string
+judge:
+  type: exact
+limits:
+  time_ms: 1000
+  memory_mb: 256
+oracle:
+  python3:
+    call: minDistance(word1, word2, {result})
+    checker: |
+      import json
+
+      def minDistance(word1, word2, result):
+          try:
+              result = json.loads(result) if isinstance(result, str) else result
+          except Exception:
+              return False
+          m, n = len(word1), len(word2)
+          dp = [[0] * (n + 1) for _ in range(m + 1)]
+          for i in range(m + 1):
+              dp[i][0] = i
+          for j in range(n + 1):
+              dp[0][j] = j
+          for i in range(1, m + 1):
+              for j in range(1, n + 1):
+                  if word1[i - 1] == word2[j - 1]:
+                      dp[i][j] = dp[i - 1][j - 1]
+                  else:
+                      dp[i][j] = 1 + min(dp[i - 1][j], dp[i][j - 1], dp[i - 1][j - 1])
+          return result == dp[m][n]
+seed: 42
+tests:
+  - name: example 1
+    in:
+      word1: horse
+      word2: ros
+    out: 3
+  - name: example 2
+    in:
+      word1: intention
+      word2: execution
+    out: 5
+  - name: empty word1
+    in:
+      word1: ""
+      word2: abc
+    out: 3
+  - name: empty word2
+    in:
+      word1: abc
+      word2: ""
+    out: 3
+  - name: identical strings
+    in:
+      word1: leetcode
+      word2: leetcode
+    out: 0
+  - name: completely different
+    in:
+      word1: abc
+      word2: def
+    out: 3
+  - name: single insertion
+    in:
+      word1: abc
+      word2: abxc
+    out: 1
+  - name: single deletion
+    in:
+      word1: abxc
+      word2: abc
+    out: 1
+  - name: single replacement
+    in:
+      word1: abc
+      word2: azc
+    out: 1
+  - name: long word1 empty word2
+    in:
+      word1: aaaaaaaaaa
+      word2: ""
+    out: 10
+  - name: shorter to longer
+    in:
+      word1: cat
+      word2: cats
+    out: 1
+  - name: longer to shorter
+    in:
+      word1: cats
+      word2: cat
+    out: 1
+  - name: repeated chars
+    in:
+      word1: aaaaa
+      word2: a
+    out: 4
+  - name: alternating chars
+    in:
+      word1: ababab
+      word2: bababa
+    out: 2
+  - name: small difference
+    in:
+      word1: dinitrophenylhydrazine
+      word2: phenylhydrazine
+    out: 7
+  - name: complex swap like
+    in:
+      word1: abcde
+      word2: edcba
+    out: 4
+  - name: large random 100
+    in:
+      word1:
+        gen: str
+        len: 100
+        alphabet: abc
+      word2:
+        gen: str
+        len: 100
+        alphabet: abc
+  - name: large random 200
+    in:
+      word1:
+        gen: str
+        len: 200
+        alphabet: xy
+      word2:
+        gen: str
+        len: 200
+        alphabet: xy
+  - name: max length test 500
+    in:
+      word1:
+        gen: str
+        len: 500
+        alphabet: a
+      word2:
+        gen: str
+        len: 500
+        alphabet: b
+  - name: max length test 500 equal
+    in:
+      word1:
+        gen: str
+        len: 500
+        alphabet: z
+      word2:
+        gen: str
+        len: 500
+        alphabet: z
+  - name: mixed length 50 450
+    in:
+      word1:
+        gen: str
+        len: 50
+        alphabet: ab
+      word2:
+        gen: str
+        len: 450
+        alphabet: ab
+  - name: prefix match
+    in:
+      word1: abcdefghijklmnopqrstuvwxyz
+      word2: abcdefghijklmnopqrstuvwxzy
+    out: 2
+  - name: offset shift
+    in:
+      word1: abc
+      word2: zabc
+    out: 1
+  - name: suffix match
+    in:
+      word1: abc
+      word2: abczzz
+    out: 3
+  - name: all same except one
+    in:
+      word1: aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaab
+      word2: aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa
+    out: 1
+  - name: empty strings
+    in:
+      word1: ""
+      word2: ""
+    out: 0
diff --git a/tests/1-500/74. search-a-2d-matrix/manifest.yaml b/tests/1-500/74. search-a-2d-matrix/manifest.yaml
index 0f600ea2..4eacefea 100644
--- a/tests/1-500/74. search-a-2d-matrix/manifest.yaml	
+++ b/tests/1-500/74. search-a-2d-matrix/manifest.yaml	
@@ -2,18 +2,27 @@ entry:
   id: 74
   title: search-a-2d-matrix
   call:
-    cpp: Solution().searchMatrix(lv(vector<vector<int>>{ {matrix} }), {target})
-    rust: Solution::search_matrix(vec![{matrix}], {target})
-    python3: Solution().searchMatrix([{matrix}], {target})
-    python2: Solution().searchMatrix([{matrix}], {target})
-    ruby: search_matrix([{matrix}], {target})
-    java: new Solution().searchMatrix(new int[][]{ {matrix} }, {target})
-    csharp: new Solution().SearchMatrix(new int[][]{ {matrix} }, {target})
-    kotlin: Solution().searchMatrix(arrayOf({matrix}), {target})
-    go: searchMatrix([][]int{ {matrix} }, {target})
-    dart: Solution().searchMatrix([{matrix}], {target})
-    swift: Solution().searchMatrix([{matrix}], {target})
-    typescript: searchMatrix([{matrix}], {target})
+    cpp: Solution().searchMatrix({matrix}, {target})
+    rust: Solution::search_matrix({matrix}, {target})
+    python3: Solution().searchMatrix({matrix}, {target})
+    python2: Solution().searchMatrix({matrix}, {target})
+    ruby: search_matrix({matrix}, {target})
+    java: new Solution().searchMatrix({matrix}, {target})
+    csharp: new Solution().SearchMatrix({matrix}, {target})
+    kotlin: Solution().searchMatrix({matrix}, {target})
+    go: searchMatrix({matrix}, {target})
+    dart: Solution().searchMatrix({matrix}, {target})
+    swift: Solution().searchMatrix({matrix}, {target})
+    typescript: searchMatrix({matrix}, {target})
+  params:
+    matrix:
+      type: array
+      items:
+        type: array
+        items:
+          type: int
+    target:
+      type: int
 judge:
   type: exact
 limits:
@@ -21,11 +30,10 @@ limits:
   memory_mb: 256
 oracle:
   python3:
-    call: Checker().searchMatrix([{matrix}], {target}, {result})
+    call: Checker().searchMatrix({matrix}, {target}, {result})
     checker:
-      "class Checker:\n    def searchMatrix(self, matrix, target, result):\n\
-      \        flat = [val for row in matrix for val in row]\n        return (target\
-      \ in flat) == result\n"
+      "class Checker:\n    def searchMatrix(self, matrix, target, result):\n        flat = [val for row in matrix for
+      val in row]\n        return (target in flat) == result\n"
 seed: 42
 tests:
   - name: Example 1
diff --git a/tests/1-500/76. minimum-window-substring/manifest.yaml b/tests/1-500/76. minimum-window-substring/manifest.yaml
index 14ff257d..2f41cee3 100644
--- a/tests/1-500/76. minimum-window-substring/manifest.yaml	
+++ b/tests/1-500/76. minimum-window-substring/manifest.yaml	
@@ -1,19 +1,24 @@
 entry:
   id: 76
   title: minimum-window-substring
+  params:
+    s:
+      type: string
+    t:
+      type: string
   call:
-    cpp: Solution().minWindow("{s}", "{t}")
-    rust: Solution::min_window("{s}".to_string(), "{t}".to_string())
-    python3: Solution().minWindow("{s}", "{t}")
-    python2: Solution().minWindow("{s}", "{t}")
-    ruby: min_window("{s}", "{t}")
-    java: new Solution().minWindow("{s}", "{t}")
-    csharp: new Solution().MinWindow("{s}", "{t}")
-    kotlin: Solution().minWindow("{s}", "{t}")
-    go: minWindow("{s}", "{t}")
-    dart: Solution().minWindow("{s}", "{t}")
-    swift: Solution().minWindow("{s}", "{t}")
-    typescript: minWindow("{s}", "{t}")
+    cpp: Solution().minWindow({s}, {t})
+    rust: Solution::min_window({s}, {t})
+    python3: Solution().minWindow({s}, {t})
+    python2: Solution().minWindow({s}, {t})
+    ruby: min_window({s}, {t})
+    java: new Solution().minWindow({s}, {t})
+    csharp: new Solution().MinWindow({s}, {t})
+    kotlin: Solution().minWindow({s}, {t})
+    go: minWindow({s}, {t})
+    dart: Solution().minWindow({s}, {t})
+    swift: Solution().minWindow({s}, {t})
+    typescript: minWindow({s}, {t})
 judge:
   type: exact
 limits:
@@ -21,7 +26,7 @@ limits:
   memory_mb: 256
 oracle:
   python3:
-    call: Checker().minWindow("{s}", "{t}", {result})
+    call: Checker().minWindow(s, t, {result})
     checker:
       "import json\nfrom collections import Counter\nclass Checker:\n    def\
       \ _norm(self, result):\n        if isinstance(result, str):\n            try:\n\
diff --git a/tests/1-500/77. combinations/manifest.yaml b/tests/1-500/77. combinations/manifest.yaml
index 4f5a0c43..25fb25a3 100644
--- a/tests/1-500/77. combinations/manifest.yaml	
+++ b/tests/1-500/77. combinations/manifest.yaml	
@@ -1,6 +1,11 @@
 entry:
   id: 77
   title: combinations
+  params:
+    n:
+      type: int
+    k:
+      type: int
   call:
     cpp: Solution().combine({n}, {k})
     rust: Solution::combine({n}, {k})
@@ -21,7 +26,7 @@ limits:
   memory_mb: 256
 oracle:
   python3:
-    call: Checker().check({n}, {k}, {result})
+    call: Checker().check(n, k, {result})
     checker:
       "import json\nimport math\n\nclass Checker:\n    def check(self, n, k,\
       \ result):\n        try:\n            res = json.loads(result) if isinstance(result,\
diff --git a/tests/1-500/78. subsets/manifest.yaml b/tests/1-500/78. subsets/manifest.yaml
index 34ad7569..caf54d56 100644
--- a/tests/1-500/78. subsets/manifest.yaml	
+++ b/tests/1-500/78. subsets/manifest.yaml	
@@ -2,18 +2,23 @@
   "id": 78
   "title": "subsets"
   "call":
-    "cpp": "Solution().subsets(lv(vector<int>{ {nums} }))"
-    "rust": "Solution::subsets(vec![{nums}])"
-    "python3": "Solution().subsets([{nums}])"
-    "python2": "Solution().subsets([{nums}])"
-    "ruby": "subsets([{nums}])"
-    "java": "new Solution().subsets(new int[]{ {nums} })"
-    "csharp": "new Solution().Subsets(new int[]{ {nums} })"
-    "kotlin": "Solution().subsets(intArrayOf({nums}))"
-    "go": "subsets([]int{ {nums} })"
-    "dart": "Solution().subsets([{nums}])"
-    "swift": "Solution().subsets([{nums}])"
-    "typescript": "subsets([{nums}])"
+    "cpp": "Solution().subsets({nums})"
+    "rust": "Solution::subsets({nums})"
+    "python3": "Solution().subsets({nums})"
+    "python2": "Solution().subsets({nums})"
+    "ruby": "subsets({nums})"
+    "java": "new Solution().subsets({nums})"
+    "csharp": "new Solution().Subsets({nums})"
+    "kotlin": "Solution().subsets({nums})"
+    "go": "subsets({nums})"
+    "dart": "Solution().subsets({nums})"
+    "swift": "Solution().subsets({nums})"
+    "typescript": "subsets({nums})"
+  params:
+    nums:
+      type: array
+      items:
+        type: int
 "judge":
   "type": "ignore_order"
 "limits":
@@ -21,18 +26,15 @@
   "memory_mb": 256
 "oracle":
   "python3":
-    "call": "Checker().check([{nums}], {result})"
+    "call": "Checker().check(nums, {result})"
     "checker":
-      "import json\nclass Checker:\n    def check(self, nums, result):\n\
-      \        try:\n            result = json.loads(result) if isinstance(result,\
-      \ str) else result\n        except Exception:\n            return False\n  \
-      \      try:\n            n = len(nums)\n            if len(result) != 2**n:\n\
-      \                return False\n            res_set = set()\n            for\
-      \ combo in result:\n                res_set.add(tuple(sorted(combo)))\n    \
-      \        if len(res_set) != 2**n:\n                return False\n          \
-      \  for combo in res_set:\n                for x in combo:\n                \
-      \    if x not in nums:\n                        return False\n            return\
-      \ True\n        except:\n            return False\n"
+      "import json\nclass Checker:\n    def check(self, nums, result):\n        try:\n            result = json.loads(result)
+      if isinstance(result, str) else result\n        except Exception:\n            return False\n        try:\n        \
+      \    n = len(nums)\n            if len(result) != 2**n:\n                return False\n            res_set = set()\n\
+      \            for combo in result:\n                res_set.add(tuple(sorted(combo)))\n            if len(res_set) !=
+      2**n:\n                return False\n            for combo in res_set:\n                for x in combo:\n          \
+      \          if x not in nums:\n                        return False\n            return True\n        except:\n     \
+      \       return False\n"
 "seed": 42
 "tests":
   - "name": "example 1"
diff --git a/tests/1-500/79. word-search/manifest.yaml b/tests/1-500/79. word-search/manifest.yaml
index 9f02db91..6b518928 100644
--- a/tests/1-500/79. word-search/manifest.yaml	
+++ b/tests/1-500/79. word-search/manifest.yaml	
@@ -2,18 +2,27 @@
   "id": 79
   "title": "word-search"
   "call":
-    "cpp": 'Solution().exist(lv(vector<vector<char>>{ {board} }), "{word}")'
-    "rust": 'Solution::exist(vec!{ {board} }.iter().map(|row| row.iter().map(|&c| c).collect()).collect(), "{word}".to_string())'
-    "python3": 'Solution().exist([{board}], "{word}")'
-    "python2": 'Solution().exist([{board}], "{word}")'
-    "ruby": 'exist({board}, "{word}")'
-    "java": 'new Solution().exist(new char[][]{ {board} }, "{word}")'
-    "csharp": 'new Solution().Exist(new char[][]{ {board} }, "{word}")'
-    "kotlin": 'Solution().exist(arrayOf({board}), "{word}")'
-    "go": 'exist([][]byte{ {board} }, "{word}")'
-    "dart": 'Solution().exist({board}, "{word}")'
-    "swift": 'Solution().exist({board}, "{word}")'
-    "typescript": 'exist({board}, "{word}")'
+    "cpp": "Solution().exist({board}, {word})"
+    "rust": "Solution::exist({board}, {word})"
+    "python3": "Solution().exist({board}, {word})"
+    "python2": "Solution().exist({board}, {word})"
+    "ruby": "exist({board}, {word})"
+    "java": "new Solution().exist({board}, {word})"
+    "csharp": "new Solution().Exist({board}, {word})"
+    "kotlin": "Solution().exist({board}, {word})"
+    "go": "exist({board}, {word})"
+    "dart": "Solution().exist({board}, {word})"
+    "swift": "Solution().exist({board}, {word})"
+    "typescript": "exist({board}, {word})"
+  params:
+    board:
+      type: array
+      items:
+        type: array
+        items:
+          type: char
+    word:
+      type: string
 "judge":
   "type": "exact"
 "limits":
@@ -21,8 +30,14 @@
   "memory_mb": 256
 "oracle":
   "python3":
-    "call": 'Checker().exist([{board}], "{word}", {result})'
-    "checker": "class Checker:\n    def exist(self, board, word, result):\n        rows, cols = len(board), len(board[0])\n        def dfs(r, c, index):\n            if index == len(word): return True\n            if r < 0 or r >= rows or c < 0 or c >= cols or board[r][c] != word[index]: return False\n            temp = board[r][c]\n            board[r][c] = \"#\"\n            found = dfs(r+1, c, index+1) or dfs(r-1, c, index+1) or dfs(r, c+1, index+1) or dfs(r, c-1, index+1)\n            board[r][c] = temp\n            return found\n        for r in range(rows):\n            for c in range(cols):\n                if dfs(r, c, 0): return result == True\n        return result == False\n"
+    "call": "Checker().exist(board, word, {result})"
+    "checker":
+      "class Checker:\n    def exist(self, board, word, result):\n        rows, cols = len(board), len(board[0])\n\
+      \        def dfs(r, c, index):\n            if index == len(word): return True\n            if r < 0 or r >= rows or
+      c < 0 or c >= cols or board[r][c] != word[index]: return False\n            temp = board[r][c]\n            board[r][c]
+      = \"#\"\n            found = dfs(r+1, c, index+1) or dfs(r-1, c, index+1) or dfs(r, c+1, index+1) or dfs(r, c-1, index+1)\n\
+      \            board[r][c] = temp\n            return found\n        for r in range(rows):\n            for c in range(cols):\n\
+      \                if dfs(r, c, 0): return result == True\n        return result == False\n"
 "seed": 42
 "tests":
   - "name": "Example 1"
diff --git a/tests/1-500/8. string-to-integer-atoi/manifest.yaml b/tests/1-500/8. string-to-integer-atoi/manifest.yaml
index b3120416..a3e48da4 100644
--- a/tests/1-500/8. string-to-integer-atoi/manifest.yaml	
+++ b/tests/1-500/8. string-to-integer-atoi/manifest.yaml	
@@ -1,19 +1,22 @@
 entry:
   id: 8
   title: string-to-integer-atoi
+  params:
+    s:
+      type: string
   call:
-    cpp: Solution().myAtoi("{s}")
-    rust: Solution::my_atoi("{s}".to_string())
-    python3: Solution().myAtoi("{s}")
-    python2: Solution().myAtoi("{s}")
-    ruby: my_atoi("{s}")
-    java: new Solution().myAtoi("{s}")
-    csharp: new Solution().MyAtoi("{s}")
-    kotlin: Solution().myAtoi("{s}")
-    go: myAtoi("{s}")
-    dart: Solution().myAtoi("{s}")
-    swift: Solution().myAtoi("{s}")
-    typescript: myAtoi("{s}")
+    cpp: Solution().myAtoi({s})
+    rust: Solution::my_atoi({s}.to_string())
+    python3: Solution().myAtoi({s})
+    python2: Solution().myAtoi({s})
+    ruby: my_atoi({s})
+    java: new Solution().myAtoi({s})
+    csharp: new Solution().MyAtoi({s})
+    kotlin: Solution().myAtoi({s})
+    go: myAtoi({s})
+    dart: Solution().myAtoi({s})
+    swift: Solution().myAtoi({s})
+    typescript: myAtoi({s})
 judge:
   type: exact
 limits:
@@ -21,7 +24,7 @@ limits:
   memory_mb: 64
 oracle:
   python3:
-    call: Checker().myAtoi("{s}", {result})
+    call: Checker().myAtoi(s, {result})
     checker:
       "class Checker:\n    def myAtoi(self, s, result):\n        s = s.strip()\n\
       \        if not s:\n            val = 0\n        else:\n            sign = 1\n\
diff --git a/tests/1-500/81. search-in-rotated-sorted-array-ii/manifest.yaml b/tests/1-500/81. search-in-rotated-sorted-array-ii/manifest.yaml
index b7dbe772..d775bd76 100644
--- a/tests/1-500/81. search-in-rotated-sorted-array-ii/manifest.yaml	
+++ b/tests/1-500/81. search-in-rotated-sorted-array-ii/manifest.yaml	
@@ -2,18 +2,25 @@
   "id": 81
   "title": "search-in-rotated-sorted-array-ii"
   "call":
-    "cpp": "Solution().search(lv(vector<int>{ {nums} }), {target})"
-    "rust": "Solution::search(vec![{nums}], {target})"
-    "python3": "Solution().search([{nums}], {target})"
-    "python2": "Solution().search([{nums}], {target})"
-    "ruby": "search([{nums}], {target})"
-    "java": "new Solution().search(new int[]{ {nums} }, {target})"
-    "csharp": "new Solution().Search(new int[]{ {nums} }, {target})"
-    "kotlin": "Solution().search(intArrayOf({nums}), {target})"
-    "go": "search([]int{ {nums} }, {target})"
-    "dart": "Solution().search([{nums}], {target})"
-    "swift": "Solution().search([{nums}], {target})"
-    "typescript": "search([{nums}], {target})"
+    "cpp": "Solution().search({nums}, {target})"
+    "rust": "Solution::search({nums}, {target})"
+    "python3": "Solution().search({nums}, {target})"
+    "python2": "Solution().search({nums}, {target})"
+    "ruby": "search({nums}, {target})"
+    "java": "new Solution().search({nums}, {target})"
+    "csharp": "new Solution().Search({nums}, {target})"
+    "kotlin": "Solution().search({nums}, {target})"
+    "go": "search({nums}, {target})"
+    "dart": "Solution().search({nums}, {target})"
+    "swift": "Solution().search({nums}, {target})"
+    "typescript": "search({nums}, {target})"
+  params:
+    nums:
+      type: array
+      items:
+        type: int
+    target:
+      type: int
 "judge":
   "type": "exact"
 "limits":
@@ -21,12 +28,11 @@
   "memory_mb": 256
 "oracle":
   "python3":
-    "call": "Checker().search([{nums}], {target}, {result})"
+    "call": "Checker().search({nums}, {target}, {result})"
     "checker":
-      "import json\nclass Checker:\n    def search(self, nums, target, result):\n\
-      \        try:\n            result = json.loads(result) if isinstance(result,\
-      \ str) else result\n        except Exception:\n            return False\n  \
-      \      return (target in nums) == result\n"
+      "import json\nclass Checker:\n    def search(self, nums, target, result):\n        try:\n            result
+      = json.loads(result) if isinstance(result, str) else result\n        except Exception:\n            return False\n \
+      \       return (target in nums) == result\n"
 "seed": 42
 "tests":
   - "name": "example 1"
diff --git a/tests/1-500/82. remove-duplicates-from-sorted-list-ii/manifest.yaml b/tests/1-500/82. remove-duplicates-from-sorted-list-ii/manifest.yaml
index 95e397fb..2589f1dc 100644
--- a/tests/1-500/82. remove-duplicates-from-sorted-list-ii/manifest.yaml	
+++ b/tests/1-500/82. remove-duplicates-from-sorted-list-ii/manifest.yaml	
@@ -2,24 +2,21 @@
   "id": 82
   "title": "remove-duplicates-from-sorted-list-ii"
   "call":
-    "cpp":
-      "listNodeToArray(Solution().deleteDuplicates(toListNode(lv(vector<int>{\
-      \ {head} }))))"
-    "rust": "ListNode::list_node_to_array(Solution::delete_duplicates(ListNode::to_list_node(vec!{head})))"
-    "python3": "list_node_to_array(Solution().deleteDuplicates(to_list_node([{head}])))"
-    "python2": "list_node_to_array(Solution().deleteDuplicates(to_list_node([{head}])))"
-    "ruby": "list_node_to_array(delete_duplicates(to_list_node({head})))"
-    "java":
-      "ListNode.listNodeToArray(new Solution().deleteDuplicates(ListNode.toListNode(new\
-      \ int[]{ {head} })))"
-    "csharp":
-      "ListNode.ListNodeToArray(new Solution().DeleteDuplicates(ListNode.ToListNode(new\
-      \ int[]{ {head} })))"
-    "kotlin": "listNodeToArray(Solution().deleteDuplicates(toListNode(intArrayOf({head}))))"
-    "go": "listNodeToArray(deleteDuplicates(toListNode({head})))"
-    "dart": "list_node_to_array(Solution().deleteDuplicates(to_list_node({head})))"
-    "swift": "list_node_to_array(Solution().deleteDuplicates(to_list_node({head})))"
-    "typescript": "list_node_to_array(deleteDuplicates(to_list_node({head})))"
+    "cpp": "listNodeToArray(Solution().deleteDuplicates({head}))"
+    "rust": "ListNode::list_node_to_array(Solution::delete_duplicates({head}))"
+    "python3": "list_node_to_array(Solution().deleteDuplicates({head}))"
+    "python2": "list_node_to_array(Solution().deleteDuplicates({head}))"
+    "ruby": "list_node_to_array(delete_duplicates({head}))"
+    "java": "ListNode.listNodeToArray(new Solution().deleteDuplicates({head}))"
+    "csharp": "ListNode.ListNodeToArray(new Solution().DeleteDuplicates({head}))"
+    "kotlin": "listNodeToArray(Solution().deleteDuplicates({head}))"
+    "go": "listNodeToArray(deleteDuplicates({head}))"
+    "dart": "list_node_to_array(Solution().deleteDuplicates({head}))"
+    "swift": "list_node_to_array(Solution().deleteDuplicates({head}))"
+    "typescript": "listNodeToArray(deleteDuplicates({head}))"
+  params:
+    head:
+      type: list_node
 "judge":
   "type": "exact"
 "limits":
@@ -27,15 +24,13 @@
   "memory_mb": 256
 "oracle":
   "python3":
-    "call": "Checker().verify([{head}], {result})"
+    "call": "Checker().verify(head, {result})"
     "checker":
-      "import json\nclass Checker:\n    def verify(self, input_arr, result_arr):\n\
-      \        from collections import Counter\n        try:\n            result_arr\
-      \ = json.loads(result_arr) if isinstance(result_arr, str) else result_arr\n\
-      \        except Exception:\n            return False\n        counts = Counter(input_arr)\n\
-      \        expected = [x for x in input_arr if counts[x] == 1]\n        if isinstance(result_arr,\
-      \ list) and len(result_arr) == 1 and isinstance(result_arr[0], list):\n    \
-      \        result_arr = result_arr[0]\n        return expected == result_arr\n"
+      "import json\nclass Checker:\n    def verify(self, input_arr, result_arr):\n        from collections import
+      Counter\n        try:\n            result_arr = json.loads(result_arr) if isinstance(result_arr, str) else result_arr\n\
+      \        except Exception:\n            return False\n        counts = Counter(input_arr)\n        expected = [x for
+      x in input_arr if counts[x] == 1]\n        if isinstance(result_arr, list) and len(result_arr) == 1 and isinstance(result_arr[0],
+      list):\n            result_arr = result_arr[0]\n        return expected == result_arr\n"
 "seed": 42
 "tests":
   - "name": "example 1"
diff --git a/tests/1-500/83. remove-duplicates-from-sorted-list/manifest.yaml b/tests/1-500/83. remove-duplicates-from-sorted-list/manifest.yaml
index 4a2f9859..52e052fc 100644
--- a/tests/1-500/83. remove-duplicates-from-sorted-list/manifest.yaml	
+++ b/tests/1-500/83. remove-duplicates-from-sorted-list/manifest.yaml	
@@ -2,24 +2,21 @@ entry:
   id: 83
   title: remove-duplicates-from-sorted-list
   call:
-    cpp:
-      listNodeToArray(Solution().deleteDuplicates(toListNode(lv(vector<int>{ {head}
-      }))))
-    rust: ListNode::list_node_to_array(Solution::delete_duplicates(ListNode::to_list_node(vec![{head}])))
-    python3: list_node_to_array(Solution().deleteDuplicates(to_list_node([{head}])))
-    python2: list_node_to_array(Solution().deleteDuplicates(to_list_node([{head}])))
-    ruby: list_node_to_array(delete_duplicates(to_list_node([{head}])))
-    java:
-      ListNode.listNodeToArray(new Solution().deleteDuplicates(ListNode.toListNode(new
-      int[]{ {head} })))
-    csharp:
-      ListNode.ListNodeToArray(new Solution().DeleteDuplicates(ListNode.ToListNode(new
-      int[]{ {head} })))
-    kotlin: listNodeToArray(Solution().deleteDuplicates(toListNode(intArrayOf({head}))))
-    go: listNodeToArray(deleteDuplicates(toListNode([]int{ {head} })))
-    dart: list_node_to_array(Solution().deleteDuplicates(to_list_node([{head}])))
-    swift: list_node_to_array(Solution().deleteDuplicates(to_list_node([{head}])))
-    typescript: listNodeToArray(deleteDuplicates(toListNode([{head}])))
+    cpp: listNodeToArray(Solution().deleteDuplicates({head}))
+    rust: ListNode::list_node_to_array(Solution::delete_duplicates({head}))
+    python3: list_node_to_array(Solution().deleteDuplicates({head}))
+    python2: list_node_to_array(Solution().deleteDuplicates({head}))
+    ruby: list_node_to_array(delete_duplicates({head}))
+    java: ListNode.listNodeToArray(new Solution().deleteDuplicates({head}))
+    csharp: ListNode.ListNodeToArray(new Solution().DeleteDuplicates({head}))
+    kotlin: listNodeToArray(Solution().deleteDuplicates({head}))
+    go: listNodeToArray(deleteDuplicates({head}))
+    dart: list_node_to_array(Solution().deleteDuplicates({head}))
+    swift: list_node_to_array(Solution().deleteDuplicates({head}))
+    typescript: listNodeToArray(deleteDuplicates({head}))
+  params:
+    head:
+      type: list_node
 judge:
   type: exact
 limits:
@@ -27,12 +24,11 @@ limits:
   memory_mb: 256
 oracle:
   python3:
-    call: Checker().check([{head}], {result})
+    call: Checker().check(head, {result})
     checker:
-      "import json\n\nclass Checker:\n    def check(self, head, result):\n\
-      \        expected = sorted(list(set(head)))\n        try:\n            got =\
-      \ json.loads(result) if isinstance(result, str) else result\n        except\
-      \ Exception:\n            return False\n        return got == expected\n"
+      "import json\n\nclass Checker:\n    def check(self, head, result):\n        expected = sorted(list(set(head)))\n\
+      \        try:\n            got = json.loads(result) if isinstance(result, str) else result\n        except Exception:\n\
+      \            return False\n        return got == expected\n"
 seed: 42
 tests:
   - name: example 1
diff --git a/tests/1-500/84. largest-rectangle-in-histogram/manifest.yaml b/tests/1-500/84. largest-rectangle-in-histogram/manifest.yaml
index 4d367a05..7597993a 100644
--- a/tests/1-500/84. largest-rectangle-in-histogram/manifest.yaml	
+++ b/tests/1-500/84. largest-rectangle-in-histogram/manifest.yaml	
@@ -2,18 +2,23 @@
   "id": 84
   "title": "largest-rectangle-in-histogram"
   "call":
-    "cpp": "Solution().largestRectangleArea(lv(vector<int>{ {heights} }))"
-    "rust": "Solution::largest_rectangle_area(vec![{heights}])"
-    "python3": "Solution().largestRectangleArea([{heights}])"
-    "python2": "Solution().largestRectangleArea([{heights}])"
-    "ruby": "largest_rectangle_area([{heights}])"
-    "java": "new Solution().largestRectangleArea(new int[]{ {heights} })"
-    "csharp": "new Solution().LargestRectangleArea(new int[]{ {heights} })"
-    "kotlin": "Solution().largestRectangleArea(intArrayOf({heights}))"
-    "go": "largestRectangleArea([]int{ {heights} })"
-    "dart": "Solution().largestRectangleArea([{heights}])"
-    "swift": "Solution().largestRectangleArea([{heights}])"
-    "typescript": "largestRectangleArea([{heights}])"
+    "cpp": "Solution().largestRectangleArea({heights})"
+    "rust": "Solution::largest_rectangle_area({heights})"
+    "python3": "Solution().largestRectangleArea({heights})"
+    "python2": "Solution().largestRectangleArea({heights})"
+    "ruby": "largest_rectangle_area({heights})"
+    "java": "new Solution().largestRectangleArea({heights})"
+    "csharp": "new Solution().LargestRectangleArea({heights})"
+    "kotlin": "Solution().largestRectangleArea({heights})"
+    "go": "largestRectangleArea({heights})"
+    "dart": "Solution().largestRectangleArea({heights})"
+    "swift": "Solution().largestRectangleArea({heights})"
+    "typescript": "largestRectangleArea({heights})"
+  params:
+    heights:
+      type: array
+      items:
+        type: int
 "judge":
   "type": "exact"
 "limits":
@@ -21,19 +26,16 @@
   "memory_mb": 256
 "oracle":
   "python3":
-    "call": "Checker().largestRectangleArea([{heights}], {result})"
+    "call": "Checker().largestRectangleArea({heights}, {result})"
     "checker":
-      "class Checker:\n    def largestRectangleArea(self, heights, result):\n\
-      \        try:\n            result = int(result)\n        except Exception:\n\
-      \            return False\n        n = len(heights)\n        left, right = [-1]\
-      \ * n, [n] * n\n        stack = []\n        for i in range(n):\n           \
-      \ while stack and heights[stack[-1]] >= heights[i]:\n                stack.pop()\n\
-      \            left[i] = stack[-1] if stack else -1\n            stack.append(i)\n\
-      \        stack.clear()\n        for i in range(n - 1, -1, -1):\n           \
-      \ while stack and heights[stack[-1]] >= heights[i]:\n                stack.pop()\n\
-      \            right[i] = stack[-1] if stack else n\n            stack.append(i)\n\
-      \        max_area = 0\n        for i in range(n):\n            max_area = max(max_area,\
-      \ heights[i] * (right[i] - left[i] - 1))\n        return max_area == result\n"
+      "class Checker:\n    def largestRectangleArea(self, heights, result):\n        try:\n            result = int(result)\n\
+      \        except Exception:\n            return False\n        n = len(heights)\n        left, right = [-1] * n, [n]
+      * n\n        stack = []\n        for i in range(n):\n            while stack and heights[stack[-1]] >= heights[i]:\n\
+      \                stack.pop()\n            left[i] = stack[-1] if stack else -1\n            stack.append(i)\n      \
+      \  stack.clear()\n        for i in range(n - 1, -1, -1):\n            while stack and heights[stack[-1]] >= heights[i]:\n\
+      \                stack.pop()\n            right[i] = stack[-1] if stack else n\n            stack.append(i)\n      \
+      \  max_area = 0\n        for i in range(n):\n            max_area = max(max_area, heights[i] * (right[i] - left[i] -
+      1))\n        return max_area == result\n"
 "seed": 42
 "tests":
   - "name": "Example 1"
diff --git a/tests/1-500/85. maximal-rectangle/manifest.yaml b/tests/1-500/85. maximal-rectangle/manifest.yaml
index 2ef62e3c..09132c49 100644
--- a/tests/1-500/85. maximal-rectangle/manifest.yaml	
+++ b/tests/1-500/85. maximal-rectangle/manifest.yaml	
@@ -1,53305 +1,468 @@
-"entry":
-  "id": 85
-  "title": "maximal-rectangle"
-  "call":
-    "cpp": "Solution().maximalRectangle(lv(vector<vector<char>>{ {matrix} }))"
-    "rust": "Solution::maximal_rectangle(vec![{matrix}])"
-    "python3": "Solution().maximalRectangle([{matrix}])"
-    "python2": "Solution().maximalRectangle([{matrix}])"
-    "ruby": "maximal_rectangle([{matrix}])"
-    "java": "new Solution().maximalRectangle(new char[][]{ {matrix} })"
-    "csharp": "new Solution().MaximalRectangle(new char[][]{ {matrix} })"
-    "kotlin": "Solution().maximalRectangle(arrayOf({matrix}))"
-    "go": "maximalRectangle([][]byte{ {matrix} })"
-    "dart": "Solution().maximalRectangle([{matrix}])"
-    "swift": "Solution().maximalRectangle([{matrix}])"
-    "typescript": "maximalRectangle([{matrix}])"
-"judge":
-  "type": "exact"
-"limits":
-  "time_ms": 2000
-  "memory_mb": 256
-"oracle":
-  "python3":
-    "call": "Checker().run([{matrix}], {result})"
-    "checker": "class Checker:\n    def run(self, matrix, result):\n        if not matrix or not matrix[0]: return result == 0\n        M, N = len(matrix), len(matrix[0])\n        m = [[int(matrix[i][j]) for j in range(N)] for i in range(M)]\n        ans = 0\n        for i in range(M):\n            for j in range(1, N):\n                if m[i][j] == 1: m[i][j] += m[i][j-1]\n        for i in range(M):\n            for j in range(N):\n                w = float('inf')\n                for k in range(i, -1, -1):\n                    w = min(w, m[k][j])\n                    if w == 0: break\n                    ans = max(ans, w * (i - k + 1))\n        return ans == result\n"
-"seed": 42
-"tests":
-  - "name": "Example 1"
-    "in":
-      "matrix":
-        elemType: char
+entry:
+  id: 85
+  title: "maximal-rectangle"
+  params:
+    matrix:
+      type: array
+      items:
+        type: array
+        items:
+          type: char
+  call:
+    cpp: "Solution().maximalRectangle({matrix})"
+    rust: "Solution::maximal_rectangle({matrix})"
+    python3: "Solution().maximalRectangle({matrix})"
+    python2: "Solution().maximalRectangle({matrix})"
+    ruby: "maximal_rectangle({matrix})"
+    java: "new Solution().maximalRectangle({matrix})"
+    csharp: "new Solution().MaximalRectangle({matrix})"
+    kotlin: "Solution().maximalRectangle({matrix})"
+    go: "maximalRectangle({matrix})"
+    dart: "Solution().maximalRectangle({matrix})"
+    swift: "Solution().maximalRectangle({matrix})"
+    typescript: "maximalRectangle({matrix})"
+
+judge:
+  type: "exact"
+
+limits:
+  time_ms: 3000
+  memory_mb: 256
+
+oracle:
+  python3:
+    call: "Checker().maximalRectangle(matrix, {result})"
+    checker: |
+      class Checker:
+          def maximalRectangle(self, matrix, result):
+              if isinstance(result, float) and result.is_integer():
+                  result = int(result)
+              if not isinstance(result, int):
+                  return False
+
+              rows = len(matrix)
+              cols = len(matrix[0])
+
+              heights = [0] * cols
+              best = 0
+
+              for row in matrix:
+                  for c, ch in enumerate(row):
+                      if ch == "1":
+                          heights[c] += 1
+                      else:
+                          heights[c] = 0
+
+                  stack = []
+                  extended = heights + [0]
+
+                  for i, h in enumerate(extended):
+                      while stack and extended[stack[-1]] > h:
+                          height = extended[stack.pop()]
+                          left = stack[-1] if stack else -1
+                          width = i - left - 1
+                          best = max(best, height * width)
+                      stack.append(i)
+
+              return result == best
+
+seed: 85085
+
+tests:
+  - name: "example_1_mixed_rectangle"
+    in:
+      matrix:
+        elemType: "char"
         value:
-          - - "1"
-            - "0"
-            - "1"
-            - "0"
-            - "0"
-          - - "1"
-            - "0"
-            - "1"
-            - "1"
-            - "1"
-          - - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-          - - "1"
-            - "0"
-            - "0"
-            - "1"
-            - "0"
-    "out": 6
-  - "name": "Example 2"
-    "in":
-      "matrix":
-        elemType: char
+          - ["1", "0", "1", "0", "0"]
+          - ["1", "0", "1", "1", "1"]
+          - ["1", "1", "1", "1", "1"]
+          - ["1", "0", "0", "1", "0"]
+    out: 6
+    judge:
+      type: "exact"
+    seed: 1
+
+  - name: "example_2_single_zero"
+    in:
+      matrix:
+        elemType: "char"
         value:
-          - - "0"
-    "out": 0
-  - "name": "Example 3"
-    "in":
-      "matrix":
-        elemType: char
+          - ["0"]
+    out: 0
+    judge:
+      type: "exact"
+    seed: 2
+
+  - name: "example_3_single_one"
+    in:
+      matrix:
+        elemType: "char"
         value:
-          - - "1"
-    "out": 1
-  - "name": "All zeros"
-    "in":
-      "matrix":
-        elemType: char
+          - ["1"]
+    out: 1
+    judge:
+      type: "exact"
+    seed: 3
+
+  - name: "single_row_all_zeros"
+    in:
+      matrix:
+        elemType: "char"
         value:
-          - - "0"
-            - "0"
-          - - "0"
-            - "0"
-    "out": 0
-  - "name": "All ones"
-    "in":
-      "matrix":
-        elemType: char
+          - ["0", "0", "0", "0", "0", "0"]
+    out: 0
+    judge:
+      type: "exact"
+    seed: 4
+
+  - name: "single_row_all_ones"
+    in:
+      matrix:
+        elemType: "char"
         value:
-          - - "1"
-            - "1"
-          - - "1"
-            - "1"
-    "out": 4
-  - "name": "Single row"
-    "in":
-      "matrix":
-        elemType: char
+          - ["1", "1", "1", "1", "1", "1", "1", "1", "1", "1"]
+    out: 10
+    judge:
+      type: "exact"
+    seed: 5
+
+  - name: "single_column_all_ones"
+    in:
+      matrix:
+        elemType: "char"
         value:
-          - - "1"
-            - "1"
-            - "0"
-            - "1"
-    "out": 2
-  - "name": "Single column"
-    "in":
-      "matrix":
-        elemType: char
+          - ["1"]
+          - ["1"]
+          - ["1"]
+          - ["1"]
+          - ["1"]
+          - ["1"]
+    out: 6
+    judge:
+      type: "exact"
+    seed: 6
+
+  - name: "single_column_mixed_runs"
+    in:
+      matrix:
+        elemType: "char"
         value:
-          - - "1"
-          - - "1"
-          - - "0"
-    "out": 2
-  - "name": "Thin rectangle"
-    "in":
-      "matrix":
-        elemType: char
+          - ["1"]
+          - ["0"]
+          - ["1"]
+          - ["1"]
+          - ["0"]
+          - ["1"]
+          - ["1"]
+          - ["1"]
+    out: 3
+    judge:
+      type: "exact"
+    seed: 7
+
+  - name: "all_zeros_3_by_4"
+    in:
+      matrix:
+        elemType: "char"
         value:
-          - - "1"
-            - "1"
-            - "1"
-    "out": 3
-  - "name": "Alternating"
-    "in":
-      "matrix":
-        elemType: char
+          - ["0", "0", "0", "0"]
+          - ["0", "0", "0", "0"]
+          - ["0", "0", "0", "0"]
+    out: 0
+    judge:
+      type: "exact"
+    seed: 8
+
+  - name: "all_ones_4_by_5"
+    in:
+      matrix:
+        elemType: "char"
         value:
-          - - "1"
-            - "0"
-            - "1"
-          - - "0"
-            - "1"
-            - "0"
-    "out": 1
-  - "name": "Checkerboard"
-    "in":
-      "matrix":
-        elemType: char
+          - ["1", "1", "1", "1", "1"]
+          - ["1", "1", "1", "1", "1"]
+          - ["1", "1", "1", "1", "1"]
+          - ["1", "1", "1", "1", "1"]
+    out: 20
+    judge:
+      type: "exact"
+    seed: 9
+
+  - name: "checkerboard_only_single_cells"
+    in:
+      matrix:
+        elemType: "char"
         value:
-          - - "1"
-            - "0"
-          - - "0"
-            - "1"
-    "out": 1
-  - "name": "Large empty center"
-    "in":
-      "matrix":
-        elemType: char
+          - ["1", "0", "1", "0", "1"]
+          - ["0", "1", "0", "1", "0"]
+          - ["1", "0", "1", "0", "1"]
+          - ["0", "1", "0", "1", "0"]
+    out: 1
+    judge:
+      type: "exact"
+    seed: 10
+
+  - name: "vertical_stripes"
+    in:
+      matrix:
+        elemType: "char"
         value:
-          - - "1"
-            - "1"
-            - "1"
-          - - "1"
-            - "0"
-            - "1"
-          - - "1"
-            - "1"
-            - "1"
-    "out": 3
-  - "name": "Full box"
-    "in":
-      "matrix":
-        elemType: char
+          - ["1", "0", "1", "0", "1"]
+          - ["1", "0", "1", "0", "1"]
+          - ["1", "0", "1", "0", "1"]
+          - ["1", "0", "1", "0", "1"]
+    out: 4
+    judge:
+      type: "exact"
+    seed: 11
+
+  - name: "horizontal_band"
+    in:
+      matrix:
+        elemType: "char"
         value:
-          - - "1"
-            - "1"
-          - - "1"
-            - "1"
-          - - "1"
-            - "1"
-    "out": 6
-  - "name": "Generated 10x10"
-    "in":
-      "matrix":
-        elemType: char
+          - ["0", "0", "0", "0", "0"]
+          - ["1", "1", "1", "1", "1"]
+          - ["1", "1", "1", "1", "1"]
+          - ["0", "0", "0", "0", "0"]
+    out: 10
+    judge:
+      type: "exact"
+    seed: 12
+
+  - name: "separate_blocks_and_bottom_row"
+    in:
+      matrix:
+        elemType: "char"
         value:
-          - - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-          - - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-          - - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-          - - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-          - - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-          - - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-          - - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-          - - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-          - - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-          - - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-    "out": 100
-  - "name": "Generated 20x20"
-    "in":
-      "matrix":
-        elemType: char
+          - ["1", "1", "0", "0", "1", "1"]
+          - ["1", "1", "0", "0", "1", "1"]
+          - ["0", "0", "0", "0", "1", "1"]
+          - ["1", "1", "1", "1", "1", "1"]
+    out: 8
+    judge:
+      type: "exact"
+    seed: 13
+
+  - name: "hollow_rectangle_border"
+    in:
+      matrix:
+        elemType: "char"
         value:
-          - - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-          - - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-          - - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-          - - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-          - - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-          - - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-          - - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-          - - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-          - - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-          - - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-          - - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-          - - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-          - - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-          - - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-          - - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-          - - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-          - - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-          - - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-          - - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-          - - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-    "out": 400
-  - "name": "Generated 50x50"
-    "in":
-      "matrix":
-        elemType: char
+          - ["1", "1", "1", "1", "1"]
+          - ["1", "0", "0", "0", "1"]
+          - ["1", "1", "1", "1", "1"]
+    out: 5
+    judge:
+      type: "exact"
+    seed: 14
+
+  - name: "left_staircase"
+    in:
+      matrix:
+        elemType: "char"
         value:
-          - - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-          - - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-          - - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-          - - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-          - - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-          - - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-          - - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-          - - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-          - - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-          - - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-          - - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-          - - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-          - - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-          - - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-          - - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-          - - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-          - - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-          - - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-          - - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-          - - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-          - - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-          - - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-          - - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-          - - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-          - - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-          - - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-          - - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-          - - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-          - - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-          - - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-          - - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-          - - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-          - - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-          - - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-          - - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-          - - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-          - - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-          - - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-          - - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-          - - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-          - - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-          - - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-          - - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-          - - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-          - - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-          - - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-          - - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-          - - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-          - - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-          - - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-    "out": 2500
-  - "name": "Large All ones 100x100"
-    "in":
-      "matrix":
-        elemType: char
+          - ["1", "0", "0", "0", "0"]
+          - ["1", "1", "0", "0", "0"]
+          - ["1", "1", "1", "0", "0"]
+          - ["1", "1", "1", "1", "0"]
+          - ["1", "1", "1", "1", "1"]
+    out: 9
+    judge:
+      type: "exact"
+    seed: 15
+
+  - name: "right_trimmed_staircase"
+    in:
+      matrix:
+        elemType: "char"
         value:
-          - - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-          - - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-          - - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-          - - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-          - - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-          - - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-          - - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-          - - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-          - - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-          - - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-          - - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-          - - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-          - - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-          - - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-          - - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-          - - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-          - - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-          - - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-          - - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-          - - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-          - - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-          - - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-          - - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-          - - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-          - - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-          - - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-          - - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-          - - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-          - - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-          - - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-          - - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-          - - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-          - - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-          - - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-          - - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-          - - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-          - - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-          - - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-          - - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-          - - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-          - - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-          - - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-          - - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-          - - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-          - - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-          - - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-          - - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-          - - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-          - - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-          - - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-          - - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-          - - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-          - - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-          - - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-          - - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-          - - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-          - - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-          - - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-          - - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-          - - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-          - - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-          - - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-          - - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-          - - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-          - - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-          - - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-          - - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-          - - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-          - - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-          - - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-          - - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-          - - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-          - - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-          - - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-          - - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-          - - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-          - - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-          - - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-          - - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-          - - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-          - - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-          - - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-          - - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-          - - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-          - - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-          - - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-          - - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-          - - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-          - - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-          - - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-          - - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-          - - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-          - - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-          - - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-          - - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-          - - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-          - - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-          - - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-          - - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-          - - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-            - "1"
-    "out": 10000
-  - "name": "Large Max 200x200"
-    "in":
-      "matrix":
-        elemType: char
+          - ["1", "1", "1", "1", "1"]
+          - ["1", "1", "1", "1", "0"]
+          - ["1", "1", "1", "0", "0"]
+          - ["1", "1", "0", "0", "0"]
+          - ["1", "0", "0", "0", "0"]
+    out: 9
+    judge:
+      type: "exact"
+    seed: 16
+
+  - name: "three_by_three_center_zero"
+    in:
+      matrix:
+        elemType: "char"
         value:
-          - - "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"
-            - "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"
-            - "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"
-            - "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"
-            - "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"
-            - "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"
-            - "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"
-            - "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"
-            - "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"
-            - "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"
-            - "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"
-            - "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"
-            - "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"
-            - "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"
-            - "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"
-            - "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"
-            - "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"
-            - "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"
-            - "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"
-            - "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"
-            - "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"
-            - "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"
-            - "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"
-            - "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"
-            - "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"
-            - "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"
-            - "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"
-            - "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"
-            - "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"
-            - "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"
-            - "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"
-            - "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"
-            - "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"
-            - "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"
-            - "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"
-            - "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"
-            - "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"
-            - "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"
-            - "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"
-            - "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"
-            - "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"
-            - "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"
-            - "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"
-            - "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"
-            - "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"
-            - "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"
-            - "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"
-            - "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"
-            - "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"
-            - "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"
-          - - "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"
-            - "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"
-            - "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"
-            - "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"
-            - "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"
-            - "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"
-            - "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"
-            - "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"
-            - "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"
-            - "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"
-            - "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"
-            - "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"
-            - "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"
-            - "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"
-            - "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"
-            - "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"
-            - "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"
-            - "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"
-            - "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"
-            - "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"
-            - "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"
-            - "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"
-            - "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"
-            - "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"
-            - "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"
-            - "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"
-            - "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"
-            - "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"
-            - "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"
-            - "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"
-            - "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"
-            - "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"
-            - "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"
-            - "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"
-            - "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"
-            - "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"
-            - "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"
-            - "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"
-            - "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"
-            - "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"
-            - "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"
-            - "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"
-            - "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"
-            - "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"
-            - "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"
-            - "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"
-            - "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"
-            - "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"
-            - "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"
-            - "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"
-          - - "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"
-            - "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"
-            - "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"
-            - "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"
-            - "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"
-            - "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"
-            - "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"
-            - "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"
-            - "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"
-            - "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"
-            - "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"
-            - "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"
-            - "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"
-            - "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"
-            - "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"
-            - "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"
-            - "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"
-            - "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"
-            - "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"
-            - "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"
-            - "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"
-            - "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"
-            - "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"
-            - "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"
-            - "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"
-            - "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"
-            - "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"
-            - "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"
-            - "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"
-            - "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"
-            - "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"
-            - "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"
-            - "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"
-            - "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"
-            - "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"
-            - "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"
-            - "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"
-            - "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"
-            - "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"
-            - "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"
-            - "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"
-            - "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"
-            - "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"
-            - "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"
-            - "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"
-            - "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"
-            - "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"
-            - "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"
-            - "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"
-            - "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"
-          - - "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"
-            - "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"
-            - "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"
-            - "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"
-            - "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"
-            - "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"
-            - "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"
-            - "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"
-            - "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"
-    "out": 0
-  - "name": "Border ones"
-    "in":
-      "matrix":
-        elemType: char
+          - ["1", "1", "1"]
+          - ["1", "0", "1"]
+          - ["1", "1", "1"]
+    out: 3
+    judge:
+      type: "exact"
+    seed: 17
+
+  - name: "wide_matrix_with_gap_column"
+    in:
+      matrix:
+        elemType: "char"
         value:
-          - - "1"
-            - "1"
-            - "1"
-          - - "1"
-            - "0"
-            - "1"
-          - - "1"
-            - "1"
-            - "1"
-    "out": 3
-  - "name": "Staircase"
-    "in":
-      "matrix":
-        elemType: char
+          - ["1", "1", "1", "0", "1", "1", "1"]
+          - ["1", "1", "1", "0", "1", "1", "1"]
+          - ["1", "1", "1", "1", "1", "1", "1"]
+    out: 9
+    judge:
+      type: "exact"
+    seed: 18
+
+  - name: "tall_narrow_with_break"
+    in:
+      matrix:
+        elemType: "char"
         value:
-          - - "1"
-            - "0"
-            - "0"
-          - - "1"
-            - "1"
-            - "0"
-          - - "1"
-            - "1"
-            - "1"
-    "out": 4
-  - "name": "Vertical strip"
-    "in":
-      "matrix":
-        elemType: char
+          - ["1", "1"]
+          - ["1", "1"]
+          - ["0", "1"]
+          - ["1", "1"]
+          - ["1", "1"]
+          - ["1", "1"]
+    out: 6
+    judge:
+      type: "exact"
+    seed: 19
+
+  - name: "complex_six_by_seven"
+    in:
+      matrix:
+        elemType: "char"
         value:
-          - - "1"
-            - "0"
-          - - "1"
-            - "0"
-          - - "1"
-            - "0"
-    "out": 3
-  - "name": "Horizontal strip"
-    "in":
-      "matrix":
-        elemType: char
+          - ["1", "0", "1", "1", "1", "1", "0"]
+          - ["1", "1", "1", "1", "1", "1", "0"]
+          - ["1", "1", "1", "0", "1", "1", "1"]
+          - ["0", "1", "1", "1", "1", "1", "1"]
+          - ["1", "1", "1", "1", "1", "0", "1"]
+          - ["1", "1", "0", "1", "1", "1", "1"]
+    out: 8
+    judge:
+      type: "exact"
+    seed: 20
+
+  - name: "last_three_columns_full_height"
+    in:
+      matrix:
+        elemType: "char"
         value:
-          - - "1"
-            - "1"
-            - "1"
-          - - "0"
-            - "0"
-            - "0"
-    "out": 3
-  - "name": "Sparse"
-    "in":
-      "matrix":
-        elemType: char
+          - ["0", "0", "1", "1", "1"]
+          - ["0", "0", "1", "1", "1"]
+          - ["1", "0", "1", "1", "1"]
+          - ["1", "1", "1", "1", "1"]
+    out: 12
+    judge:
+      type: "exact"
+    seed: 21
+
+  - name: "one_zero_breaks_square"
+    in:
+      matrix:
+        elemType: "char"
         value:
-          - - "1"
-            - "0"
-            - "0"
-            - "0"
-          - - "0"
-            - "0"
-            - "0"
-            - "1"
-    "out": 1
-  - "name": "Tall rectangle"
-    "in":
-      "matrix":
-        elemType: char
-        value:
-          - - "1"
-            - "1"
-          - - "1"
-            - "1"
-          - - "1"
-            - "1"
-          - - "1"
-            - "1"
-    "out": 8
-  - "name": "Wide rectangle"
-    "in":
-      "matrix":
-        elemType: char
-        value:
-          - - "1"
-            - "1"
-            - "1"
-            - "1"
-          - - "1"
-            - "1"
-            - "1"
-            - "1"
-    "out": 8
-  - "name": "Cross"
-    "in":
-      "matrix":
-        elemType: char
-        value:
-          - - "0"
-            - "1"
-            - "0"
-          - - "1"
-            - "1"
-            - "1"
-          - - "0"
-            - "1"
-            - "0"
-    "out": 3
+          - ["1", "1", "1", "1"]
+          - ["1", "1", "1", "1"]
+          - ["1", "1", "0", "1"]
+          - ["1", "1", "1", "1"]
+    out: 8
+    judge:
+      type: "exact"
+    seed: 22
+
+  - name: "generated_random_rows_single_column"
+    in:
+      matrix:
+        gen: "array"
+        len:
+          gen: "int"
+          min: 1
+          max: 200
+        of:
+          gen: "array"
+          len: 1
+          of:
+            gen: "char"
+            variety: ["0", "1"]
+          elemType: "char"
+        elemType: "char"
+    judge:
+      type: "exact"
+    seed: 23
+
+  - name: "generated_single_row_random_cols"
+    in:
+      matrix:
+        gen: "array"
+        len: 1
+        of:
+          gen: "array"
+          len:
+            gen: "int"
+            min: 1
+            max: 200
+          of:
+            gen: "char"
+            variety: ["0", "1"]
+          elemType: "char"
+        elemType: "char"
+    judge:
+      type: "exact"
+    seed: 24
+
+  - name: "generated_random_rows_fixed_20_cols"
+    in:
+      matrix:
+        gen: "array"
+        len:
+          gen: "int"
+          min: 1
+          max: 200
+        of:
+          gen: "array"
+          len: 20
+          of:
+            gen: "char"
+            variety: ["0", "1"]
+          elemType: "char"
+        elemType: "char"
+    judge:
+      type: "exact"
+    seed: 25
+
+  - name: "generated_large_200_by_200"
+    in:
+      matrix:
+        gen: "array"
+        len: 200
+        of:
+          gen: "array"
+          len: 200
+          of:
+            gen: "char"
+            variety: ["0", "1"]
+          elemType: "char"
+        elemType: "char"
+    judge:
+      type: "exact"
+    seed: 26
+
+  - name: "generated_large_199_by_200"
+    in:
+      matrix:
+        gen: "array"
+        len: 199
+        of:
+          gen: "array"
+          len: 200
+          of:
+            gen: "char"
+            variety: ["0", "1"]
+          elemType: "char"
+        elemType: "char"
+    judge:
+      type: "exact"
+    seed: 27
diff --git a/tests/1-500/86. partition-list/manifest.yaml b/tests/1-500/86. partition-list/manifest.yaml
index 85b923d2..7ff1c25a 100644
--- a/tests/1-500/86. partition-list/manifest.yaml	
+++ b/tests/1-500/86. partition-list/manifest.yaml	
@@ -2,28 +2,23 @@
   "id": 86
   "title": "partition-list"
   "call":
-    "cpp":
-      "listNodeToArray(Solution().partition(toListNode(lv(vector<int>{ {head}\
-      \ })), {x}))"
-    "rust":
-      "ListNode::list_node_to_array(Solution::partition(ListNode::to_list_node(vec![{head}]),\
-      \ {x}))"
-    "python3": "list_node_to_array(Solution().partition(to_list_node([{head}]), {x}))"
-    "python2": "list_node_to_array(Solution().partition(to_list_node([{head}]), {x}))"
-    "ruby": "list_node_to_array(partition(to_list_node([{head}]), {x}))"
-    "java":
-      "ListNode.listNodeToArray(new Solution().partition(ListNode.toListNode(new\
-      \ int[]{ {head} }), {x}))"
-    "csharp":
-      "ListNode.ListNodeToArray(new Solution().Partition(ListNode.ToListNode(new\
-      \ int[]{ {head} }), {x}))"
-    "kotlin":
-      "listNodeToArray(Solution().partition(toListNode(intArrayOf({head})),\
-      \ {x}))"
-    "go": "listNodeToArray(partition(toListNode([]int{ {head} }), {x}))"
-    "dart": "list_node_to_array(Solution().partition(to_list_node([{head}]), {x}))"
-    "swift": "list_node_to_array(Solution().partition(to_list_node([{head}]), {x}))"
-    "typescript": "listNodeToArray(partition(toListNode([{head}]), {x}))"
+    "cpp": "listNodeToArray(Solution().partition({head}, {x}))"
+    "rust": "ListNode::list_node_to_array(Solution::partition({head}, {x}))"
+    "python3": "list_node_to_array(Solution().partition({head}, {x}))"
+    "python2": "list_node_to_array(Solution().partition({head}, {x}))"
+    "ruby": "list_node_to_array(partition({head}, {x}))"
+    "java": "ListNode.listNodeToArray(new Solution().partition({head}, {x}))"
+    "csharp": "ListNode.ListNodeToArray(new Solution().Partition({head}, {x}))"
+    "kotlin": "listNodeToArray(Solution().partition({head}, {x}))"
+    "go": "listNodeToArray(partition({head}, {x}))"
+    "dart": "list_node_to_array(Solution().partition({head}, {x}))"
+    "swift": "list_node_to_array(Solution().partition({head}, {x}))"
+    "typescript": "listNodeToArray(partition({head}, {x}))"
+  params:
+    head:
+      type: list_node
+    x:
+      type: int
 "judge":
   "type": "exact"
 "limits":
@@ -31,11 +26,10 @@
   "memory_mb": 256
 "oracle":
   "python3":
-    "call": "Checker().check([{head}], {x}, {result})"
+    "call": "Checker().check(head, x, {result})"
     "checker":
-      "class Checker:\n    def check(self, head, x, result):\n        small\
-      \ = [v for v in head if v < x]\n        large = [v for v in head if v >= x]\n\
-      \        return result == (small + large)\n"
+      "class Checker:\n    def check(self, head, x, result):\n        small = [v for v in head if v < x]\n      \
+      \  large = [v for v in head if v >= x]\n        return result == (small + large)\n"
 "seed": 42
 "tests":
   - "name": "example 1"
diff --git a/tests/1-500/87. scramble-string/manifest.yaml b/tests/1-500/87. scramble-string/manifest.yaml
index 1bd8fbcd..9e7f1291 100644
--- a/tests/1-500/87. scramble-string/manifest.yaml	
+++ b/tests/1-500/87. scramble-string/manifest.yaml	
@@ -2,18 +2,23 @@
   "id": 87
   "title": "scramble-string"
   "call":
-    "cpp": 'Solution().isScramble("{s1}", "{s2}")'
-    "rust": 'Solution::is_scramble("{s1}".to_string(), "{s2}".to_string())'
-    "python3": 'Solution().isScramble("{s1}", "{s2}")'
-    "python2": 'Solution().isScramble("{s1}", "{s2}")'
-    "ruby": 'is_scramble("{s1}", "{s2}")'
-    "java": 'new Solution().isScramble("{s1}", "{s2}")'
-    "csharp": 'new Solution().IsScramble("{s1}", "{s2}")'
-    "kotlin": 'Solution().isScramble("{s1}", "{s2}")'
-    "go": 'isScramble("{s1}", "{s2}")'
-    "dart": 'Solution().isScramble("{s1}", "{s2}")'
-    "swift": 'Solution().isScramble("{s1}", "{s2}")'
-    "typescript": 'isScramble("{s1}", "{s2}")'
+    "cpp": "Solution().isScramble({s1}, {s2})"
+    "rust": "Solution::is_scramble({s1}, {s2})"
+    "python3": "Solution().isScramble({s1}, {s2})"
+    "python2": "Solution().isScramble({s1}, {s2})"
+    "ruby": "is_scramble({s1}, {s2})"
+    "java": "new Solution().isScramble({s1}, {s2})"
+    "csharp": "new Solution().IsScramble({s1}, {s2})"
+    "kotlin": "Solution().isScramble({s1}, {s2})"
+    "go": "isScramble({s1}, {s2})"
+    "dart": "Solution().isScramble({s1}, {s2})"
+    "swift": "Solution().isScramble({s1}, {s2})"
+    "typescript": "isScramble({s1}, {s2})"
+  "params":
+    "s1":
+      "type": "string"
+    "s2":
+      "type": "string"
 "judge":
   "type": "exact"
 "limits":
@@ -21,7 +26,7 @@
   "memory_mb": 256
 "oracle":
   "python3":
-    "call": 'Checker().isScramble("{s1}", "{s2}", {result})'
+    "call": "Checker().isScramble(s1, s2, {result})"
     "checker":
       "class Checker:\n    def isScramble(self, s1, s2, result):\n      \
       \  def solve(a, b):\n            if a == b: return True\n            if sorted(a)\
diff --git a/tests/1-500/89. gray-code/manifest.yaml b/tests/1-500/89. gray-code/manifest.yaml
index ab5b4d59..653727db 100644
--- a/tests/1-500/89. gray-code/manifest.yaml	
+++ b/tests/1-500/89. gray-code/manifest.yaml	
@@ -14,6 +14,9 @@
     "dart": "Solution().grayCode({n})"
     "swift": "Solution().grayCode({n})"
     "typescript": "grayCode({n})"
+  "params":
+    "n":
+      "type": "int"
 "judge":
   "type": "exact"
 "limits":
@@ -21,16 +24,33 @@
   "memory_mb": 256
 "oracle":
   "python3":
-    "call": "Checker().check({n}, {result})"
-    "checker":
-      "import json\nclass Checker:\n    def check(self, n, result):\n   \
-      \     try:\n            result = json.loads(result) if isinstance(result, str)\
-      \ else result\n        except Exception:\n            return False\n       \
-      \ if len(result) != (1 << n): return False\n        if sorted(result) != list(range(1\
-      \ << n)):\n            return False\n        for i in range(len(result)):\n\
-      \            curr = result[i]\n            nxt = result[(i + 1) % len(result)]\n\
-      \            diff = curr ^ nxt\n            if diff == 0 or (diff & (diff -\
-      \ 1)) != 0: return False\n        return True\n"
+    "call": "Checker().check(n, {result})"
+    "checker": |
+      import json
+
+      class Checker:
+          def check(self, n, result):
+              try:
+                  result = json.loads(result) if isinstance(result, str) else result
+              except Exception:
+                  return False
+
+              for i, x in enumerate(result):
+                  if isinstance(x, float) and x.is_integer():
+                      result[i] = int(x)
+
+              if len(result) != (1 << n):
+                  return False
+              if sorted(result) != list(range(1 << n)):
+                  return False
+
+              for i in range(len(result)):
+                  curr = result[i]
+                  nxt = result[(i + 1) % len(result)]
+                  diff = curr ^ nxt
+                  if diff == 0 or (diff & (diff - 1)) != 0:
+                      return False
+              return True
 "seed": 42
 "tests":
   - "name": "n=1"
diff --git a/tests/1-500/9. palindrome-number/manifest.yaml b/tests/1-500/9. palindrome-number/manifest.yaml
index de709775..9ae4f47e 100644
--- a/tests/1-500/9. palindrome-number/manifest.yaml	
+++ b/tests/1-500/9. palindrome-number/manifest.yaml	
@@ -1,6 +1,9 @@
 entry:
   id: 9
   title: palindrome-number
+  params:
+    x:
+      type: int
   call:
     cpp: Solution().isPalindrome({x})
     rust: Solution::is_palindrome({x})
@@ -21,7 +24,7 @@ limits:
   memory_mb: 256
 oracle:
   python3:
-    call: Checker().isPalindrome({x}, {result})
+    call: Checker().isPalindrome(x, {result})
     checker:
       "import json\nclass Checker:\n    def _norm(self, result):\n        if\
       \ isinstance(result, str):\n            try:\n                result = json.loads(result)\n\
diff --git a/tests/1-500/90. subsets-ii/manifest.yaml b/tests/1-500/90. subsets-ii/manifest.yaml
index a97f2c57..feb9dd8d 100644
--- a/tests/1-500/90. subsets-ii/manifest.yaml	
+++ b/tests/1-500/90. subsets-ii/manifest.yaml	
@@ -2,18 +2,23 @@
   "id": 90
   "title": "subsets-ii"
   "call":
-    "cpp": "Solution().subsetsWithDup(lv(vector<int>{ {nums} }))"
-    "rust": "Solution::subsets_with_dup(vec![{nums}])"
-    "python3": "Solution().subsetsWithDup([{nums}])"
-    "python2": "Solution().subsetsWithDup([{nums}])"
-    "ruby": "subsets_with_dup([{nums}])"
-    "java": "new Solution().subsetsWithDup(new int[]{ {nums} })"
-    "csharp": "new Solution().SubsetsWithDup(new int[]{ {nums} })"
-    "kotlin": "Solution().subsetsWithDup(intArrayOf({nums}))"
-    "go": "subsetsWithDup([]int{ {nums} })"
-    "dart": "Solution().subsetsWithDup([{nums}])"
-    "swift": "Solution().subsetsWithDup([{nums}])"
-    "typescript": "subsetsWithDup([{nums}])"
+    "cpp": "Solution().subsetsWithDup({nums})"
+    "rust": "Solution::subsets_with_dup({nums})"
+    "python3": "Solution().subsetsWithDup({nums})"
+    "python2": "Solution().subsetsWithDup({nums})"
+    "ruby": "subsets_with_dup({nums})"
+    "java": "new Solution().subsetsWithDup({nums})"
+    "csharp": "new Solution().SubsetsWithDup({nums})"
+    "kotlin": "Solution().subsetsWithDup({nums})"
+    "go": "subsetsWithDup({nums})"
+    "dart": "Solution().subsetsWithDup({nums})"
+    "swift": "Solution().subsetsWithDup({nums})"
+    "typescript": "subsetsWithDup({nums})"
+  params:
+    nums:
+      type: array
+      items:
+        type: int
 "judge":
   "type": "ignore_order"
 "limits":
@@ -21,22 +26,17 @@
   "memory_mb": 256
 "oracle":
   "python3":
-    "call": "Checker().subsetsWithDup([{nums}], {result})"
+    "call": "Checker().subsetsWithDup(nums, {result})"
     "checker":
-      "import json\nclass Checker:\n    def subsetsWithDup(self, nums, result):\n\
-      \        try:\n            result = json.loads(result) if isinstance(result,\
-      \ str) else result\n        except Exception:\n            return False\n  \
-      \      def get_subsets(arr):\n            arr.sort()\n            res = []\n\
-      \            def backtrack(start, path):\n                res.append(list(path))\n\
-      \                for i in range(start, len(arr)):\n                    if i\
-      \ > start and arr[i] == arr[i-1]:\n                        continue\n      \
-      \              path.append(arr[i])\n                    backtrack(i+1, path)\n\
-      \                    path.pop()\n            backtrack(0, [])\n            return\
-      \ res\n        expected = get_subsets(nums)\n        import collections\n  \
-      \      def count_subsets(subsets):\n            normalized = []\n          \
-      \  for s in subsets:\n                normalized.append(tuple(sorted(s)))\n\
-      \            return collections.Counter(normalized)\n        return count_subsets(result)\
-      \ == count_subsets(expected)\n"
+      "import json\nclass Checker:\n    def subsetsWithDup(self, nums, result):\n        try:\n            result
+      = json.loads(result) if isinstance(result, str) else result\n        except Exception:\n            return False\n \
+      \       def get_subsets(arr):\n            arr.sort()\n            res = []\n            def backtrack(start, path):\n\
+      \                res.append(list(path))\n                for i in range(start, len(arr)):\n                    if i
+      > start and arr[i] == arr[i-1]:\n                        continue\n                    path.append(arr[i])\n       \
+      \             backtrack(i+1, path)\n                    path.pop()\n            backtrack(0, [])\n            return
+      res\n        expected = get_subsets(nums)\n        import collections\n        def count_subsets(subsets):\n       \
+      \     normalized = []\n            for s in subsets:\n                normalized.append(tuple(sorted(s)))\n        \
+      \    return collections.Counter(normalized)\n        return count_subsets(result) == count_subsets(expected)\n"
 "seed": 42
 "tests":
   - "name": "Example 1"
diff --git a/tests/1-500/91. decode-ways/manifest.yaml b/tests/1-500/91. decode-ways/manifest.yaml
index b52d505a..85655417 100644
--- a/tests/1-500/91. decode-ways/manifest.yaml	
+++ b/tests/1-500/91. decode-ways/manifest.yaml	
@@ -2,18 +2,21 @@
   "id": 91
   "title": "decode-ways"
   "call":
-    "cpp": 'Solution().numDecodings("{s}")'
-    "rust": 'Solution::num_decodings("{s}".to_string())'
-    "python3": 'Solution().numDecodings("{s}")'
-    "python2": 'Solution().numDecodings("{s}")'
-    "ruby": 'num_decodings("{s}")'
-    "java": 'new Solution().numDecodings("{s}")'
-    "csharp": 'new Solution().NumDecodings("{s}")'
-    "kotlin": 'Solution().numDecodings("{s}")'
-    "go": 'numDecodings("{s}")'
-    "dart": 'Solution().numDecodings("{s}")'
-    "swift": 'Solution().numDecodings("{s}")'
-    "typescript": 'numDecodings("{s}")'
+    "cpp": "Solution().numDecodings({s})"
+    "rust": "Solution::num_decodings({s})"
+    "python3": "Solution().numDecodings({s})"
+    "python2": "Solution().numDecodings({s})"
+    "ruby": "num_decodings({s})"
+    "java": "new Solution().numDecodings({s})"
+    "csharp": "new Solution().NumDecodings({s})"
+    "kotlin": "Solution().numDecodings({s})"
+    "go": "numDecodings({s})"
+    "dart": "Solution().numDecodings({s})"
+    "swift": "Solution().numDecodings({s})"
+    "typescript": "numDecodings({s})"
+  "params":
+    "s":
+      "type": "string"
 "judge":
   "type": "exact"
 "limits":
@@ -21,7 +24,7 @@
   "memory_mb": 256
 "oracle":
   "python3":
-    "call": 'Checker().numDecodings("{s}", {result})'
+    "call": "Checker().numDecodings(s, {result})"
     "checker":
       "class Checker:\n    def numDecodings(self, s, result):\n        if\
       \ not s: return result == 0\n        n = len(s)\n        dp = [0] * (n + 1)\n\
diff --git a/tests/1-500/92. reverse-linked-list-ii/manifest.yaml b/tests/1-500/92. reverse-linked-list-ii/manifest.yaml
index 0cb813ed..1550022f 100644
--- a/tests/1-500/92. reverse-linked-list-ii/manifest.yaml	
+++ b/tests/1-500/92. reverse-linked-list-ii/manifest.yaml	
@@ -2,36 +2,25 @@
   "id": 92
   "title": "reverse-linked-list-ii"
   "call":
-    "cpp":
-      "listNodeToArray(Solution().reverseBetween(toListNode(lv(vector<int>{ {head}\
-      \ })), {left}, {right}))"
-    "rust":
-      "ListNode::list_node_to_array(Solution::reverse_between(ListNode::to_list_node(vec![{head}]),\
-      \ {left}, {right}))"
-    "python3":
-      "list_node_to_array(Solution().reverseBetween(to_list_node([{head}]),\
-      \ {left}, {right}))"
-    "python2":
-      "list_node_to_array(Solution().reverseBetween(to_list_node([{head}]),\
-      \ {left}, {right}))"
-    "ruby": "list_node_to_array(reverse_between(to_list_node([{head}]), {left}, {right}))"
-    "java":
-      "ListNode.listNodeToArray(new Solution().reverseBetween(ListNode.toListNode(new\
-      \ int[]{ {head} }), {left}, {right}))"
-    "csharp":
-      "ListNode.ListNodeToArray(new Solution().ReverseBetween(ListNode.ToListNode(new\
-      \ int[]{ {head} }), {left}, {right}))"
-    "kotlin":
-      "listNodeToArray(Solution().reverseBetween(toListNode(intArrayOf({head})),\
-      \ {left}, {right}))"
-    "go": "listNodeToArray(reverseBetween(toListNode([]int{ {head} }), {left}, {right}))"
-    "dart":
-      "list_node_to_array(Solution().reverseBetween(to_list_node([{head}]),\
-      \ {left}, {right}))"
-    "swift":
-      "list_node_to_array(Solution().reverseBetween(to_list_node([{head}]),\
-      \ {left}, {right}))"
-    "typescript": "listNodeToArray(reverseBetween(toListNode([{head}]), {left}, {right}))"
+    "cpp": "listNodeToArray(Solution().reverseBetween({head}, {left}, {right}))"
+    "rust": "ListNode::list_node_to_array(Solution::reverse_between({head}, {left}, {right}))"
+    "python3": "list_node_to_array(Solution().reverseBetween({head}, {left}, {right}))"
+    "python2": "list_node_to_array(Solution().reverseBetween({head}, {left}, {right}))"
+    "ruby": "list_node_to_array(reverse_between({head}, {left}, {right}))"
+    "java": "ListNode.listNodeToArray(new Solution().reverseBetween({head}, {left}, {right}))"
+    "csharp": "ListNode.ListNodeToArray(new Solution().ReverseBetween({head}, {left}, {right}))"
+    "kotlin": "listNodeToArray(Solution().reverseBetween({head}, {left}, {right}))"
+    "go": "listNodeToArray(reverseBetween({head}, {left}, {right}))"
+    "dart": "list_node_to_array(Solution().reverseBetween({head}, {left}, {right}))"
+    "swift": "list_node_to_array(Solution().reverseBetween({head}, {left}, {right}))"
+    "typescript": "listNodeToArray(reverseBetween({head}, {left}, {right}))"
+  params:
+    head:
+      type: list_node
+    left:
+      type: int
+    right:
+      type: int
 "judge":
   "type": "exact"
 "limits":
@@ -39,12 +28,11 @@
   "memory_mb": 256
 "oracle":
   "python3":
-    "call": "Checker().reverse_between([{head}], {left}, {right}, {result})"
+    "call": "Checker().reverse_between(head, left, right, {result})"
     "checker":
-      "class Checker:\n    def reverse_between(self, head, left, right, result):\n\
-      \        if left == right:\n            return head == result\n        arr =\
-      \ list(head)\n        sub = arr[left-1:right]\n        arr[left-1:right] = sub[::-1]\n\
-      \        return arr == result\n"
+      "class Checker:\n    def reverse_between(self, head, left, right, result):\n        if left == right:\n   \
+      \         return head == result\n        arr = list(head)\n        sub = arr[left-1:right]\n        arr[left-1:right]
+      = sub[::-1]\n        return arr == result\n"
 "seed": 42
 "tests":
   - "name": "example 1"
diff --git a/tests/1-500/93. restore-ip-addresses/manifest.yaml b/tests/1-500/93. restore-ip-addresses/manifest.yaml
index fede4463..c070ef4a 100644
--- a/tests/1-500/93. restore-ip-addresses/manifest.yaml	
+++ b/tests/1-500/93. restore-ip-addresses/manifest.yaml	
@@ -2,18 +2,21 @@
   "id": 93
   "title": "restore-ip-addresses"
   "call":
-    "cpp": 'Solution().restoreIpAddresses("{s}")'
-    "rust": 'Solution::restore_ip_addresses("{s}".to_string())'
-    "python3": 'Solution().restoreIpAddresses("{s}")'
-    "python2": 'Solution().restoreIpAddresses("{s}")'
-    "ruby": 'restore_ip_addresses("{s}")'
-    "java": 'new Solution().restoreIpAddresses("{s}")'
-    "csharp": 'new Solution().RestoreIpAddresses("{s}")'
-    "kotlin": 'Solution().restoreIpAddresses("{s}")'
-    "go": 'restoreIpAddresses("{s}")'
-    "dart": 'Solution().restoreIpAddresses("{s}")'
-    "swift": 'Solution().restoreIpAddresses("{s}")'
-    "typescript": 'restoreIpAddresses("{s}")'
+    "cpp": "Solution().restoreIpAddresses({s})"
+    "rust": "Solution::restore_ip_addresses({s})"
+    "python3": "Solution().restoreIpAddresses({s})"
+    "python2": "Solution().restoreIpAddresses({s})"
+    "ruby": "restore_ip_addresses({s})"
+    "java": "new Solution().restoreIpAddresses({s})"
+    "csharp": "new Solution().RestoreIpAddresses({s})"
+    "kotlin": "Solution().restoreIpAddresses({s})"
+    "go": "restoreIpAddresses({s})"
+    "dart": "Solution().restoreIpAddresses({s})"
+    "swift": "Solution().restoreIpAddresses({s})"
+    "typescript": "restoreIpAddresses({s})"
+  "params":
+    "s":
+      "type": "string"
 "judge":
   "type": "ignore_order"
 "limits":
@@ -21,7 +24,7 @@
   "memory_mb": 256
 "oracle":
   "python3":
-    "call": 'Checker().restoreIpAddresses("{s}", {result})'
+    "call": "Checker().restoreIpAddresses(s, {result})"
     "checker":
       "class Checker:\n    def restoreIpAddresses(self, s, result):\n   \
       \     def is_valid(ip):\n            parts = ip.split('.')\n            if len(parts)\
diff --git a/tests/1-500/94. binary-tree-inorder-traversal/manifest.yaml b/tests/1-500/94. binary-tree-inorder-traversal/manifest.yaml
index a9d2cf15..94b599c3 100644
--- a/tests/1-500/94. binary-tree-inorder-traversal/manifest.yaml	
+++ b/tests/1-500/94. binary-tree-inorder-traversal/manifest.yaml	
@@ -1,25 +1,22 @@
 "entry":
   "id": 94
   "title": "binary-tree-inorder-traversal"
+  "params":
+    "root":
+      "type": "tree_node"
   "call":
-    "cpp":
-      "treeNodeToArray(Solution().inorderTraversal(toTreeNode(lv(vector<optional<int>>{\
-      \ {root} }))))"
-    "rust": "TreeNode::tree_node_to_array(Solution::inorder_traversal(TreeNode::to_tree_node(vec![{root}])))"
-    "python3": "Solution().inorderTraversal(to_tree_node([{root}]))"
-    "python2": "Solution().inorderTraversal(to_tree_node([{root}]))"
-    "ruby": "inorderTraversal(to_tree_node([{root}]))"
-    "java":
-      "TreeNode.treeNodeToArray(new Solution().inorderTraversal(TreeNode.toTreeNode(new\
-      \ Integer[]{ {root} })))"
-    "csharp":
-      "TreeNode.TreeNodeToArray(new Solution().InorderTraversal(TreeNode.ToTreeNode(new\
-      \ int?[]{ {root} })))"
-    "kotlin": "treeNodeToArray(Solution().inorderTraversal(toTreeNode(arrayOf({root}))))"
-    "go": "treeNodeToArray(inorderTraversal(toTreeNode([]interface{}{ {root} })))"
-    "dart": "tree_node_to_array(Solution().inorderTraversal(to_tree_node([{root}])))"
-    "swift": "tree_node_to_array(Solution().inorderTraversal(to_tree_node([{root}])))"
-    "typescript": "treeNodeToArray(inorderTraversal(toTreeNode([{root}])))"
+    "cpp": "Solution().inorderTraversal({root})"
+    "rust": "Solution::inorder_traversal({root})"
+    "python3": "Solution().inorderTraversal({root})"
+    "python2": "Solution().inorderTraversal({root})"
+    "ruby": "inorderTraversal({root})"
+    "java": "new Solution().inorderTraversal({root})"
+    "csharp": "new Solution().InorderTraversal({root})"
+    "kotlin": "Solution().inorderTraversal({root})"
+    "go": "inorderTraversal({root})"
+    "dart": "Solution().inorderTraversal({root})"
+    "swift": "Solution().inorderTraversal({root})"
+    "typescript": "inorderTraversal({root})"
 "judge":
   "type": "exact"
 "limits":
@@ -27,7 +24,7 @@
   "memory_mb": 256
 "oracle":
   "python3":
-    "call": "Checker().inorderTraversal([{root}], {result})"
+    "call": "Checker().inorderTraversal(root, {result})"
     "checker":
       "import json\nclass Checker:\n  def inorderTraversal(self, root_arr,\
       \ result):\n      try:\n          result = json.loads(result) if isinstance(result,\
diff --git a/tests/1-500/95. unique-binary-search-trees-ii/manifest.yaml b/tests/1-500/95. unique-binary-search-trees-ii/manifest.yaml
index 3792cb81..8068e136 100644
--- a/tests/1-500/95. unique-binary-search-trees-ii/manifest.yaml	
+++ b/tests/1-500/95. unique-binary-search-trees-ii/manifest.yaml	
@@ -3,17 +3,20 @@
   "title": "unique-binary-search-trees-ii"
   "call":
     "cpp": "treeNodesArrayToVector(Solution().generateTrees({n}))"
-    "rust": "Solution::generate_trees({n})"
+    "rust": "Solution::generate_trees({n}).into_iter().map(TreeNode::tree_node_to_array).collect::<Vec<_>>()"
     "python3": "[tree_node_to_array(t) for t in Solution().generateTrees({n})]"
     "python2": "[tree_node_to_array(t) for t in Solution().generateTrees({n})]"
-    "ruby": "generate_trees({n})"
+    "ruby": "generate_trees({n}).map { |e| tree_node_to_array(e) }"
     "java": "TreeNode.treeNodesArrayToArrayList(new Solution().generateTrees({n}))"
     "csharp": "TreeNode.TreeNodeListToArrayList(new Solution().GenerateTrees({n}))"
     "kotlin": "generateTrees({n}).map { treeNodeToArray(it) }"
     "go": "treesToArrays(generateTrees({n}))"
-    "dart": "generateTrees({n}).map((e) => treeNodeToArray(e)).toList()"
-    "swift": "generateTrees({n}).map { treeNodeToArray($0) }"
+    "dart": "generateTrees({n}).map((e) => tree_node_to_array(e)).toList()"
+    "swift": "generateTrees({n}).map { tree_node_to_array($0) }"
     "typescript": "generateTrees({n}).map((e) => treeNodeToArray(e))"
+  "params":
+    "n":
+      "type": "int"
 "judge":
   "type": "exact"
 "limits":
@@ -21,7 +24,7 @@
   "memory_mb": 256
 "oracle":
   "python3":
-    "call": "Checker().check({n}, {result})"
+    "call": "Checker().check(n, {result})"
     "checker":
       "import json\nclass Checker:\n    def tree_to_list(self, root):\n \
       \       if not root: return []\n        res, q = [], [root]\n        while q:\n\
diff --git a/tests/1-500/96. unique-binary-search-trees/manifest.yaml b/tests/1-500/96. unique-binary-search-trees/manifest.yaml
index cdd83aed..7ed82bf0 100644
--- a/tests/1-500/96. unique-binary-search-trees/manifest.yaml	
+++ b/tests/1-500/96. unique-binary-search-trees/manifest.yaml	
@@ -14,6 +14,9 @@ entry:
     dart: Solution().numTrees({n})
     swift: Solution().numTrees({n})
     typescript: numTrees({n})
+  params:
+    n:
+      type: int
 judge:
   type: exact
 limits:
@@ -21,7 +24,7 @@ limits:
   memory_mb: 256
 oracle:
   python3:
-    call: Checker().numTrees({n}, {result})
+    call: Checker().numTrees(n, {result})
     checker:
       "class Checker:\n    def numTrees(self, n, result):\n        try:\n \
       \           result = int(result)\n        except Exception:\n            return\
diff --git a/tests/1-500/97. interleaving-string/manifest.yaml b/tests/1-500/97. interleaving-string/manifest.yaml
index 2998bef3..a0e42162 100644
--- a/tests/1-500/97. interleaving-string/manifest.yaml	
+++ b/tests/1-500/97. interleaving-string/manifest.yaml	
@@ -2,20 +2,25 @@
   "id": 97
   "title": "interleaving-string"
   "call":
-    "cpp": 'Solution().isInterleave("{s1}", "{s2}", "{s3}")'
-    "rust":
-      "Solution::is_interleave(\"{s1}\".to_string(), \"{s2}\".to_string(), \"\
-      {s3}\".to_string())"
-    "python3": 'Solution().isInterleave("{s1}", "{s2}", "{s3}")'
-    "python2": 'Solution().isInterleave("{s1}", "{s2}", "{s3}")'
-    "ruby": 'is_interleave("{s1}", "{s2}", "{s3}")'
-    "java": 'new Solution().isInterleave("{s1}", "{s2}", "{s3}")'
-    "csharp": 'new Solution().IsInterleave("{s1}", "{s2}", "{s3}")'
-    "kotlin": 'Solution().isInterleave("{s1}", "{s2}", "{s3}")'
-    "go": 'isInterleave("{s1}", "{s2}", "{s3}")'
-    "dart": 'Solution().isInterleave("{s1}", "{s2}", "{s3}")'
-    "swift": 'Solution().isInterleave("{s1}", "{s2}", "{s3}")'
-    "typescript": 'isInterleave("{s1}", "{s2}", "{s3}")'
+    "cpp": "Solution().isInterleave({s1}, {s2}, {s3})"
+    "rust": "Solution::is_interleave({s1}, {s2}, {s3})"
+    "python3": "Solution().isInterleave({s1}, {s2}, {s3})"
+    "python2": "Solution().isInterleave({s1}, {s2}, {s3})"
+    "ruby": "is_interleave({s1}, {s2}, {s3})"
+    "java": "new Solution().isInterleave({s1}, {s2}, {s3})"
+    "csharp": "new Solution().IsInterleave({s1}, {s2}, {s3})"
+    "kotlin": "Solution().isInterleave({s1}, {s2}, {s3})"
+    "go": "isInterleave({s1}, {s2}, {s3})"
+    "dart": "Solution().isInterleave({s1}, {s2}, {s3})"
+    "swift": "Solution().isInterleave({s1}, {s2}, {s3})"
+    "typescript": "isInterleave({s1}, {s2}, {s3})"
+  "params":
+    "s1":
+      "type": "string"
+    "s2":
+      "type": "string"
+    "s3":
+      "type": "string"
 "judge":
   "type": "exact"
 "limits":
@@ -23,7 +28,7 @@
   "memory_mb": 256
 "oracle":
   "python3":
-    "call": 'Checker().check("{s1}", "{s2}", "{s3}", {result})'
+    "call": "Checker().check(s1, s2, s3, {result})"
     "checker":
       "import json\nclass Checker:\n    def check(self, s1, s2, s3, res):\n\
       \        try:\n            res = json.loads(res) if isinstance(res, str) else\
diff --git a/tests/1-500/98. validate-binary-search-tree/manifest.yaml b/tests/1-500/98. validate-binary-search-tree/manifest.yaml
index 27b0d89f..ac390d16 100644
--- a/tests/1-500/98. validate-binary-search-tree/manifest.yaml	
+++ b/tests/1-500/98. validate-binary-search-tree/manifest.yaml	
@@ -2,18 +2,21 @@ entry:
   id: 98
   title: validate-binary-search-tree
   call:
-    cpp: Solution().isValidBST(toTreeNode(lv(vector<optional<int>>{ {root} })))
-    rust: Solution::is_valid_bst(TreeNode::to_tree_node(vec![{root}]))
-    python3: Solution().isValidBST(to_tree_node([{root}]))
-    python2: Solution().isValidBST(to_tree_node([{root}]))
-    ruby: is_valid_bst(to_tree_node([{root}]))
-    java: new Solution().isValidBST(TreeNode.toTreeNode(new Integer[]{ {root} }))
-    csharp: new Solution().IsValidBST(TreeNode.ToTreeNode(new int?[]{ {root} }))
-    kotlin: Solution().isValidBST(toTreeNode(arrayOf({root})))
-    go: isValidBST(toTreeNode([]interface{}{ {root} }))
-    dart: Solution().isValidBST(to_tree_node([{root}]))
-    swift: Solution().isValidBST(to_tree_node([{root}]))
-    typescript: isValidBST(toTreeNode([{root}]))
+    cpp: Solution().isValidBST({root})
+    rust: Solution::is_valid_bst({root})
+    python3: Solution().isValidBST({root})
+    python2: Solution().isValidBST({root})
+    ruby: is_valid_bst({root})
+    java: new Solution().isValidBST({root})
+    csharp: new Solution().IsValidBST({root})
+    kotlin: Solution().isValidBST({root})
+    go: isValidBST({root})
+    dart: Solution().isValidBST({root})
+    swift: Solution().isValidBST({root})
+    typescript: isValidBST({root})
+  params:
+    root:
+      type: tree_node
 judge:
   type: exact
 limits:
@@ -21,16 +24,13 @@ limits:
   memory_mb: 256
 oracle:
   python3:
-    call: Checker().isValidBST([{root}], {result})
+    call: Checker().isValidBST(root, {result})
     checker:
-      "class Checker:\n    def isValidBST(self, root_arr, result):\n      \
-      \  def is_bst(arr, idx, min_v, max_v):\n            if idx >= len(arr) or arr[idx]\
-      \ is None:\n                return True\n            val = arr[idx]\n      \
-      \      if not (min_v < val < max_v):\n                return False\n       \
-      \     left = 2 * idx + 1\n            right = 2 * idx + 2\n            return\
-      \ (is_bst(arr, left, min_v, val) and \n                    is_bst(arr, right,\
-      \ val, max_v))\n        expected = is_bst(root_arr, 0, float('-inf'), float('inf'))\n\
-      \        return expected == result\n"
+      "class Checker:\n    def isValidBST(self, root_arr, result):\n        def is_bst(arr, idx, min_v, max_v):\n \
+      \           if idx >= len(arr) or arr[idx] is None:\n                return True\n            val = arr[idx]\n     \
+      \       if not (min_v < val < max_v):\n                return False\n            left = 2 * idx + 1\n            right
+      = 2 * idx + 2\n            return (is_bst(arr, left, min_v, val) and \n                    is_bst(arr, right, val, max_v))\n\
+      \        expected = is_bst(root_arr, 0, float('-inf'), float('inf'))\n        return expected == result\n"
 seed: 42
 tests:
   - name: Example 1
@@ -46,8 +46,8 @@ tests:
         - 5
         - 1
         - 4
-        - null
-        - null
+        -
+        -
         - 3
         - 6
     out: false
@@ -60,7 +60,7 @@ tests:
     in:
       root:
         - 1
-        - null
+        -
         - 2
     out: true
   - name: Two nodes invalid
@@ -68,7 +68,7 @@ tests:
       root:
         - 1
         - 2
-        - null
+        -
     out: false
   - name: Max int range edge
     in:
@@ -85,21 +85,17 @@ tests:
       root:
         - 10
         - 5
-        - null
+        -
         - 2
         - 7
-        - null
-        - null
         - 1
     out: true
   - name: Deep right tree
     in:
       root:
         - 10
-        - null
+        -
         - 20
-        - null
-        - null
         - 15
         - 25
     out: true
@@ -109,8 +105,8 @@ tests:
         - 5
         - 1
         - 6
-        - null
-        - null
+        -
+        -
         - 3
         - 7
     out: false
@@ -142,8 +138,8 @@ tests:
         - 5
         - 4
         - 6
-        - null
-        - null
+        -
+        -
         - 3
         - 7
     out: false
@@ -153,10 +149,10 @@ tests:
         - 5
         - 1
         - 6
-        - null
+        -
         - 8
-        - null
-        - null
+        -
+        -
     out: false
   - name: All same values
     in:
@@ -178,7 +174,7 @@ tests:
         - 10
         - 5
         - 15
-        - null
+        -
         - 8
         - 12
         - 20
@@ -189,7 +185,7 @@ tests:
         - 10
         - 5
         - 15
-        - null
+        -
         - 12
         - 8
         - 20
@@ -198,7 +194,7 @@ tests:
     in:
       root:
         - -2147483648
-        - null
+        -
         - 2147483647
     out: true
   - name: Negative boundary invalid
@@ -206,7 +202,7 @@ tests:
       root:
         - -2147483648
         - -2147483648
-        - null
+        -
     out: false
   - name: Full tree valid
     in:
@@ -234,7 +230,7 @@ tests:
     in:
       root:
         - 1
-        - null
+        -
         - 1
     out: false
   - name: Left deep valid
@@ -252,8 +248,8 @@ tests:
         - 10
         - 5
         - 15
-        - null
-        - null
+        -
+        -
         - 12
         - 20
     out: true